工作流处理逻辑修改

biz-base/src/main/java/com/dayou/controller/PersonalProductionController.java

@@ -111,12 +111,13 @@ public class PersonalProductionController extends BaseController {
 
     /**
      * 审核产品
-     * @param id
+     * @param taskRecordDTO
      * @return
      */
-    @GetMapping("/pass/{id}")
-    public RestResponse<Boolean> checkPass(@PathVariable("id") Long id){
-        Boolean ret = personalProductionService.checkPass(id);
+    @FinishTask
+    @PutMapping("/pass")
+    public RestResponse<Boolean> checkPass(@RequestBody TaskRecordDTO<PersonalProduction> taskRecordDTO){
+        Boolean ret = personalProductionService.checkPass(taskRecordDTO);
         return RestResponse.data(ret);
     }
 
@@ -127,7 +128,7 @@ public class PersonalProductionController extends BaseController {
      */
     @FinishTask
     @PostMapping("/in")
-    public RestResponse<Boolean> repertoryIn(@RequestBody @Valid TaskRecordDTO<Long> taskRecordDTO){
+    public RestResponse<Boolean> repertoryIn(@RequestBody @Valid TaskRecordDTO<PersonalProduction> taskRecordDTO){
         Boolean ret = personalProductionService.repertoryIn(taskRecordDTO);
         return RestResponse.data(ret);
     }
@@ -139,7 +140,7 @@ public class PersonalProductionController extends BaseController {
      */
     @FinishTask
     @PostMapping("/out")
-    public RestResponse<Boolean> repertoryOut(@RequestBody @Valid TaskRecordDTO<Long> taskRecordDTO){
+    public RestResponse<Boolean> repertoryOut(@RequestBody @Valid TaskRecordDTO<PersonalProduction> taskRecordDTO){
         Boolean ret = personalProductionService.repertoryOut(taskRecordDTO);
         return RestResponse.data(ret);
     }

domain/src/main/java/com/dayou/dto/WorkNodeCommit.java

@@ -74,4 +74,9 @@ public class WorkNodeCommit {
 
     private Boolean ifFeedback;
 
+    /**
+     * 客户id
+     */
+    private Long ccId;
+
 }

domain/src/main/java/com/dayou/enums/workflow/CallbackEnum.java

@@ -41,6 +41,11 @@ public enum CallbackEnum {
      * 个贷出具产品类型校验
      */
     CHECK_PERSONAL_PRODUCTION_TYPE("CHECK_PERSONAL_PRODUCTION_TYPE"),
+
+    /**
+     *  个贷客户类型校验（如果是银行客户，报告出库无需申请）
+     */
+    CHECK_PERSONAL_CLIENT_TYPE("CHECK_PERSONAL_CLIENT_TYPE")
     ;
 
     private String code;

service/src/main/java/com/dayou/service/ICustomerCompanyService.java

@@ -29,4 +29,11 @@ public interface ICustomerCompanyService extends IService<CustomerCompany> {
         Boolean delete(Long id);
 
     List<CustomerCompany> simpleAll(CustomerCompany customer);
+
+        /**
+         * 判断客户是否是出库免申请
+         * @param id
+         * @return
+         */
+        Boolean avoidWareHouseApply(Long id);
 }

service/src/main/java/com/dayou/service/IPersonalProductionService.java

@@ -32,9 +32,9 @@ public interface IPersonalProductionService extends IService<PersonalProduction>
 
     Boolean removeFile(Long id);
 
-    Boolean checkPass(Long id);
+    Boolean checkPass(TaskRecordDTO<PersonalProduction> taskRecordDTO);
 
-    Boolean repertoryIn(TaskRecordDTO<Long> taskRecordDTO);
+    Boolean repertoryIn(TaskRecordDTO<PersonalProduction> taskRecordDTO);
 
-    Boolean repertoryOut(TaskRecordDTO<Long> taskRecordDTO);
+    Boolean repertoryOut(TaskRecordDTO<PersonalProduction> taskRecordDTO);
 }

service/src/main/java/com/dayou/service/impl/CustomerCompanyServiceImpl.java

@@ -86,4 +86,11 @@ public class CustomerCompanyServiceImpl extends ServiceImpl<CustomerCompanyMappe
         lambdaQueryWrapper.orderByDesc(BaseEntity::getId);
         return this.list(lambdaQueryWrapper);
     }
+
+    @Override
+    public Boolean avoidWareHouseApply(Long id) {
+        CustomerCompany cc = this.getOne(new LambdaQueryWrapper<CustomerCompany>().eq(BaseEntity::getId, id).isNull(CustomerCompany::getParentId)
+                .eq(CustomerCompany::getTerminal, Boolean.FALSE).eq(CustomerCompany::getCompanyType, "银行及金融机构").eq(BaseEntity::getDeleted, Boolean.FALSE));
+        return cc!=null;
+    }
 }

service/src/main/java/com/dayou/service/impl/PersonalProductionServiceImpl.java

@@ -40,10 +40,8 @@ import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 
 import static com.dayou.common.Constants.*;
 import static com.dayou.enums.CertificateEnum.*;
@@ -360,41 +358,60 @@ public class PersonalProductionServiceImpl extends ServiceImpl<PersonalProductio
     }
 
     @Override
-    public Boolean checkPass(Long id) {
-        return this.update(new LambdaUpdateWrapper<PersonalProduction>().eq(BaseEntity::getId,id).set(PersonalProduction::getCheckState, ReportStatus.已审核));
+    public Boolean checkPass(TaskRecordDTO<PersonalProduction> taskRecordDTO) {
+        PersonalProduction production = taskRecordDTO.getTaskData();
+        Long targetId = production.getTargetId();
+        String type = production.getProduction();
+        if (STATEMENT.name().equals(type)){
+            return this.update(new LambdaUpdateWrapper<PersonalProduction>().eq(PersonalProduction::getProduction,type)
+                    .eq(PersonalProduction::getTargetId,targetId).set(PersonalProduction::getCheckState, ReportStatus.已审核));
+        }else{
+            return this.update(new LambdaUpdateWrapper<PersonalProduction>().ne(PersonalProduction::getProduction,STATEMENT.name())
+                    .eq(PersonalProduction::getTargetId,targetId).set(PersonalProduction::getCheckState, ReportStatus.已审核));
+        }
     }
 
     @Override
-    public Boolean repertoryIn(TaskRecordDTO<Long> taskRecordDTO) {
-        Long productionId = taskRecordDTO.getTaskData();
-        PersonalProduction production = this.getOne(new LambdaQueryWrapper<PersonalProduction>().eq(BaseEntity::getId, productionId).eq(BaseEntity::getDeleted, Boolean.FALSE));
-
-        if (production==null){
-            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"产品不存在，入库失败。");
-        }
-
-        if (production.getRepertoryState()!=null && production.getRepertoryState()){
-            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"产品已出库，请确认产品状态。");
+    public Boolean repertoryIn(TaskRecordDTO<PersonalProduction> taskRecordDTO) {
+        PersonalProduction taskData = taskRecordDTO.getTaskData();
+        List<PersonalProduction> productions;
+        if (taskData.getProduction().equals(STATEMENT.name())){
+            productions = this.list(new LambdaQueryWrapper<PersonalProduction>()
+                    .eq(PersonalProduction::getTargetId,taskData.getTargetId()).eq(PersonalProduction::getProduction,taskData.getProduction())
+                    .eq(BaseEntity::getDeleted, Boolean.FALSE));
+        }else {
+            productions = this.list(new LambdaQueryWrapper<PersonalProduction>()
+                    .eq(PersonalProduction::getTargetId,taskData.getTargetId()).ne(PersonalProduction::getProduction,STATEMENT.name())
+                    .eq(BaseEntity::getDeleted, Boolean.FALSE));
         }
 
-        if (production.getRepertoryState()!=null && !production.getRepertoryState()){
-            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"产品已入库，无需再次入库");
+        if (CollectionUtil.isEmpty(productions)){
+            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"产品不存在，入库失败。");
         }
-        return this.update(new LambdaUpdateWrapper<PersonalProduction>().set(PersonalProduction::getRepertoryState,Boolean.FALSE).set(PersonalProduction::getRepertoryInTime,new Date()).eq(BaseEntity::getId,productionId));
+        List<Long> productionIds = productions.stream().map(BaseEntity::getId).collect(Collectors.toList());
+        return this.update(new LambdaUpdateWrapper<PersonalProduction>().set(PersonalProduction::getRepertoryState,Boolean.FALSE)
+                .set(PersonalProduction::getRepertoryInTime,new Date()).in(BaseEntity::getId,productionIds));
     }
 
     @Override
-    public Boolean repertoryOut(TaskRecordDTO<Long> taskRecordDTO) {
-        Long productionId = taskRecordDTO.getTaskData();
-        PersonalProduction production = this.getOne(new LambdaQueryWrapper<PersonalProduction>().eq(BaseEntity::getId, productionId).eq(BaseEntity::getDeleted, Boolean.FALSE));
-        if (production.getRepertoryState() == null) {
-            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR, "产品还未入库，无法出库。");
+    public Boolean repertoryOut(TaskRecordDTO<PersonalProduction> taskRecordDTO) {
+        PersonalProduction taskData = taskRecordDTO.getTaskData();
+        List<PersonalProduction> productions;
+        if (taskData.getProduction().equals(STATEMENT.name())){
+            productions = this.list(new LambdaQueryWrapper<PersonalProduction>()
+                    .eq(PersonalProduction::getTargetId,taskData.getTargetId()).eq(PersonalProduction::getProduction,taskData.getProduction())
+                    .eq(BaseEntity::getDeleted, Boolean.FALSE));
+        }else {
+            productions = this.list(new LambdaQueryWrapper<PersonalProduction>()
+                    .eq(PersonalProduction::getTargetId,taskData.getTargetId()).ne(PersonalProduction::getProduction,STATEMENT.name())
+                    .eq(BaseEntity::getDeleted, Boolean.FALSE));
         }
 
-        if (production.getRepertoryState() != null && production.getRepertoryState()) {
-            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR, "产品已出库，无法再次出库。");
-        }
-        if (!production.getProduction().equals(STATEMENT.name())){
+        if (productions.size()==1 && productions.get(0).getProduction().equals(STATEMENT.name())){
+            //价值意见书出库无需申请审核
+            return this.update(new LambdaUpdateWrapper<PersonalProduction>().set(PersonalProduction::getRepertoryState, Boolean.TRUE).set(PersonalProduction::getRepertoryOutTime,new Date())
+                    .eq(BaseEntity::getId, productions.get(0).getId()));
+        }else{
             //非价值意见书 需做出库前校验
 //            Long outId = beforeOutCheck(production);
 //            //更新申请记录中的出库状态
@@ -407,10 +424,6 @@ public class PersonalProductionServiceImpl extends ServiceImpl<PersonalProductio
 //                ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR, "财务部未审核或审核不通过，产品暂时无法出库。");
 //                return Boolean.FALSE;
 //            }
-        }else{
-            //价值意见书出库无需申请审核
-            return this.update(new LambdaUpdateWrapper<PersonalProduction>().set(PersonalProduction::getRepertoryState, Boolean.TRUE).set(PersonalProduction::getRepertoryOutTime,new Date())
-                    .eq(BaseEntity::getId, production.getId()));
         }
         return null;
     }

service/src/main/java/com/dayou/workflow/config/WorkNodeProcessable.java

@@ -8,10 +8,13 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.dayou.common.BaseEntity;
 import com.dayou.dto.HandlerPermissionDTO;
 import com.dayou.dto.WorkNodeCommit;
+import com.dayou.dto.WorkNodeDTO;
 import com.dayou.entity.*;
 import com.dayou.enums.MainBusinessEnum;
 import com.dayou.enums.workflow.HandlerPermissionEnum;
 import com.dayou.enums.workflow.NodeLogEnum;
+import com.dayou.enums.workflow.NodeStateEnum;
+import com.dayou.enums.workflow.WorkflowNodeEnum;
 import com.dayou.exception.ErrorCode;
 import com.dayou.mapper.DepartmentMapper;
 import com.dayou.mapper.MajorMapper;
@@ -21,8 +24,11 @@ import com.dayou.service.IUserPostService;
 import com.dayou.service.IUserService;
 import com.dayou.service.workflow.IWorkFlowLogService;
 import com.dayou.service.workflow.IWorkFlowNodeInstanceService;
+import com.dayou.service.workflow.IWorkNodeService;
 import com.dayou.service.workflow.IWorkTaskRecordService;
 import com.dayou.utils.LoginContext;
+import com.dayou.workflow.handler.MajorNodeHandler;
+import com.dayou.workflow.handler.PersonalNodeHandler;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -31,6 +37,9 @@ import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.List;
 
+import static com.dayou.common.Constants.MAJOR_HANDLER;
+import static com.dayou.common.Constants.PERSONAL_HANDLER;
+import static com.dayou.enums.workflow.NodeLogEnum.PASS;
 import static com.dayou.enums.workflow.NodeStateEnum.*;
 
 /**
@@ -52,32 +61,53 @@ public class WorkNodeProcessable {
     @Autowired
     private WorkTaskRecordMapper workTaskRecordMapper;
 
+    @Autowired
+    private IWorkNodeService workNodeService;
 
 
     /**
-     * 前进
+     * 提交流程前置处理
      * @param commit
      * @return
      */
-    public boolean forward(WorkNodeCommit commit){
-        WorkFlowNodeInstance instanceNode = workFlowNodeInstanceService.getById(commit.getInstanceNodeId());
-
+    @Transactional
+    protected WorkNodeDTO beforeForward(WorkNodeCommit commit,WorkFlowNodeInstance currentInstanceNode){
         //节点控制前置处理。
         //当任务不需要当前节点处理人产生业务数据的时候，则把任务状态改为已完成。
-        List<Long> notBusinessHandleTaskId = workTaskRecordMapper.getNotBusinessHandleTaskId(instanceNode.getId());
+        List<Long> notBusinessHandleTaskId = workTaskRecordMapper.getNotBusinessHandleTaskId(currentInstanceNode.getId());
         if (CollectionUtil.isNotEmpty(notBusinessHandleTaskId)){
-            return workTaskRecordService.update(new LambdaUpdateWrapper<WorkTaskRecord>().set(WorkTaskRecord::getFinished,Boolean.TRUE)
+            workTaskRecordService.update(new LambdaUpdateWrapper<WorkTaskRecord>().set(WorkTaskRecord::getFinished,Boolean.TRUE)
                     .set(WorkTaskRecord::getFinishTime, LocalDateTime.now()).in(BaseEntity::getId,notBusinessHandleTaskId));
         }
 
-        // 校验相同节点是否已创建
-//        WorkFlowNodeInstance nextInstanceNode = workFlowNodeInstanceService.getOne(new LambdaQueryWrapper<WorkFlowNodeInstance>()
-//                .eq(WorkFlowNodeInstance::getFlowId, instanceNode.getFlowId()).eq(WorkFlowNodeInstance::getBusinessId, instanceNode.getBusinessId())
-//                .eq(BaseEntity::getDeleted, Boolean.FALSE));
+        if (commit.getState().equals(PASS) && commit.getIfCheckTask()){
+            if (checkCurrentNodeTaskState(currentInstanceNode)){
+                //将当前节点状态变更成已完成
+                workFlowNodeInstanceService.update(new LambdaUpdateWrapper<WorkFlowNodeInstance>().set(WorkFlowNodeInstance::getState,NodeStateEnum.FINISHED)
+                        .set(WorkFlowNodeInstance::getComment,commit.getComments()).eq(BaseEntity::getId,currentInstanceNode.getId()));
+                addWorkflowLog(commit,currentInstanceNode);
+            }else {
+                ErrorCode.throwBusinessException(ErrorCode.TASK_NOT_FINISHED);
+            }
+        }
+
+        //确认当前节点是否需要校验业务数据
+        //寻找下一个节点，有可能下一个节点并非流程配置的节点，需根据业务数据变动
+        WorkNodeDTO nextWorkNode = workNodeService.getNextWorkNode(currentInstanceNode.getFlowId(), currentInstanceNode.getNodeId());
+
+        if (nextWorkNode==null && !currentInstanceNode.getNodeCode().equals(WorkflowNodeEnum.BUSINESS_ARCHIVING.name())){
+            ErrorCode.throwBusinessException(ErrorCode.NEXT_NODE_NOT_EXISTS);
+        }
+
+        return nextWorkNode;
+    }
+
 
-        return instanceNode!=null;
+    public boolean forward(WorkNodeCommit workNodeCommit) {
+        return Boolean.FALSE;
     }
 
+
     /**
      * 跳过
      * @param commit
@@ -123,15 +153,7 @@ public class WorkNodeProcessable {
         workTaskRecordService.remove(new LambdaQueryWrapper<WorkTaskRecord>().eq(WorkTaskRecord::getInstanceId,instanceNodeId));
 
         //添加日志
-        WorkFlowLog log = new WorkFlowLog();
-                log.setBusinessId(currentNode.getBusinessId());
-                log.setBusinessType(currentNode.getBusinessType());
-                log.setHandingTime(new Date().getTime() - currentNode.getCreated().getTime());
-                log.setHandlerId(LoginContext.getCurrentUserId());
-                log.setComments(commit.getComments());
-                log.setState(NodeLogEnum.REVERSE.name());
-                log.setInstanceId(commit.getInstanceNodeId());
-        return workFlowLogService.add(log);
+        return addWorkflowLog(commit,currentNode);
 
     }
 
@@ -160,19 +182,81 @@ public class WorkNodeProcessable {
                 .eq(WorkFlowNodeInstance::getId,commit.getInstanceNodeId()));
 
         //添加日志
-        WorkFlowLog log = new WorkFlowLog();
-                    log.setBusinessId(currentNode.getBusinessId());
-                    log.setBusinessType(currentNode.getBusinessType());
-                    log.setHandingTime(new Date().getTime() - currentNode.getCreated().getTime());
-                    log.setHandlerId(LoginContext.getCurrentUserId());
-                    log.setComments(commit.getComments());
-                    log.setState(NodeLogEnum.TERMINATE.name());
-                    log.setInstanceId(commit.getInstanceNodeId());
-        return workFlowLogService.add(log);
+        return addWorkflowLog(commit,currentNode);
     }
 
 
     public Long searchHandlerId(WorkFlowNodeInstance instanceNode, HandlerPermissionDTO handlerPermissionDTO){
         return 0L;
     }
+
+    /**
+     * 检查节点任务状态
+     * @param currentInstanceNode
+     * @return
+     */
+    private Boolean checkCurrentNodeTaskState(WorkFlowNodeInstance currentInstanceNode){
+        List<WorkTaskRecord> notFinish = workTaskRecordService.list(new LambdaQueryWrapper<WorkTaskRecord>().eq(WorkTaskRecord::getInstanceId, currentInstanceNode.getId())
+                .eq(WorkTaskRecord::getFinished,Boolean.FALSE)
+                .eq(BaseEntity::getDeleted, Boolean.FALSE));
+        return CollectionUtil.isEmpty(notFinish);
+
+    }
+
+    /**
+     * 添加流程日志
+     * @param workNodeCommit
+     */
+    protected boolean addWorkflowLog(WorkNodeCommit workNodeCommit,WorkFlowNodeInstance currentInstanceNode){
+        WorkFlowLog log = new WorkFlowLog();
+        log.setBusinessId(currentInstanceNode.getBusinessId());
+        log.setBusinessType(currentInstanceNode.getBusinessType());
+        log.setHandingTime(new Date().getTime() - currentInstanceNode.getCreated().getTime());
+        log.setHandlerId(LoginContext.getCurrentUserId());
+        log.setComments(workNodeCommit.getComments());
+        log.setState(workNodeCommit.getState().name());
+        log.setInstanceId(workNodeCommit.getInstanceNodeId());
+        log.setBusinessSubId(workNodeCommit.getBusinessSubId());
+        log.setBusinessMinId(workNodeCommit.getBusinessMinId());
+        return workFlowLogService.add(log);
+    }
+
+    /**
+     * 构建节点实例
+     * @param nextWorkNode
+     * @param currentInstanceNode
+     * @param businessSubId
+     * @param businessMinId
+     * @return
+     */
+    private WorkFlowNodeInstance buildNodeInstance(WorkNodeDTO nextWorkNode, WorkFlowNodeInstance currentInstanceNode, String businessSubId, String businessMinId){
+        WorkFlowNodeInstance nodeInstance = new WorkFlowNodeInstance();
+        nodeInstance.setNodeId(nextWorkNode.getId());
+        nodeInstance.setFlowId(nextWorkNode.getFlowId());
+        nodeInstance.setBusinessId(currentInstanceNode.getBusinessId());
+        nodeInstance.setBusinessSubId(businessSubId);
+        nodeInstance.setBusinessMinId(businessMinId);
+        nodeInstance.setBusinessType(currentInstanceNode.getBusinessType());
+        nodeInstance.setSequence((currentInstanceNode.getSequence()==null?0:currentInstanceNode.getSequence())+1);
+        nodeInstance.setState(NodeStateEnum.PENDING.name());
+        return nodeInstance;
+    }
+
+    /**
+     * 创建运行时的下一个节点实例
+     * @param currentInstanceNode
+     */
+    protected void addNextInstanceNode(WorkFlowNodeInstance currentInstanceNode,WorkNodeDTO nextWorkNode,Long handlerId,String businessSubId,String businessMinId){
+        if (nextWorkNode!=null){
+            List<WorkNodeTask> tasks = nextWorkNode.getTasks();
+            //如果该节点下面只有一个任务，且由系统控制。则需要相关条件判断需不需要创建该节点实例
+            WorkFlowNodeInstance nodeInstance = buildNodeInstance(nextWorkNode, currentInstanceNode,businessSubId,businessMinId);
+            workFlowNodeInstanceService.add(nodeInstance);
+            if (CollectionUtil.isNotEmpty(tasks)){
+                workTaskRecordService.doCreateNodeTaskRecord(this,tasks,nodeInstance,handlerId);
+            }
+            // 节点下面没有任务，说明是状态节点。状态节点业务上未定义逻辑
+        }
+    }
+
 }

service/src/main/java/com/dayou/workflow/config/WorkflowInterceptor.java

@@ -9,14 +9,11 @@ import com.dayou.dto.WorkNodeCommit;
 import com.dayou.dto.WorkNodeDTO;
 import com.dayou.entity.*;
 import com.dayou.enums.MainBusinessEnum;
-import com.dayou.enums.ProductionEnum;
 import com.dayou.enums.workflow.CallbackEnum;
 import com.dayou.enums.workflow.NodeStateEnum;
 import com.dayou.enums.workflow.WorkflowNodeEnum;
 import com.dayou.exception.ErrorCode;
 import com.dayou.mapper.WorkFlowNodeInstanceMapper;
-import com.dayou.mapper.WorkNodeTaskMapper;
-import com.dayou.mapper.WorkTaskRecordMapper;
 import com.dayou.service.workflow.IWorkFlowLogService;
 import com.dayou.service.workflow.IWorkFlowNodeInstanceService;
 import com.dayou.service.workflow.IWorkNodeService;
@@ -38,7 +35,6 @@ import org.springframework.transaction.annotation.Transactional;
 import java.lang.reflect.Method;
 import java.util.Date;
 import java.util.List;
-import java.util.Map;
 
 import static com.dayou.common.Constants.MAJOR_HANDLER;
 import static com.dayou.common.Constants.PERSONAL_HANDLER;
@@ -106,41 +102,41 @@ public class WorkflowInterceptor implements MethodInterceptor, ApplicationContex
             String ifVerify = currentInstanceNode.getVerify();
             if (StrUtil.isNotEmpty(ifVerify)){
                 CallbackEnum callback = CallbackEnum.valueOf(ifVerify);
-                if (callback !=null){
-                    //根据callback 确定具体的业务数据
-                    //获取产品类型
-                    List<ProductionEnum> production = workNodeCommit.getProduction();
-                    switch (callback){
-                        case CHECK_PRODUCTION_CHECK:
-                           nextWorkNode = workNodeService.getNextWorkNodeByCheckState(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(),
-                                   workNodeCommit.getDoSecondCheck(),workNodeCommit.getDoThirdCheck());
-                            break;
-                        case CHECK_PRODUCTION_TYPE:
-                            //1. 获取业务上出具的产品类型。
-                            //2.根据出具的产品类型 确定需要哪些节点
-                            Map<String,List<WorkflowNodeEnum>> majorNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.MAJOR_BUSINESS.name(),
-                                    production);
-                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(), majorNecessaryNodes);
-                            break;
-                        case CHECK_PRODUCTION_FUND:
-                            if (workNodeCommit.getIfProductionFund()){
-                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
-                            }
-                            break;
-                        case CHECK_PERSONAL_PRODUCTION_TYPE:
-                            //1. 获取业务上出具的产品类型。
-                            //2.根据出具的产品类型 确定需要哪些节点
-                            Map<String,List<WorkflowNodeEnum>> personalNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.PERSONAL_BUSINESS.name(),
-                                    production);
-                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(), personalNecessaryNodes);
-                            break;
-                        case CHECK_FEEDBACK:
-                            if (!workNodeCommit.getIfFeedback()){
-                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
-                            }
-                            break;
-                    }
-                }
+//                if (callback !=null){
+//                    //根据callback 确定具体的业务数据
+//                    //获取产品类型
+//                    List<ProductionEnum> production = workNodeCommit.getProduction();
+//                    switch (callback){
+//                        case CHECK_PRODUCTION_CHECK:
+//                           nextWorkNode = workNodeService.getNextWorkNodeByCheckState(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(),
+//                                   workNodeCommit.getDoSecondCheck(),workNodeCommit.getDoThirdCheck());
+//                            break;
+//                        case CHECK_PRODUCTION_TYPE:
+//                            //1. 获取业务上出具的产品类型。
+//                            //2.根据出具的产品类型 确定需要哪些节点
+//                            Map<String,List<WorkflowNodeEnum>> majorNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.MAJOR_BUSINESS.name(),
+//                                    production);
+//                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(), majorNecessaryNodes);
+//                            break;
+//                        case CHECK_PRODUCTION_FUND:
+//                            if (workNodeCommit.getIfProductionFund()){
+//                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
+//                            }
+//                            break;
+//                        case CHECK_PERSONAL_PRODUCTION_TYPE:
+//                            //1. 获取业务上出具的产品类型。
+//                            //2.根据出具的产品类型 确定需要哪些节点
+//                            Map<String,List<WorkflowNodeEnum>> personalNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.PERSONAL_BUSINESS.name(),
+//                                    production);
+//                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(), personalNecessaryNodes);
+//                            break;
+//                        case CHECK_FEEDBACK:
+//                            if (!workNodeCommit.getIfFeedback()){
+//                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
+//                            }
+//                            break;
+//                    }
+//                }
             }
 
             if (nextWorkNode==null ){
@@ -152,30 +148,30 @@ public class WorkflowInterceptor implements MethodInterceptor, ApplicationContex
 
             }
 
-            if (CollectionUtil.isNotEmpty(workNodeCommit.getReportNos())){
-
-                //主流程分支
-                String code = workNodeService.getOne(new LambdaQueryWrapper<WorkNode>()
-                        .select(WorkNode::getCode)
-                        .eq(BaseEntity::getId, currentInstanceNode.getNodeId()).eq(BaseEntity::getDeleted, Boolean.FALSE)).getCode();
-                WorkflowNodeEnum workflowNodeEnum = WorkflowNodeEnum.valueOf(code);
-
-                if (workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_STATEMENT)){
-                    for (String businessSubId :workNodeCommit.getReportNos()){
-                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),businessSubId,null);
-                    }
-                }
-                else if(workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_REPORT) || workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_LETTER)){
-                    for (String businessMinId :workNodeCommit.getReportNos()){
-                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),businessMinId);
-                    }
-                }else {
-                    addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
-                }
-            }
-            else {
-                addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
-            }
+//            if (CollectionUtil.isNotEmpty(workNodeCommit.getReportNos())){
+//
+//                //主流程分支
+//                String code = workNodeService.getOne(new LambdaQueryWrapper<WorkNode>()
+//                        .select(WorkNode::getCode)
+//                        .eq(BaseEntity::getId, currentInstanceNode.getNodeId()).eq(BaseEntity::getDeleted, Boolean.FALSE)).getCode();
+//                WorkflowNodeEnum workflowNodeEnum = WorkflowNodeEnum.valueOf(code);
+//
+//                if (workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_STATEMENT)){
+//                    for (String businessSubId :workNodeCommit.getReportNos()){
+//                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),businessSubId,null);
+//                    }
+//                }
+//                else if(workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_REPORT) || workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_LETTER)){
+//                    for (String businessMinId :workNodeCommit.getReportNos()){
+//                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),businessMinId);
+//                    }
+//                }else {
+//                    addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
+//                }
+//            }
+//            else {
+//                addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
+//            }
 
         }
         return proceed;

