Source/UBCS/ubcs-ops/ubcs-flow/src/main/java/com/vci/ubcs/flow/engine/service/impl/VCIFlowserviceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,176 @@
/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill åº„骞 (smallchill@163.com)
 */
package com.vci.ubcs.flow.engine.service.impl;

import com.vci.ubcs.flow.core.constant.ProcessConstant;
import com.vci.ubcs.flow.core.entity.BladeFlow;
import com.vci.ubcs.flow.core.utils.TaskUtil;
import com.vci.ubcs.flow.engine.entity.*;
import com.vci.ubcs.flow.engine.service.FlowEngineService;
import com.vci.ubcs.flow.engine.service.FlowTaskUserService;
import com.vci.ubcs.flow.engine.service.VICFlowService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.*;
import org.flowable.engine.*;
import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.support.Kv;
import org.springframework.stereotype.Service;
import java.util.*;

/**
 * å·¥ä½œæµæœåŠ¡å®žçŽ°ç±»
 *
 * @author Chill
 */
@Slf4j
@Service
@AllArgsConstructor
public class VCIFlowserviceImpl implements VICFlowService {

   private final RuntimeService runtimeService;
   private final IdentityService identityService;
   private final RepositoryService repositoryService;
   private final TaskService taskService;
   private final FlowTaskUserService flowTaskUserService;
   private final FlowEngineService flowEngineService;
   private final HistoryService historyService;

   @Override
   public R<BladeFlow> startProcess(FlowTaskDTO flowTaskUserC){
      String modelKey = flowTaskUserC.getModelKey();
      String templateId = flowTaskUserC.getTemplateId();

      Kv kv = Kv.create()
         .set(ProcessConstant.TASK_VARIABLE_CREATE_USER, AuthUtil.getUserName());

      // è®¾ç½®æµç¨‹å¯åŠ¨ç”¨æˆ·
      identityService.setAuthenticatedUserId(TaskUtil.getTaskUser());

      // å¼€å¯æµç¨‹
      //查询最新的流程部署id
      ProcessDefinition latesDefinition = repositoryService.createProcessDefinitionQuery().latestVersion().processDefinitionKey(modelKey).singleResult();
      String processDefinitionId = latesDefinition.getId();

      //查询每一步审核人
      List<FlowTaskUser> taskUsers = flowTaskUserService.getTaskUserByTemplateAndModelKey(templateId,modelKey);
      Set<String> taskIdSet = new HashSet<>();
      for (FlowTaskUser taskUser:taskUsers){
         kv.put(taskUser.getTaskId(),TaskUtil.getTaskUser(taskUser.getUserId()));
         taskIdSet.add(taskUser.getTaskId());
      }

      //对比配置的审核人员和流程中节点是否一致，可能存在流程节点变更了，多了或者少了节点，但是配置审核人员的节点没有变
//      List<Map<String,String>> processTasks = flowEngineService.getNodeByFlowableKey(modelKey);
//      for (Map<String,String> mi:processTasks){
//         String taskId = mi.get(flowEngineService.getTaskIdString());
//         if(!taskIdSet.contains(taskId)){
//            throw new ServiceException("流程已重新部署，节点已改变，请设置审核人员！");
//         }
//      }
//      if(taskIdSet.size()!=processTasks.size()){
//         throw new ServiceException("流程已重新部署，节点已改变，请设置审核人员！");
//      }

      //流程中文件、变量等
      //do..

      ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefinitionId, modelKey, kv);
      // ç»„装流程通用类
      BladeFlow flow = new BladeFlow();
      flow.setProcessInstanceId(processInstance.getId());

      return R.data(flow);
   }

   public static String NODE_NOW = "now";
   public static String NODE_NEXT = "next";
   /**
    * èŽ·å–任务节点
    *
    * @param node   æŸ¥è¯¢èŠ‚点选择
    * @param processInstanceId æµç¨‹å®žä¾‹id
    */
   public FlowTaskDTO nextFlowNode(String node, String processInstanceId) {
      FlowTaskDTO flowTaskDTO = new FlowTaskDTO();
      List<FlowTaskDTO> taskList = new ArrayList<>();//节点按钮
      flowTaskDTO.setToTasks(taskList);

      Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).active().singleResult();
      ExecutionEntity ee = (ExecutionEntity) runtimeService.createExecutionQuery()
         .executionId(task.getExecutionId()).singleResult();
      // å½“前审批节点
      String crruentActivityId = ee.getActivityId();
      BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
      FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(crruentActivityId);

      //这个实例的所有节点
      ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
      Map<String, Object> processVariables = processInstance.getProcessVariables();//所有参数
      flowTaskDTO.setVars(processVariables);

      String modelKey = processInstance.getProcessDefinitionKey();
      List<FlowTaskDTO> mis = flowEngineService.getNodeByFlowableKey(modelKey);

      // è¾“出连线
      List<SequenceFlow> outFlows = flowNode.getOutgoingFlows();
      for (SequenceFlow sequenceFlow : outFlows) {
         //当前审批节点
         if (NODE_NOW.equals(node)) {
            FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
            System.out.println("当前节点: id=" + sourceFlowElement.getId() + ",name=" + sourceFlowElement.getName());
         } else if (NODE_NEXT.equals(node)) {
            // ä¸‹ä¸€ä¸ªå®¡æ‰¹èŠ‚点
            FlowElement targetFlow = sequenceFlow.getTargetFlowElement();
            if (targetFlow instanceof UserTask) {
               System.out.println("下一节点: id=" + targetFlow.getId() + ",name=" + targetFlow.getName());
            }
            // å¦‚果下个审批节点为排他网关
            if (targetFlow instanceof ExclusiveGateway) {

               ExclusiveGateway exclusiveGateway = (ExclusiveGateway) targetFlow;
               List<SequenceFlow> exclusiveGatewayOutgoingFlows = exclusiveGateway.getOutgoingFlows();
               for (SequenceFlow nexti:exclusiveGatewayOutgoingFlows){
                  String conditionExpression = nexti.getConditionExpression();//condition
                  String taskId = nexti.getTargetRef();//taskId
                  String name = nexti.getName();//toName,驳回、同意

                  for (FlowTaskDTO flowTaskUserCi:mis){
                     if(taskId.equals(flowTaskUserCi.getTaskId())){
                        flowTaskUserCi.setCondition(conditionExpression);
                        if(conditionExpression.split("=").length>1) {
                           flowTaskUserCi.setConditionKey(conditionExpression.split("=")[0]);
                           flowTaskUserCi.setConditionValue(conditionExpression.split("=")[1]);
                        }
                        flowTaskUserCi.setToName(name);
                        flowTaskUserCi.setToTaskId(taskId);
                        flowTaskUserCi.setToTaskName(flowTaskUserCi.getTaskName());
                        taskList.add(flowTaskUserCi);
                     }
                  }
               }
            }
         }
      }
      return flowTaskDTO;
   }
}