Merge remote-tracking branch 'origin/dev_v1.0.0' into dev_v1.0.0

sop-business/src/main/java/com/qmth/sop/business/service/impl/SopScheduleServiceImpl.java

@@ -1,6 +1,5 @@
 package com.qmth.sop.business.service.impl;
 
-import cn.hutool.core.date.DateUtil;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -74,60 +73,52 @@ public class SopScheduleServiceImpl extends ServiceImpl<SopScheduleMapper, TBSop
         Map<String, List<Map<String, Object>>> result = new HashMap<>();
         List<TBSopPlanDateLogDto> tbSopPlanDateLogDtoList = tbSopPlanDateLogService.findSopPlanDateLog(serviceId);
         if (!CollectionUtils.isEmpty(tbSopPlanDateLogDtoList)) {
-            Set<Long> sopIdSet = new HashSet<>();//有几条sop
-            Long minStartTime = null, maxEndTime = null;//取最小开始和最大结束时间
             Map<Long, Long> endTimeMap = new HashMap<>();//取终止的流程日期
             List<Map<String, Object>> plan = new ArrayList<>(), actualed = new ArrayList<>();
             LinkedMultiValueMap<Long, TBSopPlanDateLogDto> sopPlanDateLogDtoLinkedMultiValueMap = new LinkedMultiValueMap<>();
             for (TBSopPlanDateLogDto t : tbSopPlanDateLogDtoList) {
-                sopIdSet.add(t.getSopId());
                 sopPlanDateLogDtoLinkedMultiValueMap.add(t.getSopId(), t);
-                if (Objects.isNull(minStartTime) || minStartTime > t.getBeginTime()) {
-                    minStartTime = t.getBeginTime();
-                }
-                if (Objects.isNull(maxEndTime) || maxEndTime < t.getEndTime()) {
-                    maxEndTime = t.getEndTime();
-                }
                 if (t.getStatus() == FlowStatusEnum.END) {
                     endTimeMap.put(t.getSopId(), t.getFlowUpdateTime());
                 }
             }
-            List<String> daysBetweenMaxMinTime = DateDisposeUtils.getDaysBetween(minStartTime, maxEndTime, SystemConstant.DEFAULT_DATE_YMD_PATTERN);
             Map<String, Integer> daysBetweenPlanCalculat = new LinkedHashMap<>();
             Map<String, Integer> daysBetweenActaledCalculat = new LinkedHashMap<>();
-            String nowDate = DateUtil.format(new Date(), SystemConstant.DEFAULT_DATE_YMD_PATTERN);
-            for (int i = 0; i < daysBetweenMaxMinTime.size(); i++) {
-                if (Objects.equals(nowDate, daysBetweenMaxMinTime.get(i))) {
-                    daysBetweenPlanCalculat.put(daysBetweenMaxMinTime.get(i), -1);
-                } else {
-                    daysBetweenPlanCalculat.put(daysBetweenMaxMinTime.get(i), 0);
-                }
-            }
-            daysBetweenActaledCalculat.putAll(daysBetweenPlanCalculat);
             for (Map.Entry<Long, List<TBSopPlanDateLogDto>> entry : sopPlanDateLogDtoLinkedMultiValueMap.entrySet()) {
                 List<TBSopPlanDateLogDto> list = entry.getValue();
                 TBSopPlanDateLog planDateLog = list.get(0);//计划
                 TBSopPlanDateLog planActaledDateLog = null;
                 if (list.size() > 1) {//实际
                     planActaledDateLog = list.get(list.size() - 1);
-                } else {
-                    planActaledDateLog = list.get(0);
+                }
+                if (Objects.nonNull(planActaledDateLog) && endTimeMap.containsKey(planActaledDateLog.getSopId())) {
+                    planActaledDateLog.setEndTime(endTimeMap.get(planActaledDateLog.getSopId()));
                 }
                 if (Objects.nonNull(planDateLog)) {
                     List<String> daysBetweenPlan = DateDisposeUtils.getDaysBetween(planDateLog.getBeginTime(), planDateLog.getEndTime(), SystemConstant.DEFAULT_DATE_YMD_PATTERN);
-                    Map<String, Object> daysBetweenPlanMap = daysBetweenPlan.stream().collect(Collectors.toMap(s -> s, s -> s, (k1, k2) -> k1, LinkedHashMap::new));
-                    for (Map.Entry<String, Integer> entryPlan : daysBetweenPlanCalculat.entrySet()) {
-                        if (daysBetweenPlanMap.containsKey(entryPlan.getKey())) {
-                            daysBetweenPlanCalculat.put(entryPlan.getKey(), daysBetweenPlanCalculat.get(entryPlan.getKey()) + 1);
+                    Map<String, Integer> daysBetweenPlanMap = new LinkedHashMap<>();
+                    for (int i = 0; i < daysBetweenPlan.size(); i++) {
+                        daysBetweenPlanMap.put(daysBetweenPlan.get(i), i + 1);
+                    }
+                    for (Map.Entry<String, Integer> entryPlan : daysBetweenPlanMap.entrySet()) {
+                        if (daysBetweenPlanCalculat.containsKey(entryPlan.getKey())) {
+                            daysBetweenPlanCalculat.put(entryPlan.getKey(), daysBetweenPlanCalculat.get(entryPlan.getKey()) + entryPlan.getValue());
+                        } else {
+                            daysBetweenPlanCalculat.put(entryPlan.getKey(), entryPlan.getValue());
                         }
                     }
                 }
                 if (Objects.nonNull(planActaledDateLog)) {
                     List<String> daysBetweenActualed = DateDisposeUtils.getDaysBetween(planActaledDateLog.getBeginTime(), planActaledDateLog.getEndTime(), SystemConstant.DEFAULT_DATE_YMD_PATTERN);
-                    Map<String, Object> daysBetweenActualedMap = daysBetweenActualed.stream().collect(Collectors.toMap(s -> s, s -> s, (k1, k2) -> k1, LinkedHashMap::new));
-                    for (Map.Entry<String, Integer> entryPlan : daysBetweenActaledCalculat.entrySet()) {
-                        if (daysBetweenActualedMap.containsKey(entryPlan.getKey())) {
-                            daysBetweenActaledCalculat.put(entryPlan.getKey(), daysBetweenActaledCalculat.get(entryPlan.getKey()) + 1);
+                    Map<String, Integer> daysBetweenActualedMap = new LinkedHashMap<>();
+                    for (int i = 0; i < daysBetweenActualed.size(); i++) {
+                        daysBetweenActualedMap.put(daysBetweenActualed.get(i), i + 1);
+                    }
+                    for (Map.Entry<String, Integer> entryActualed : daysBetweenActualedMap.entrySet()) {
+                        if (daysBetweenActaledCalculat.containsKey(entryActualed.getKey())) {
+                            daysBetweenActaledCalculat.put(entryActualed.getKey(), daysBetweenActaledCalculat.get(entryActualed.getKey()) + entryActualed.getValue());
+                        } else {
+                            daysBetweenActaledCalculat.put(entryActualed.getKey(), entryActualed.getValue());
                         }
                     }
                 }
@@ -135,13 +126,13 @@ public class SopScheduleServiceImpl extends ServiceImpl<SopScheduleMapper, TBSop
             for (Map.Entry<String, Integer> entryPlan : daysBetweenPlanCalculat.entrySet()) {
                 Map<String, Object> map = new HashMap<>();
                 map.put("datetime", entryPlan.getKey());
-                map.put("count", entryPlan.getValue() < 0 ? 0 : entryPlan.getValue());
+                map.put("count", entryPlan.getValue());
                 plan.add(map);
             }
             for (Map.Entry<String, Integer> entryActaled : daysBetweenActaledCalculat.entrySet()) {
                 Map<String, Object> map = new HashMap<>();
                 map.put("datetime", entryActaled.getKey());
-                map.put("count", entryActaled.getValue() < 0 ? 0 : entryActaled.getValue());
+                map.put("count", entryActaled.getValue());
                 actualed.add(map);
             }
             result.put("plan", plan);

sop-business/src/main/java/com/qmth/sop/business/service/impl/TBSopInfoServiceImpl.java

@@ -961,7 +961,7 @@ public class TBSopInfoServiceImpl extends ServiceImpl<TBSopInfoMapper, TBSopInfo
         LinkedHashMap<String, FlowTaskResult> setupMapNew = new LinkedHashMap<>(setupMap.size());
         for (Map.Entry<String, FlowTaskResult> entry : setupMap.entrySet()) {
             if (entry.getValue().getSetup().intValue() > 0) {
-                if (entry.getValue().getSetup().intValue() == 1 || entry.getValue().getSetup().intValue() == 3 || entry.getValue().getSetup().intValue() == 4) {
+                if (entry.getValue().getSetup().intValue() == 1 || entry.getValue().getSetup().intValue() == 3) {
                     for (FlowFormWidgetResult f : entry.getValue().getFormProperty()) {
                         f.setReadable(true);
                         f.setWritable(false);
@@ -1032,19 +1032,15 @@ public class TBSopInfoServiceImpl extends ServiceImpl<TBSopInfoMapper, TBSopInfo
         FlowResult flowResultParam = JSONObject.parseObject(sopSaveParam.getFormProperties(), FlowResult.class);
         LinkedHashMap<String, FlowTaskResult> setupParamMap = flowResultParam.getSetupMap();
         for (Map.Entry<String, FlowTaskResult> entry : setupParamMap.entrySet()) {
-            if (entry.getValue().getSetup() != 0 && entry.getValue().getSetup() > 1) {//更新动态表单字段和处理时限
+            if (entry.getValue().getSetup() != 0) {//更新动态表单字段和处理时限
                 tbSopInfoService.saveDynamicSop(tfCustomFlow, tfCustomFlowEntity.getCode(), tfCustomFlowEntity.getFlowId(), entry.getValue());
             }
         }
         FlowResult flowResult = JSONObject.parseObject(tfCustomFlowEntity.getFlowProcessVar(), FlowResult.class);
         LinkedHashMap<String, FlowTaskResult> setupMap = flowResult.getSetupMap();
         for (Map.Entry<String, FlowTaskResult> entry : setupMap.entrySet()) {
-            if (entry.getValue().getSetup().intValue() > 1) {
-                if (Objects.nonNull(setupParamMap.get(entry.getKey()))) {
-                    setupMap.put(entry.getKey(), setupParamMap.get(entry.getKey()));
-                } else {
-                    break;
-                }
+            if (Objects.nonNull(setupParamMap.get(entry.getKey()))) {
+                setupMap.put(entry.getKey(), setupParamMap.get(entry.getKey()));
             }
         }
         flowResult.setSetupMap(setupMap);
@@ -1107,7 +1103,9 @@ public class TBSopInfoServiceImpl extends ServiceImpl<TBSopInfoMapper, TBSopInfo
                 break;
             }
         }
-        Optional.ofNullable(processLimitedTime).orElseThrow(() -> ExceptionResultEnum.ERROR.exception(ProcessLimitedEnum.convertKeyToEnum(fieldId).getTitle() + "处理时限时间为空"));
+        if (!fieldId.contains(ProcessLimitedEnum.SERVICE_FINISH_PLAN_BEGIN_DATE.getKey())) {
+            Optional.ofNullable(processLimitedTime).orElseThrow(() -> ExceptionResultEnum.ERROR.exception(ProcessLimitedEnum.convertKeyToEnum(fieldId).getTitle() + "处理时限时间为空"));
+        }
         return processLimitedTime;
     }
 
@@ -1124,19 +1122,21 @@ public class TBSopInfoServiceImpl extends ServiceImpl<TBSopInfoMapper, TBSopInfo
     public void saveSopPlanDate(FlowTaskResult flowTaskResult, Long sopId, Long flowId, Long userId) {
         Long serviceFinishPlanBeginDate = this.getProcessLimitedTime(flowTaskResult, ProcessLimitedEnum.SERVICE_FINISH_PLAN_BEGIN_DATE.getKey());
         Long serviceFinishPlanEndDate = this.getProcessLimitedTime(flowTaskResult, ProcessLimitedEnum.SERVICE_FINISH_PLAN_DATE.getKey());
-        serviceFinishPlanBeginDate = serviceFinishPlanBeginDate + 1000;
-        TBSopPlanDateLog tbSopPlanDateLog = tbSopPlanDateLogService.getOne(new QueryWrapper<TBSopPlanDateLog>().lambda().eq(TBSopPlanDateLog::getFlowId, flowId).orderByDesc(TBSopPlanDateLog::getCreateTime).last(" limit 1 "));
-        if (Objects.isNull(tbSopPlanDateLog)) {
-            tbSopPlanDateLog = new TBSopPlanDateLog(sopId, flowId, serviceFinishPlanBeginDate, serviceFinishPlanEndDate, userId);
-            tbSopPlanDateLogService.save(tbSopPlanDateLog);
-        } else {
-            TBSopPlanDateLog tbSopPlanDateLogNew = new TBSopPlanDateLog();
-            BeanUtils.copyProperties(tbSopPlanDateLog, tbSopPlanDateLogNew);
-            tbSopPlanDateLogNew.setBeginTime(serviceFinishPlanBeginDate);
-            tbSopPlanDateLogNew.setEndTime(serviceFinishPlanEndDate);
-            if (!tbSopPlanDateLogNew.equals(tbSopPlanDateLog)) {
-                tbSopPlanDateLogNew.updateInfo(userId);
-                tbSopPlanDateLogService.save(tbSopPlanDateLogNew);
+        if (Objects.nonNull(serviceFinishPlanBeginDate)) {
+            serviceFinishPlanBeginDate = serviceFinishPlanBeginDate + 1000;
+            TBSopPlanDateLog tbSopPlanDateLog = tbSopPlanDateLogService.getOne(new QueryWrapper<TBSopPlanDateLog>().lambda().eq(TBSopPlanDateLog::getFlowId, flowId).orderByDesc(TBSopPlanDateLog::getCreateTime).last(" limit 1 "));
+            if (Objects.isNull(tbSopPlanDateLog)) {
+                tbSopPlanDateLog = new TBSopPlanDateLog(sopId, flowId, serviceFinishPlanBeginDate, serviceFinishPlanEndDate, userId);
+                tbSopPlanDateLogService.save(tbSopPlanDateLog);
+            } else {
+                TBSopPlanDateLog tbSopPlanDateLogNew = new TBSopPlanDateLog();
+                BeanUtils.copyProperties(tbSopPlanDateLog, tbSopPlanDateLogNew);
+                tbSopPlanDateLogNew.setBeginTime(serviceFinishPlanBeginDate);
+                tbSopPlanDateLogNew.setEndTime(serviceFinishPlanEndDate);
+                if (!tbSopPlanDateLogNew.equals(tbSopPlanDateLog)) {
+                    tbSopPlanDateLogNew.updateInfo(userId);
+                    tbSopPlanDateLogService.save(tbSopPlanDateLogNew);
+                }
             }
         }
     }