service/src/main/java/com/dayou/workflow/handler/MajorNodeHandler.java

@@ -1,28 +1,30 @@
 package com.dayou.workflow.handler;
 
 import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.dayou.common.BaseEntity;
 import com.dayou.dto.HandlerPermissionDTO;
 import com.dayou.dto.WorkNodeCommit;
+import com.dayou.dto.WorkNodeDTO;
 import com.dayou.entity.*;
+import com.dayou.enums.MainBusinessEnum;
+import com.dayou.enums.ProductionEnum;
+import com.dayou.enums.workflow.CallbackEnum;
 import com.dayou.enums.workflow.HandlerPermissionEnum;
-import com.dayou.enums.workflow.NodeLogEnum;
+import com.dayou.enums.workflow.WorkflowNodeEnum;
 import com.dayou.mapper.*;
 import com.dayou.service.IUserPostService;
-import com.dayou.service.IUserService;
-import com.dayou.service.workflow.IWorkFlowLogService;
 import com.dayou.service.workflow.IWorkFlowNodeInstanceService;
-import com.dayou.utils.LoginContext;
-import com.dayou.workflow.annotation.WorkflowControl;
+import com.dayou.service.workflow.IWorkNodeService;
 import com.dayou.workflow.config.WorkNodeProcessable;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.util.Arrays;
