三色任务和自查任务

linwe

2024-08-02 a1eede2f9f7c2590952ab1bdf34210020cdde7c6

 src/main/java/org/springblade/modules/eCallEventTwo/service/impl/EcOrderServiceImpl.java

@@ -1,22 +1,37 @@
package org.springblade.modules.eCallEventTwo.service.impl;

import cn.hutool.core.convert.Convert;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import liquibase.repackaged.org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.common.utils.SpringUtils;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.modules.eCallEventTwo.dto.EcOrderDTO;
import org.springblade.modules.eCallEventTwo.dto.*;
import org.springblade.modules.eCallEventTwo.entity.ECallEventTwoEntity;
import org.springblade.modules.eCallEventTwo.entity.EcOrder;
import org.springblade.modules.eCallEventTwo.mapper.EcOrderMapper;
import org.springblade.modules.eCallEventTwo.service.EcOrderService;
import org.springblade.modules.eCallEventTwo.service.IECallEventTwoService;
import org.springblade.modules.grid.entity.GridEntity;
import org.springblade.modules.grid.service.IGridService;
import org.springblade.modules.police.entity.PoliceAffairsGridEntity;
import org.springblade.modules.police.service.IPoliceAffairsGridService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * EcOrderService业务层处理
@@ -27,9 +42,12 @@
@Service
public class EcOrderServiceImpl extends ServiceImpl<EcOrderMapper, EcOrder> implements EcOrderService {

   private static final int DEFAULT_SCALE = 2; // 默认保留两位小数
   private static final RoundingMode DEFAULT_ROUNDING_MODE = RoundingMode.HALF_UP; // 默认四舍五入
   @Autowired
   private IECallEventTwoService ecOrderService;

   protected static final Logger log = LoggerFactory.getLogger(EcOrderServiceImpl.class);
   /**
    * 查询工单
    *
@@ -97,22 +115,211 @@
   }

   @Override
   public boolean SynchronizeData() {
      processPages(100);
   public boolean SynchronizeData(EcOrderParamDTO ecOrderParamDTO) {
      processPages(100, ecOrderParamDTO);
      return true;
   }

   public void processPages(int pageSize) {
      long count = count(new QueryWrapper<>());
   public void processPages(int pageSize, EcOrderParamDTO ecOrderParamDTO) {
      QueryWrapper<EcOrder> ecOrderQueryWrapper = new QueryWrapper<>();
      if (StringUtils.isNotBlank(ecOrderParamDTO.getStartTime()) && StringUtils.isNotEmpty(ecOrderParamDTO.getEndTime())) {
         ecOrderQueryWrapper.between("import_time", ecOrderParamDTO.getStartTime(), ecOrderParamDTO.getEndTime());
      }
      // System.out.println("**********参数**************************" + JSON.toJSONString(ecOrderParamDTO));
      long count = count(ecOrderQueryWrapper);
      System.out.println("**********总数**************************" + count);
      int totalPages = (int) Math.ceil((double) count / pageSize); // 计算总页数

      for (int pageNum = 1; pageNum <= totalPages; pageNum++) {
         Page<EcOrder> page = new Page<>(pageNum, pageSize);
         IPage<EcOrder> resultPage = baseMapper.selectPage(page, new QueryWrapper<>());
         IPage<EcOrder> resultPage = baseMapper.selectPage(page, ecOrderQueryWrapper);
         List<EcOrder> records = resultPage.getRecords();
         List<ECallEventTwoEntity> recordEntityList = BeanUtil.copy(records, ECallEventTwoEntity.class);
         boolean b = ecOrderService.saveOrUpdateBatch(recordEntityList);
         List<ECallEventTwoEntity> addList = new ArrayList<>();
         List<ECallEventTwoEntity> updateList = new ArrayList<>();
         // 过滤出已同步的订单
         recordEntityList.forEach(record -> {
            long count1 = ecOrderService.count(Wrappers.<ECallEventTwoEntity>lambdaQuery().eq(ECallEventTwoEntity::getOrderCode, record.getOrderCode()));
            if (count1 == 0) {
               setGridInfo(record);
               addList.add(record);
            } else {
               updateList.add(record);
            }
         });
         // 同步订单
         boolean b = false;
         if (addList.size() > 0) {
            b = ecOrderService.saveBatch(addList);
         }
         if (updateList.size() > 0) {
            b = ecOrderService.saveOrUpdateBatch(updateList);
         }
         System.out.println("更新第" + pageNum + "页" + b);
      }
   }

   @Override
   @DS("master")
   public boolean saveEcOrder(List<ECallEventTwoEntity> recordEntityList) {
      return false;
   }


   /**
    * 设置警格网格信息
    *
    * @param ecOrderEntity
    */
   public void setGridInfo(ECallEventTwoEntity ecOrderEntity) {
      try {
         if (ecOrderEntity.getSceneGeoLng() == null || ecOrderEntity.getSceneGeoLat() == null) {
            return;
         }
         // 根据位置设置网格，警格编号
         IGridService gridService = SpringUtils.getBean(IGridService.class);
         IPoliceAffairsGridService policeAffairsGridService = SpringUtils.getBean(IPoliceAffairsGridService.class);
         String point = "'POINT(" + ecOrderEntity.getSceneGeoLng().toString() + " " + ecOrderEntity.getSceneGeoLat().toString() + ")'";
         // 点坐标解析网格
         List<GridEntity> gridEntityList = gridService.spatialAnalysis(point);
         if (gridEntityList.size() > 0) {
            GridEntity gridEntity = gridEntityList.get(0);
            ecOrderEntity.setGridCode(gridEntity.getGridCode());
         }
         // 点坐标解析警格
         List<PoliceAffairsGridEntity> policeAffairsGridEntityList = policeAffairsGridService.spatialAnalysis(point);
         if (policeAffairsGridEntityList.size() > 0) {
            PoliceAffairsGridEntity policeAffairsGridEntity = policeAffairsGridEntityList.get(0);
            ecOrderEntity.setJwGridCode(policeAffairsGridEntity.getJwGridCode());
         }
      } catch (Exception e) {
         System.out.println("获取警格网格信息失败" + e);
      }
   }

