Merge branch 'V0.0.2' of http://10.87.10.227:4000/jzyd_yyds/soc into V0.0.2

# Conflicts:
#	soc-common/soc-common-core/src/main/java/com/xunmei/common/core/event/WorkTimeChangeEvent.java
#	soc-modules/soc-modules-core/src/main/java/com/xunmei/core/listener/WorkTimeChangeEventListener.java
#	soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/listener/WorkTimeChangeEventListener.java
#	soc-modules/soc-modules-core/src/test/java/com/test/TestController.java
#	soc-modules/soc-modules-system/src/main/java/com/xunmei/system/controller/SysWorkTimeController.java
#	soc-modules/soc-modules-system/src/main/java/com/xunmei/system/service/impl/SysWorkTimeServiceImpl.java

project_data/sql/0.0.2/soc/soc.sql

@@ -1068,6 +1068,19 @@ END IF;
 
     END IF;
 
+    -- 履职项所属机构id字段
+    IF
+        NOT EXISTS ( SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'core_resumption_plan_to_point' AND COLUMN_NAME = 'of_org_id' ) THEN
+        ALTER TABLE `core_resumption_plan_to_point` ADD COLUMN `of_org_id` bigint NULL COMMENT '所属机构id';
+
+    END IF;
+
+    -- 履职计划所属机构类型
+    IF
+        NOT EXISTS ( SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'core_resumption_plan' AND COLUMN_NAME = 'plan_of_org_type' ) THEN
+        ALTER TABLE `core_resumption_plan` ADD COLUMN `plan_of_org_type` INT NULL DEFAULT NULL COMMENT '所属机构类型';
+
+    END IF;
 	-- 履职任务NFC表增加submitby
     IF
         NOT EXISTS ( SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'core_resumption_data_nfc' AND COLUMN_NAME = 'submit_by' ) THEN

soc-common/soc-common-core/src/main/java/com/xunmei/common/core/domain/edu/dto/CoreEduTrainingPlanEditDto.java