-import java.util.Date;
 import java.util.List;
+import java.util.Map;
 
 import static com.dayou.enums.workflow.NodeStateEnum.SKIP;
 import static com.dayou.enums.workflow.WorkflowNodeEnum.*;
@@ -42,8 +44,6 @@ public class MajorNodeHandler extends WorkNodeProcessable {
     @Autowired
     private WorkFlowNodeInstanceMapper workFlowNodeInstanceMapper;
     @Autowired
-    private IWorkFlowLogService workFlowLogService;
-    @Autowired
     private MajorProductionMapper majorProductionMapper;
     @Autowired
     private MajorTargetMapper majorTargetMapper;
@@ -53,31 +53,79 @@ public class MajorNodeHandler extends WorkNodeProcessable {
     private DepartmentMapper departmentMapper;
     @Autowired
     private IUserPostService userPostService;
+    @Autowired
+    private IWorkNodeService workNodeService;
 
 
     @Override
-    @WorkflowControl
     public boolean forward(WorkNodeCommit workNodeCommit) {
-         return super.forward(workNodeCommit);
+        WorkFlowNodeInstance currentInstanceNode = workFlowNodeInstanceService.getById(workNodeCommit.getInstanceNodeId());
+        WorkNodeDTO nextWorkNode = beforeForward(workNodeCommit,currentInstanceNode);
+        if (nextWorkNode!=null){
+            String ifVerify = currentInstanceNode.getVerify();
+            if (StrUtil.isNotEmpty(ifVerify)){
+                CallbackEnum callback = CallbackEnum.valueOf(ifVerify);
+                if (callback !=null){
+                    //根据callback 确定具体的业务数据
+                    //获取产品类型
+                    List<ProductionEnum> production = workNodeCommit.getProduction();
+                    switch (callback){
+                        case CHECK_PRODUCTION_CHECK:
+                            nextWorkNode = workNodeService.getNextWorkNodeByCheckState(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(),
+                                    workNodeCommit.getDoSecondCheck(),workNodeCommit.getDoThirdCheck());
+                            break;
+                        case CHECK_PRODUCTION_TYPE:
+                            //1. 获取业务上出具的产品类型。
+                            //2.根据出具的产品类型 确定需要哪些节点
+                            Map<String,List<WorkflowNodeEnum>> majorNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.MAJOR_BUSINESS.name(),
+                                    production);
+                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(),currentInstanceNode.getNodeCode(), majorNecessaryNodes);
+                            break;
+                        case CHECK_PRODUCTION_FUND:
+                            if (workNodeCommit.getIfProductionFund()){
+                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
+                            }
+                            break;
+                    }
+                }
+            }
+            if (CollectionUtil.isNotEmpty(workNodeCommit.getReportNos())){
+
+                //主流程分支
+                String code = workNodeService.getOne(new LambdaQueryWrapper<WorkNode>()
+                        .select(WorkNode::getCode)
+                        .eq(BaseEntity::getId, currentInstanceNode.getNodeId()).eq(BaseEntity::getDeleted, Boolean.FALSE)).getCode();
+                WorkflowNodeEnum workflowNodeEnum = WorkflowNodeEnum.valueOf(code);
+
+                if (workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_STATEMENT)){
+                    for (String businessSubId :workNodeCommit.getReportNos()){
+                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),businessSubId,null);
+                    }
+                }
+                else if(workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_REPORT) || workflowNodeEnum.equals(WorkflowNodeEnum.WRITE_LETTER)){
+                    for (String businessMinId :workNodeCommit.getReportNos()){
+                        addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),businessMinId);
+                    }
+                }else {
+                    addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
+                }
+            }
+            else {
+                addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
+            }
+            return Boolean.TRUE;
+        }
+        return Boolean.FALSE;
     }
 
     @Override