   /**
    * 获取单位考核指标
    *
    * @return
    */
   @Override
   public List<Map<String, String>> getUnitAssessmentIndicators() {
      List<Map<String, String>> result = baseMapper.getUnitAssessmentIndicators();
      return result;
   }


   /**
    * 统计办结率
    */
   @Override
   public IPage<EcOrderDTO> getCount(IPage<EcOrderDTO> page, EcOrderParamDTO ecOrderParamDTO) {
      // acpt_org_code
      List<EcOrderDTO> result = baseMapper.getOrgCode(page, ecOrderParamDTO);
      for (EcOrderDTO ecOrderDTO : result) {
         if (ecOrderParamDTO.getTagMain().equals("Y")) {
            ecOrderParamDTO.setSinkOrgCode(ecOrderDTO.getSinkOrgCode());
         } else {
            ecOrderParamDTO.setSubjectOrgCode(ecOrderDTO.getSubjectOrgCode());
         }
         // 统计办结率
         buildRate(ecOrderParamDTO, ecOrderDTO);
         // 获取单位名称
         if (ecOrderParamDTO.getTagMain().equals("Y")) {
            ecOrderDTO.setOrgCode(ecOrderDTO.getSinkOrgCode());
            ecOrderDTO.setOrgName(ecOrderDTO.getSinkOrgName());
         } else {
            ecOrderDTO.setOrgCode(ecOrderDTO.getSubjectOrgCode());
            ecOrderDTO.setOrgName(ecOrderDTO.getSubjectOrgName());
         }
      }
      return page.setRecords(result);
   }