@@ -34,8 +34,8 @@ public class CoreEduTrainingPlanEditDto {
     @ApiModelProperty(value = "执行次数")
     private Integer execTimes;
 
-    @ApiModelProperty(value = "计划状态")
-    private int planStatus;
+    /*@ApiModelProperty(value = "计划状态")
+    private Integer planStatus;*/
 
     @ApiModelProperty(value = "是否立即生效", notes = "0:否,1:是")
     private Boolean buildTaskNow = Boolean.FALSE;

soc-common/soc-common-core/src/main/java/com/xunmei/common/core/enums/RetrievalTaskCycle.java

@@ -9,7 +9,7 @@ public enum RetrievalTaskCycle
 {
     NOCYCLE(0, "无周期"),
     DAYCYCLE(1, "每日"),
-    WEEKCYCLE(2, "每月"),
+    WEEKCYCLE(2, "每周"),
     MONTHCYCLE(3, "每月"),
     QUARTERCYCLE(4, "每季度"),
     HALFYEARCYCLE(5, "每半年"),

soc-common/soc-common-core/src/main/java/com/xunmei/common/core/event/WorkTimeChangeEvent.java

@@ -5,6 +5,7 @@ import io.swagger.annotations.ApiModelProperty;
 import lombok.Getter;
 import org.springframework.context.ApplicationEvent;
 
+import java.util.Date;
 import java.util.List;
 
 
@@ -14,14 +15,11 @@ public class WorkTimeChangeEvent extends ApplicationEvent {
     @ApiModelProperty(value = "机构id数组", notes = "受影响的机构")
     private final List<Long> orgIds;
 
-    @ApiModelProperty(value = "作息时间列表", notes = "受影响的作息时间列表")
-    private List<SysWorkTime> dataList;
-
+    private final List<SysWorkTime> dataList;
 
     public WorkTimeChangeEvent(Object source, List<Long> orgIds, List<SysWorkTime> dataList) {
         super(source);
         this.orgIds = orgIds;
         this.dataList = dataList;
     }
-
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/drill/controller/CoreDrillPlanController.java

@@ -74,7 +74,8 @@ public class CoreDrillPlanController extends BaseController {
     @Log(title = "预案演练计划", businessType = BusinessType.UPDATE)
     @PutMapping
     public AjaxResult edit(@RequestBody @Validated CoreDrillPlanUpdateDto coreDrillPlan) {
-        return toAjax(coreDrillPlanService.updateCoreDrillPlan(coreDrillPlan));
+        coreDrillPlanService.updateCoreDrillPlan(coreDrillPlan);
+        return success();
     }
 
     /**

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/drill/service/ICoreDrillPlanService.java

@@ -51,7 +51,7 @@ public interface ICoreDrillPlanService extends IService<CoreDrillPlan> {
      * @param coreDrillPlan 预案演练计划
      * @return 结果
      */
-    int updateCoreDrillPlan(CoreDrillPlanUpdateDto coreDrillPlan);
+    void updateCoreDrillPlan(CoreDrillPlanUpdateDto coreDrillPlan);
 
     /**
      * 批量删除预案演练计划

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/drill/service/impl/CoreDrillPlanServiceImpl.java

@@ -22,11 +22,11 @@ import com.xunmei.common.core.domain.drill.vo.CoreDrillPlanDataVo;
 import com.xunmei.common.core.domain.drill.vo.CoreDrillPlanDetailVo;
 import com.xunmei.common.core.domain.drill.vo.CoreDrillPlanPageVo;
 import com.xunmei.common.core.domain.drill.vo.CoreDrillPlanRoleVo;
+import com.xunmei.common.core.enums.EduTrainingPlanCycleEnum;
 import com.xunmei.common.core.enums.OrgTypeEnum;
 import com.xunmei.common.core.enums.drill.DrillPlanStatus;
 import com.xunmei.common.core.enums.edu.EduTrainingPlanStatus;
 import com.xunmei.common.core.exception.SystemException;
-import com.xunmei.common.core.utils.AssertUtil;
 import com.xunmei.common.core.utils.DateUtils;
 import com.xunmei.common.core.web.page.TableDataInfo;
 import com.xunmei.common.security.utils.SecurityUtils;
@@ -241,59 +241,70 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public int updateCoreDrillPlan(CoreDrillPlanUpdateDto request) {
+    public void updateCoreDrillPlan(CoreDrillPlanUpdateDto request) {
         final CoreDrillPlan plan = getById(request.getId());
-        AssertUtil.isNotEmpty(plan, "计划不存在!");
-        //此处判断能否修改,如果可以 需要删除任务,且还需要判断是否需要生成任务
-        Boolean can = checkCanUpdate(request, plan);
-        if (!can) {
-            throw new RuntimeException("当前任务已生成且存在已执行情况,无法修改培训机构类型,具体培训机构,培训角色,培训周期等信息!");
+
+        if (plan.getPlanStatus() == DrillPlanStatus.DRAFT.getCode()) {
+            //草稿状态 可以修改计划
+            doUpdatePlan(plan, request);
+            return;
+        }
+
+        if (plan.getStandard() == 1) {
+            //标准计划
+            updateStandardPlan(plan, request);
+        } else {
+            //标准计划
+            updateCommonPlan(plan, request);
         }
-        //可以修改计划
+
+
+    }
+
+    private void doUpdatePlan(CoreDrillPlan plan, CoreDrillPlanUpdateDto request) {
         BeanUtils.copyProperties(request, plan);
         plan.setUpdateTime(DateUtils.getNowDate());
         plan.setFileList(ObjectUtil.isNotEmpty(request.getFileList()) ? JSON.toJSONString(request.getFileList()) : null);
         plan.setUpdateBy(SecurityUtils.getLoginUser().getSysUser().getId().toString());
         coreDrillPlanToRoleMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
+        //List<CoreEduTrainingPlanToRole> trainingPlanToRoleList = batchSavePlanToRole(request.getPlanRoleId(), plan.getId());
         coreDrillPlanToExecOrgMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
         batchSavePlanToExecOrg(request.getPlanExecOrgIdList(), plan.getId());
-        List<CoreDrillPlanToRole> coreDrillPlanToRoleList = batchSavePlanToRole(request.getPlanRoleId(), plan.getId());
-        final int i = coreDrillPlanMapper.updateById(plan);
-        if (plan.getStandard() == 1) {
-            //如果标准计划可以修改，那么需要删除所有计划与任务，重新创建计划任务
-            updateStandardPlan(plan, coreDrillPlanToRoleList);
-        } else {
-            //普通计划
-            updateCommonPlan(plan);
-        }
-
-
-        return i;
+        coreDrillPlanMapper.updateById(plan);
     }
 
-    private void updateStandardPlan(CoreDrillPlan plan, List<CoreDrillPlanToRole> drillPlanToRoleList) {
-        //没下发的就不管
-        if (0 == plan.getIssue()) {
-            return;
-        }
-        Long planId = plan.getId();
+    private void updateStandardPlan(CoreDrillPlan plan, CoreDrillPlanUpdateDto request) {
 
-        deletePlanAndTaskByParentPlanId(planId);
-        List<CoreDrillPlan> planList = buildPlanData(plan, drillPlanToRoleList,false);
+        //使用中的标准计划
 
-        if (plan.getPlanStatus() == DrillPlanStatus.DELETED.getCode()) {
-            log.info("计划已被修改为" + DrillPlanStatus.DELETED.getDesc() + "，不再生成任务!");
-            return;
+        Long planId = plan.getId();
+        // 判断标准计划能否修改:存在下发的计划生成了任务且任务存在已执行
+        Integer standardPlanHasDone = coreDrillTaskMapper.checkHasTaskIsDoneByPlanParentId(planId);
+        if (standardPlanHasDone == 1) {
+            //验证修改的字段是否符合要求
+            String errorMsg = "有任务已执行或已过期,仅允许修改培训主题!";
+            validatePlanForStandard(request, plan, errorMsg, 1);
+            doUpdatePlan(plan, request);
+        } else {
+            doUpdatePlan(plan, request);
+            List<CoreDrillPlan> list = lambdaQuery().eq(CoreDrillPlan::getParentId, planId).select(CoreDrillPlan::getId).list();
+            List<Long> collect = list.stream().map(CoreDrillPlan::getId).collect(Collectors.toList());
+            coreDrillTaskService.delByStartTimeAndEndTimeAndPlanIdList(collect, null, null);
+            for (CoreDrillPlan drillPlan : list) {
+                CompletableFuture.runAsync(() -> {
+                    //如果不是省联社或者办事处，状态启用，并且是无周期或者立即生效
+                    if ((ObjectUtil.equal(EduTrainingPlanStatus.USING.getCode(), plan.getPlanStatus())
+                            && (ObjectUtil.equal(EduTrainingPlanCycleEnum.NONE, plan.getPlanCycle()) || ObjectUtil.equal(1, plan.getBuildTaskNow())))) {
+                        CoreDrillPlanDataVo detailPlanData = getCoreDrillPlanDataVo(drillPlan.getId());
+                        coreDrillTaskService.createTaskForNow(detailPlanData, plan.getPlanStartDate(), plan.getPlanEndDate());
+                    }
+                }, threadPoolTaskExecutor);
+            }
         }
 
+        //TODO 修改任务名称
+        //coreEduTrainingTaskMapper.updateTaskNameByPlanId(planId, planName, plan.getStartDate(), plan.getEndDate());
 
-        for (CoreDrillPlan drillPlan : planList) {
-            final CoreDrillPlanDataVo dataVo = getCoreDrillPlanDataVo(drillPlan.getId());
-            CompletableFuture.runAsync(() -> {
-                //说明有任务并且都没执行过，需要重新生成任务
-                coreDrillTaskService.createTaskForNow(dataVo, plan.getPlanStartDate(), plan.getPlanEndDate());
-            }, threadPoolTaskExecutor);
-        }
     }
 
     private void deletePlanAndTaskByParentPlanId(Long planId) {
@@ -316,74 +327,32 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         }
     }
 
-    private void updateCommonPlan(CoreDrillPlan plan) {
-        /*
-                   判断能否修改: 如果上面返回了true; 说明两种情况
-                   1:计划生成了任务,但是未执行:  此时需要删除所有任务,修改计划数据后重新创建任务
-                   2:计划生成了任务且执行了,但是没有修改到关键信息,此时则不能删除任务,只允许修改计划信息
-
-         */
-        final Integer done = coreDrillTaskMapper.checkHasTaskIsDone(Arrays.asList(plan.getId()));
-        if (ObjectUtil.equal(1, done)) {
-            //此为情况二, 计划生成了任务且执行 不能删除任务,只允许修改计划信息,所以直接返回
-            //TODO 考虑是否同步修改已生成的任务的名称
-            return;
-        }
-
-        if (plan.getPlanStatus() == DrillPlanStatus.DELETED.getCode()) {
-            log.info("计划已被修改为" + DrillPlanStatus.DELETED.getDesc() + "，不再生成任务!");
-            return;
-        }
-
-        //此为情况一,计划没有生成任务或者生成了任务但未执行
-        final CoreDrillPlanDataVo dataVo = getCoreDrillPlanDataVo(plan.getId());
-        if (ObjectUtil.equal(1, plan.getBuildTaskNow()) && ObjectUtil.equal(DrillPlanStatus.USING.getCode(), plan.getPlanStatus())) {
-            coreDrillTaskMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
-            CompletableFuture.runAsync(() -> {
-                //说明有任务并且都没执行过，需要重新生成任务
-                coreDrillTaskService.createTaskForNow(dataVo, plan.getPlanStartDate(), plan.getPlanEndDate());
-            }, threadPoolTaskExecutor);
+    private void updateCommonPlan(CoreDrillPlan plan, CoreDrillPlanUpdateDto request) {
+        //使用中的普通计划
+        if (plan.getExecTimes() > request.getExecTimes()) {
+            throw new RuntimeException("执行次数不能小于基准计划执行次数!");
         }
+        String errorMsg = "子计划仅允许修改培训频次!";
+        validatePlanForStandard(request, plan, errorMsg, 0);
+        doUpdatePlan(plan, request);
     }
 
-    private Boolean checkCanUpdate(CoreDrillPlanUpdateDto request, CoreDrillPlan plan) {
-        if (ObjectUtil.isAllEmpty(request.getExecOrgType(), request.getPlanExecOrgIdList())) {
-            throw new RuntimeException("培训机构类型和执行机构不能同时为空!");
-        }
 
-        // 如果是下发的计划，执行频次不应低于省联社下发时设定的次数
-        if (ObjectUtil.equal(plan.getStandard(), 0)) {
-            validatePlanForStandard(request, plan);
+    private void validatePlanForStandard(CoreDrillPlanUpdateDto request, CoreDrillPlan plan, String errorMsg, Integer type) {
+        validateFieldForStandard(request.getPlanCycle(), plan.getPlanCycle(), errorMsg);
+        validateFieldForStandard(request.getExecOrgType(), plan.getExecOrgType(), errorMsg);
+        List<Long> execOrgIdList = coreDrillPlanToExecOrgMapper.selectOrgIdByPlanId(plan.getId());
+        validateListForStandard(execOrgIdList, request.getPlanExecOrgIdList(), errorMsg);
+        validateFieldForStandard(request.getRemark(), plan.getRemark(), errorMsg);
+        validateFieldForStandard(JSON.toJSONString(request.getFileList()), plan.getFileList(), errorMsg);
+        if (type == 0) {
+            //标准计划可以修改名称
+            validateFieldForStandard(request.getPlanName(), plan.getPlanName(), errorMsg);
         }
-
-        final Long planId = plan.getId();
-        boolean flag = true;
-
-        // 判断计划是否有任务已经执行过
-        Integer done = coreDrillTaskMapper.checkHasTaskIsDone(Arrays.asList(planId));
-
-        // 判断标准计划能否修改:存在下发的计划生成了任务且任务存在已执行
-        Integer standardPlanHasDone = coreDrillTaskMapper.checkHasTaskIsDoneByPlanParentId(planId);
-        if (standardPlanHasDone != null) {
-            throw new RuntimeException("该计划下存在任务已执行的情况,无法修改!");
+        if (type != 0) {
+            //子计划可以修改执行次数，但只能增加不能减少
+            validateFieldForStandard(request.getExecTimes(), plan.getExecTimes(), errorMsg);
         }
-
-        // 验证计划
-        flag = validatePlan(request, plan, planId, true);
-
-        return null == done || flag;
-    }
-
-    private void validatePlanForStandard(CoreDrillPlanUpdateDto request, CoreDrillPlan plan) {
-        if (request.getExecTimes() < plan.getExecTimes()) {
-            throw new RuntimeException("培训次数不应低于基准次数!");
-        }
-        validateFieldForStandard(request.getPlanStatus(), plan.getPlanStatus(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getPlanCycle(), plan.getPlanCycle(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getExecOrgType(), plan.getExecOrgType(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getPlanName(), plan.getPlanName(), "下发计划仅允许修改培训次数!");
-
-        validateRoleAndOrgForStandard(request, plan);
     }
 
     private void validateFieldForStandard(Object requestValue, Object planValue, String errorMessage) {
@@ -392,56 +361,14 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         }
     }
 
-    private void validateRoleAndOrgForStandard(CoreDrillPlanUpdateDto request, CoreDrillPlan plan) {
-        // 执行角色
-        List<Long> roleIdLit = coreDrillPlanToRoleMapper.selectRoleIdByPlanId(plan.getId());
-        List<Long> planRoleId = request.getPlanRoleId();
-        if (ObjectUtil.isEmpty(planRoleId)) {
-            throw new RuntimeException("下发计划仅允许修改培训次数!");
-        }
-        validateListForStandard(roleIdLit, planRoleId, "下发计划仅允许修改培训次数!");
-
-        // 执行机构
-        List<Long> execOrgIdList = coreDrillPlanToExecOrgMapper.selectOrgIdByPlanId(plan.getId());
-        List<Long> planExecOrgIdList = request.getPlanExecOrgIdList();
-        validateListForStandard(execOrgIdList, planExecOrgIdList, "下发计划仅允许修改培训次数!");
-    }
-
     private void validateListForStandard(List<Long> planList, List<Long> requestList, String errorMessage) {
         if (planList.size() != requestList.size() || !planList.containsAll(requestList)) {
             throw new RuntimeException(errorMessage);
         }
     }
 
-    private boolean validatePlan(CoreDrillPlanUpdateDto request, CoreDrillPlan plan, Long planId, boolean flag) {
-        flag = flag && validateField(request.getPlanStatus(), plan.getPlanStatus());
-        flag = flag && validateField(request.getPlanCycle(), plan.getPlanCycle());
-        flag = flag && validateField(request.getExecOrgType(), plan.getExecOrgType());
-        flag = flag && validateField(request.getFileList(), plan.getFileList());
-
-        // 执行角色
-        List<Long> roleIdLit = coreDrillPlanToRoleMapper.selectRoleIdByPlanId(planId);
-        List<Long> planRoleId = request.getPlanRoleId();
-        flag = flag && !ObjectUtil.isEmpty(planRoleId) && roleIdLit.containsAll(planRoleId);
-
-        // 执行机构
-        List<Long> execOrgIdList = coreDrillPlanToExecOrgMapper.selectOrgIdByPlanId(planId);
-        List<Long> planExecOrgIdList = request.getPlanExecOrgIdList();
-        flag = flag && validateList(execOrgIdList, planExecOrgIdList);
-
-        return flag;
-    }
-
-    private boolean validateField(Object requestValue, Object planValue) {
-        return ObjectUtil.equal(requestValue, planValue);
-    }
-
-    private boolean validateList(List<Long> planList, List<Long> requestList) {
-        return planList.size() == requestList.size() && planList.containsAll(requestList);
-    }
-
 
-    public List<CoreDrillPlanToRole> batchSavePlanToRole(List<Long> roleIdList, Long planId) {
+    public void batchSavePlanToRole(List<Long> roleIdList, Long planId) {
         List<CoreDrillPlanToRole> planRoleList = new ArrayList<>();
         for (Long roleId : roleIdList) {
             CoreDrillPlanToRole role = new CoreDrillPlanToRole();
@@ -452,10 +379,9 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         if (CollectionUtil.isNotEmpty(planRoleList)) {
             coreDrillPlanToRoleService.saveBatch(planRoleList);
         }
-        return planRoleList;
     }
 
-    public List<CoreDrillPlanToExecOrg> batchSavePlanToExecOrg(List<Long> orgIdList, Long planId) {
+    public void batchSavePlanToExecOrg(List<Long> orgIdList, Long planId) {
 
         List<CoreDrillPlanToExecOrg> planOrgList = new ArrayList<CoreDrillPlanToExecOrg>();
         for (Long orgId : orgIdList) {
@@ -468,7 +394,6 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
             coreDrillPlanToExecOrgService.saveBatch(planOrgList);
         }
 
-        return planOrgList;
     }
 
     /**
@@ -555,7 +480,7 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         }
         // 下发 按钮显示逻辑:仅省联社安全保卫管理人员进入且由省联社管理安全保卫人员创建的计划才显示
         //todo 判断当前人的角色信息
-        List<CoreDrillPlan> list = buildPlanData(plan, new ArrayList<>(),true);
+        List<CoreDrillPlan> list = buildPlanData(plan, new ArrayList<>(), true);
         //下发后修改为使用中
         plan.setPlanStatus(DrillPlanStatus.USING.getCode());
         plan.setIssue(1);
@@ -586,7 +511,7 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         DateRange range = DateUtils.getStartAndEnd(new Date(), plan.getPlanCycle());
         List<Long> list = coreDrillPlanMapper.selectIdByParentId(planId);
         coreDrillPlanMapper.updatePlanStatusByIdOrParentId(planId, EduTrainingPlanStatus.DELETED.getCode());
-        coreDrillTaskService.delByStartTimeAndEndTimeAndPlanIdList(list,range.getStartTime(),range.getEndTime());
+        coreDrillTaskService.delByStartTimeAndEndTimeAndPlanIdList(list, range.getStartTime(), range.getEndTime());
         return coreDrillPlanMapper.updateById(plan);
     }
 
@@ -632,7 +557,7 @@ public class CoreDrillPlanServiceImpl extends ServiceImpl<CoreDrillPlanMapper, C
         );
     }
 
-    private List<CoreDrillPlan> buildPlanData(CoreDrillPlan plan, List<CoreDrillPlanToRole> planRoleList,boolean isPublish) {
+    private List<CoreDrillPlan> buildPlanData(CoreDrillPlan plan, List<CoreDrillPlanToRole> planRoleList, boolean isPublish) {
         if (ObjectUtil.isEmpty(planRoleList)) {
             //获取执行角色
             LambdaQueryWrapper<CoreDrillPlanToRole> ros = new LambdaQueryWrapper<>();

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/edu/mapper/CoreEduTrainingPlanMapper.java

@@ -83,4 +83,6 @@ public interface CoreEduTrainingPlanMapper extends BaseMapper<CoreEduTrainingPla
     int updatePlanStatus(@Param("planId") Long planId, @Param("status") int status);
 
     void updatePlanStatusByIdOrParentId(@Param("planId") Long planId, @Param("status") int status);
+
+    void updatePlanStatusByIdList(@Param("list") List<Long> list, @Param("status") int status);
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/edu/service/impl/CoreEduTrainingPlanServiceImpl.java

@@ -22,6 +22,7 @@ import com.xunmei.common.core.domain.edu.vo.CoreEduTrainingPlanDataVo;
 import com.xunmei.common.core.domain.edu.vo.CoreEduTrainingPlanDetailVo;
 import com.xunmei.common.core.domain.edu.vo.CoreEduTrainingPlanPageVo;
 import com.xunmei.common.core.domain.edu.vo.CoreEduTrainingPlanRoleVo;
+import com.xunmei.common.core.enums.EduTrainingPlanCycleEnum;
 import com.xunmei.common.core.enums.OrgTypeEnum;
 import com.xunmei.common.core.enums.edu.EduTrainingPlanStatus;
 import com.xunmei.common.core.utils.AssertUtil;
@@ -242,149 +243,95 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
     public int updateCoreEduTrainingPlan(CoreEduTrainingPlanEditDto request) {
         final CoreEduTrainingPlan plan = getById(request.getId());
 
-        if (plan.getPlanStatus()==EduTrainingPlanStatus.DRAFT.getCode()) {
-            throw new RuntimeException("当前计划已被删除,无法修改!");
+        if (plan.getPlanStatus() == EduTrainingPlanStatus.DRAFT.getCode()) {
+            //草稿状态 可以修改计划
+            doUpdatePlan(plan, request);
         }
 
-
-        //此处判断能否修改,如果可以 需要删除任务,且还需要判断是否需要生成任务
-        Boolean can = checkCanUpdate(request, plan);
-        if (!can) {
-            throw new RuntimeException("当前任务已生成且存在已执行情况,无法修改培训机构类型,具体培训机构,培训角色,培训周期，状态等信息!");
-        }
-        //可以修改计划
-        BeanUtils.copyProperties(request, plan);
-        plan.setUpdateTime(DateUtils.getNowDate());
-        plan.setFileList(ObjectUtil.isNotEmpty(request.getFileList()) ? JSON.toJSONString(request.getFileList()) : null);
-        plan.setUpdateBy(SecurityUtils.getLoginUser().getSysUser().getId().toString());
-        coreEduTrainingPlanToRoleMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
-        //List<CoreEduTrainingPlanToRole> trainingPlanToRoleList = batchSavePlanToRole(request.getPlanRoleId(), plan.getId());
-        coreEduTrainingPlanToExecOrgMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
-        batchSavePlanToExecOrg(request.getPlanExecOrgIdList(), plan.getId());
-        final int i = coreEduTrainingPlanMapper.updateById(plan);
         if (plan.getStandard() == 1) {
-            //如果标准计划可以修改，那么需要删除所有计划与任务，重新创建计划任务
-            updateStandardPlan(plan, null);//移除角色属性
+            //标准计划
+            updateStandardPlan(plan, request);
         } else {
-            //普通计划
-            updateCommonPlan(plan);
-        }
-
-
-        return i;
-    }
-
-    private void updateStandardPlan(CoreEduTrainingPlan plan, List<CoreEduTrainingPlanToRole> trainingPlanToRoleList) {
-        //没下发的就不管
-        if (0 == plan.getIssue()) {
-            return;
-        }
-        Long planId = plan.getId();
-        deletePlanAndTaskByParentPlanId(planId);
-        List<CoreEduTrainingPlan> planList = buildPlanData(plan, trainingPlanToRoleList, false);
-
-        if (plan.getPlanStatus() == EduTrainingPlanStatus.DELETED.getCode()) {
-            log.info("计划已被修改为" + EduTrainingPlanStatus.DELETED.getDesc() + "，不再生成任务!");
-            return;
+            //标准计划
+            updateCommonPlan(plan, request);
         }
 
-        for (CoreEduTrainingPlan trainingPlan : planList) {
-            CoreEduTrainingPlanDataVo dataVo = getCoreEduTrainingPlanDataVo(trainingPlan.getId());
-            CompletableFuture.runAsync(() -> {
-                //说明有任务并且都没执行过，需要重新生成任务
-                coreEduTrainingTaskService.createTaskForNow(dataVo, plan.getStartDate(), plan.getEndDate());
-            }, threadPoolTaskExecutor);
-        }
+        return 1;
     }
 
-    private void deletePlanAndTaskByParentPlanId(Long planId) {
-        //删除原有数据， 然后重新生成计划，任务
-        List<Long> planIdList = coreEduTrainingPlanMapper.selectAllIdByParentId(planId);
-        if (ObjectUtil.isEmpty(planIdList)) {
-            return;
+    private void updateCommonPlan(CoreEduTrainingPlan plan, CoreEduTrainingPlanEditDto request) {
+        //使用中的普通计划
+        if (plan.getExecTimes() > request.getExecTimes()) {
+            throw new RuntimeException("执行次数不能小于基准计划执行次数!");
         }
-        if (ObjectUtil.isNotEmpty(planIdList)) {
-            coreEduTrainingPlanMapper.deleteBatchIds(planIdList);
-            coreEduTrainingPlanToExecOrgMapper.delete(new LambdaQueryWrapper<CoreEduTrainingPlanToExecOrg>().in(CoreEduTrainingPlanToExecOrg::getPlanId, planIdList));
-            coreEduTrainingPlanToRoleMapper.delete(new LambdaQueryWrapper<CoreEduTrainingPlanToRole>().in(CoreEduTrainingPlanToRole::getPlanId, planIdList));
-        }
-        List<CoreEduTrainingTask> taskIdList = coreEduTrainingTaskMapper.selectList(new LambdaQueryWrapper<CoreEduTrainingTask>().in(CoreEduTrainingTask::getPlanId, planIdList).select(CoreEduTrainingTask::getId));
-        List<Long> collect = taskIdList.stream().map(CoreEduTrainingTask::getId).collect(Collectors.toList());
-        if (ObjectUtil.isNotEmpty(collect)) {
-            coreEduTrainingTaskMapper.deleteBatchIds(collect);
-            coreEduTrainingTaskToRoleMapper.delete(new LambdaQueryWrapper<CoreEduTrainingTaskToRole>().in(CoreEduTrainingTaskToRole::getEduTrainingTaskId, collect));
+        String errorMsg = "子计划仅允许修改培训频次!";
+        validatePlanForStandard(request, plan, errorMsg, 0);
+        doUpdatePlan(plan, request);
 
-        }
     }
 
-    private void updateCommonPlan(CoreEduTrainingPlan plan) {
-        /*
-                   判断能否修改: 如果上面返回了true; 说明两种情况
-                   1:计划生成了任务,但是未执行:  此时需要删除所有任务,修改计划数据后重新创建任务
-                   2:计划生成了任务且执行了,但是没有修改到关键信息,此时则不能删除任务,只允许修改计划信息
-
-         */
-        final Integer done = coreEduTrainingTaskMapper.checkHasTaskIsDone(Arrays.asList(plan.getId()));
-        if (ObjectUtil.equal(1, done)) {
-            //此为情况二, 计划生成了任务且执行 不能删除任务,只允许修改计划信息,所以直接返回
-            //TODO 考虑是否同步修改已生成的任务的名称
-            return;
-        }
-        if (plan.getPlanStatus() == EduTrainingPlanStatus.DELETED.getCode()) {
-            log.info("计划已被修改为" + EduTrainingPlanStatus.DELETED.getDesc() + "，不再生成任务!");
-            return;
-        }
-        //此为情况一,计划没有生成任务或者生成了任务但未执行
-        final CoreEduTrainingPlanDataVo dataVo = getCoreEduTrainingPlanDataVo(plan.getId());
-        if (ObjectUtil.equal(1, plan.getBuildTaskNow()) && ObjectUtil.equal(0, plan.getPlanStatus())) {
-            coreEduTrainingTaskMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
-            coreEduTrainingTaskToRoleMapper.delete(new LambdaQueryWrapper<CoreEduTrainingTaskToRole>().eq(CoreEduTrainingTaskToRole::getEduTrainingTaskId, plan.getId()));
-            CompletableFuture.runAsync(() -> {
-                //说明有任务并且都没执行过，需要重新生成任务
-                coreEduTrainingTaskService.createTaskForNow(dataVo, plan.getStartDate(), plan.getEndDate());
-            }, threadPoolTaskExecutor);
-        }
+    private void doUpdatePlan(CoreEduTrainingPlan plan, CoreEduTrainingPlanEditDto request) {
+        BeanUtils.copyProperties(request, plan);
+        plan.setUpdateTime(DateUtils.getNowDate());
+        plan.setFileList(ObjectUtil.isNotEmpty(request.getFileList()) ? JSON.toJSONString(request.getFileList()) : null);
+        plan.setUpdateBy(SecurityUtils.getLoginUser().getSysUser().getId().toString());
+        coreEduTrainingPlanToRoleMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
+        //List<CoreEduTrainingPlanToRole> trainingPlanToRoleList = batchSavePlanToRole(request.getPlanRoleId(), plan.getId());
+        coreEduTrainingPlanToExecOrgMapper.deleteByMap(MapUtil.of("plan_id", plan.getId()));
+        batchSavePlanToExecOrg(request.getPlanExecOrgIdList(), plan.getId());
+        coreEduTrainingPlanMapper.updateById(plan);
     }
 
-    private Boolean checkCanUpdate(CoreEduTrainingPlanEditDto request, CoreEduTrainingPlan plan) {
-        if (ObjectUtil.isAllEmpty(request.getExecOrgType(), request.getPlanExecOrgIdList())) {
-            throw new RuntimeException("培训机构类型和执行机构不能同时为空!");
-        }
-
-        // 如果是下发的计划，执行频次不应低于省联社下发时设定的次数
-        if (ObjectUtil.equal(plan.getStandard(), 0)) {
-            validatePlanForStandard(request, plan);
-        }
-
-        final Long planId = plan.getId();
-        boolean flag = true;
+    private void updateStandardPlan(CoreEduTrainingPlan plan, CoreEduTrainingPlanEditDto request) {
 
-        // 判断计划是否有任务已经执行过
-        Integer done = coreEduTrainingTaskMapper.checkHasTaskIsDone(Arrays.asList(planId));
+        //使用中的标准计划
 
+        Long planId = plan.getId();
         // 判断标准计划能否修改:存在下发的计划生成了任务且任务存在已执行
         Integer standardPlanHasDone = coreEduTrainingTaskMapper.checkHasTaskIsDoneByPlanParentId(planId);
-        if (standardPlanHasDone != null) {
-            throw new RuntimeException("该计划下存在任务已执行的情况,无法修改!");
+        if (standardPlanHasDone == 1) {
+            //验证修改的字段是否符合要求
+            String errorMsg = "有任务已执行或已过期,仅允许修改培训主题!";
+            validatePlanForStandard(request, plan, errorMsg, 1);
+            doUpdatePlan(plan, request);
+        } else {
+            doUpdatePlan(plan, request);
+            List<CoreEduTrainingPlan> list = lambdaQuery().eq(CoreEduTrainingPlan::getParentId, planId).select(CoreEduTrainingPlan::getId).list();
+            List<Long> collect = list.stream().map(CoreEduTrainingPlan::getId).collect(Collectors.toList());
+            coreEduTrainingTaskService.delByStartTimeAndEndTimeAndPlanIdList(collect, null, null);
+            for (CoreEduTrainingPlan trainingPlan : list) {
+                CompletableFuture.runAsync(() -> {
+                    //如果不是省联社或者办事处，状态启用，并且是无周期或者立即生效
+                    if ((ObjectUtil.equal(EduTrainingPlanStatus.USING.getCode(), plan.getPlanStatus())
+                            && (ObjectUtil.equal(EduTrainingPlanCycleEnum.NONE, plan.getPlanCycle()) || ObjectUtil.equal(1, plan.getBuildTaskNow())))) {
+                        CoreEduTrainingPlanDataVo detailPlanData = getCoreEduTrainingPlanDataVo(trainingPlan.getId());
+                        coreEduTrainingTaskService.createTaskForNow(detailPlanData, plan.getStartDate(), plan.getEndDate());
+                    }
+                }, threadPoolTaskExecutor);
+            }
         }
 
-        // 验证计划
-        flag = validatePlan(request, plan, planId, true);
+        //TODO 修改任务名称
+        //coreEduTrainingTaskMapper.updateTaskNameByPlanId(planId, planName, plan.getStartDate(), plan.getEndDate());
 
-        return null == done || flag;
     }
 
-    private void validatePlanForStandard(CoreEduTrainingPlanEditDto request, CoreEduTrainingPlan plan) {
-        if (request.getExecTimes() < plan.getExecTimes()) {
-            throw new RuntimeException("培训次数不应低于基准次数!");
-        }
-        validateFieldForStandard(request.getPlanStatus(), plan.getPlanStatus(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getPlanCycle(), plan.getPlanCycle(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getExecOrgType(), plan.getExecOrgType(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getPlanName(), plan.getPlanName(), "下发计划仅允许修改培训次数!");
-        validateFieldForStandard(request.getRemark(), plan.getRemark(), "下发计划仅允许修改培训次数!");
 
-        validateRoleAndOrgForStandard(request, plan);
+    private void validatePlanForStandard(CoreEduTrainingPlanEditDto request, CoreEduTrainingPlan plan, String errorMsg, Integer type) {
+        validateFieldForStandard(request.getPlanCycle(), plan.getPlanCycle(), errorMsg);
+        validateFieldForStandard(request.getExecOrgType(), plan.getExecOrgType(), errorMsg);
+        List<Long> execOrgIdList = coreEduTrainingPlanToExecOrgMapper.selectOrgIdByPlanId(plan.getId());
+        validateListForStandard(execOrgIdList, request.getPlanExecOrgIdList(), errorMsg);
+        validateFieldForStandard(request.getRemark(), plan.getRemark(), errorMsg);
+        validateFieldForStandard(JSON.toJSONString(request.getFileList()), plan.getFileList(), errorMsg);
+        if (type == 0) {
+            //标准计划可以修改名称
+            validateFieldForStandard(request.getPlanName(), plan.getPlanName(), errorMsg);
+        }
+        if (type != 0) {
+            //子计划可以修改执行次数，但只能增加不能减少
+            validateFieldForStandard(request.getExecTimes(), plan.getExecTimes(), errorMsg);
+        }
     }
 
     private void validateFieldForStandard(Object requestValue, Object planValue, String errorMessage) {
@@ -393,53 +340,12 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
         }
     }
 
-    private void validateRoleAndOrgForStandard(CoreEduTrainingPlanEditDto request, CoreEduTrainingPlan plan) {
-        // 执行角色
-       /* List<Long> roleIdLit = coreEduTrainingPlanToRoleMapper.selectRoleIdByPlanId(plan.getId());
-        List<Long> planRoleId = request.getPlanRoleId();
-        if (ObjectUtil.isEmpty(planRoleId)) {
-            throw new RuntimeException("下发计划仅允许修改培训次数!");
-        }
-        validateListForStandard(roleIdLit, planRoleId, "下发计划仅允许修改培训次数!");*/
-
-        // 执行机构
-        List<Long> execOrgIdList = coreEduTrainingPlanToExecOrgMapper.selectOrgIdByPlanId(plan.getId());
-        List<Long> planExecOrgIdList = request.getPlanExecOrgIdList();
-        validateListForStandard(execOrgIdList, planExecOrgIdList, "下发计划仅允许修改培训次数!");
-    }
-
     private void validateListForStandard(List<Long> planList, List<Long> requestList, String errorMessage) {
         if (planList.size() != requestList.size() || !planList.containsAll(requestList)) {
             throw new RuntimeException(errorMessage);
         }
     }
 
-    private boolean validatePlan(CoreEduTrainingPlanEditDto request, CoreEduTrainingPlan plan, Long planId, boolean flag) {
-        flag = flag && validateField(request.getPlanStatus(), plan.getPlanStatus());
-        flag = flag && validateField(request.getPlanCycle(), plan.getPlanCycle());
-        flag = flag && validateField(request.getExecOrgType(), plan.getExecOrgType());
-
-        // 执行角色
-        List<Long> roleIdLit = coreEduTrainingPlanToRoleMapper.selectRoleIdByPlanId(planId);
-        List<Long> planRoleId = request.getPlanRoleId();
-        flag = flag && !ObjectUtil.isEmpty(planRoleId) && roleIdLit.containsAll(planRoleId);
-
-        // 执行机构
-        List<Long> execOrgIdList = coreEduTrainingPlanToExecOrgMapper.selectOrgIdByPlanId(planId);
-        List<Long> planExecOrgIdList = request.getPlanExecOrgIdList();
-        flag = flag && validateList(execOrgIdList, planExecOrgIdList);
-
-        return flag;
-    }
-
-    private boolean validateField(Object requestValue, Object planValue) {
-        return ObjectUtil.equal(requestValue, planValue);
-    }
-
-    private boolean validateList(List<Long> planList, List<Long> requestList) {
-        return planList.size() == requestList.size() && planList.containsAll(requestList);
-    }
-
     @Override
     public CoreEduTrainingPlanDataVo getCoreEduTrainingPlanDataVo(Long id) {
         final CoreEduTrainingPlanDataVo dataVo = coreEduTrainingPlanMapper.getDetailPlanData(id);
@@ -461,7 +367,7 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
         return planRoleList;
     }
 
-    public List<CoreEduTrainingPlanToExecOrg> batchSavePlanToExecOrg(List<Long> orgIdList, Long planId) {
+    public void batchSavePlanToExecOrg(List<Long> orgIdList, Long planId) {
         List<CoreEduTrainingPlanToExecOrg> planOrgList = new ArrayList<CoreEduTrainingPlanToExecOrg>();
         for (Long orgId : orgIdList) {
             CoreEduTrainingPlanToExecOrg org = new CoreEduTrainingPlanToExecOrg();
@@ -473,7 +379,6 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
             coreEduTrainingPlanToExecOrgService.saveBatch(planOrgList);
         }
 
-        return planOrgList;
     }
 
     /**
@@ -485,15 +390,25 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
     @Override
     @Transactional(rollbackFor = Exception.class)
     public int deleteCoreEduTrainingPlanByIds(Long id) {
-        Integer count = coreEduTrainingTaskMapper.checkHasTaskIsDone(Collections.singletonList(id));
-        if (count != null && count > 0) {
-            throw new RuntimeException("已有任务完成，无法删除");
+        CoreEduTrainingPlan plan = getById(id);
+        if (EduTrainingPlanStatus.DRAFT.getCode() == plan.getPlanStatus()) {
+            removeById(id);
         }
         final Integer done = coreEduTrainingTaskMapper.checkHasTaskIsDoneByPlanParentId(id);
         if (done != null && done > 0) {
+            throw new RuntimeException("计划有已完成或者已逾期的任务，不能被删除");
+        }
+        List<Long> list = baseMapper.selectIdByParentId(id);
+        list.add(id);
+        coreEduTrainingTaskService.delByStartTimeAndEndTimeAndPlanIdList(list, null, null);
+
+
+        Integer count = coreEduTrainingTaskMapper.checkHasTaskIsDone(Collections.singletonList(id));
+        if (count != null && count > 0) {
             throw new RuntimeException("已有任务完成，无法删除");
         }
-        final CoreEduTrainingPlan plan = getById(id);
+
+
         if (plan.getStandard() == 0) {
             //自建计划
             final List<CoreEduTrainingTask> coreEduTrainingTasks = coreEduTrainingTaskMapper.selectList(new LambdaQueryWrapper<CoreEduTrainingTask>()
@@ -576,16 +491,24 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
         final CoreEduTrainingPlan plan = coreEduTrainingPlanMapper.selectById(planId);
         AssertUtil.isNotEmpty(plan, "计划不存在!");
         AssertUtil.equal(plan.getIssue(), 0, "计划已完成下发!");
-        List<CoreEduTrainingPlan> list = buildPlanData(plan, new ArrayList<>(), true);
+        List<CoreEduTrainingPlan> planList = lambdaQuery().eq(CoreEduTrainingPlan::getParentId, planId).select(CoreEduTrainingPlan::getId).list();
+        if (planList.isEmpty()){
+            planList = buildPlanData(plan, new ArrayList<>(), true);
+        }else {
+            planList.forEach(plan1 -> plan1.setPlanStatus(EduTrainingPlanStatus.USING.getCode()));
+            List<Long> collect = planList.stream().map(CoreEduTrainingPlan::getId).collect(Collectors.toList());
+            coreEduTrainingPlanMapper.updatePlanStatusByIdList(collect, EduTrainingPlanStatus.USING.getCode());
+        }
         //下发后修改为使用中
         plan.setPlanStatus(EduTrainingPlanStatus.USING.getCode());
         plan.setIssue(1);
         this.updateById(plan);
         //事务提交后执行
+        List<CoreEduTrainingPlan> finalPlanList = planList;
         TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
             @Override
             public void afterCommit() {
-                for (CoreEduTrainingPlan trainingPlan : list) {
+                for (CoreEduTrainingPlan trainingPlan : finalPlanList) {
                     CompletableFuture.runAsync(() -> {
                         //如果不是省联社或者办事处，状态启用，并且是无周期或者立即生效
                         if ((ObjectUtil.equal(EduTrainingPlanStatus.USING.getCode(), plan.getPlanStatus())
@@ -682,7 +605,7 @@ public class CoreEduTrainingPlanServiceImpl extends ServiceImpl<CoreEduTrainingP
         DateRange range = DateUtils.getStartAndEnd(new Date(), plan.getPlanCycle());
         List<Long> list = coreEduTrainingPlanMapper.selectIdByParentId(planId);
         coreEduTrainingPlanMapper.updatePlanStatusByIdOrParentId(planId, EduTrainingPlanStatus.DELETED.getCode());
-        coreEduTrainingTaskService.delByStartTimeAndEndTimeAndPlanIdList(list,range.getStartTime(),range.getEndTime());
+        coreEduTrainingTaskService.delByStartTimeAndEndTimeAndPlanIdList(list, range.getStartTime(), range.getEndTime());
         return coreEduTrainingPlanMapper.updateById(plan);
     }
 

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/edu/service/impl/CoreEduTrainingTaskServiceImpl.java

@@ -390,7 +390,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
 
         if (plan.getPlanCycle() != 0) {
             //如果不是无周期的计划，那么需要查询出他的时间范围
-            DateRange dateRange = DateUtils.getStartAndEnd(new Date(),EduTrainingPlanCycleEnum.toCommmonEnum( plan.getPlanCycle()));
+            DateRange dateRange = DateUtils.getStartAndEnd(new Date(), EduTrainingPlanCycleEnum.toCommmonEnum(plan.getPlanCycle()));
             start = dateRange.getStartTime();
             end = dateRange.getEndTime();
         } else {
@@ -735,7 +735,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
                 //此处因为planService会导致循环依赖
                 final CoreEduTrainingPlanDataVo detailPlanData = coreEduTrainingPlanMapper.getDetailPlanData(plan.getId());
                 detailPlanData.setFileList(ObjectUtil.isNotEmpty(detailPlanData.getFile()) ? JSON.parseArray(detailPlanData.getFile(), String.class) : null);
-                DateRange range = DateUtils.getStartAndEnd(finalDate,EduTrainingPlanCycleEnum.toCommmonEnum( plan.getPlanCycle()) );
+                DateRange range = DateUtils.getStartAndEnd(finalDate, EduTrainingPlanCycleEnum.toCommmonEnum(plan.getPlanCycle()));
                 this.createTaskForNow(detailPlanData, range.getStartTime(), range.getEndTime());
             }, threadPoolTaskExecutor);
 
@@ -748,6 +748,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void delTaskByIdList(List<Long> taskIdList) {
         if (ObjectUtil.isNotEmpty(taskIdList)) {
             coreEduTrainingTaskMapper.deleteBatchIds(taskIdList);
@@ -759,11 +760,12 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void delByStartTimeAndEndTimeAndPlanIdList(List<Long> planIdList, Date startTime, Date endTime) {
         if (ObjectUtil.isNotEmpty(planIdList)) {
             List<CoreEduTrainingTask> taskList = lambdaQuery()
-                    .ge(CoreEduTrainingTask::getStartDate, startTime)
-                    .le(CoreEduTrainingTask::getEndDate, endTime)
+                    .ge(ObjectUtil.isNotNull(startTime), CoreEduTrainingTask::getStartDate, startTime)
+                    .le(ObjectUtil.isNotNull(endTime), CoreEduTrainingTask::getEndDate, endTime)
                     .in(CoreEduTrainingTask::getPlanId, planIdList)
                     .select(CoreEduTrainingTask::getId)
                     .list();
@@ -916,7 +918,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     private void dealTimeWorkChangeForMonthly(WorkTimeChangeEvent event, String todayStr, List<SysWorkTime> futureWorkTime) {
         List<Long> orgIds = event.getOrgIds();
         DateTime today = DateUtil.parse(todayStr, Constants.DAILY_FORMAT);
-        DateRange dateRange = DateUtils.getStartAndEnd(today,CycleCommonEnum.MONTHLY);
+        DateRange dateRange = DateUtils.getStartAndEnd(today, CycleCommonEnum.MONTHLY);
         //查询机构当周是否存在任务
         List<CoreEduTrainingTask> taskList = lambdaQuery()
                 .eq(CoreEduTrainingTask::getPlanCycle, EduTrainingPlanCycleEnum.MONTHLY.getCode())
@@ -962,7 +964,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     private void dealTimeWorkChangeForQuarterly(WorkTimeChangeEvent event, String todayStr, List<SysWorkTime> futureWorkTime) {
         List<Long> orgIds = event.getOrgIds();
         DateTime today = DateUtil.parse(todayStr, Constants.DAILY_FORMAT);
-        DateRange dateRange = DateUtils.getStartAndEnd(today,CycleCommonEnum.QUARTERLY);
+        DateRange dateRange = DateUtils.getStartAndEnd(today, CycleCommonEnum.QUARTERLY);
         //查询机构当周是否存在任务
         List<CoreEduTrainingTask> taskList = lambdaQuery()
                 .eq(CoreEduTrainingTask::getPlanCycle, EduTrainingPlanCycleEnum.QUARTERLY.getCode())
@@ -1008,7 +1010,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     private void dealTimeWorkChangeForHalfYearly(WorkTimeChangeEvent event, String todayStr, List<SysWorkTime> futureWorkTime) {
         List<Long> orgIds = event.getOrgIds();
         DateTime today = DateUtil.parse(todayStr, Constants.DAILY_FORMAT);
-        DateRange dateRange = DateUtils.getStartAndEnd(today,CycleCommonEnum.HALF_YEARLY);
+        DateRange dateRange = DateUtils.getStartAndEnd(today, CycleCommonEnum.HALF_YEARLY);
         //查询机构当周是否存在任务
         List<CoreEduTrainingTask> taskList = lambdaQuery()
                 .eq(CoreEduTrainingTask::getPlanCycle, EduTrainingPlanCycleEnum.HALF_YEARLY.getCode())
@@ -1055,7 +1057,7 @@ public class CoreEduTrainingTaskServiceImpl extends ServiceImpl<CoreEduTrainingT
     private void dealTimeWorkChangeForYearly(WorkTimeChangeEvent event, String todayStr, List<SysWorkTime> futureWorkTime) {
         List<Long> orgIds = event.getOrgIds();
         DateTime today = DateUtil.parse(todayStr, Constants.DAILY_FORMAT);
-        DateRange dateRange = DateUtils.getStartAndEnd(today,CycleCommonEnum.YEARLY);
+        DateRange dateRange = DateUtils.getStartAndEnd(today, CycleCommonEnum.YEARLY);
         //查询机构当周是否存在任务
         List<CoreEduTrainingTask> taskList = lambdaQuery()
                 .eq(CoreEduTrainingTask::getPlanCycle, EduTrainingPlanCycleEnum.YEARLY.getCode())

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/listener/WorkTimeChangeEventListener.java

@@ -31,9 +31,9 @@ public class WorkTimeChangeEventListener implements ApplicationListener<WorkTime
 
     private void eduTask(WorkTimeChangeEvent event) {
         try {
-            log.info("鏁欒偛鍩硅�寮€濮嬪�鐞嗘満鏋勪綔鎭�彉鏇�");
+            log.info("教育培训开始处理机构作息变更");
             coreEduTrainingTaskService.taskChangeForTimeWorkChange(event);
-            log.info("鏁欒偛鍩硅�缁撴潫澶勭悊鏈烘瀯浣滄伅鍙樻洿");
+            log.info("教育培训结束处理机构作息变更");
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
@@ -42,9 +42,9 @@ public class WorkTimeChangeEventListener implements ApplicationListener<WorkTime
 
     private void resumptionTask(WorkTimeChangeEvent event) {
         try {
-            log.info("灞ヨ亴寮€濮嬪�鐞嗘満鏋勪綔鎭�彉鏇�");
+            log.info("履职开始处理机构作息变更");
             rebuildResumptionTaskBusiness.rebuildTask(event);
-            log.info("灞ヨ亴缁撴潫澶勭悊鏈烘瀯浣滄伅鍙樻洿");
+            log.info("履职结束处理机构作息变更");
         } catch (Exception e) {
             log.error(e.getMessage(), e);
         }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/controller/ApiPlanController.java

@@ -70,12 +70,11 @@ public class ApiPlanController {
     public AjaxResult distribute(@RequestBody DistributeDto dto) {
         try {
             appPlanService.distributeToOrg(dto);
-            AppPlanVo plan = appPlanService.findById(dto.getId());
+            AppPlan plan = appPlanService.getById(dto.getId());
             //如果选择了计划立即生效
             if (plan.getBuildTaskNow()==1) {
                 DateTime datetime = new DateTime();
                 datetime.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
-                //当有周期存在时保持原有接口不变（doTask），否则按照新的接口创建
                 Integer plancycle = plan.getPlanCycle();
                 if (plancycle != null) {
                     if (plancycle == 2) {
@@ -147,33 +146,46 @@ public class ApiPlanController {
     public AjaxResult edit(@RequestBody AppPlanVo info) {
         try {
             appPlanService.saveOrUpdatePlan(info);
-            //立即执行
-            if (info.getExecOrgType()==3&&info.getBuildTaskNow()==1) {
-                DateTime datetime = new DateTime();
-                datetime.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
-                //当有周期存在时保持原有接口不变（doTask），否则按照新的接口创建
-                Integer plancycle = info.getPlanCycle();
-                if (plancycle != null) {
-                    if (plancycle == 2) {
-                        taskBusiness.syncDay(datetime, plancycle);
-                    }
-                    if (plancycle == 3) {
-                        taskBusiness.syncWeek(datetime, plancycle);
-                    }
-                    if (plancycle == 4) {
-                        taskBusiness.syncMonth(datetime, plancycle);
-                    }
-                    if (plancycle == 5) {
-                        taskBusiness.syncQuarter(datetime, plancycle);
-                    }
-                    if (plancycle == 6) {
-                        taskBusiness.syncHalfYear(datetime, plancycle);
-                    }
-                    if (plancycle == 7) {
-                        taskBusiness.syncYear(datetime, plancycle);
+            Long planOfOrgType = null;
+            if (info.getId()==null){
+                Long orgId = info.getPlanCreateOrgId();
+                planOfOrgType = Long.valueOf(remoteOrgService.selectSysOrgById(orgId, SecurityConstants.INNER).getType());
+            }else {
+                AppPlan plan = appPlanService.getById(info.getId());
+                planOfOrgType = plan.getPlanOfOrgType();
+            }
+            //判断是否是编辑并且计划所属任务不存在已完成或者逾期,需要删除所有任务重新生成
+            boolean isEditAll = info.getHasEdit() == null&&info.getId()!=null;
+            //如果计划所属机构类型为行社并且勾选立即执行,新增的时候立即生成任务
+            if ((info.getId()==null&&planOfOrgType==3&&info.getBuildTaskNow()==1)||isEditAll){
+                    DateTime datetime = new DateTime();
+                    datetime.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+                    //当有周期存在时保持原有接口不变（doTask），否则按照新的接口创建
+                    Integer plancycle = info.getPlanCycle();
+                    if (plancycle != null) {
+                        if (plancycle == 2) {
+                            taskBusiness.syncDay(datetime, plancycle);
+                        }
+                        if (plancycle == 3) {
+                            taskBusiness.syncWeek(datetime, plancycle);
+                        }
+                        if (plancycle == 4) {
+                            taskBusiness.syncMonth(datetime, plancycle);
+                        }
+                        if (plancycle == 5) {
+                            taskBusiness.syncQuarter(datetime, plancycle);
+                        }
+                        if (plancycle == 6) {
+                            taskBusiness.syncHalfYear(datetime, plancycle);
+                        }
+                        if (plancycle == 7) {
+                            taskBusiness.syncYear(datetime, plancycle);
+                        }
                     }
-                }
+
             }
+
+
             return AjaxResult.success();
         } catch (Exception e) {
             e.printStackTrace();
@@ -209,7 +221,36 @@ public class ApiPlanController {
     @GetMapping(value = "/distributeCheHui/{id}")
 //    @RequiresPermissions("core:plan:findById")
     public AjaxResult distributeCheHui(@PathVariable Long id) {
-        return AjaxResult.success(appPlanService.distributeCheHui(id));
+        int i = appPlanService.distributeCheHui(id);
+        AppPlan plan = appPlanService.getById(id);
+        //撤回后的下发如果存在子计划并且勾选立即执行也需要生成任务
+        if(i>0&&plan.getBuildTaskNow()==1){
+            DateTime datetime = new DateTime();
+            datetime.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+            //当有周期存在时保持原有接口不变（doTask），否则按照新的接口创建
+            Integer plancycle = plan.getPlanCycle();
+            if (plancycle != null) {
+                if (plancycle == 2) {
+                    taskBusiness.syncDay(datetime, plancycle);
+                }
+                if (plancycle == 3) {
+                    taskBusiness.syncWeek(datetime, plancycle);
+                }
+                if (plancycle == 4) {
+                    taskBusiness.syncMonth(datetime, plancycle);
+                }
+                if (plancycle == 5) {
+                    taskBusiness.syncQuarter(datetime, plancycle);
+                }
+                if (plancycle == 6) {
+                    taskBusiness.syncHalfYear(datetime, plancycle);
+                }
+                if (plancycle == 7) {
+                    taskBusiness.syncYear(datetime, plancycle);
+                }
+            }
+        }
+        return AjaxResult.success(i);
     }
 
     @ApiOperation(value = "获取详情")

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/domain/AppPlan.java

@@ -102,6 +102,10 @@ public class AppPlan extends Model<AppPlan> implements Serializable {
      */
     private Long planOfOrgId;
     /**
+     * 计划所属机构类型
+     */
+    private Long planOfOrgType;
+    /**
      * 计划执行次数
      */
     private String count;

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/domain/AppPlanToPoint.java

@@ -40,4 +40,5 @@ public class AppPlanToPoint extends Model<AppPlanToPoint> implements Serializabl
      * 检查要点是否必须检查
      */
     private boolean required;
+    private Long ofOrgId;
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/listener/WorkTimeChangeEventListener.java

@@ -1,27 +0,0 @@
-package com.xunmei.core.resumption.listener;
-
-import com.xunmei.common.core.event.WorkTimeChangeEvent;
-import com.xunmei.core.resumption.task.RebuildResumptionTaskBusiness;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationListener;
-import org.springframework.context.event.EventListener;
-import org.springframework.stereotype.Component;
-import org.springframework.transaction.event.TransactionPhase;
-import org.springframework.transaction.event.TransactionalEventListener;
-
-@Component
-public class WorkTimeChangeEventListener implements ApplicationListener<WorkTimeChangeEvent> {
-
-    @Autowired
-    private RebuildResumptionTaskBusiness rebuildTaskBusiness;
-
-    @Override
-    @EventListener(WorkTimeChangeEvent.class)
-    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
-    public void onApplicationEvent(WorkTimeChangeEvent event) {
-
-        rebuildTaskBusiness.rebuildTask(event);
-
-
-    }
-}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/service/impl/AppPlanServiceImpl.java

@@ -9,6 +9,8 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.xunmei.common.core.constant.SecurityConstants;
+import com.xunmei.common.core.domain.DateRange;
+import com.xunmei.common.core.utils.DateUtils;
 import com.xunmei.common.security.utils.SecurityUtils;
 import com.xunmei.core.resumption.domain.*;
 import com.xunmei.core.resumption.dto.DistributeDto;
@@ -138,47 +140,53 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
 
     @Override
     public void distributeToOrg(DistributeDto dto) {
-        for (DistributeStatusDto d :
-                dto.getOrgAndStatus()) {
-
-            AppPlan plan = baseMapper.selectById(dto.getId());
-            plan.setOrgId(d.getOrgId().toString());
-            plan.setDistributeStatus("1");
-            plan.setPlanOfOrgId(d.getOrgId());
-            plan.setPlanStatus(d.getStatus());
-            plan.setDistributePlanStatus(d.getStatus().toString());
-            plan.setCreateTime(new Date());
-            plan.setId(null);
+        //如果计划所属机构类型为省联社,生成下发子计划
+        if (baseMapper.selectById(dto.getId()).getPlanOfOrgType() == 1) {
+            for (DistributeStatusDto d :
+                    dto.getOrgAndStatus()) {
+
+                AppPlan plan = baseMapper.selectById(dto.getId());
+                plan.setOrgId(d.getOrgId().toString());
+                plan.setDistributeStatus("1");
+                plan.setPlanOfOrgId(d.getOrgId());
+                plan.setPlanOfOrgType(Long.valueOf(orgService.selectSysOrgById(d.getOrgId(), SecurityConstants.INNER).getType()));
+                plan.setPlanStatus(d.getStatus());
+                plan.setDistributePlanStatus(d.getStatus().toString());
+                plan.setCreateTime(new Date());
+                plan.setId(null);
 //            plan.setPlanName(plan.getPlanName()+"下发"+orgService.selectOrgById(d.getOrgId(),SecurityConstants.INNER).getName());
-            plan.setPlanName(plan.getPlanName());
-            plan.setParentId(dto.getId());
-            baseMapper.insert(plan);
-            Long id = plan.getId();
+                plan.setPlanName(plan.getPlanName());
+                plan.setParentId(dto.getId());
+                baseMapper.insert(plan);
+                Long id = plan.getId();
 
-            List<Long> roleList = appPlanToRoleMapper.selectList(new LambdaQueryWrapper<AppPlanToRole>().eq(AppPlanToRole::getPlanId, dto.getId())).stream().map(AppPlanToRole::getRoleId).collect(Collectors.toList());
-            AppPlanToRole atr = null;
-            for (Long roleId : roleList) {
-                atr = new AppPlanToRole();
-                atr.setRoleId(roleId);
-                atr.setPlanId(id);
-                appPlanToRoleMapper.insert(atr);
-            }
+                List<Long> roleList = appPlanToRoleMapper.selectList(new LambdaQueryWrapper<AppPlanToRole>().eq(AppPlanToRole::getPlanId, dto.getId())).stream().map(AppPlanToRole::getRoleId).collect(Collectors.toList());
+                AppPlanToRole atr = null;
+                for (Long roleId : roleList) {
+                    atr = new AppPlanToRole();
+                    atr.setRoleId(roleId);
+                    atr.setPlanId(id);
+                    appPlanToRoleMapper.insert(atr);
+                }
 
-            List<AppPlanToPoint> itemList = appPlanToItemMapper.selectList(new LambdaQueryWrapper<AppPlanToPoint>().eq(AppPlanToPoint::getPlanId, dto.getId()));
-            AppPlanToPoint item = null;
-            for (AppPlanToPoint ruleItemVo : itemList) {
-                item = new AppPlanToPoint();
-                item.setPointId(ruleItemVo.getPointId());
-                item.setPlanId(id);
-                item.setPointScan(ruleItemVo.isPointScan());
-                item.setRequired(ruleItemVo.isRequired());
-                appPlanToItemMapper.insert(item);
+                List<AppPlanToPoint> itemList = appPlanToItemMapper.selectList(new LambdaQueryWrapper<AppPlanToPoint>().eq(AppPlanToPoint::getPlanId, dto.getId()));
+                AppPlanToPoint item = null;
+                for (AppPlanToPoint ruleItemVo : itemList) {
+                    item = new AppPlanToPoint();
+                    item.setPointId(ruleItemVo.getPointId());
+                    item.setPlanId(id);
+                    item.setPointScan(ruleItemVo.isPointScan());
+                    item.setRequired(ruleItemVo.isRequired());
+                    appPlanToItemMapper.insert(item);
+                }
             }
         }
-        //修改下发标识
+        //更新下发标识
         AppPlan plan = new AppPlan();
         plan.setId(dto.getId());
+        //设置下发状态1
         plan.setDistribute("1");
+        //设置计划状态为使用中
         plan.setPlanStatus(1);
         plan.setBuildTaskNow(null);
         baseMapper.updateById(plan);
@@ -194,12 +202,19 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
 //修改计划状态为停用
             ap.setPlanStatus(2);
             baseMapper.updateById(ap);
+            //撤回需要删除本周期所有任务
+            DateRange dateRange = DateUtils.getStartAndEnd(new Date(), plan.getPlanCycle());
+            resumptionMapper.delete(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, plan.getId()).between(Resumption::getYmdDate, dateRange.getStartTime(), dateRange.getEndTime()));
+
         }
         //设置下发状态为未下发
         plan.setDistribute("0");
-        plan.setPlanStatus(0);
+        plan.setPlanStatus(2);
         baseMapper.updateById(plan);
 
+//撤回需要删除本周期所有任务
+        DateRange dateRange = DateUtils.getStartAndEnd(new Date(), plan.getPlanCycle());
+        resumptionMapper.delete(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, plan.getId()).between(Resumption::getYmdDate, dateRange.getStartTime(), dateRange.getEndTime()));
 
     }
 
@@ -281,14 +296,17 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
             if (size > 0) {
                 throw new RuntimeException("计划名称重复，请确认！");
             }
-            //如果计划为行社并且勾选立即生效
-            if (app.getExecOrgType() == 3 && app.getBuildTaskNow()==1) {
+
+            plan.setBuildTaskNow(app.getBuildTaskNow());
+            plan.setDistribute("0");
+            //设置计划所属机构类型
+            plan.setPlanOfOrgType(Long.valueOf(orgService.selectSysOrgById(app.getPlanCreateOrgId(), SecurityConstants.INNER).getType()));
+            //如果计划所属机构类型为行社并且勾选立即生效
+            if (plan.getPlanOfOrgType() == 3 && plan.getBuildTaskNow() == 1) {
                 plan.setPlanStatus(1);
             } else {
                 plan.setPlanStatus(0);
             }
-            plan.setBuildTaskNow(app.getBuildTaskNow());
-            plan.setDistribute("0");
             baseMapper.insert(plan);
             Long id = plan.getId();
 
@@ -314,61 +332,26 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 item.setPlanId(id);
                 item.setPointScan(ruleItemVo.isPointScan());
                 item.setRequired(ruleItemVo.isRequired());
+                item.setOfOrgId(ruleItemVo.getOfOrgId());
                 appPlanToItemMapper.insert(item);
             }
-
-
-//            Integer orgId = app.getExecOrgType();
-//            if (orgId != null) {
-//                AppPlanToCheckOrg checkOrg = new AppPlanToCheckOrg();
-//                AppPlanToExecOrg execOrg = new AppPlanToExecOrg();
-//                List<SysOrg> sysOrgs = orgService.selectByOrgType(orgId, SecurityConstants.INNER);
-//                List<Long> orgids = sysOrgs.stream().map(SysOrg::getId).collect(Collectors.toList());
-//                for (Long i :
-//                        orgids) {
-//                    checkOrg.setOrgId(i);
-//                    checkOrg.setPlanId(id);
-//                    execOrg.setOrgId(i);
-//                    execOrg.setPlanId(id);
-//                    appPlanToCheckOrgMapper.insert(checkOrg);
-//                    appPlanToExecOrgMapper.insert(execOrg);
-//                }
-//
-//
-//
-//            }
         } else {
             if (app.getRoleList() == null) {
                 app.setRoleList(new ArrayList<>());
             }
 
-            //获取计划对应的已完成任务数量
-            Long num = resumptionMapper.selectCount(new QueryWrapper<Resumption>().eq("plan_id", app.getId()).eq("status", 3));
-            if (num > 0) {
-                //如果状态为已禁用
-                if (app.getPlanStatus() == 0) {
-                    throw new RuntimeException("计划已生成任务，不能禁用！");
-                }
-
-            }
-
             //修改所有子计划
             List<AppPlan> appPlans = baseMapper.selectList(new LambdaQueryWrapper<AppPlan>().eq(AppPlan::getParentId, plan.getId()));
             for (AppPlan ap :
                     appPlans) {
-                Long nums = resumptionMapper.selectCount(new QueryWrapper<Resumption>().eq("plan_id", ap.getId()).eq("status", 3));
-                if (nums > 0) {
-                    if (app.getPlanStatus() == 0) {
-                        throw new RuntimeException("计划已生成任务，不能禁用！");
-                    }
-                }
-                ap.setPlanName(plan.getPlanName());
+
                 ap.setPlanType(plan.getPlanType());
                 ap.setPlanCycle(plan.getPlanCycle());
-//                ap.setPlanStatus(plan.getPlanStatus());
                 ap.setExecOrgType(plan.getExecOrgType());
                 ap.setPlanExec(plan.getPlanExec());
                 ap.setModifiedBy(SecurityUtils.getUserId());
+                ap.setPlanName(plan.getPlanName());
+
                 baseMapper.updateById(ap);
 
                 if (app.getRoleList().size() > 0) {
@@ -378,7 +361,7 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 }
 
                 QueryWrapper<AppPlanToPoint> api = new QueryWrapper<>();
-                api.lambda().eq(AppPlanToPoint::getPlanId, ap.getId());
+                api.lambda().eq(AppPlanToPoint::getPlanId, ap.getId()).eq(AppPlanToPoint::getOfOrgId,app.getPlanCreateOrgId());
                 appPlanToItemMapper.delete(api);
 
                 List<Long> roleList = app.getRoleList();
@@ -391,8 +374,10 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 }
 
 
-                List<RuleItemVo> itemList = app.getItemList();
-                if (itemList.size() == 0) {
+                List<RuleItemVo> valitemList = app.getItemList();
+                List<RuleItemVo> itemList = valitemList.stream().filter(e-> e.getOfOrgId().equals(app.getPlanCreateOrgId())).collect(Collectors.toList());
+
+                if (valitemList.size() == 0) {
                     throw new RuntimeException("请选择履职要点");
                 }
                 AppPlanToPoint item = null;
@@ -402,9 +387,16 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                     item.setPlanId(ap.getId());
                     item.setPointScan(ruleItemVo.isPointScan());
                     item.setRequired(ruleItemVo.isRequired());
+                    item.setOfOrgId(ruleItemVo.getOfOrgId());
                     appPlanToItemMapper.insert(item);
                 }
-
+                //如果计划是编辑全部,代表不存在已完成或者逾期的任务,需要删除重新生成
+                if (app.getHasEdit() == null) {
+                    resumptionMapper.delete(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, ap.getId()));
+                }else {
+                    //否则代表编辑名称,需要同步未进行的任务名称
+                    resumptionMapper.updateNameByPlanId(app.getPlanName(),ap.getId());
+                }
 
             }
 
@@ -419,7 +411,7 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
 
 
             QueryWrapper<AppPlanToPoint> api = new QueryWrapper<>();
-            api.lambda().eq(AppPlanToPoint::getPlanId, id);
+            api.lambda().eq(AppPlanToPoint::getPlanId, id).eq(AppPlanToPoint::getOfOrgId,app.getPlanCreateOrgId());
             appPlanToItemMapper.delete(api);
 
 
@@ -438,8 +430,10 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 appPlanToRoleMapper.insert(atr);
             }
 
-            List<RuleItemVo> itemList = app.getItemList();
-            if (itemList.size() == 0) {
+            List<RuleItemVo> valitemList = app.getItemList();
+            List<RuleItemVo> itemList = valitemList.stream().filter(e-> e.getOfOrgId().equals(app.getPlanCreateOrgId())).collect(Collectors.toList());
+
+            if (valitemList.size() == 0) {
                 throw new RuntimeException("请选择履职要点");
             }
             AppPlanToPoint item = null;
@@ -449,6 +443,7 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 item.setPlanId(id);
                 item.setPointScan(ruleItemVo.isPointScan());
                 item.setRequired(ruleItemVo.isRequired());
+                item.setOfOrgId(ruleItemVo.getOfOrgId());
                 appPlanToItemMapper.insert(item);
             }
 
@@ -473,6 +468,10 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
             plan.setPlanCreateOrgId(null);
             plan.setPlanCreateOrgName(null);
             baseMapper.updateById(plan);
+            //如果计划是编辑全部,代表不存在已完成或者逾期的任务,需要删除重新生成
+            if (app.getHasEdit() == null) {
+                resumptionMapper.delete(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, plan.getId()));
+            }
         }
     }
 
@@ -482,6 +481,27 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
         AppPlan appPlan = baseMapper.selectById(id);
 
         AppPlanVo appPlanVo = convertToAppPlanVo(appPlan);
+        //查询计划是否存在对应的状态为完成或者逾期的任务
+        List<Integer> status = new ArrayList<>();
+        status.add(3);
+        status.add(4);
+        Long sum = resumptionMapper.selectCount(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, id).in(Resumption::getStatus, status));
+        if (sum > 0) {
+            //如果存在完成或者逾期的任务设置编辑状态为1
+            appPlanVo.setHasEdit(1);
+        }
+        //查找子计划是否存在完成或者逾期的任务
+        List<AppPlan> appPlans = baseMapper.selectList(new LambdaQueryWrapper<AppPlan>().eq(AppPlan::getParentId, id));
+        for (AppPlan p :
+                appPlans) {
+            Long csum = resumptionMapper.selectCount(new LambdaQueryWrapper<Resumption>().eq(Resumption::getPlanId, p.getId()).in(Resumption::getStatus, status));
+            if (csum > 0) {
+                //如果存在完成或者逾期的任务设置编辑状态为1
+                appPlanVo.setHasEdit(1);
+                break;
+            }
+        }
+
         SysOrg org = orgService.selectSysOrgById(appPlan.getPlanCreateOrgId(), SecurityConstants.INNER);
         appPlanVo.setPlanCreateOrgType(org.getType());
         QueryWrapper<AppPlanToRole> apr = new QueryWrapper<>();
@@ -531,9 +551,9 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
         /**
          * 验证计划是否被应用
          */
-        Long num = resumptionMapper.selectCount(new QueryWrapper<Resumption>().eq("plan_id", id).eq("status", 3));
+        Long num = resumptionMapper.selectCount(new QueryWrapper<Resumption>().eq("plan_id", id).in("status", 3,4));
         if (num > 0) {
-            throw new RuntimeException("计划已生成任务，不能删除！");
+            throw new RuntimeException("计划有已完成或者已逾期的任务，不能被删除。");
         }
         //查找子计划
         List<AppPlan> childrens = baseMapper.selectList(new LambdaQueryWrapper<AppPlan>().eq(AppPlan::getParentId, id));
@@ -543,7 +563,7 @@ public class AppPlanServiceImpl extends ServiceImpl<AppPlanMapper, AppPlan> impl
                 childrens) {
             Long nums = resumptionMapper.selectCount(new QueryWrapper<Resumption>().eq("plan_id", ap.getId()).eq("status", 3));
             if (nums > 0) {
-                throw new RuntimeException("子计划已生成任务，不能删除！");
+                throw new RuntimeException("子计划有已完成或者已逾期的任务，不能被删除。");
             }
             //删除计划对应的任务
             resumptionMapper.delete(new QueryWrapper<Resumption>().eq("plan_id", ap.getId()));

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/task/ResumptionTaskBusiness.java

@@ -200,15 +200,11 @@ public class ResumptionTaskBusiness extends TaskCreatingServiceImplBase<AppPlanM
      */
     @Async
     public void syncDay(final DateTime dateTime, int plancycle) {//plancycle==0
-//        R<SysConfig> officeBuilding_open_allhours = systemParameService.findFirstByCode("officeBuilding_open_allhours", SecurityConstants.INNER);
-//        SysConfig officeAllHourParam = officeBuilding_open_allhours.getData();
         //获取履职计划
         List<AppPlan> AppPlanList = appPlanService.list((new QueryWrapper<AppPlan>()).lambda()
                 .eq(AppPlan::getPlanStatus, 1)
                 .eq(AppPlan::getPlanCycle, plancycle)
                 .in(AppPlan::getPlanOfOrgId, getHangsheOrgIds()));
-//                .eq(AppPlan::getPlanType, 1)
-//                .notIn(AppPlan::getPlanExec, canteenPlanExec));
         for (AppPlan appPlan : AppPlanList) {
             //获取履职计划中对应的检查要点
             List<AppRulePointTaskVo> pointList = appRulePointService.findPointByPlan(appPlan.getId());

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/vo/appPlan/AppPlanVo.java

@@ -24,6 +24,8 @@ public class AppPlanVo extends PageDto<AppPlan> {
     private List<Long> ids;
     private Long id;
     private Integer buildTaskNow;
+    //涉及编辑内容
+    private Integer hasEdit;
     /**
      * 计划名称
      */

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/resumption/vo/appPlan/RuleItemVo.java

@@ -48,6 +48,10 @@ public class RuleItemVo {
      * 区域Id
      */
     private Long areaId;
+    /**
+     * 检查点所属机构id
+     */
+    private Long ofOrgId;
 
 
     /**

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/retrieval/service/ICoreMonitoringRetrievalTaskService.java

@@ -8,6 +8,7 @@ import com.xunmei.common.core.domain.retrieval.domain.CoreMonitoringRetrievalTas
 import com.xunmei.common.core.domain.retrieval.dto.RetrievalTaskPageDto;
 import com.xunmei.common.core.domain.retrieval.vo.CoreMonitoringRetrievalTaskOneVo;
 import com.xunmei.common.core.domain.safetyindex.domain.CoreSafetyExceptionData;
+import com.xunmei.common.core.event.WorkTimeChangeEvent;
 import com.xunmei.common.core.web.page.TableDataInfo;
 import com.xunmei.core.access.domain.TMonitoringRetrievalPlan;
 import com.xunmei.core.access.dto.CoreMonitoringTaskRegistrationDTO;
@@ -115,4 +116,6 @@ public interface ICoreMonitoringRetrievalTaskService extends IService<CoreMonito
     List<PanelListVo> selectCurUserTaskList(PanelListDto panelListDto);
 
     List<CoreSafetyExceptionData> selectMonitorExceptionData(DateTime time);
+
+    void taskChangeForTimeWorkChange(WorkTimeChangeEvent event);
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/retrieval/service/impl/CoreMonitoringRetrievalTaskServiceImpl.java

@@ -10,6 +10,7 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.xunmei.common.core.constant.Constants;
 import com.xunmei.common.core.constant.ErrorMsgConstants;
 import com.xunmei.common.core.constant.SecurityConstants;
 import com.xunmei.common.core.domain.DateRange;
@@ -23,10 +24,15 @@ import com.xunmei.common.core.domain.retrieval.vo.CoreMonitoringRetrievalTaskOne
 import com.xunmei.common.core.domain.retrieval.vo.CoreMonitoringRetrievalTaskVo;
 import com.xunmei.common.core.domain.retrieval.vo.TaskDataVo;
 import com.xunmei.common.core.domain.safetyindex.domain.CoreSafetyExceptionData;
+import com.xunmei.common.core.domain.worktime.domain.SysWorkTime;
+import com.xunmei.common.core.domain.worktime.dto.WorkTimeDto;
+import com.xunmei.common.core.enums.CycleCommonEnum;
 import com.xunmei.common.core.enums.EduTrainingPlanCycleEnum;
 import com.xunmei.common.core.enums.RetrievalTaskCycle;
+import com.xunmei.common.core.event.WorkTimeChangeEvent;
 import com.xunmei.common.core.utils.DateHelper;
 import com.xunmei.common.core.utils.DateUtils;
+import com.xunmei.common.core.utils.KeyValue;
 import com.xunmei.common.core.utils.Ymd;
 import com.xunmei.common.core.web.domain.AjaxResult;
 import com.xunmei.common.core.web.page.TableDataInfo;
@@ -50,14 +56,13 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.net.URLEncoder;
-import java.time.DayOfWeek;
-import java.time.LocalDate;
-import java.time.ZoneId;
+import java.time.*;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -491,7 +496,7 @@ public class CoreMonitoringRetrievalTaskServiceImpl extends ServiceImpl<CoreMoni
             taskList.add(task);
         }
         //判断作息（无周期排开）
-        if(!plan.getPlanCycle().equals(RetrievalTaskCycle.NOCYCLE.getCode())){
+        if(!plan.getPlanCycle().equals(RetrievalTaskCycle.NOCYCLE.getCode().toString())){
             boolean flag = checkWorkTime(dateRange.getStartTime(), dateRange.getEndTime(), sysOrg.getId());
             if(flag){
                 for (int i = 1; i <= plan.getPlanFrequency(); i++) {
@@ -584,6 +589,202 @@ public class CoreMonitoringRetrievalTaskServiceImpl extends ServiceImpl<CoreMoni
         return Stream.of(overTimeExceptionData, numsExceptionData).flatMap(Collection::stream).collect(Collectors.toList());
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void taskChangeForTimeWorkChange(WorkTimeChangeEvent event) {
+        //修改的作息的日期
+        Date ymdDate  =  event.getDataList().get(0).getDate();
+
+        //受影响的机构
+        List<Long> orgIds = event.getOrgIds();
+        //判断ymdDate是否是当天
+        Date today = new Date();
+        //要删除的任务
+        List<CoreMonitoringRetrievalTask> deleteTaskList = new ArrayList<>();
+        //要重新生成任务的机构和计划
+        List<KeyValue> keyValues = new ArrayList<>();
+        //判断ymdDate 月today是否是同一日期
+        if(DateUtil.isSameDay(ymdDate,today)){
+           //获取当天的调阅任务
+            Map<String,Object> dayObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.DAYCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> list = (List<CoreMonitoringRetrievalTask>) dayObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(list)){
+                deleteTaskList.addAll(list);
+            }
+            List<KeyValue> keyValueList = (List<KeyValue>) dayObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueList)){
+                keyValues.addAll(keyValueList);
+            }
+        }else{
+            //周
+            Map<String,Object> weekObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.WEEKCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> listweek = (List<CoreMonitoringRetrievalTask>) weekObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(listweek)){
+                deleteTaskList.addAll(listweek);
+            }
+            List<KeyValue> keyValueListweek = (List<KeyValue>) weekObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueListweek)){
+                keyValues.addAll(keyValueListweek);
+            }
+            //月
+            Map<String,Object> monthObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.MONTHCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> listmonth = (List<CoreMonitoringRetrievalTask>) monthObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(listmonth)){
+                deleteTaskList.addAll(listmonth);
+            }
+            List<KeyValue> keyValueListmonth = (List<KeyValue>) monthObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueListmonth)){
+                keyValues.addAll(keyValueListmonth);
+            }
+            //季度
+            Map<String,Object> quarterObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.QUARTERCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> listquarter = (List<CoreMonitoringRetrievalTask>) quarterObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(listquarter)){
+                deleteTaskList.addAll(listquarter);
+            }
+            List<KeyValue> keyValueListquarter = (List<KeyValue>) quarterObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueListquarter)){
+                keyValues.addAll(keyValueListquarter);
+            }
+            //半年
+            Map<String,Object> halfYearObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.HALFYEARCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> listhalfYear = (List<CoreMonitoringRetrievalTask>) halfYearObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(listhalfYear)){
+                deleteTaskList.addAll(listhalfYear);
+            }
+            List<KeyValue> keyValueListhalfYear = (List<KeyValue>) halfYearObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueListhalfYear)){
+                keyValues.addAll(keyValueListhalfYear);
+            }
+            //年
+            Map<String,Object> yearObjectMap = this.deleteTaskList(ymdDate,orgIds,RetrievalTaskCycle.YEARCYCLE.getCode());
+            List<CoreMonitoringRetrievalTask> listYear = (List<CoreMonitoringRetrievalTask>) yearObjectMap.get("deleteTaskList");
+            if(CollectionUtil.isNotEmpty(listYear)){
+                deleteTaskList.addAll(listYear);
+            }
+            List<KeyValue> keyValueListYear = (List<KeyValue>) yearObjectMap.get("keyValues");
+            if(CollectionUtil.isNotEmpty(keyValueListYear)){
+                keyValues.addAll(keyValueListYear);
+            }
+        }
+        //删除任务
+        if(CollectionUtil.isNotEmpty(deleteTaskList)){
+            this.removeBatchByIds(deleteTaskList);
+        }
+        //生成新的任务
+        if(CollectionUtil.isNotEmpty(keyValues)){
+           this.createNewtask(keyValues,ymdDate);
+        }
+
+    }
+
+    private void createNewtask(List<KeyValue> keyValues,Date taskTime) {
+        List<CoreMonitoringRetrievalTask> taskList = new ArrayList<>();
+        Set<Long>  planId = new HashSet<>();
+        for(KeyValue keyValue:keyValues){
+            planId.add((Long) keyValue.getValue());
+        }
+        QueryWrapper<TMonitoringRetrievalPlan> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().in(TMonitoringRetrievalPlan::getId, planId);
+        queryWrapper.lambda().eq(TMonitoringRetrievalPlan::getPlanStatus, 1);
+        queryWrapper.lambda().eq(TMonitoringRetrievalPlan::getIsDeleted, 0);
+        queryWrapper.lambda().eq(TMonitoringRetrievalPlan::getCreateType, 1);
+        List<TMonitoringRetrievalPlan> plans = itMonitoringRetrievalPlanService.list(queryWrapper);
+        List<TMonitoringRetrievalPlan> planList = new ArrayList<>();
+        //获取所有机构
+        List<SysOrg> orgList = RemoteCallHandlerExecutor.executeRemoteCall(() -> orgService.findAllOrg(SecurityConstants.INNER), ErrorMsgConstants.QUERY_ORG_DATA_ERROR);
+        for(TMonitoringRetrievalPlan p:plans){
+            List<KeyValue> keyValuesa = keyValues.stream().filter(r->r.getValue().toString().equals(p.getId().toString())).collect(Collectors.toList());
+            List<SysOrg> orgs = orgList.stream().filter(r->keyValuesa.stream().anyMatch(s->s.getKey().toString().equals(r.getId().toString()))).collect(Collectors.toList());
+            for (SysOrg s : orgs) {
+                TMonitoringRetrievalPlan plan = new TMonitoringRetrievalPlan();
+                BeanUtils.copyProperties(p, plan);
+                plan.setPlanName(p.getPlanName());
+                plan.setOrgId(s.getId());
+                plan.setOrgName(s.getShortName());
+                plan.setRoleId(p.getRoleId());
+                plan.setRoleName(p.getRoleName());
+                plan.setOrgPath(s.getPath());
+                plan.setOrgType(p.getOrgType());
+                plan.setPlanCycle(p.getPlanCycle());
+                plan.setPlanFrequency(p.getPlanFrequency());
+                plan.setPlanStatus(0);
+                plan.setCreateBy(SecurityUtils.getUsername());
+                plan.setUpdateTime(DateUtils.getNowDate());
+                plan.setUpdateBy(SecurityUtils.getUsername());
+                plan.setCreateTime(DateUtils.getNowDate());
+                plan.setDescription(p.getDescription());
+                plan.setCreateType(1);
+                plan.setParentId(p.getId());
+                plan.setIsDistribute("1");
+                planList.add(plan);
+            }
+        }
+        for (TMonitoringRetrievalPlan plan : planList) {
+            DateRange dateRange =  DateUtils.getStartAndEnd(taskTime, Integer.valueOf(plan.getPlanCycle()+1));
+            Instant instant = dateRange.getStartTime().toInstant();
+
+            // 创建 ZonedDateTime 对象，并指定时区
+            ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
+            // 转换为 LocalDate 对象
+            LocalDate localDate = zdt.toLocalDate();
+            //获取计划关联的机构
+            List<SysOrg> listByType = orgList.stream().filter(r -> r.getId().equals(plan.getOrgId()) && r.getDeleted() == 0 && r.getIsLock().equals(0)).collect(Collectors.toList());
+            if (CollectionUtil.isNotEmpty(listByType)) {
+                List<CoreMonitoringRetrievalTask> list = this.buildCoreMonitoringRetrievalTask(plan, localDate, listByType.get(0));
+                if (CollectionUtil.isNotEmpty(list)) {
+                    taskList.addAll(list);
+                }
+            }
+        }
+        this.saveBatch(taskList);
+    }
+
+    private Map<String,Object> deleteTaskList(Date ymdDate,List<Long> orgIds,Integer cycle){
+        Map<String,Object> objectMap = new HashMap<>();
+        QueryWrapper<CoreMonitoringRetrievalTask> queryWrapper = new QueryWrapper<>();
+         //每日条件
+        Date datetime = ymdDate;
+        if(!cycle.equals(RetrievalTaskCycle.DAYCYCLE.getCode())){
+             //根据ymdDate获取周的第一天的日期
+            DateRange dateRange =  DateUtils.getStartAndEnd(ymdDate,cycle+1);
+            datetime = dateRange.getStartTime();
+        }
+        queryWrapper.lambda().eq(CoreMonitoringRetrievalTask::getYmdDate,datetime);
+        //公共条件
+        queryWrapper.lambda().in(CoreMonitoringRetrievalTask::getOrgId,orgIds);
+        queryWrapper.lambda().eq(CoreMonitoringRetrievalTask::getCycle,cycle);
+        List<CoreMonitoringRetrievalTask> taskList = this.list(queryWrapper);
+        List<CoreMonitoringRetrievalTask> deleteTaskList = new ArrayList<>();
+        List<KeyValue> keyValues = new ArrayList<>();
+        if(CollectionUtil.isNotEmpty(taskList)){
+            //将数据按机构分组
+            Map<Long,List<CoreMonitoringRetrievalTask>> taskMap = taskList.stream().collect(Collectors.groupingBy(CoreMonitoringRetrievalTask::getOrgId));
+            for(Long key:taskMap.keySet()){
+                List<CoreMonitoringRetrievalTask> taskList1 = taskMap.get(key);
+               //将taskList1 按batchNum进行分组
+                Map<Long,List<CoreMonitoringRetrievalTask>> taskMap1 = taskList1.stream().collect(Collectors.groupingBy(CoreMonitoringRetrievalTask::getBatchNum));
+                for(Long key1:taskMap1.keySet()){
+                    List<CoreMonitoringRetrievalTask> taskList2 = taskMap1.get(key1);
+                    int num = (int) taskList2.stream().filter(t->t.getStatus().equals(2)).count();
+                    //没有完成的任务，改批次的任务删除
+                    if(num==0){
+                        deleteTaskList.addAll(taskList2);
+                        Long planId = taskList2.get(0).getPlanId();
+                        KeyValue keyValue = new KeyValue();
+                        keyValue.setKey(key);
+                        keyValue.setValue(planId);
+                        keyValues.add(keyValue);
+                    }
+                }
+            }
+        }
+        objectMap.put("deleteTaskList",deleteTaskList);
+        objectMap.put("keyValues",keyValues);
+        return objectMap;
+    }
+
+
     private boolean checkWorkTime(Date workstartTime, Date workendTime,Long orgId){
         Map<String,Object> map = new HashMap<>();
         map.put("workstartTime",DateUtil.format(workstartTime,"yyyy-MM-dd"));
@@ -596,4 +797,14 @@ public class CoreMonitoringRetrievalTaskServiceImpl extends ServiceImpl<CoreMoni
             return  false;
         }
     }
+    private List<SysWorkTime> selectWorkTimeList(Date now, CycleCommonEnum cycle, WorkTimeChangeEvent event) {
+        DateRange range = DateUtils.getStartAndEnd(now, cycle);
+        String startTime = DateUtil.format(range.getStartTime(), Constants.DAILY_FORMAT);
+        String endTime = DateUtil.format(range.getEndTime(), Constants.DAILY_FORMAT);
+        WorkTimeDto workTimeDto = new WorkTimeDto();
+        workTimeDto.setOrgIdList(event.getOrgIds());
+        workTimeDto.setStartTime(startTime);
+        workTimeDto.setEndTime(endTime);
+        return workTimeService.findWorkTimeByRange(workTimeDto, SecurityConstants.FROM_SOURCE);
+    }
 }

soc-modules/soc-modules-core/src/main/resources/mapper/edu/CoreEduTrainingPlanMapper.xml

@@ -123,28 +123,28 @@
         <include refid="selectCoreEduTrainingPlanVo"/>
         where id = #{id}
     </select>
-<sql id="pageIncludeSP">
-    <if test="request.execOrgType!=null">
-        and sp.exec_org_type = #{request.execOrgType}
-    </if>
-    <if test="request.planCycle!=null">
-        and sp.plan_cycle = #{request.planCycle}
-    </if>
-    <if test="request.planStatus!=null">
-        and sp.plan_status = #{request.planStatus}
-    </if>
-    <if test="request.planName!=null">
-        and p.plan_name like concat('%',#{request.planName},'%')
-    </if>
-    <choose>
-        <when test="request.checkSub==true">
-            and sp.belong_org_path like concat(#{request.belongOrgPath},'%')
-        </when>
-        <otherwise>
-            and sp.belong_org_id = #{request.belongOrgId}
-        </otherwise>
-    </choose>
-</sql>
+    <sql id="pageIncludeSP">
+        <if test="request.execOrgType!=null">
+            and sp.exec_org_type = #{request.execOrgType}
+        </if>
+        <if test="request.planCycle!=null">
+            and sp.plan_cycle = #{request.planCycle}
+        </if>
+        <if test="request.planStatus!=null">
+            and sp.plan_status = #{request.planStatus}
+        </if>
+        <if test="request.planName!=null">
+            and p.plan_name like concat('%',#{request.planName},'%')
+        </if>
+        <choose>
+            <when test="request.checkSub==true">
+                and sp.belong_org_path like concat(#{request.belongOrgPath},'%')
+            </when>
+            <otherwise>
+                and sp.belong_org_id = #{request.belongOrgId}
+            </otherwise>
+        </choose>
+    </sql>
     <sql id="pageIncludeP">
         <if test="request.planName!=null">
             and p.plan_name like concat('%',#{request.planName},'%')
@@ -447,7 +447,7 @@
         from core_edu_training_plan p left join sys_user u on p.update_by=u.id
         where p.deleted = 0
         <if test="request.planRoleId!=null">
-            and p.id in (  select distinct p1.id
+            and p.id in ( select distinct p1.id
             from core_edu_training_plan p1
             inner join core_edu_training_plan_to_role r1 on p1.id = r1.plan_id
             where p1.deleted = 0
@@ -556,9 +556,9 @@
         <if test="request.planStatus!=null">
             and sp.plan_status = #{request.planStatus}
         </if>
-<!--        <if test="request.planName!=null">-->
-<!--            and sp.plan_name = #{request.planName}-->
-<!--        </if>-->
+        <!--        <if test="request.planName!=null">-->
+        <!--            and sp.plan_name = #{request.planName}-->
+        <!--        </if>-->
         <choose>
             <when test="request.checkSub==true">
                 and sp.belong_org_path like concat(#{request.belongOrgPath},'%')
@@ -584,10 +584,22 @@
     </select>
 
     <update id="updatePlanStatus">
-        update core_edu_training_plan set plan_status = #{status} where id = #{planId}
+        update core_edu_training_plan
+        set plan_status = #{status}
+        where id = #{planId}
     </update>
 
     <update id="updatePlanStatusByIdOrParentId">
-        update core_edu_training_plan set plan_status = #{status} where id = #{planId} or parent_id = #{planId}
+        update core_edu_training_plan
+        set plan_status = #{status}
+        where id = #{planId}
+           or parent_id = #{planId}
+    </update>
+
+    <update id="updatePlanStatusByIdList">
+        update core_edu_training_plan set plan_status = #{status} where id in
+        <foreach collection="list" item="item" index="index" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
     </update>
 </mapper>

soc-modules/soc-modules-core/src/main/resources/mapper/edu/CoreEduTrainingTaskMapper.xml

@@ -57,7 +57,7 @@
     </sql>
 
     <select id="checkHasTaskIsDone" resultType="java.lang.Integer">
-        select 1 from core_edu_training_task where status !=0 and plan_id in
+        select 1 from core_edu_training_task where status in (2,3) and plan_id in
         <foreach collection="list" item="item" index="index" open="(" close=")" separator=",">
             #{item}
         </foreach>
@@ -176,7 +176,7 @@
     <select id="checkHasTaskIsDoneByPlanParentId" resultType="java.lang.Integer">
         select 1
         from core_edu_training_task
-        where status != 0
+        where status in (2,3)
           and plan_id in
               (select id from core_edu_training_plan where plan_status = 0 and deleted = 0 and parent_id = #{planId})
         limit 1

soc-modules/soc-modules-core/src/main/resources/mapper/resumption/AppPlanMapper.xml

@@ -219,6 +219,7 @@
 
     <select id="selectByPlanId" resultType="com.xunmei.core.resumption.vo.appPlan.RuleItemVo">
         SELECT h.point_id      as id,
+               h.of_org_id,
                a.item_id,
                b.NAME          AS item_name,
                b.DESC          AS item_desc,--                b.item_num,
@@ -229,7 +230,7 @@
                h.required,
                d.NAME          AS ruleName,
                a.business_type AS businessType
-        FROM (SELECT point_id, point_scan, required FROM core_resumption_plan_to_point WHERE plan_id = #{planId}) h
+        FROM (SELECT point_id, point_scan, required,of_org_id FROM core_resumption_plan_to_point WHERE plan_id = #{planId}) h
                  LEFT JOIN core_resumption_rule_point a ON h.point_id = a.id
                  LEFT JOIN core_resumption_rule_item b ON a.item_id = b.id
                  LEFT JOIN sys_area c ON a.area_id = c.id

soc-modules/soc-modules-core/src/main/resources/mapper/resumption/ResumptionMapper.xml

@@ -15,7 +15,7 @@
         <!--          and ymd_quarter = #{resumption.ymd.quarter}-->
     </update>
     <update id="updateNameByPlanId">
-update   core_resumption set name=#{planName} where plan_id =#{planId}
+update   core_resumption set name=#{planName} where plan_id =#{planId} and status in (1,2)
 
 
     </update>

soc-modules/soc-modules-core/src/test/java/com/test/TestController.java

@@ -21,7 +21,7 @@ public class TestController {
     @Test
     public void workTimeChangeEventTest () {
         List<Long> list = new ArrayList<>();
-        WorkTimeChangeEvent event = new WorkTimeChangeEvent(this, list,null);
-        coreEduTrainingTaskService.taskChangeForTimeWorkChange(event);
+        //WorkTimeChangeEvent event = new WorkTimeChangeEvent(this, list, ymdDate);
+        //coreEduTrainingTaskService.taskChangeForTimeWorkChange(event);
     }
 }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/controller/SysWorkTimeController.java

@@ -73,10 +73,8 @@ public class SysWorkTimeController extends BaseController {
 //    @RequiresPermissions("system:set:monthedit")
     @PostMapping("/month/edit")
     public AjaxResult monthedit(@RequestBody WorkTimeMonthEditNewDto sysWorkTimeSet) {
-        // Date today = DateUtil.beginOfDay(new Date());
+
         List<Long> orgIds = sysWorkTimeSet.getOrgIdList();
-        //List<SysWorkTime> exists = sysWorkTimeService.findByYmd(orgIds, today);
-        // List<SysWorkTime> workTimeLists = new ArrayList<>();
         for (Long orgId : orgIds) {
             sysWorkTimeService.batchnew(orgId, sysWorkTimeSet.getWorkTimeList());
         }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/service/impl/SysWorkTimeServiceImpl.java

@@ -1,9 +1,12 @@
 package com.xunmei.system.service.impl;
 
 import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.date.DateField;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSON;
 import com.alibaba.nacos.shaded.com.google.gson.Gson;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -12,20 +15,23 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.xunmei.common.core.constant.SecurityConstants;
 import com.xunmei.common.core.domain.worktime.dto.WorkTimeDto;
+import com.xunmei.common.core.event.WorkTimeChangeEvent;
+import com.xunmei.common.core.utils.DateHelper;
 import com.xunmei.common.core.utils.DateUtils;
 import com.xunmei.common.core.utils.Ymd;
 import com.xunmei.common.core.web.domain.AjaxResult;
 import com.xunmei.common.core.web.page.TableDataInfo;
 import com.xunmei.common.security.utils.SecurityUtils;
-import com.xunmei.system.api.RemoteResumptionTaskService;
 import com.xunmei.common.core.domain.worktime.domain.SysWorkTime;
 import com.xunmei.system.domain.SysWorkTimeSet;
 import com.xunmei.system.dto.SysWorkTimeDto;
+import com.xunmei.system.dto.WorkTimeMonthEditNewDto;
 import com.xunmei.system.mapper.SysWorkTimeMapper;
 import com.xunmei.system.mapper.SysWorkTimeSetMapper;
 import com.xunmei.system.service.ISysOrgService;
 import com.xunmei.system.service.ISysWorkTimeService;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
@@ -57,11 +63,6 @@ public class SysWorkTimeServiceImpl extends ServiceImpl<SysWorkTimeMapper, SysWo
     @Autowired
     private ApplicationContext context;
 
-    @Autowired
-    RemoteResumptionTaskService remoteResumptionTaskService;
-    @Autowired
-    ApplicationEventPublisher applicationEventPublisher;
-
     public static Date extractDate(String dateString, String dateFormat) throws ParseException {
         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat, Locale.ENGLISH);
         sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
@@ -341,17 +342,6 @@ public class SysWorkTimeServiceImpl extends ServiceImpl<SysWorkTimeMapper, SysWo
                 s.setModifiedName(SecurityUtils.getUsername());
                 baseMapper.insert(s);
             }
-            if (DateUtil.isSameDay(s.getYmdDate(), now)) {
-                List<Long> orgIds = new ArrayList<>();
-                orgIds.add(orgId);
-                Map<String, Object> param = new HashMap<>();
-                param.put("orgIds", orgIds);
-                param.put("sysWorkTime", new Gson().toJson(s));
-                log.info("时间{}修改作息远程调用生成履职任务", new Date());
-                AjaxResult result = remoteResumptionTaskService.dayTaskByWorkTime(param, SecurityConstants.INNER);
-                log.info("时间{}修改作息远程调用生成履职任务返回{}", new Date(), result.get("msg"));
-            }
-
         }
         return workTimeDtoList;
     }
@@ -401,6 +391,7 @@ public class SysWorkTimeServiceImpl extends ServiceImpl<SysWorkTimeMapper, SysWo
      * @return 结果
      */
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void updateSysWorkTime(SysWorkTime sysWorkTime) {
 
         sysWorkTime.setUpdateTime(DateUtils.getNowDate());
@@ -421,6 +412,7 @@ public class SysWorkTimeServiceImpl extends ServiceImpl<SysWorkTimeMapper, SysWo
 //
 //        }
 
+
     }
 
     /**
@@ -472,4 +464,5 @@ public class SysWorkTimeServiceImpl extends ServiceImpl<SysWorkTimeMapper, SysWo
     public int checkWorkTime(Map<String, Object> param) {
         return sysWorkTimeMapper.checkWorkTime(param);
     }
+
 }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/service/impl/SysWorkTimeSetServiceImpl.java

@@ -8,6 +8,7 @@ import cn.hutool.core.date.DateField;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -553,4 +554,103 @@ public class SysWorkTimeSetServiceImpl extends ServiceImpl<SysWorkTimeSetMapper,
     public int deleteSysWorkTimeSetById(Long id) {
         return sysWorkTimeSetMapper.deleteById(id);
     }
+//    /**
+//     * 生成下个月的作息
+//     */
+//    @Transactional(rollbackFor = Exception.class)
+//    public void generateNextMonth() {
+//        Calendar calendar = Calendar.getInstance();
+//        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+//        System.out.println("============================ work_time_job 1================== : " + calendar.getTime());
+//
+//        calendar.set(Calendar.DAY_OF_MONTH, 1);
+//        calendar.add(Calendar.MONTH, 1);
+//        Integer year = calendar.get(Calendar.YEAR);
+//        generateWorkTime(year, calendar.get(Calendar.MONTH));
+//    }
+//
+//    @Transactional(rollbackFor = Exception.class)
+//    public void generateWorkTime(int year, int month) {
+//        Calendar calendar = Calendar.getInstance();
+//        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+//        calendar.set(Calendar.DAY_OF_MONTH, 1);
+//        calendar.set(Calendar.MONTH, month);
+//        calendar.set(Calendar.YEAR, year);
+//        System.out.println("============================ work_time_job 1================== : " + calendar.getTime());
+//        List<SysWorkTimeSet> workTimes = this.list(new LambdaQueryWrapper<SysWorkTimeSet>().eq(SysWorkTimeSet::getYear,year));
+//        Map<Long,List<SysWorkTimeSet>> group= workTimes.stream()
+//                .sorted(Comparator.comparing(SysWorkTimeSet::getEffectiveDate).reversed())
+//                .collect(Collectors.groupingBy(w->w.getOrgId()));
+//
+//        final Date date = com.xunmei.common.core.utils.DateHelper.getDate(calendar.getTime());
+//        System.out.println("============================ work_time_job 2================== : " + date);
+//        final com.xunmei.common.core.utils.DateHelper dateTime = new com.xunmei.common.core.utils.DateHelper(date);
+//        final Date start = dateTime.monthStart();
+//        final Date end = dateTime.monthEnd();
+//        final List<DateTime> dateTimeList = DateUtil.rangeToList(start, end, DateField.DAY_OF_MONTH);
+//        System.out.println(JSON.toJSONString(dateTimeList));
+////        HolidayDto holidayDto = new HolidayDto();
+////        holidayDto.setYear(year);
+////        List<Holiday> holidayList = this.holidayService.all(holidayDto);
+////        List<Date> holidayDates = null;
+////        if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(holidayList)) {
+////            holidayDates = holidayList.stream().map(p -> p.getYmdDate()).collect(Collectors.toList());
+////        }
+//        List<SysWorkTime> workTimeEditDtoList = new ArrayList<>();
+//        for (DateTime time : dateTimeList) {
+//            Date date1 = time.toJdkDate();
+//            System.out.println("date1:"+date1);
+//            for(Long orgId:group.keySet()) {
+//                Optional<SysWorkTimeSet> ws=   group.get(orgId).stream().filter(w->date1.after(w.getEffectiveDate())||DateUtil.isSameDay(date1,w.getEffectiveDate())).findFirst();
+//                if(!ws.isPresent()){
+//                    continue;
+//                }
+//                SysWorkTimeSet set=ws.get();
+//                List<SysWorkTimeSetDayofweek> temp=ws.get().getDayOfWeeks();
+//                int i = time.dayOfWeek();
+//                SysWorkTimeSetDayofweek dayOfWeekSet = temp.stream().filter(e->e.getDayOfWeek().equals(i)).findFirst().get();
+//                boolean isEnable = ObjectUtil.isNotNull(dayOfWeekSet) && dayOfWeekSet.getIsWorkday();
+//                WorkTimeEditDto dto = new WorkTimeEditDto();
+//                dto.setDate(time);
+//                dto.setOrgId(orgId);
+//                dto.setIsEnable(isEnable);
+//                if (ObjectUtil.isNull(dayOfWeekSet) || !dayOfWeekSet.getIsWorkday()) {
+//                    Optional<WorkTimeSetDayOfWeek> firstWorkDay = set.getDayOfWeeks().stream().filter(f -> f.getIsWorkday()).findFirst();
+//                    if (firstWorkDay.isPresent()) {
+//                        dayOfWeekSet = firstWorkDay.get();
+//                    }
+//                }
+//                //dto.setIsEnable(dayOfWeekSet.getIsWorkday());
+//                workTimeEditDtoList.add(dto);
+//                dto.setWorkTime(dayOfWeekSet.getWorkTime());
+//                dto.setWorkOffTime(dayOfWeekSet.getWorkOffTime());
+//                dto.setOpenTime(dayOfWeekSet.getOpenTime());
+//                dto.setCloseTime(dayOfWeekSet.getCloseTime());
+//                dto.setNoonbreakStart(dayOfWeekSet.getNoonbreakStart());
+//                dto.setNoonbreakEnd(dayOfWeekSet.getNoonbreakEnd());
+//                workTimeEditDtoList.add(dto);
+//            }
+//        }
+//
+//        Map<Long,List<WorkTimeEditDto>> groupDay= workTimeEditDtoList.stream().collect(Collectors.groupingBy(w->w.getOrgId()));
+//        //获取所有机构下个月的按日配置的作息
+//        List<WorkTimeNewVo> list = new ArrayList<>();
+//        list = objectMapper.getNextMonthWorkTime(DateUtil.format(start, "yyyy-MM"));
+//        for(Long orgId:groupDay.keySet()){
+//            List<WorkTimeEditDto> workTimeEditDtos = groupDay.get(orgId);
+//            List<WorkTimeNewVo> workTimeNewVos = list.stream().filter(w -> w.getOrgId().equals(orgId)).collect(Collectors.toList());
+//            //去掉workTimeEditDtos中机构与日期在workTimeNewVos中存在的数据
+//            List<WorkTimeEditDto> list1 = null;
+//            if(org.apache.commons.collections4.CollectionUtils.isNotEmpty(workTimeNewVos)){
+//                list1 = workTimeEditDtos.stream().filter(s -> {
+//                    return workTimeNewVos.stream().noneMatch(f -> f.getOrgId().equals(s.getOrgId()) && f.getYmdDate().equals(s.getDate()));
+//                }).collect(Collectors.toList());
+//            }else{
+//                list1 = workTimeEditDtos;
+//            }
+//
+//            batch(orgId, date, list1);
+//        }
+//
+//    }
 }