-    @WorkflowControl
     public boolean skip(WorkNodeCommit workNodeCommit){
         WorkFlowNodeInstance instanceNode = workFlowNodeInstanceService.getById(workNodeCommit.getInstanceNodeId());
          workFlowNodeInstanceService.update(new LambdaUpdateWrapper<WorkFlowNodeInstance>().set(WorkFlowNodeInstance::getState,SKIP)
                 .set(WorkFlowNodeInstance::getComment,workNodeCommit.getComments())
                 .eq(WorkFlowNodeInstance::getId,workNodeCommit.getInstanceNodeId()));
         //添加日志
-        WorkFlowLog log = new WorkFlowLog();
-                    log.setBusinessId(instanceNode.getBusinessId());
-                    log.setBusinessType(instanceNode.getBusinessType());
-                    log.setHandingTime(new Date().getTime() - instanceNode.getCreated().getTime());
-                    log.setHandlerId(LoginContext.getCurrentUserId());
-                    log.setComments(workNodeCommit.getComments());
-                    log.setState(NodeLogEnum.SKIP.name());
-                    log.setInstanceId(workNodeCommit.getInstanceNodeId());
-        return workFlowLogService.add(log);
+        return addWorkflowLog(workNodeCommit,instanceNode);
     }
 
     @Override