   @NotNull
   private void buildRate(EcOrderParamDTO ecOrderParamDTO, EcOrderDTO ecOrder) {
      // 统计订单
      EcOrderDTO ecOrderDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderDTO.class);
      int i = baseMapper.selectEcOrderCount(ecOrderDTO);
      // 统计派发
      EcDispatchDTO ecDispatchDTO = BeanUtil.copy(ecOrderParamDTO, EcDispatchDTO.class);
      int i1 = baseMapper.selectEcDispatchCount(ecDispatchDTO);
      // 统计处理
      EcHandleDTO ecHandleDTO = BeanUtil.copy(ecOrderParamDTO, EcHandleDTO.class);
      int i2 = baseMapper.selectEcHandleCount(ecHandleDTO);
      // 统计回访
      EcOrderCheckDTO ecOrderCheckDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderCheckDTO.class);
      int i3 = baseMapper.selectEcOrderCheckCount(ecOrderCheckDTO);
      // 统计办结
      EcOrderDoneDTO ecOrderDoneDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderDoneDTO.class);
      int i4 = baseMapper.selectEcOrderDoneCount(ecOrderDoneDTO);
      // 统计答复
      EcOrderRespDTO ecOrderRespDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderRespDTO.class);
      int i5 = baseMapper.selectEcOrderRespCount(ecOrderRespDTO);
      // 统计核实
      EcOrderReviewDTO ecOrderReviewDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderReviewDTO.class);
      int i6 = baseMapper.selectEcOrderReviewCount(ecOrderReviewDTO);
      // 统计督办
      EcOrderSuperviseDTO ecOrderSuperviseDTO = BeanUtil.copy(ecOrderParamDTO, EcOrderSuperviseDTO.class);
      int i7 = baseMapper.selectEcOrderSuperviseCount(ecOrderSuperviseDTO);
      // 工单数   派发单数   办理单数（率）   办结单数（率）   答复单数（率）   回访单数（率）   核实单数   督办单数
      // Map<String, String> result = new HashMap<>();
      // 工单数
      // result.put("orderNumber", String.valueOf(i));
      ecOrder.setOrderNumber(String.valueOf(i));
      // 派发单数（率）
      // result.put("dispatchRate", getRate(i1, i));
      ecOrder.setDispatchRate(getRate(i1, i));
      // result.put("dispatchNumber", String.valueOf(i1));
      ecOrder.setDispatchNumber(String.valueOf(i1));
      // 办理单数（率）
      // result.put("handRate", getRate(i2, i));
      ecOrder.setHandRate(getRate(i2, i));
      // result.put("handNumber", String.valueOf(i2));
      // 办结单数（率）
      // result.put("checkRate", getRate(i3, i));
      ecOrder.setCheckRate(getRate(i3, i));
      // result.put("checkNumber", String.valueOf(i3));
      // 答复单数（率）
      // result.put("doneRate", getRate(i4, i));
      ecOrder.setDoneRate(getRate(i4, i));
      // result.put("doneNumber", String.valueOf(i4));
      // 回访单数（率）
      // result.put("respRate", getRate(i5, i));
      ecOrder.setRespRate(getRate(i5, i));
      // result.put("respNumber", String.valueOf(i5));
      // 核实单数（率）
      // result.put("reviewRate", getRate(i6, i));
      ecOrder.setReviewRate(getRate(i6, i));
      // result.put("reviewNumber", String.valueOf(i6));
      // 督办单数
      // result.put("superviseNumber", String.valueOf(i7));
      ecOrder.setSuperviseNumber(String.valueOf(i7));
      // 返回结果
      // return result;
   }


   public static String getRate(int dividend, int divisor) {
      // 检查除数是否为0
      if (divisor == 0) {
         return "0";
      }
      // 将int转换为BigDecimal
      BigDecimal bdDividend = BigDecimal.valueOf(dividend);
      BigDecimal bdDivisor = BigDecimal.valueOf(divisor);
      // 执行除法操作，设置精度（scale）和舍入模式（RoundingMode）
      int scale = DEFAULT_SCALE;
      RoundingMode roundingMode = DEFAULT_ROUNDING_MODE;
      // 进行除法运算
      BigDecimal result;
      try {
         result = bdDividend.divide(bdDivisor, scale, roundingMode);
      } catch (ArithmeticException e) {
         // 处理因除数为0或其他原因引发的算术异常
         throw new RuntimeException("除法运算出错", e);
      }
      return result.toString();
   }

}