Liu Haoyu / vehicle-simple

  package com.objecteye.service.impl;
  
  import cn.hutool.core.date.DateTime;
  import cn.hutool.core.date.DateUtil;
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;

  import com.objecteye.entity.*;

  import com.objecteye.pojo.RabbitMQInfo;
  import com.objecteye.pojo.RabbitMQVehicle;
  import com.objecteye.pojo.ResponseParamPerson;

  import com.objecteye.service.DeployService;
  import com.objecteye.service.PersonnelService;

  import com.objecteye.utils.*;
  import lombok.extern.slf4j.Slf4j;

  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.data.domain.Sort;
  import org.springframework.data.mongodb.core.MongoTemplate;
  import org.springframework.data.mongodb.core.aggregation.Aggregation;
  import org.springframework.data.mongodb.core.aggregation.AggregationResults;
  import org.springframework.data.mongodb.core.query.Criteria;
  import org.springframework.data.mongodb.core.query.Query;

  import org.springframework.data.mongodb.core.query.Update;

  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.scheduling.annotation.Scheduled;

  import org.springframework.stereotype.Component;

  
  import java.math.BigDecimal;
  import java.math.RoundingMode;
  import java.util.*;
  import java.util.regex.Pattern;
  import java.util.stream.Collectors;
  
  /**
   * 服务实现层
   *
   * @author Administrator
   */

  @Component

  @Slf4j

  public class DeployServiceImpl implements DeployService {

      @Autowired
      private RedisTemplate redisTemplate;
      @Autowired

      private MongoTemplate mongoTemplate;
      @Autowired
      private PersonnelService personnelService;
      @Autowired
      private CompareDistance compareDistance;
      @Autowired
      private VehicleEngine vehicleEngine;

  
      /**
       * 查询全部
       */
      @Override
      public List<SyDeploy> findAll() {

          return mongoTemplate.find(Query.query(Criteria.where("isDelete").is(0)), SyDeploy.class);

      }
  
      @Override
      public Integer cancelOrReNewDeployTask(int deployId) {

          SyDeploy syDeploy = mongoTemplate.findOne(Query.query(Criteria.where("id").is(deployId)), SyDeploy.class);

          if (syDeploy == null) {
              throw new RuntimeException("未找到对应布控任务");
          }

          Integer status = syDeploy.getStatus();
          if (status == 0) {
              syDeploy.setStatus(1);

              mongoTemplate.save(syDeploy);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, deployId);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYIDANDENDTIME, deployId);

              changeAllTaskDetailStatus(syDeploy, 1);
          } else if (status == 1) {
              String endTime = syDeploy.getEndTime();
              DateTime parse = DateUtil.parse(endTime);
              long time = parse.getTime();
              long nowTime = System.currentTimeMillis();
              if (nowTime > time) {
                  throw new RuntimeException("布控结束时间过期");
              }
              syDeploy.setStatus(0);

              mongoTemplate.save(syDeploy);

              changeAllTaskDetailStatus(syDeploy, 0);

              redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, deployId, syDeploy.getEndTime());
              redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, deployId, syDeploy.getStartTime());

          }
          return syDeploy.getStatus();
      }
  
      /**
       * 修改任务下所有布控项明细的状态值
       *
       * @param syDeploy 布控任务
       * @param status   修改之后的状态
       */
      private void changeAllTaskDetailStatus(SyDeploy syDeploy, int status) {
          String deployId = String.valueOf(syDeploy.getId());
          for (String deployLid : syDeploy.getDeployLib().split(",")) {
              String hashKey;
              if (syDeploy.getDeployType() == 0) {
                  hashKey = deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM;
              } else {
                  hashKey = deployId + "|" + deployLid;
              }
              if (syDeploy.getDeployType() == 2) {
                  Set<Integer> detailIntIds = redisTemplate.opsForHash().keys(hashKey);
                  for (Integer detailId : detailIntIds) {
                      redisTemplate.opsForHash().put(hashKey, detailId, status);
                  }
              } else {
                  Set<String> detailIds = redisTemplate.opsForHash().keys(hashKey);
                  for (String detailId : detailIds) {
                      redisTemplate.opsForHash().put(hashKey, detailId, status);
                  }
              }
  
          }
      }
  
      @Override
      public Integer cancelOrReNewTaskByPersonId(int deployId, int featureId, int personId) {
          String key = deployId + "|" + featureId;
          Object o = redisTemplate.opsForHash().get(key, personId);
          if (o != null) {
              String s = o.toString();
              int status = Integer.parseInt(s);
              if (status == 1) {
                  redisTemplate.opsForHash().put(key, personId, 0);
              } else {
                  redisTemplate.opsForHash().put(key, personId, 1);
              }
          } else {
              redisTemplate.opsForHash().put(key, personId, 1);
          }
          return (Integer) redisTemplate.opsForHash().get(key, personId);
      }
  
      @Override
      public Integer cancelOrReNewTaskByVehicleId(int deployId, int featureId, String id) {
          String key = deployId + "|" + featureId;
          Object o = redisTemplate.opsForHash().get(key, id);
          if (o != null) {
              String s = o.toString();
              int status = Integer.parseInt(s);
              if (status == 1) {
                  redisTemplate.opsForHash().put(key, id, 0);
              } else {
                  redisTemplate.opsForHash().put(key, id, 1);
              }
          } else {
              redisTemplate.opsForHash().put(key, id, 1);
          }
          return (Integer) redisTemplate.opsForHash().get(key, id);
      }
  
      @Override
      public Integer cancelOrReNewTaskByPlate(int deployId, String plate) {
          String key = deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM;
          Object o = redisTemplate.opsForHash().get(key, plate);
          if (o != null) {
              String s = o.toString();
              int status = Integer.parseInt(s);
              if (status == 1) {
                  redisTemplate.opsForHash().put(key, plate, 0);
              } else {
                  redisTemplate.opsForHash().put(key, plate, 1);
              }
          } else {
              redisTemplate.opsForHash().put(key, plate, 1);
          }
  
          return (Integer) redisTemplate.opsForHash().get(key, plate);
      }
  
      /**
       * 按分页查询
       */
      @Override
      public PageResult findPage(int pageNum, int pageSize) {

          List<SyDeploy> result = mongoTemplate
                  .find(Query.query(Criteria.where("isDelete").is(0)).limit(pageSize).skip((pageNum - 1) * pageSize), SyDeploy.class);
          long count = mongoTemplate
                  .count(Query.query(Criteria.where("isDelete").is(0)), SyDeploy.class);

          List<DeployResultMsg> deployResultMsgs = new ArrayList<>();

          if (result.size() > 0) {

              for (SyDeploy deploy : result) {
                  DeployResultMsg deployResultMsg = new DeployResultMsg();
                  deployResultMsg.setDeployName(deploy.getName());
                  deployResultMsg.setDeployId(deploy.getId());
                  deployResultMsg.setStatus(deploy.getStatus());
                  deployResultMsgs.add(deployResultMsg);
              }
          }

          return new PageResult<>(count, deployResultMsgs);

      }
  
      /**
       * 增加

       *
       * @param syDeploy

       */

      @Override

      public void add(SyDeploy syDeploy) {

          // 处理前端传递的时间戳

          makeTimeLongToTimeStr(syDeploy);

          String now = DateUtil.now();

          if (DateUtil.parse(syDeploy.getStartTime()).getTime() <= System.currentTimeMillis()) {
              syDeploy.setStartTime(now);
              syDeploy.setStatus(0);

          } else {

              syDeploy.setStatus(1);

          }

          String endTimeStr = syDeploy.getEndTime();
          syDeploy.setIsDelete(0);
          syDeploy.setCreateDate(now);
          syDeploy.setSinglemonitor(0);
          int deployType = syDeploy.getDeployType();

          syDeploy.setDeployType(deployType);
          String featureIds = syDeploy.getDeployLib();

          String[] split = featureIds.split(",");
  

          syDeploy.setDeployLib(featureIds);

          mongoTemplate.insert(syDeploy);
          String deployId = syDeploy.getId();

          // 布控库中每一条数据都放到redis中
          makeLibRedisDetail(split, deployId, deployType);
  

          redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, deployId, syDeploy.getStartTime());
          if (syDeploy.getThresld() != null) {
              redisTemplate.opsForHash().put(GlobalUtil.DEPLOYTHRESLD, deployId, syDeploy.getThresld());

          }
          redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_LIB, deployId, featureIds);
          redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_TYPE, deployId, deployType);
          redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, deployId, endTimeStr);
      }
  
      /**
       * 重置时间参数
       *
       * @param syDeploy 原始数据
       */
      private void makeTimeLongToTimeStr(SyDeploy syDeploy) {
          syDeploy.setStartTime(DateUtil.format(new Date(Long.parseLong(syDeploy.getStartTime())), "yyyy-MM-dd HH:mm:ss"));
          syDeploy.setEndTime(DateUtil.format(new Date(Long.parseLong(syDeploy.getEndTime())), "yyyy-MM-dd HH:mm:ss"));
      }
  
      /**
       * 布控库中每一条数据都放到redis中
       *
       * @param split      所有的布控库id
       * @param deployId   布控任务id
       * @param deployType 布控任务类型
       */

      private void makeLibRedisDetail(String[] split, String deployId, int deployType) {

          for (String s : split) {
              s = s.trim();
              if (deployType == 0) {
                  redisTemplate.opsForHash().put(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, s, 0);
              } else if (deployType == 1) {

                  List<UploadVehicleDbResult> vehicleId = mongoTemplate.find(Query.query(new Criteria("vehicleId").is(s)), UploadVehicleDbResult.class);
                  String key = deployId + "|" + s;

                  for (UploadVehicleDbResult uploadVehicleDbResult : vehicleId) {
                      String id = uploadVehicleDbResult.getId();
                      redisTemplate.opsForHash().put(key, id, 0);
                  }
              } else if (deployType == 2) {

                  List<SyPersonnel> personIdByFid = personnelService.findPersonIdByFid(s);
                  String key = deployId + "|" + s;

                  for (SyPersonnel syPersonnel : personIdByFid) {

                      redisTemplate.opsForHash().put(key, syPersonnel.getId(), 0);

                  }
              }
          }
      }
  
      @Override

      public void update(SyDeploy deploy) {
          // 处理前端传递的时间戳
          makeTimeLongToTimeStr(deploy);
          long l = System.currentTimeMillis();
          String endTime = deploy.getEndTime();
          long time = DateUtil.parse(endTime).getTime();

          String deployId = deploy.getId();

          if (l > time) {
              deploy.setStatus(1);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, deployId);
          } else if (l < DateUtil.parse(deploy.getStartTime()).getTime()) {
              deploy.setStatus(1);
              redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, deployId, deploy.getStartTime());
          }
          String deployLib = deploy.getDeployLib();
          Integer deployType = deploy.getDeployType();

  
          // 删除历史
          deleteRedisWhenUpdateDeploy(deployId);
          // 布控库中每一条数据都放到redis中
          if (deployLib != null && !"".equals(deployLib)) {
              makeLibRedisDetail(deployLib.split(","), deployId, deployType);
          }
  

          redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_LIB, deployId, deployLib);
          redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_TYPE, deployId, deployType);
          redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, deployId, endTime);
  

          mongoTemplate.save(deploy);

      }
  
      /**
       * 删除历史的所有对应布控任务布控库redis数据
       *
       * @param deployId 布控任务id
       */

      private void deleteRedisWhenUpdateDeploy(String deployId) {
          SyDeploy oldSyDeploy = mongoTemplate.findOne(Query.query(Criteria.where("id").is(deployId)), SyDeploy.class);

          if (oldSyDeploy.getDeployType() == 0) {
              redisTemplate.delete(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM);
          } else {
              String oldDeployLib = oldSyDeploy.getDeployLib();
              // 删除历史
              List<String> deleteIds = new ArrayList<>();
              for (String libId : oldDeployLib.split(",")) {
                  deleteIds.add(deployId + "|" + libId);
              }
              redisTemplate.delete(deleteIds);
          }
      }
  
      /**
       * 根据ID获取实体
       *
       * @param id
       * @return
       */
      @Override

      public SyDeploy findOne(String id) {
          SyDeploy syDeploy = mongoTemplate.findOne(Query.query(Criteria.where("id").is(id)), SyDeploy.class);

          if (syDeploy != null) {
              syDeploy.setStartTime(String.valueOf(DateUtil.parse(syDeploy.getStartTime()).getTime()));
              syDeploy.setEndTime(String.valueOf(DateUtil.parse(syDeploy.getEndTime()).getTime()));

          }
          return syDeploy;
      }
  
  
      /**
       * 批量删除

       *
       * @param ids

       */
      @Override

      public void delete(List<String> ids) {

          for (String id : ids) {

              deleteRedisWhenUpdateDeploy(id);

              mongoTemplate.updateMulti(Query.query(Criteria.where("id").is(id)), Update.update("isDelete", 1), SyDeploy.class);

              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOY_LIB, id);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOY_TYPE, id);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYIDANDENDTIME, id);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, id);
              redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYTHRESLD, id);

          }
      }
  
  
      /**
       * 布控任务查询列表- 分页
       *
       * @param pageNum  当前页 码
       * @param pageSize 每页记录数
       * @param deploy   布控任务类型
       * @return 结果集
       */
      @Override
      public PageResult findPage(SyDeploy deploy, int pageNum, int pageSize) {

          Integer deployType = deploy.getDeployType();

          List<SyDeploy> tempDeployList = mongoTemplate
                  .find(Query.query(Criteria.where("deployType").is(deployType).and("isDelete").is(0))
                          .limit(pageSize).skip((pageNum - 1) * pageSize), SyDeploy.class);
          long count = mongoTemplate
                  .count(Query.query(Criteria.where("deployType").is(deployType).and("isDelete").is(0)), SyDeploy.class);

          List<MonitorTaskResultInfo> resultInfos = new ArrayList<>();
  
          // 查询出指定任务类型的所有任务报警次数

          Map<String, Long> deployIdWarningNumberMap = getDeployIdWarningNumberMap(deployType);

          for (SyDeploy syDeploy : tempDeployList) {
              long warningNumber = deployIdWarningNumberMap.getOrDefault(syDeploy.getId(), 0L);
              MonitorTaskResultInfo monitorTaskResultInfo = new MonitorTaskResultInfo();
              monitorTaskResultInfo.setId(syDeploy.getId());
              monitorTaskResultInfo.setStatus(syDeploy.getStatus());
              monitorTaskResultInfo.setName(syDeploy.getName());
              monitorTaskResultInfo.setCreateDate(syDeploy.getCreateDate());
              monitorTaskResultInfo.setWarningNumber(warningNumber);
              resultInfos.add(monitorTaskResultInfo);
          }
  

          return new PageResult<>((long) Math.ceil((double) count / pageSize), resultInfos);

      }
  
      /**
       * 获取指定任务类型id报警数量
       *
       * @param deployType 报警类型
       * @return 结果集
       */

      private Map<String, Long> getDeployIdWarningNumberMap(Integer deployType) {

          Aggregation aggregation = Aggregation.newAggregation(
                  Aggregation.match(Criteria.where("alarmType").is(deployType)),
                  Aggregation.group("deployId").count().as("count"),
                  Aggregation.project("deployId", "count")
          );
          AggregationResults<JSONObject> aggregationResults = mongoTemplate.aggregate(aggregation, "plateAlarmMsg", JSONObject.class);

          List<JSONObject> deployIdsWarningNumberList = aggregationResults.getMappedResults();

          Map<String, Long> resultMap = new HashMap<>(16);

          for (JSONObject jsonObject : deployIdsWarningNumberList) {

              if (jsonObject == null) {
                  continue;
              }

              resultMap.put(jsonObject.getString("_id"), jsonObject.getLongValue("count"));

          }
  
          return resultMap;
      }
  
      /**
       * 布控任务-任务内容 查询列表
       *
       * @param deployId    任务id
       * @param currentpage 页码
       * @param pagevolume  页码容量
       * @return 结果集
       */
      @Override

      public PageResult findMonitorTaskDetail(String deployId, int currentpage, int pagevolume) {
          SyDeploy syDeploy = mongoTemplate.findOne(Query.query(Criteria.where("id").is(deployId)), SyDeploy.class);

          Integer deployType = syDeploy.getDeployType();
          List<MonitorTaskContentResultInfo> resultInfos = new ArrayList<>();
          if (null != deployType) {
              if (0 == deployType) {
                  Set<String> plateNumberSet = redisTemplate.opsForHash().keys(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM);
                  for (String plateNumber : plateNumberSet) {
                      MonitorTaskContentResultInfo monitorTaskContentResultInfo = new MonitorTaskContentResultInfo();
                      monitorTaskContentResultInfo.setPlateNumber(plateNumber);
                      monitorTaskContentResultInfo.setCreateDate(syDeploy.getCreateDate());
                      monitorTaskContentResultInfo.setDeployTime(syDeploy.getStartTime() + "-" + syDeploy.getEndTime());
                      monitorTaskContentResultInfo.setDeployId(String.valueOf(deployId));
                      Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, plateNumber);
                      monitorTaskContentResultInfo.setStatus(String.valueOf(status));
                      resultInfos.add(monitorTaskContentResultInfo);
                  }
              } else {
                  String[] deployLibArr = syDeploy.getDeployLib().split(",");
  
                  for (String deployLib : deployLibArr) {
                      Map<String, Integer> oneLibPicUrlStatusMap = redisTemplate.opsForHash().entries(deployId + "|" + deployLib);
                      for (Map.Entry<String, Integer> entry : oneLibPicUrlStatusMap.entrySet()) {
                          MonitorTaskContentResultInfo monitorTaskContentResultInfo = new MonitorTaskContentResultInfo();
                          monitorTaskContentResultInfo.setDeployTime(syDeploy.getStartTime() + "-" + syDeploy.getEndTime());
                          monitorTaskContentResultInfo.setCreateDate(syDeploy.getCreateDate());
                          monitorTaskContentResultInfo.setId(String.valueOf(entry.getKey()));
                          monitorTaskContentResultInfo.setFeatureId(deployLib);
                          monitorTaskContentResultInfo.setDeployId(String.valueOf(deployId));
                          String urlKey = "";
                          if (1 == deployType) {
                              urlKey = "vehicleUrl";
                          } else if (2 == deployType) {
                              urlKey = "personUrl";
                          }
                          monitorTaskContentResultInfo.setUrl((String) redisTemplate.opsForHash().get(urlKey, entry.getKey()));
                          Integer status = entry.getValue();
                          monitorTaskContentResultInfo.setStatus(String.valueOf(status));
                          resultInfos.add(monitorTaskContentResultInfo);
                      }
                  }
              }
          }
          return makePageResultByBaseList(resultInfos, currentpage, pagevolume);
      }
  
  
      /**
       * 统一手动分页
       *
       * @param baseList    原始数据集合
       * @param currentpage 页码
       * @param pagevolume  页面容量
       * @return 结果集
       */
      private PageResult makePageResultByBaseList(List baseList, Integer currentpage, Integer pagevolume) {
          // 总页数
          int pageTotal = (baseList.size() / pagevolume) + ((baseList.size() % pagevolume > 0) ? 1 : 0);
  
          int fromIndex = (currentpage - 1) * pagevolume;
          int toIndex;
          if (currentpage == pageTotal) {
              toIndex = baseList.size();
          } else if (pageTotal == 0) {
              return new PageResult<>(pageTotal, new ArrayList<>());
          } else {
              toIndex = currentpage * pagevolume;
              if (toIndex > baseList.size()) {
                  toIndex = baseList.size();
              }
              if (fromIndex >= toIndex) {
                  return new PageResult<>(pageTotal, new ArrayList<>());
              }
          }
  
          return new PageResult<>(pageTotal, baseList.subList(fromIndex, toIndex));
      }
  
      /**
       * 每隔一分钟秒执行一次
       */
      @Scheduled(fixedRate = 60 * 1000)
      public void monitorDeployState() {

          Map<String, String> map = redisTemplate.opsForHash().entries(GlobalUtil.DEPLOYID_STATRTIME);
          Set<String> integers = map.keySet();
          for (String integer : integers) {

              String endTime = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOYIDANDENDTIME, integer);
              long currentTimeStamp = System.currentTimeMillis();
              long deployEndTimeStamp = Objects.requireNonNull(DateUtil.parse(endTime)).getTime();
              long deployStartTimeStamp = DateUtil.parse(map.get(integer)).getTime();
              // 没有到开始时间的不做处理
              if (currentTimeStamp >= deployStartTimeStamp && currentTimeStamp <= deployEndTimeStamp) {

                  SyDeploy syDeploy = mongoTemplate.findOne(Query.query(Criteria.where("id").is(integer)), SyDeploy.class);

                  if (syDeploy == null) {
                      return;
                  }
                  if (1 == syDeploy.getStatus()) {
                      syDeploy.setStatus(0);

                      mongoTemplate.save(syDeploy);

                  }
              } else if (currentTimeStamp > deployEndTimeStamp) {

                  mongoTemplate.updateMulti(Query.query(Criteria.where("id").is(integer)), Update.update("status", 1), SyDeploy.class);

                  redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, integer);
              }
          }
      }
  
      /**

       * 布控任务- 主列表查询
       *
       * @param monitorMainTableQueryInfo 请求参数
       * @return 分页结果集
       */
      @Override
      public PageResult monitorMainTableByPage(MonitorMainTableQueryInfo monitorMainTableQueryInfo) {
          Integer currentpage = monitorMainTableQueryInfo.getCurrentpage();
          Integer pagevolume = monitorMainTableQueryInfo.getPagevolume();
          Integer deployType = monitorMainTableQueryInfo.getDeployType();
  
          Long startTime = monitorMainTableQueryInfo.getStartTime();
          Long endTime = monitorMainTableQueryInfo.getEndTime();
          Criteria criteria = new Criteria();
          if (null != startTime && null != endTime) {
              criteria.and("picTime").gte(startTime).lte(endTime);
          } else if (null != startTime) {
              criteria.and("picTime").gte(startTime);
          } else if (null != endTime) {
              criteria.and("picTime").lte(endTime);
          }

          if (monitorMainTableQueryInfo.getPlateNumber() != null) {
              String plateNumber = monitorMainTableQueryInfo.getPlateNumber().replaceAll("\\?", "\\\\S").replaceAll("\\*", ".*");
              Pattern pattern = Pattern.compile(plateNumber, Pattern.CASE_INSENSITIVE);
              criteria.and("plateNum").regex(pattern);
          }
          criteria.and("alarmType").is(deployType);
          Query query = Query.query(criteria);
          query.fields().include("baseId");
          query.fields().include("alarmTime");
          query.fields().include("plateNum");
          query.fields().include("snapshotUrl");
          query.fields().include("equipmentName");
          if (0 != deployType) {
              query.fields().include("similarity");
              query.fields().include("libUrl");
              query.fields().include("libId");
          }
  
          List<PlateAlarmMsg> plateAlarmMsgs = mongoTemplate.find(query.skip((currentpage - 1) * pagevolume).limit(pagevolume)
                  .with(Sort.by(Sort.Order.desc("picTime"))), PlateAlarmMsg.class);
          long total = mongoTemplate.count(query, PlateAlarmMsg.class);
  
          List<MonitorMainTableResultInfo> resultInfos = new ArrayList<>();
  
          Map<String, String> personIdRabbitMqVehicleIdMap = new HashMap<>();
          if (2 == deployType) {
              List<String> personIdList = plateAlarmMsgs.stream().map(PlateAlarmMsg::getBaseId).collect(Collectors.toList());
              Query findIdByPersonIdsQuery = new Query(Criteria.where("personid").in(personIdList));
              findIdByPersonIdsQuery.fields().include("id");
              findIdByPersonIdsQuery.fields().include("personid");
              List<RabbitMQVehicle> rabbitMqVehicles = mongoTemplate.find(findIdByPersonIdsQuery, RabbitMQVehicle.class);
              personIdRabbitMqVehicleIdMap = rabbitMqVehicles.stream().collect(Collectors.toMap(RabbitMQVehicle::getPersonid, RabbitMQVehicle::getId));
          }
          for (PlateAlarmMsg plateAlarmMsg : plateAlarmMsgs) {
              MonitorMainTableResultInfo monitorMainTableResultInfo = new MonitorMainTableResultInfo();
              if (null != plateAlarmMsg) {

                  monitorMainTableResultInfo.setPlateNumber(plateAlarmMsg.getPlateNum());
                  monitorMainTableResultInfo.setSnapshotUrl(plateAlarmMsg.getSnapshotUrl());
                  monitorMainTableResultInfo.setPicTime(plateAlarmMsg.getAlarmTime());
                  String id;
                  if (2 == deployType) {
                      id = personIdRabbitMqVehicleIdMap.get(plateAlarmMsg.getBaseId());
                  } else {
                      id = plateAlarmMsg.getBaseId();
                  }
                  monitorMainTableResultInfo.setId(id);
                  if (0 != deployType) {
                      monitorMainTableResultInfo.setLibId(plateAlarmMsg.getLibId());
                      monitorMainTableResultInfo.setLibUrl(plateAlarmMsg.getLibUrl());
                      monitorMainTableResultInfo.setThreshold(plateAlarmMsg.getSimilarity());
                  }
              }
              resultInfos.add(monitorMainTableResultInfo);
          }
  
          // 总页数
          long pageTotal = (total / pagevolume) + ((total % pagevolume > 0) ? 1 : 0);
  
          return new PageResult<>(pageTotal, resultInfos);
      }
  
      /**
       * 布控监听器
       *
       * @param rabbitMqVehicle 消息体
       */
      @Override
      public void rabbitMqMsgListener(RabbitMQVehicle rabbitMqVehicle) {

          // 设备id - 布控任务

          List<String> deployIds = getAllDeployTaskStatusEqualsTo0();
          if (null != deployIds) {
              for (String deployId : deployIds) {

                  // 获取布控类型
                  Integer deployType = (Integer) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_TYPE, deployId);
                  if (null != deployType) {
                      // 车牌布控
                      if (deployType == 0) {
                          rabbitMqMsgPlateNumberHandler(rabbitMqVehicle, deployId);
                      } else if (deployType == 1) {
                          // 车辆布控
                          rabbitMqMsgVehicleHandler(rabbitMqVehicle, deployId);
                      }
                  }
              }
          }
      }
  

      /**
       * 获取所有未删除并且处于激活状态的任务主键
       *
       * @return 结果集
       */
      List<String> getAllDeployTaskStatusEqualsTo0() {
          return mongoTemplate.find(Query.query(Criteria.where("status").is(0).and("isDelete").is(0)), SyDeploy.class)
                  .stream().map(SyDeploy::getId).collect(Collectors.toList());
      }
  

      @Override
      public void rabbitMqMsgListener(PersonMsg personMsg) {

          // 设备id - 布控任务

          List<String> integers = getAllDeployTaskStatusEqualsTo0();

          if (null != integers) {

              for (String deployId : integers) {

                  // 获取布控类型
                  Integer deployType = (Integer) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_TYPE, deployId);
                  if (null != deployType) {
                      if (deployType == 2) {
                          // 人像布控
                          rabbitMqPersonHandler(personMsg, deployId);
                      }
                  }
              }
          }
      }
  
      /**
       * 根据布控库和布控类型查找所有布控id
       *
       * @param libId      布控库id
       * @param deployType 布控类型
       * @return 对应布控id
       */
      @Override

      public List<String> getDeployListByLibAndDeployType(String libId, int deployType) {
          List<SyDeploy> deployList = mongoTemplate.find(Query.query(Criteria.where("deployType").is(deployType).and("isDelete").is(0)), SyDeploy.class);
          List<String> list = new ArrayList<>();

          if (deployList != null) {

              list = deployList.stream().filter(syDeploy -> Arrays.asList(syDeploy.getDeployLib().split(",")).contains(libId))

                      .map(SyDeploy::getId).collect(Collectors.toList());
          }
          return list;
      }
  
      /**
       * 车牌布控处理
       *
       * @param rabbitMqVehicle 消息体
       * @param deployId        布控任务id
       */

      private void rabbitMqMsgPlateNumberHandler(RabbitMQVehicle rabbitMqVehicle, String deployId) {

          String latitude = rabbitMqVehicle.getLatitude();
          String longitude = rabbitMqVehicle.getLongitude();
          String snapshotUrl = rabbitMqVehicle.getSnapshoturl();
          Long pictime = rabbitMqVehicle.getPictime();
          String vehiclePlateHphm = rabbitMqVehicle.getVehicle_plate_hphm();
  
          PlateAlarmMsg plateAlarmMsg = null;
          String deployLib = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_LIB, deployId);
          if (null != vehiclePlateHphm) {
              if (null != deployLib) {
                  if (deployLib.contains(vehiclePlateHphm)) {
                      Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, vehiclePlateHphm);
                      if (status != null && 0 == status) {
                          plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)

                                  .longitude(longitude).latitude(latitude)

                                  .picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                                  .plateNum(vehiclePlateHphm).alarmType(0).build();
                      }
                  }
              }
          }
          plateAlarmMsgProducer(plateAlarmMsg);
      }
  
      /**
       * PlateAlarmMsg 消息发生器
       *
       * @param plateAlarmMsg 消息体
       */
      private void plateAlarmMsgProducer(PlateAlarmMsg plateAlarmMsg) {
          if (plateAlarmMsg != null) {

              PlateAlarmMsg save = mongoTemplate.insert(plateAlarmMsg);

              String s = JSON.toJSONString(save);
              redisTemplate.opsForList().leftPush("ALARM", s);
          }
      }
  
      /**
       * 车辆布控处理
       *
       * @param rabbitMqVehicle 消息体
       * @param deployId        布控任务id
       */

      private void rabbitMqMsgVehicleHandler(RabbitMQVehicle rabbitMqVehicle, String deployId) {

          String latitude = rabbitMqVehicle.getLatitude();
          String longitude = rabbitMqVehicle.getLongitude();
          String snapshotUrl = rabbitMqVehicle.getSnapshoturl();
          Long pictime = rabbitMqVehicle.getPictime();
          double[] vehicleFeaFeature = rabbitMqVehicle.getVehicle_fea_feature();
          double distance1 = compareDistance.getDistance(vehicleFeaFeature);
          String vehiclePlateHphm = rabbitMqVehicle.getVehicle_plate_hphm();
  
          String deployLib = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_LIB, deployId);
          PlateAlarmMsg plateAlarmMsg = null;
          if (null != vehiclePlateHphm) {
              String vehicleIdStr = (String) redisTemplate.opsForHash().get("vehiclePlate", vehiclePlateHphm);
              if (vehicleIdStr != null) {
                  Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + deployLib, vehicleIdStr);
                  if (status == null || 0 == status) {
                      float[] vehicleIds = (float[]) redisTemplate.opsForHash().get("vehicleId", vehicleIdStr);
                      if (vehicleIds != null) {
                          double[] features = floatArrToDoubleArr(vehicleIds);
                          double distance = compareDistance.getDistance(features);
                          double v = compareDistance.simDistance(vehicleFeaFeature, distance1, features, distance);
                          v = v > 1 ? 1.00 : v;
                          String vehicleUrl = (String) redisTemplate.opsForHash().get("vehicleUrl", vehicleIdStr);
                          //将数据储存到mongo中
                          plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)

                                  .longitude(longitude).latitude(latitude)

                                  .libUrl(vehicleUrl).picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                                  .plateNum(vehiclePlateHphm).alarmType(1).similarity(v).libId(vehicleIdStr).build();
                      }
  
                  }
              }
          }
          if (plateAlarmMsg == null) {
              double max = 0;
              String key = "";
              // 获取工作中的所有车辆信息
              Set<String> openVehicleIds = new HashSet<>();
              if (deployLib != null) {
                  for (String detailDeployLib : deployLib.split(",")) {
                      Map<String, Integer> vehicleIdStatusMap = redisTemplate.opsForHash().entries(deployId + "|" + detailDeployLib);
                      openVehicleIds.addAll(vehicleIdStatusMap.entrySet().stream().filter(entry -> 0 == entry.getValue())
                              .map(Map.Entry::getKey).collect(Collectors.toList()));
                  }
              }
              // 判断是否需要报警
              for (String openVehicleId : openVehicleIds) {
                  float[] floats = (float[]) redisTemplate.opsForHash().get("vehicleId", openVehicleId);
                  if (floats == null) {
                      continue;
                  }
                  double[] featureArr = floatArrToDoubleArr(floats);
                  double distance = compareDistance.getDistance(featureArr);
                  double similar = compareDistance.simDistance(vehicleFeaFeature, distance1, featureArr, distance);
                  if (max < similar) {
                      max = similar;
                      key = openVehicleId;
                      if (max >= 1) {
                          max = 1.00;
                          break;
                      }
                  }
              }
              if (max >= (float) redisTemplate.opsForHash().get(GlobalUtil.DEPLOYTHRESLD, deployId)) {
                  String vehicleUrl = (String) redisTemplate.opsForHash().get("vehicleUrl", key);
                  plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)

                          .longitude(longitude).latitude(latitude)

                          .libUrl(vehicleUrl).picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                          .alarmType(1).similarity(max).build();
              }
          }
          plateAlarmMsgProducer(plateAlarmMsg);
      }
  
      /**
       * float数组转 double数组
       *
       * @param floats float数组
       * @return double数组
       */
      private double[] floatArrToDoubleArr(float[] floats) {
          double[] result = new double[floats.length];
          for (int i = 0; i < floats.length; i++) {
              result[i] = floats[i];
          }
          return result;
      }
  
      /**
       * 人像布控处理
       *
       * @param personMsg 消息体
       * @param deployId  任务id
       */

      public void rabbitMqPersonHandler(PersonMsg personMsg, String deployId) {

          float[] fea = personMsg.getFea();

          String longitude = personMsg.getLongitude();
          String latitude = personMsg.getLatitude();
          String url = personMsg.getUrl();
          long captureTime = personMsg.getCaptureTime();
          String snapshotUrl = personMsg.getImageUrl();
  
          HashMap<String, Object> map = new HashMap<>(16);
          map.put("topN", 3);
          map.put("threshold", 0);
          map.put("threadNum", 2);
          map.put("feature", fea);
          String s = vehicleEngine.searchDataFromDeployDb(map);