service/src/main/java/com/dayou/workflow/handler/PersonalNodeHandler.java

@@ -1,21 +1,32 @@
 package com.dayou.workflow.handler;
 
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.dayou.common.BaseEntity;
 import com.dayou.dto.HandlerPermissionDTO;
 import com.dayou.dto.WorkNodeCommit;
+import com.dayou.dto.WorkNodeDTO;
 import com.dayou.entity.Department;
 import com.dayou.entity.Personal;
 import com.dayou.entity.WorkFlowNodeInstance;
+import com.dayou.enums.MainBusinessEnum;
+import com.dayou.enums.ProductionEnum;
+import com.dayou.enums.workflow.CallbackEnum;
 import com.dayou.enums.workflow.HandlerPermissionEnum;
+import com.dayou.enums.workflow.WorkflowNodeEnum;
 import com.dayou.mapper.DepartmentMapper;
 import com.dayou.mapper.PersonalMapper;
+import com.dayou.service.ICustomerCompanyService;
 import com.dayou.service.IUserPostService;
-import com.dayou.workflow.annotation.WorkflowControl;
+import com.dayou.service.workflow.IWorkFlowNodeInstanceService;
+import com.dayou.service.workflow.IWorkNodeService;
 import com.dayou.workflow.config.WorkNodeProcessable;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
+import java.util.Map;
+
 import static com.dayou.common.Constants.PERSONAL_DEPARTMENT;
 
 /**
@@ -37,13 +48,58 @@ public class PersonalNodeHandler extends WorkNodeProcessable {
     @Autowired
     private IUserPostService userPostService;
 
+    @Autowired
+    private IWorkFlowNodeInstanceService workFlowNodeInstanceService;
 
+    @Autowired
+    private IWorkNodeService workNodeService;
+
+    @Autowired
+    private ICustomerCompanyService customerCompanyService;
 
 
     @Override
-    @WorkflowControl
     public boolean forward(WorkNodeCommit workNodeCommit) {
-       return super.forward(workNodeCommit);
+        WorkFlowNodeInstance currentInstanceNode = workFlowNodeInstanceService.getById(workNodeCommit.getInstanceNodeId());
+        WorkNodeDTO nextWorkNode = beforeForward(workNodeCommit,currentInstanceNode);
+        if (nextWorkNode!=null){
+            String ifVerify = currentInstanceNode.getVerify();
+            if (StrUtil.isNotEmpty(ifVerify)) {
+                CallbackEnum callback = CallbackEnum.valueOf(ifVerify);
+                if (callback != null) {
+                    //根据callback 确定具体的业务数据
+                    //获取产品类型
+                    List<ProductionEnum> production = workNodeCommit.getProduction();
+                    switch (callback) {
+                        case CHECK_PERSONAL_PRODUCTION_TYPE:
+                            //1. 获取业务上出具的产品类型。
+                            //2.根据出具的产品类型 确定需要哪些节点
+                            Map<String, List<WorkflowNodeEnum>> personalNecessaryNodes = CallbackEnum.NecessaryNode.getByProduction(MainBusinessEnum.PERSONAL_BUSINESS.name(),
+                                    production);
+                            nextWorkNode = workNodeService.getNextWorkNodeByBusiness(currentInstanceNode.getFlowId(), currentInstanceNode.getNodeCode(), personalNecessaryNodes);
+                            break;
+                        case CHECK_FEEDBACK:
+                            if (!workNodeCommit.getIfFeedback()) {
+                                nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
+                            }
+                            break;
+                        case CHECK_PERSONAL_CLIENT_TYPE:
+                            Long ccId = workNodeCommit.getCcId();
+                            if (ccId !=null){
+                                if (customerCompanyService.avoidWareHouseApply(ccId)){
+                                    for (int i=0; i<2; i++){
+                                        nextWorkNode = workNodeService.getNextWorkNode(nextWorkNode.getFlowId(), nextWorkNode.getId());
+                                    }
+
+                                }
+                            }
+                    }
+                }
+            }
+            addNextInstanceNode(currentInstanceNode,nextWorkNode, workNodeCommit.getNextHandlerId(),workNodeCommit.getBusinessSubId(),workNodeCommit.getBusinessMinId());
+            return Boolean.TRUE;
+        }
+        return Boolean.FALSE;
     }
 
     @Override