feat: base frame

This commit is contained in:
yjz
2024-05-30 17:57:32 +08:00
commit d4937a2428
2787 changed files with 770496 additions and 0 deletions
@@ -0,0 +1,30 @@
package com.jero.modules.activiti.config;
import com.jero.modules.activiti.listener.MyGlobalEventListener;
import com.jero.modules.activiti.service.impl.image.ICustomProcessDiagramGenerator;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.activiti.spring.boot.ProcessEngineConfigurationConfigurer;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import java.util.Collections;
/**
* @author liJiaRao
* @date 2023-09-05 17:53
*/
@Configuration
public class ActivitiConfig implements ProcessEngineConfigurationConfigurer {
@Resource
private ICustomProcessDiagramGenerator customProcessDiagramGenerator;
@Override
public void configure(SpringProcessEngineConfiguration springProcessEngineConfiguration) {
//全局监听器
springProcessEngineConfiguration.setEventListeners(Collections.singletonList(new MyGlobalEventListener()));
//有bug 自定义id
//springProcessEngineConfiguration.setIdGenerator(new MyGen());
springProcessEngineConfiguration.setProcessDiagramGenerator(customProcessDiagramGenerator);
}
}
@@ -0,0 +1,29 @@
package com.jero.modules.activiti.config;
import lombok.extern.slf4j.Slf4j;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import java.util.List;
/**
* @author liJiaRao
* @date 2023-09-05 14:54
*/
@Slf4j
public class MultiInstanceTaskHandler implements TaskListener {
@Override
public void notify(DelegateTask delegateTask) {
DelegateExecution execution = delegateTask.getExecution();
System.out.println("流程实例总数:" + execution.getVariable("nrOfInstances"));
System.out.println("当前活动的流程实例总数:" + execution.getVariable("nrOfActiveInstances"));
System.out.println("已经完成实例的数目:" + execution.getVariable("nrOfCompletedInstances"));
System.out.println("leader" + execution.getVariable("leader"));
System.out.println("---------------------------------------分隔线----------------------------------------------------");
}
}
@@ -0,0 +1,25 @@
package com.jero.modules.activiti.config;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.LocalDateTimeUtil;
import org.activiti.engine.impl.cfg.IdGenerator;
import org.springframework.stereotype.Component;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.atomic.AtomicLong;
/**
* @author liJiaRao
* @date 2023-09-05 17:39
*/
@Component
public class MyGen implements IdGenerator {
@Override
public synchronized String getNextId() {
DateTime date = DateUtil.date();
//标准日期格式:yyyyMMddHHmmssSSS
return DateUtil.format(date, DatePattern.PURE_DATETIME_MS_PATTERN);
}
}
@@ -0,0 +1,130 @@
package com.jero.modules.activiti.config;
import java.awt.*;
/**
* 常量类
*@author jjd
**/
public final class WorkflowConstants {
/**businessKey**/
public static final String WORKLOW_BUSINESS_KEY = "businessKey";
/**按钮网关**/
public static final String WAY_TYPE = "wayType";
/**按钮网关**/
public static final String WAY_TYPE_PREFIX = "way_type_";
/**项目id**/
public static final String PROJECT_ID = "projectId";
/**核心企业Id变量**/
public static final String CORE_ENTERPRISE_ID="coreEnterpriseId";
/**链属企业Id变量**/
public static final String CHAIN_ENTERPRISE_ID="chainEnterpriseId";
/**银行企业Id变量**/
public static final String BANK_ENTERPRISE_ID="bankEnterpriseId";
/**保理公司Id变量**/
public static final String BAOLI_ENTERPRISE_ID="baoliEnterpriseId";
/**立账开立企业Id变量**/
public static final String START_ENTERPRISE_ID="startEnterpriseId";
/**立账合作企业Id变量**/
public static final String PARTNER_ENTERPRISE_ID="partnerEnterpriseId";
/**母公司企业id**/
public static final String PARENT_ENTERPRISE_ID="parentEnterpriseId";
/**指定签收企业id**/
public static final String RECEIVE_ENTERPRISE_ID ="receiveEnterpriseId";
/**转出方企业Id变量**/
public static final String TRANSFER_ENTERPRISE_ID="transEnterpriseId";
/**指定签收企业id**/
public static final String AC_TASK_ID ="acTaskId";
/**企业所有角色**/
public static final String ENT_ALL_ROLE ="all";
/**运营所有角色**/
public static final String OPER_ALL_ROLE ="oper";
/**流程定义缓存时间**/
public static final int PROCESS_DEFINITION_CACHE = 60;
/**流程实例激活**/
public static final int PROCESS_INSTANCE_ACTIVE = 1;
/**流程实例挂起**/
public static final int PROCESS_INSTANCE_SUSPEND = 0;
/**读取图片**/
public static final String READ_IMAGE = "image";
/**读取xml**/
public static final String READ_XML = "xml";
/**流程激活**/
public static final Integer ACTIVE_PROCESSDEFINITION = 1;
/**流程挂起**/
public static final Integer SUSPEND_PROCESSDEFINITION = 2;
/**流程状态:0-全部,1-正常,2-已挂起**/
public static final int QUERY_ALL = 0;
public static final int QUERY_NORMAL = 1;
public static final int QUERY_SUSPENDED = 2;
/**流程实例状态:0-全部,1-正常,2-已删除**/
public static final int INSTANCE_ALL = 0;
public static final int INSTANCE_NOT_DELETED = 1;
public static final int INSTANCE_DELETED = 2;
/** 系统管理员ID **/
public static final String INTERFACE_SYSTEM_ID = "-1";
/** 系统管理员名称 **/
public static final String INTERFACE_SYSTEM_NAME = "系统操作";
/** 流程部署类型:1-启动并激活,2-启动即挂起 **/
public static final int PROCESS_START_ACTIVE = 1;
public static final int PROCESS_START_SUSPEND = 2;
/** 用于标识流程项目配置信息校验结果:1:新流程,2:新版本, 3:流程类别有误 **/
public static final int CHECK_NEW_PROCESS = 1;
public static final int CHECK_NEW_VERSION = 2;
public static final int CHECK_ERROR_PROCESS_TYPE = 3;
/** 默认网关条件值 **/
public static final Integer default_GATEWAY_CONDITION_VALUE = 1;
/** 工作流-业务状态表数据类型:1-工作流状态,2-业务状态 **/
public static final Integer PROCESS_STATUS = 1;
public static final Integer BIZNESS_STATUS = 2;
/** 新增流程时标识:1-直接保存,2-提示覆盖 **/
public static final Integer PROCESS_STATUS_SAVE = 1;
public static final Integer BIZNESS_STATUS_WARN = 2;
/** 模板类型标识:1-新创建或直接导入的模板,2-默认模板生成 **/
public static final Integer MODEL_TYPE_1 = 1;
public static final Integer MODEL_TYPE_2 = 2;
/** 查询流程定义标识:1-查询最新版本流程定义,2-查询所有版本 **/
public static final Integer QUERY_PROCESS_LATEST_VERSION = 1;
public static final Integer QUERY_PROCESS_ALL_VERSION = 2;
/** 按钮网关 通过1 */
public static final String WAY_TYPE_PASS = "1";
/** 按钮网关 驳回或结束0 */
public static final String WAY_TYPE_REJECT = "0";
/** 按钮网关 退回2 */
public static final String WAY_TYPE_BACK = "2";
/**任务参数为空**/
public static final int TASK_CHECK_PARAM_NULL = -1;
/**任务已办理**/
public static final int TASK_CHECK_COMPLETED = 1;
/**无权限办理**/
public static final int TASK_CHECK_NO_PERMISSIONS= 2;
/**任务校验通过**/
public static final int TASK_CHECK_PASS = 0;
/** 动态流程图颜色定义 **/
public static final Color COLOR_NORMAL = new Color(0, 205, 0);
public static final Color COLOR_CURRENT = new Color(255, 0, 0);
/** 定义生成流程图时的边距(像素) **/
public static final int PROCESS_PADDING = 5;
}
@@ -0,0 +1,312 @@
package com.jero.modules.activiti.controller;
import cn.hutool.core.bean.BeanUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.DictPoint;
import com.jero.common.constant.enums.LanguageEnum;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.MessageUtils;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.entity.ProcessNode;
import com.jero.modules.activiti.enums.CommitFlagEnum;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.service.*;
import com.jero.common.api.vo.ResultCommon;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.activiti.bpmn.converter.BpmnXMLConverter;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.editor.language.json.converter.BpmnJsonConverter;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.repository.ProcessDefinitionQuery;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.*;
/**
* @author liJiaRao
* @date 2023-08-02 15:05
*/
@Slf4j
@Transactional(rollbackFor = Exception.class)
@RestController
@Api(tags = "流程控制")
@RequestMapping("/activiti")
public class ActivitiController {
@Autowired
private ProcessService processService;
@Resource
private RepositoryService repositoryService;
@Resource
private HistoryService historyService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private ProcessNodeService processNodeService;
@Resource
private ProcessModelNodeService modelNodeService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private ProcessAllService processAllService;
@Resource
private ProcessApprovalRecordService processApprovalRecordService;
@ApiOperation(value="启动流程")
@PostMapping("/start")
public Result<Map<String, String>> start(@RequestBody Map<String,Object> map) {
String key = map.get("key").toString();
String prcName = map.get("prcName").toString();
String prcMes = map.get("prcMes").toString();
Date dueTime = (Date) map.get("dueTime");
// 1、创建ProcessEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、获取RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3、根据流程key启动流程
ProcessInstance processInstance = runtimeService
.startProcessInstanceByKey(key, map);
String processInstanceId = processInstance.getId();
//根据流程实例id更新流程总表
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
process.setCreateUserId(loginUser.getId());
process.setPrcName(prcName);
process.setPrcMes(prcMes);
process.setDueTime(dueTime);
process.setProjectId("业务id");
processAllService.updateById(process);
String processDefinitionId = processInstance.getProcessDefinitionId();
// 输出内容
Map<String, String> map1 = new HashMap<>();
map1.put("流程Id", processInstance.getDeploymentId());
map1.put("流程定义id", processDefinitionId);
map1.put("流程实例id", processInstanceId);
map1.put("当前活动Id", processInstance.getActivityId());
//String mainDrafter = map.get("mainDrafter").toString();
return Result.OK(map1);
}
@ApiOperation(value="查询待办列表")
@GetMapping("/getTaskList")
public Result<List<Map<String, String>>> testFindPersonalTaskList(@RequestParam(value = "assignee") String assignee,
@RequestParam(value = "processKey") String processKey,
@RequestParam(value = "group") String group) {
//根据流程key 和 任务负责人 查询任务
TaskQuery taskQuery = taskService.createTaskQuery();
if (StringUtils.isNotBlank(assignee)) {
//只查询该任务负责人的任务
taskQuery.taskAssignee(assignee);
}
if (StringUtils.isNotBlank(group)) {
//只查询该组的任务
taskQuery.taskCandidateGroup(group);
}
if (StringUtils.isNotBlank(processKey)) {
//流程Key
taskQuery.processDefinitionKey(processKey);
}
List<Task> list = taskQuery.list();
List<Map<String, String>> result = new ArrayList<>();
for (Task task : list) {
Map<String, String> map = new HashMap<>();
map.put("流程实例id", task.getProcessInstanceId());
map.put("任务id", task.getId());
map.put("任务负责人:", task.getAssignee());
map.put("任务名称:", task.getName());
result.add(map);
}
return Result.OK(result);
}
@ApiOperation(value="完成任务")
@PostMapping("/complete")
public Result<Object> complete(@RequestBody Map<String,Object> map) {
//todo 判断当前节点,执行不同的操作
String taskId = map.get("taskId").toString();
//Integer commitFlag = Integer.valueOf(map.get("commitFlag").toString());
//String commitText = map.get("commitText").toString();
//String commitFile = map.get("commitFile").toString();
Task task=taskService.createTaskQuery() // 创建任务查询
.taskId(taskId) // 根据任务id查询
.singleResult();
String taskName = task.getName();
if ("填写基本信息,在线编辑,分发其他起草人".equals(taskName)){
}else if ("其他起草人线下填写,上传".equals(taskName)){
}
//更新审批表为完成,填充数据
//ProcessApprovalRecord approvalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
//approvalRecord.setCommitFlag(commitFlag == 1? CommitFlagEnum.PASS.getValue() : CommitFlagEnum.REJECT.getValue());
//approvalRecord.setCommitText(commitText);
//approvalRecord.setCommitFile(commitFile);
//approvalRecord.setFinishFlag(FinishFlagEnum.COMPLETE.getValue());
//approvalRecord.setEndTime(new Date());
//processApprovalRecordService.updateById(approvalRecord);
//审批节点
taskService.complete(taskId, map);
return Result.OK();
}
@GetMapping("/deleteProcessInstance")
@ApiOperation(value = "删除流程实例", notes = "删除流程实例")
public Result<Object> deleteProcessInstance(@RequestParam(value = "id", required = false) String id) {
runtimeService.deleteProcessInstance(id,"删除");
return Result.OK();
}
@GetMapping("/deleteDeployment")
@ApiOperation(value = "删除已部署的流程定义", notes = "删除已部署的流程定义")
public Result<Object> deleteDeployment(@RequestParam(value = "id", required = false) String id) {
// true 表示级联删除引用,比如 act_ru_execution 数据
repositoryService.deleteDeployment(id, true);
return Result.OK();
}
@GetMapping("/findProcessDefinition")
@ApiOperation(value = "查询流程定义列表", notes = "查询流程定义列表")
public Result<List<Map<String, Object>>> findProcessDefinition(@RequestParam(value = "processDefinitionKey", required = false) String processDefinitionKey,
@RequestParam(value = "processDefinitionName", required = false) String processDefinitionName) {
List<Map<String, Object>> allList = new ArrayList<>();
//创建一个流程定义查询
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
if (StringUtils.isNotBlank(processDefinitionKey)) {
//根据流程定义Key查询
processDefinitionQuery.processDefinitionKey(processDefinitionKey);
}
if (StringUtils.isNotBlank(processDefinitionName)) {
//根据流程定义name查询
processDefinitionQuery.processDefinitionNameLike(processDefinitionName);
}
List<ProcessDefinition> processDefinitionList = processDefinitionQuery
.orderByProcessDefinitionVersion().asc()
.list();
//定义有序map,相同的key,添加map值后,后面的会覆盖前面的值
Map<String,ProcessDefinition> processDefinitionMap = new LinkedHashMap<>();
//遍历相同的key,替换最新的值
for(ProcessDefinition pd : processDefinitionList){
processDefinitionMap.put(pd.getKey(), pd);
}
for (ProcessDefinition processDefinition : processDefinitionMap.values()) {
//String deploymentId = processDefinition.getDeploymentId();
//Deployment deployment = repositoryService.createDeploymentQuery().deploymentId(deploymentId).singleResult();
//map.put("processDefinition", BeanUtil.beanToMap(processDefinition));
allList.add(BeanUtil.beanToMap(processDefinition));
}
return Result.OK(allList);
}
@GetMapping(value = "/readResource")
@ApiOperation(value = "获取实时流程图", notes = "获取实时流程图,输出跟踪流程信息")
public void getFlowImgByInstanceId(@RequestParam(value = "processInstanceId") String
processInstanceId, HttpServletResponse response) {
try {
processService.readResource(processInstanceId, response);
} catch (Exception e) {
e.printStackTrace();
}
}
@GetMapping(value = "/export")
@ApiOperation(value = "将流程模型导出为 bpmn文件", notes = "将流程模型导出为 bpmn文件")
public void export(@RequestParam(value = "modelId", required = false) String modelId, HttpServletResponse response) {
try {
ObjectNode objectNode = null;
try {
objectNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelId));
} catch (IOException e) {
e.printStackTrace();
}
BpmnModel bpmnModel = new BpmnJsonConverter().convertToBpmnModel(objectNode);
// 流程非空判断
if (!CollectionUtils.isEmpty(bpmnModel.getProcesses())) {
BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
String filename = bpmnModel.getMainProcess().getId() + ".bpmn";
response.setHeader("Content-Disposition", "attachment; filename=" + filename);
IOUtils.copy(in, response.getOutputStream());
response.flushBuffer();
} else {
log.error("导出model的bpmn文件失败:modelId={}", modelId);
}
} catch (Exception e) {
log.error("导出model的bpmn文件失败:modelId={}", modelId, e);
}
}
@GetMapping("test")
public Result<String> getRedisTest() {
String msg1 = MessageUtils.getMessage("message");
String msg2 = MessageUtils.getMessage("message.operate.error", "123456");
LanguageEnum language = MessageUtils.getLanguage();
return Result.OK(msg1 + "\n" + msg2);
}
@DictPoint
@GetMapping("/getNodeList")
@ApiImplicitParams({
@ApiImplicitParam(name = "processDefinitionKey", value = "流程定义key"),
@ApiImplicitParam(name = "processDefinitionId", value = "流程定义id"),
@ApiImplicitParam(name = "processInstanceId", value = "流程实例id(这个参数会去查绑定好的用户)")
})
@ApiOperation("获得节点列表")
public Result<List<ProcessNode>> getNodeList(String processDefinitionKey,String processDefinitionId,String processInstanceId) {
if (StringUtils.isNotBlank(processInstanceId)){
HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery()
.processInstanceId(processInstanceId)
.singleResult();
processDefinitionId = processInstance.getProcessDefinitionId();
}
if (StringUtils.isBlank(processDefinitionId)){
processDefinitionId = repositoryService.createProcessDefinitionQuery() // 创建部署信息查询器
.processDefinitionKey(processDefinitionKey) // 根据流程部署key查询
.latestVersion() // 根据版本倒序取最后一个版本
.singleResult().getId();
}
//查询节点信息
List<ProcessNode> nodeList = processNodeService.getNodeList(processDefinitionId,processInstanceId);
return Result.OK(nodeList);
}
@PostMapping("/saveNodeUserLink")
@ApiImplicitParams({
@ApiImplicitParam(name = "processDefinitionId", value = "流程定义id"),
@ApiImplicitParam(name = "processInstanceId", value = "流程实例id")
})
@ApiOperation("保存节点用户关系")
public Result<String> saveNodeUserLink(String processDefinitionId,String processInstanceId,@RequestBody Map<String,Object> map) {
processNodeLinkService.saveNodeUserLink(processDefinitionId,processInstanceId,map);
return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
}
}
@@ -0,0 +1,517 @@
package com.jero.modules.activiti.controller;
import cn.hutool.core.collection.CollStreamUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.jero.common.api.vo.Result;
import com.jero.common.util.MessageUtils;
import com.jero.modules.activiti.entity.ProcessModelNode;
import com.jero.modules.activiti.listener.CompleteListener;
import com.jero.modules.activiti.listener.CreateListener;
import com.jero.modules.activiti.listener.EndListener;
import com.jero.modules.activiti.listener.StartListener;
import com.jero.modules.activiti.service.ProcessNodeService;
import com.jero.modules.activiti.service.ProcessModelNodeService;
import com.jero.modules.activiti.util.CreatedTools;
import com.jero.modules.activiti.vo.AddTaskVO;
import com.jero.common.api.vo.ResultCommon;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.activiti.bpmn.converter.BpmnXMLConverter;
import org.activiti.bpmn.model.*;
import org.activiti.bpmn.model.Process;
import org.activiti.editor.constants.ModelDataJsonConstants;
import org.activiti.editor.language.json.converter.BpmnJsonConverter;
import org.activiti.engine.*;
import org.activiti.engine.delegate.BaseExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.repository.*;
import org.activiti.engine.runtime.ProcessInstance;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author liJiaRao
* @date 2023-10-07 9:51
*/
@Slf4j
@RestController
@Api(tags = "工作流模板管理")
@RequestMapping("/activitiModel")
public class ModelerController {
@Autowired
private RepositoryService repositoryService;
@Autowired
private ObjectMapper objectMapper;
@Resource
private ProcessNodeService processNodeService;
@Resource
private ProcessModelNodeService processModelNodeService;
@Resource
private RuntimeService runtimeService;
//@Autowired
//private IFormVariableService iFormVariableService;
//@Autowired
//private ICategoryService iCategoryService;
@ApiOperation(value = "导入model文件")
@ApiImplicitParams({
@ApiImplicitParam(name = "name", value = "模型名称")
})
@PostMapping("/importModelFile")
public Result<String> importModelFile(@RequestPart(value = "file", required = false) MultipartFile file,
@RequestParam(value = "name", required = false) String name) throws Exception {
InputStream fileInputStream = file.getInputStream();
XMLInputFactory xif = XMLInputFactory.newInstance();
InputStreamReader in = new InputStreamReader(fileInputStream, "UTF-8");
XMLStreamReader xtr = xif.createXMLStreamReader(in);
// 转为bpmnModel
BpmnModel bpmnModel = new BpmnXMLConverter().convertToBpmnModel(xtr);
Model model = repositoryService.newModel();
Process mainProcess = bpmnModel.getMainProcess();
String modelKey = mainProcess.getId();
ModelQuery modelQuery = repositoryService.createModelQuery();
List<Model> list = modelQuery.latestVersion().modelKey(modelKey).list();
int version = list.size()>0 ? list.get(0).getVersion() + 1 : 1;
ObjectNode modelNode = objectMapper.createObjectNode();
modelNode.put(ModelDataJsonConstants.MODEL_NAME, name);
modelNode.put(ModelDataJsonConstants.MODEL_REVISION, version);
model.setName(name);
model.setKey(modelKey);
model.setMetaInfo(modelNode.toString());
model.setVersion(version);
repositoryService.saveModel(model);
String modelId = model.getId();
ObjectNode objectNode = new BpmnJsonConverter().convertToJson(bpmnModel);
repositoryService.addModelEditorSource(modelId, objectNode.toString().getBytes(StandardCharsets.UTF_8));
//生成节点
processModelNodeService.generateNode(modelId);
return Result.OK(modelId);
}
/**
* 给没有生成节点的模板生成节点
* @return
* @throws Exception
*/
@ApiOperation(value = "generateNode")
@PostMapping("/generateNode")
public Result<String> generateNode() throws Exception {
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
processDefinitionQuery.latestVersion();
List<ProcessDefinition> processDefinitionList = processDefinitionQuery.list();
for (ProcessDefinition processDefinition : processDefinitionList) {
ModelQuery modelQuery = repositoryService.createModelQuery();
modelQuery.deploymentId(processDefinition.getDeploymentId());
Model model = modelQuery.singleResult();
String modelId = model.getId();
LambdaQueryWrapper<ProcessModelNode> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessModelNode::getModelId,modelId);
if (processModelNodeService.count(wrapper) == 0){
processModelNodeService.generateNode(modelId);
}
}
return Result.OK();
}
@ApiOperation(value = "模板列表")
@ApiImplicitParams({ @ApiImplicitParam(name = "name", value = "名称"),
@ApiImplicitParam(name = "category", value = "类型") })
@GetMapping("/modelList")
public Result<List<Model>> modelList(String name, String category) {
ModelQuery modelQuery = repositoryService.createModelQuery();
if (StringUtils.isNotBlank(category)) {
modelQuery.modelCategoryLike("%"+category+"%");
}
if (StringUtils.isNotBlank(name)) {
modelQuery.modelNameLike("%" + name + "%");
}
modelQuery.latestVersion();
List<Model> list = modelQuery.orderByCreateTime().desc().list();
return Result.OK(list);
}
@ApiOperation(value = "模板列表-分页")
@ApiImplicitParams({ @ApiImplicitParam(name = "name", value = "名称"),
@ApiImplicitParam(name = "current", value = "当前页"),
@ApiImplicitParam(name = "size", value = "每页条数") })
@GetMapping("/modelListPage")
public Result<Map<String, Object>> modelListPage(String name, int current, int size) {
if (StringUtils.isBlank(name)) {
name = "";
} else {
current = 1;
}
ModelQuery modelQuery = repositoryService.createModelQuery();
//if (StringUtils.isNotNull(category_id)) {
// modelQuery.modelCategory(category_id);
//}
//modelQuery.modelNameLike("%" + name + "%").modelTenantId("子系统1");
long total = modelQuery.count();
List<Model> list = modelQuery.orderByCreateTime().desc().listPage((current - 1) * size, size);
List<Map<String, Object>> resultList = new ArrayList<>();
Map<String, Object> map = new HashMap<>();
for(Model model:list){
Map<String, Object> resultMap = beanToMap(model);
//if(resultMap.get("category")!=null){
// Category category = iCategoryService.getById(resultMap.get("category").toString());
// resultMap.put("categoryName",category.getType());
//}
resultList.add(resultMap);
}
map.put("records", resultList);
map.put("current", current);
map.put("size", size);
map.put("total", total);
return Result.OK(map);
}
public static <T> Map<String, Object> beanToMap(T bean) {
Map<String, Object> map = new HashMap<>();
if (bean != null) {
BeanMap beanMap = BeanMap.create(bean);
for (Object key : beanMap.keySet()) {
map.put(key+"", beanMap.get(key));
}
}
return map;
}
@ApiOperation(value = "删除模板")
@ApiImplicitParam(name = "modelId", value = "模型id")
@GetMapping("/deleteModel")
public Result<String> deleteModel(String modelId) {
repositoryService.deleteModel(modelId);
return Result.OK("删除成功");
}
@ApiOperation(value = "修改流程所属分类")
@ApiImplicitParam(name = "modelId", value = "模型id")
@GetMapping("/updatModel")
public Result<String> updatModel(String modelId,String categoryId) {
Model modelData = repositoryService.getModel(modelId);
modelData.setCategory(categoryId);
repositoryService.saveModel(modelData);
return Result.OK("修改成功");
}
@ApiOperation(value = "部署")
@ApiImplicitParam(name = "modelId", value = "模型id")
@GetMapping("/deploy")
public Result<Map<String, String>> deploy(String modelId) throws Exception {
// 获取模型
Model modelData = repositoryService.getModel(modelId);
byte[] bytes = repositoryService.getModelEditorSource(modelData.getId());
if (bytes == null) {
return Result.OK("模型数据为空,请先设计流程并成功保存,再进行发布。");
}
// 生成/更新 模板变量表
//iFormVariableService.createAndUpdateFormVariable(bytes, modelId);
JsonNode modelNode = new ObjectMapper().readTree(bytes);
BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
model.setTargetNamespace(modelData.getCategory());
if (model.getProcesses().size() == 0) {
return Result.OK("数据模型不符要求,请至少设计一条主线流程。");
}
byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(model);
// 发布流程
String processName = modelData.getName() + ".bpmn20.xml";
Deployment deployment = repositoryService.createDeployment()
.name(modelData.getName())
.category(modelData.getCategory())
.addString(processName, new String(bpmnBytes, StandardCharsets.UTF_8))
.deploy();
modelData.setDeploymentId(deployment.getId());
repositoryService.saveModel(modelData);
//创建一个流程定义查询
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
processDefinitionQuery.deploymentId(deployment.getId());
ProcessDefinition processDefinition = processDefinitionQuery.singleResult();
String processDefinitionId = processDefinition.getId();
processNodeService.copyNodeFromModel(modelId,processDefinitionId);
// 4、输出部署信息
Map<String, String> map = new HashMap<>();
map.put("流程部署id", deployment.getId());
map.put("流程部署名称:", deployment.getName());
map.put("流程部署key", deployment.getKey());
map.put("流程定义Id", processDefinitionId);
return Result.OK(map);
}
@GetMapping("/getNodeList")
@ApiImplicitParams({
@ApiImplicitParam(name = "modelId", value = "模型id"),
@ApiImplicitParam(name = "key", value = "key")
})
@ApiOperation("获得节点列表")
public Result<Map<String,Object>> getNodeList(String modelId,String key) {
if (StringUtils.isNotBlank(key)){
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
processDefinitionQuery.processDefinitionKey(key);
processDefinitionQuery.latestVersion();
ProcessDefinition processDefinition = processDefinitionQuery.singleResult();
ModelQuery modelQuery = repositoryService.createModelQuery();
modelQuery.deploymentId(processDefinition.getDeploymentId());
Model model = modelQuery.singleResult();
model.getDeploymentId();
modelId = model.getId();
}
//查询节点信息
LambdaQueryWrapper<ProcessModelNode> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessModelNode::getModelId,modelId);
wrapper.orderByAsc(ProcessModelNode::getSort);
List<ProcessModelNode> nodeOriginList = processModelNodeService.list(wrapper);
//获取所有子流程id
List<String> subProcessIdList = nodeOriginList.stream()
.map(ProcessModelNode::getXmlSubNodeId)
.filter(StringUtils::isNotBlank)
.distinct()
.collect(Collectors.toList());
Map<String,String> startEventReplace = new HashMap<>();
Map<String,List<ProcessModelNode>> endEventReplace = new HashMap<>();
//确定结束节点的连线
List<ProcessModelNode> removeNodeList = new ArrayList<>();
for (String subProcessId : subProcessIdList) {
//获得全部子流程节点
List<ProcessModelNode> subNodeList = nodeOriginList.stream()
.filter(item -> subProcessId.equals(item.getXmlSubNodeId()))
.collect(Collectors.toList());
Map<String, String> sourceTargetMap = CollStreamUtil.toMap(subNodeList, ProcessModelNode::getXmlSourceRef, ProcessModelNode::getXmlTargetRef);
Map<String, ProcessModelNode> targetSourceMap = CollStreamUtil.toIdentityMap(subNodeList, ProcessModelNode::getXmlTargetRef);
for (ProcessModelNode subNode : subNodeList) {
String xmlNodeId = subNode.getXmlNodeId();
String nodeType = subNode.getNodeType();
if ("startEvent".equals(nodeType)){
//通过关联的线获取下一个节点的id
String s = sourceTargetMap.get(xmlNodeId);
startEventReplace.put(subProcessId,s);
}else if ("endEvent".equals(nodeType)){
//subEndEventList.add(xmlNodeId);
//通过target拿到线
ProcessModelNode flow = targetSourceMap.get(xmlNodeId);
if (endEventReplace.containsKey(subProcessId)) {
List<ProcessModelNode> processModelNodes = endEventReplace.get(subProcessId);
processModelNodes.add(flow);
}else {
List<ProcessModelNode> processModelNodes = new ArrayList<>();
processModelNodes.add(flow);
endEventReplace.put(subProcessId,processModelNodes);
}
removeNodeList.add(flow);
}
}
}
//把之前删除的结束节点更新后在加回来
List<ProcessModelNode> addNodeList = new ArrayList<>();
for (ProcessModelNode modelNode : nodeOriginList) {
String nodeType = modelNode.getNodeType();
String nodeName = modelNode.getNodeName();
String xmlSourceRef = modelNode.getXmlSourceRef();
String xmlTargetRef = modelNode.getXmlTargetRef();
if ("sequenceFlow".equals(nodeType)){
if (endEventReplace.containsKey(xmlSourceRef)) {
List<ProcessModelNode> processModelNodes = endEventReplace.get(xmlSourceRef);
for (ProcessModelNode modelNode1 : processModelNodes) {
modelNode1.setXmlTargetRef(xmlTargetRef);
addNodeList.add(modelNode1);
}
//modelNode.setXmlTargetRef(modelNode1.getXmlTargetRef());
}
if (startEventReplace.containsKey(xmlTargetRef)) {
xmlTargetRef = startEventReplace.get(xmlTargetRef);
modelNode.setXmlTargetRef(xmlTargetRef);
}
}
}
//删除结束节点的连线
nodeOriginList.removeAll(removeNodeList);
//获得子流程之后的连线
List<ProcessModelNode> beforeSubProcessFlowList = nodeOriginList.stream()
.filter(item -> subProcessIdList.contains(item.getXmlSourceRef()))
.collect(Collectors.toList());
//获得子流程之后的连线map
Map<String, ProcessModelNode> beforeSubProcessFlowMap = CollStreamUtil.toIdentityMap(beforeSubProcessFlowList, ProcessModelNode::getXmlSourceRef);
//把之前删除的结束节点更新后在加回来
nodeOriginList.addAll(addNodeList);
//找到驳回的线
List<ProcessModelNode> rejectFlowList = nodeOriginList.stream()
.filter(item -> "驳回".equals(item.getNodeName()))
.collect(Collectors.toList());
//全部去除
//nodeOriginList.removeAll(rejectFlowList);
Map<String, ProcessModelNode> rejectSourceIdIsGatewayMap = CollStreamUtil.toIdentityMap(rejectFlowList, ProcessModelNode::getXmlSourceRef);
//找到全部的通过线
List<ProcessModelNode> passFlowList = nodeOriginList.stream()
.filter(item -> "通过".equals(item.getNodeName()))
.filter(item -> "sequenceFlow".equals(item.getNodeType()))
.collect(Collectors.toList());
//全部去除
nodeOriginList.removeAll(passFlowList);
//获得来源id为网关的对应map(通过线的来源id一定是审批网关)
Map<String, ProcessModelNode> passSourceIdIsGatewayMap = CollStreamUtil.toIdentityMap(passFlowList, ProcessModelNode::getXmlSourceRef);
//根据通过的线获取全部审批网关id
List<String> approvalGatewayList = passFlowList.stream().map(ProcessModelNode::getXmlSourceRef).collect(Collectors.toList());
//根据审批网关id获取网关前的线(目标id为网关id的是网关前的线)
List<ProcessModelNode> beforeGatewayFlowList = nodeOriginList.stream()
.filter(item -> approvalGatewayList.contains(item.getXmlTargetRef()))
.collect(Collectors.toList());
//全部去除
nodeOriginList.removeAll(beforeGatewayFlowList);
ArrayList<Map<String,Object>> edges = new ArrayList<>();
//组合来源id和去向id
for (ProcessModelNode modelNode : beforeGatewayFlowList) {
//网关前的节点id
String beforeGatewayNodeId = modelNode.getXmlSourceRef();
//这里是网关id
String xmlTargetRef = modelNode.getXmlTargetRef();
//网关后的线
ProcessModelNode modelNode1 = passSourceIdIsGatewayMap.get(xmlTargetRef);
//网关后的节点id
String afterGatewayNodeId = modelNode1.getXmlTargetRef();
Map<String,Object> edge = new HashMap<>();
edge.put("label","通过");
edge.put("source", beforeGatewayNodeId);
edge.put("target",afterGatewayNodeId);
edges.add(edge);
//网关后的线
ProcessModelNode modelNode2 = rejectSourceIdIsGatewayMap.get(xmlTargetRef);
////网关后的节点id
String afterGatewayNodeId1 = modelNode2.getXmlTargetRef();
Map<String,Object> edge2 = new HashMap<>();
edge2.put("label","驳回");
edge2.put("source", beforeGatewayNodeId);
edge2.put("target",afterGatewayNodeId1);
edges.add(edge2);
}
//找到全部的审批网关(审批网关名字是null)
List<ProcessModelNode> gatewayList = nodeOriginList.stream()
.filter(item -> approvalGatewayList.contains(item.getXmlNodeId()))
.collect(Collectors.toList());
//全部去除
nodeOriginList.removeAll(gatewayList);
ArrayList<Map<String,Object>> nodes = new ArrayList<>();
Map<String, ProcessModelNode> stringProcessModelNodeMap = CollStreamUtil.toIdentityMap(nodeOriginList, ProcessModelNode::getXmlNodeId);
for (ProcessModelNode modelNode : nodeOriginList) {
String nodeType = modelNode.getNodeType();
String nodeName = modelNode.getNodeName();
String xmlSourceRef = modelNode.getXmlSourceRef();
String xmlTargetRef = modelNode.getXmlTargetRef();
if ("sequenceFlow".equals(nodeType)){
Map<String,Object> edge = new HashMap<>();
edge.put("label",nodeName);
edge.put("source", xmlSourceRef);
edge.put("target",xmlTargetRef);
edges.add(edge);
}else if ("userTask".equals(nodeType)){
Map<String,Object> node = new HashMap<>();
node.put("id",modelNode.getXmlNodeId());
node.put("name",nodeName!=null?nodeName:"网关");
node.put("isApprovalNode",modelNode.getIsApprovalNode());
node.put("isCanDeleted",modelNode.getIsCanDeleted());
nodes.add(node);
}else if ("gateway".equals(nodeType)){
Map<String,Object> node = new HashMap<>();
node.put("id",modelNode.getXmlNodeId());
node.put("name","条件网关");
node.put("isApprovalNode",modelNode.getIsApprovalNode());
node.put("isCanDeleted",modelNode.getIsCanDeleted());
nodes.add(node);
}else if ("InclusiveGateway".equals(nodeType)){
Map<String,Object> node = new HashMap<>();
node.put("id",modelNode.getXmlNodeId());
node.put("name","包容网关");
node.put("isApprovalNode",modelNode.getIsApprovalNode());
node.put("isCanDeleted",modelNode.getIsCanDeleted());
nodes.add(node);
}
}
Map<String,Object> result = new HashMap<>();
result.put("nodes",nodes);
result.put("edges",edges);
return Result.OK(result);
}
@PostMapping("/addTask")
@ApiOperation("新增节点")
public Object addTask(@RequestBody AddTaskVO addTaskVO) {
processModelNodeService.addTask(addTaskVO);
return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
}
@PostMapping("/deleteTask")
@ApiOperation("删除节点")
public Object deleteTask(@RequestBody AddTaskVO addTaskVO) {
processModelNodeService.deleteTask(addTaskVO);
return Result.OK(MessageUtils.getMessage(ResultCommon.OK));
}
@GetMapping("/clearAllProcesses")
@ApiOperation("清理所有流程")
public void clearAllProcesses() {
// 获取流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取RuntimeService并批量删除所有流程实例
RuntimeService runtimeService = processEngine.getRuntimeService();
List<String> instanceIds = runtimeService.createProcessInstanceQuery().list()
.stream()
.map(ProcessInstance::getId)
.collect(Collectors.toList());
for (String id : instanceIds) {
runtimeService.deleteProcessInstance(id, "Cleanup all instances");
}
// 获取RepositoryService并批量删除所有流程
RepositoryService repositoryService = processEngine.getRepositoryService();
List<String> deploymentIds = repositoryService.createProcessDefinitionQuery().list()
.stream()
.map(ProcessDefinition::getDeploymentId)
.collect(Collectors.toList());
for (String id : deploymentIds) {
repositoryService.deleteDeployment(id, true);
}
}
}
@@ -0,0 +1,71 @@
package com.jero.modules.activiti.controller;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.constant.CommonConstant;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.system.query.QueryGenerator;
import com.jero.modules.sys.entity.LawsWorkingGroupUser;
import com.jero.modules.sys.service.ILawsWorkingGroupUserService;
import com.jero.modules.system.entity.SysUser;
import com.jero.modules.system.service.ISysDepartService;
import com.jero.modules.system.service.ISysUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author: Mzaxd
* @Date: 2023/10/16 11:43
* 流程中的选人组件接口
*/
@Slf4j
@RestController
@Api(tags = "工作流选人接口")
@RequestMapping("/act/user")
public class UserController {
@Resource
private ISysUserService sysUserService;
@Resource
private ISysDepartService sysDepartService;
@Resource
private ILawsWorkingGroupUserService workingGroupUserService;
/**
* 获取工作组用户列表数据
*
* @param user
* @param pageNo
* @param pageSize
* @param req
* @return
*/
@AutoLog(value = "工作流选人接口-工作组人员分页列表")
@ApiOperation(value="工作流选人接口-工作组人员分页列表", notes="流程中心-工作组人员分页列表")
@GetMapping("/workGroupPage")
public Result<?> queryWorkGroupPageList(LawsWorkingGroupUser lawsWorkingGroupUser,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) {
lawsWorkingGroupUser.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
IPage<LawsWorkingGroupUser> pageList = workingGroupUserService.queryPage(lawsWorkingGroupUser, pageNo, pageSize, req);
workingGroupUserService.userAssignment(pageList.getRecords());
return Result.OK(pageList);
}
}
@@ -0,0 +1,244 @@
package com.jero.modules.activiti.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jero.common.api.vo.Result;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.system.query.QueryGenerator;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.MessageUtils;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
import com.jero.modules.activiti.process.common.common.DraftCommon;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.service.ProcessDraftService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.vo.DelegateTaskParam;
import com.jero.modules.activiti.vo.ResolveTaskParam;
import com.jero.modules.laws.common.util.CurrentUserUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jetbrains.annotations.NotNull;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
/**
* @author liJiaRao
* @date 2023-10-16 15:50
*/
@Slf4j
@RestController
@Api(tags = "工作中心")
@RequestMapping("/workCenter")
public class WorkCenterController {
@Resource
private ProcessAllService processAllService;
@Resource
private ProcessDraftService processDraftService;
@Resource
private ProcessApprovalRecordService processApprovalRecordService;
@Resource
private IProcessHandleService processHandleService;
@ApiOperation(value = "查询待办流程列表")
@GetMapping("/getTodoList")
public Result<IPage<ProcessAll>> getTodoList(ProcessAll processAll,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<ProcessAll> queryWrapper = getProcessAllQueryWrapper(processAll, false);
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = loginUser.getId();
queryWrapper.eq("par.user_id",userId);
queryWrapper.eq("par.finish_flag", FinishFlagEnum.INCOMPLETE.getValue());
queryWrapper.ne("pa.prc_status", ProcessStatusEnum.WITHDRAWN.getValue());
queryWrapper.ne("pa.prc_status", ProcessStatusEnum.COMPLETED.getValue());
Page<ProcessAll> page = new Page<>(pageNo, pageSize);
IPage<ProcessAll> todoList = processAllService.getTodoList(page, queryWrapper, req);
return Result.OK(todoList);
}
@ApiOperation(value = "查询已办流程列表")
@GetMapping("/getCompletedList")
public Result<?> getCompletedList(ProcessAll processAll,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<ProcessAll> queryWrapper = getProcessAllQueryWrapper(processAll,true);
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = loginUser.getId();
queryWrapper.eq("par.user_id",userId);
queryWrapper.eq("par.finish_flag",FinishFlagEnum.COMPLETE.getValue());
queryWrapper.ne("pa.prc_status", ProcessStatusEnum.WITHDRAWN.getValue());
Page<ProcessAll> page = new Page<>(pageNo, pageSize);
IPage<ProcessAll> completedList = processAllService.getCompletedList(page, queryWrapper, req);
return Result.OK(completedList);
}
@ApiOperation(value = "查询已发流程列表")
@GetMapping("/getSentList")
public Result<?> getSentList(ProcessAll processAll,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<ProcessAll> queryWrapper = getProcessAllQueryWrapper(processAll, true);
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = loginUser.getId();
queryWrapper.eq("pa.create_user_id",userId);
queryWrapper.ne("pa.prc_status", ProcessStatusEnum.WITHDRAWN.getValue());
Page<ProcessAll> page = new Page<>(pageNo, pageSize);
IPage<ProcessAll> sentList = processAllService.getSentList(page, queryWrapper, req);
return Result.OK(sentList);
}
@ApiOperation(value = "监控流程")
@GetMapping("/getAllList")
public Result<?> getAllList(ProcessAll processAll,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
QueryWrapper<ProcessAll> queryWrapper = getProcessAllQueryWrapper(processAll, true);
Page<ProcessAll> page = new Page<>(pageNo, pageSize);
IPage<ProcessAll> sentList = processAllService.getAllList(page, queryWrapper, req);
return Result.OK(sentList);
}
@ApiOperation(value = "查询流程审批记录")
@GetMapping("/getApprovalRecordList")
public Result<?> getApprovalRecordList(ProcessApprovalRecord processApprovalRecord,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
Page<ProcessApprovalRecord> page = new Page<>(pageNo, pageSize);
Page<ProcessApprovalRecord> pageList;
try {
pageList = processApprovalRecordService.pageList(page, processApprovalRecord, req);
}catch (Exception e){
return Result.error(MessageUtils.getMessage(ResultCommon.ERROR));
}
return Result.OK(pageList);
}
@ApiOperation(value = "查询草稿")
@GetMapping("/getDraftList")
public Result<?> getDraftList(ProcessDraft processDraft,
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
HttpServletRequest req) {
LambdaQueryWrapper<ProcessDraft> queryWrapper = QueryGenerator.initQueryWrapper(processDraft,req.getParameterMap()).lambda();
queryWrapper.eq(ProcessDraft::getUserId, CurrentUserUtil.getId());
queryWrapper.isNull(ProcessDraft::getTaskId);
queryWrapper.and(a -> {
a.ne(ProcessDraft::getSaveSource, DraftCommon.INITIAL_SOURCE)
.or()
.isNull(ProcessDraft::getSaveSource);
});
//queryWrapper.eq(!Objects.isNull(processDraft.getPrcType()), ProcessDraft::getPrcType, processDraft.getPrcType());
Page<ProcessDraft> page = new Page<>(pageNo, pageSize);
IPage<ProcessDraft> sentList = processDraftService.page(page, queryWrapper);
sentList.getRecords().forEach(item -> {
String taskId = item.getTaskId();
if (StringUtils.isBlank(taskId)){
return;
}
ProcessApprovalRecord record = processApprovalRecordService.getToDoByTaskId(taskId);
if (record != null) {
item.setNodeId(record.getNodeId());
item.setNodeName(record.getTaskName());
}
});
return Result.OK(sentList);
}
@NotNull
private QueryWrapper<ProcessAll> getProcessAllQueryWrapper(ProcessAll processAll, boolean groupBy) {
String prcName = processAll.getPrcName();
String prcNum = processAll.getPrcNum();
Integer prcType = processAll.getPrcType();
Integer prcStatus = processAll.getPrcStatus();
QueryWrapper<ProcessAll> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(prcName), "pa.prc_name", prcName);
queryWrapper.like(StringUtils.isNotBlank(prcNum), "pa.prc_num", prcNum);
queryWrapper.eq(prcType != null, "pa.prc_type", prcType);
queryWrapper.eq(prcStatus != null, "pa.prc_status", prcStatus);
queryWrapper.groupBy(groupBy, "pa.id");
return queryWrapper;
}
@AutoLog(value = "强制撤回")
@ApiOperation(value = "强制撤回")
@PostMapping("/forcedWithdrawal")
public Result<?> forcedWithdrawal(@RequestBody Map<String, String> map) {
String processInstanceId = map.get("processInstanceId");
processAllService.forcedWithdrawal(processInstanceId);
String projectId = map.get("projectId");
processAllService.updateDraftStatusByProjectId(projectId);
return Result.OK();
}
/**
* 加签
*/
@ApiOperation(value="加签")
@PostMapping("/delegateTask")
public Result<Object> delegateTask(@RequestBody DelegateTaskParam param) {
processAllService.delegateTask(param);
return Result.OK();
}
@ApiOperation(value="解决加签")
@PostMapping("/resolveTask")
public Result<Object> resolveTask(@RequestBody ResolveTaskParam param) {
processAllService.resolveTask(param);
return Result.OK();
}
/**
* 转办
*/
@ApiOperation(value="转办")
@PostMapping("/transfer")
public Result<Object> transferTask(@RequestBody DelegateTaskParam param) {
processHandleService.transfer(param.getTaskId(), param.getUserId());
return Result.OK();
}
/**
* 催办
*/
@ApiOperation(value="催办")
@PostMapping("/urging")
public Result<Object> urging(@RequestBody DelegateTaskParam param) {
processAllService.urging(param.getTaskId());
return Result.OK();
}
/**
* 根据taskId查询
*/
@ApiOperation(value="根据taskId查询")
@GetMapping("/getByTaskId")
public Result<ProcessApprovalRecord> getByTaskId(String taskId) {
ProcessApprovalRecord processApprovalRecord = processApprovalRecordService.getByTaskId(taskId);
return Result.OK(processApprovalRecord);
}
}
@@ -0,0 +1,142 @@
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.jero.modules.activiti.editor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.activiti.editor.constants.ModelDataJsonConstants;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Model;
import org.apache.batik.transcoder.TranscoderInput;
import org.apache.batik.transcoder.TranscoderOutput;
import org.apache.batik.transcoder.image.PNGTranscoder;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
/**
* @author Tijs Rademakers
*/
@Slf4j
@Api("工作流编辑器")
@RestController
@RequestMapping(value = "/service")
public class ModelEditorController implements ModelDataJsonConstants {
@Autowired
private RepositoryService repositoryService;
@Autowired
private ObjectMapper objectMapper;
@ApiOperation(value = "获取模型json数据")
@ApiImplicitParam(name = "modelId", value = "模型id")
@SuppressWarnings("deprecation")
@GetMapping(value = "/model/{modelId}/json", produces = "application/json")
public ObjectNode getEditorJson(@PathVariable String modelId) {
ObjectNode modelNode = null;
Model model = repositoryService.getModel(modelId);
if (model != null) {
try {
if (StringUtils.isNotEmpty(model.getMetaInfo())) {
modelNode = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
} else {
modelNode = objectMapper.createObjectNode();
modelNode.put(MODEL_NAME, model.getName());
}
modelNode.put(MODEL_ID, model.getId());
byte[] modelEditorSource = repositoryService.getModelEditorSource(model.getId());
String s = new String(modelEditorSource, "utf-8");
ObjectNode editorJsonNode = (ObjectNode) objectMapper
.readTree(s);
modelNode.put("model", editorJsonNode);
} catch (Exception e) {
log.error("Error creating model JSON", e);
throw new ActivitiException("Error creating model JSON", e);
}
}
return modelNode;
}
@ApiOperation(value = "模型保存")
@ApiImplicitParams({ @ApiImplicitParam(name = "modelId", value = "模型id"),
@ApiImplicitParam(name = "name", value = "名称"),
@ApiImplicitParam(name = "json_xml", value = "流程图xml"),
@ApiImplicitParam(name = "svg_xml", value = "流程配置xml"),
@ApiImplicitParam(name = "description", value = "描述") })
@PutMapping(value = "/model/{modelId}/save")
@ResponseStatus(value = HttpStatus.OK)
public void saveModel(@PathVariable String modelId, @RequestParam("name") String name,
@RequestParam("json_xml") String json_xml, @RequestParam("svg_xml") String svg_xml,
@RequestParam("description") String description) {
try {
Model model = repositoryService.getModel(modelId);
ObjectNode modelJson = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
modelJson.put(MODEL_NAME, name);
modelJson.put(MODEL_DESCRIPTION, description);
model.setMetaInfo(modelJson.toString());
model.setName(name);
repositoryService.saveModel(model);
repositoryService.addModelEditorSource(model.getId(), json_xml.getBytes("utf-8"));
InputStream svgStream = new ByteArrayInputStream(svg_xml.getBytes("utf-8"));
TranscoderInput input = new TranscoderInput(svgStream);
PNGTranscoder transcoder = new PNGTranscoder();
// Setup output
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
TranscoderOutput output = new TranscoderOutput(outStream);
// Do the transformation
transcoder.transcode(input, output);
final byte[] result = outStream.toByteArray();
repositoryService.addModelEditorSourceExtra(model.getId(), result);
outStream.close();
} catch (Exception e) {
log.error("Error saving model", e);
throw new ActivitiException("Error saving model", e);
}
}
@ApiOperation(value = "获取模型stencilset的数据")
@GetMapping(value = "/editor/stencilset", produces = "application/json;charset=utf-8")
public @ResponseBody String getStencilset() {
InputStream stencilsetStream = this.getClass().getClassLoader().getResourceAsStream("stencilset.json");
try {
return IOUtils.toString(stencilsetStream, "utf-8");
} catch (Exception e) {
throw new ActivitiException("Error while loading stencil set", e);
}
}
}
@@ -0,0 +1,38 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
*
*@author liJiaRao
*@date 2023-08-04 16:04
*/
/**
* 二进制资源表
*/
@Data
@TableName(value = "act_ge_bytearray")
public class ActGeBytearray {
@TableId(value = "ID_", type = IdType.INPUT)
private String id;
@TableField(value = "REV_")
private Integer rev;
@TableField(value = "NAME_")
private String name;
@TableField(value = "DEPLOYMENT_ID_")
private String deploymentId;
@TableField(value = "BYTES_")
private byte[] bytes;
@TableField(value = "GENERATED_")
private Integer generated;
}
@@ -0,0 +1,191 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
*流程总表
*@author liJiaRao
*@date 2023-10-16 15:49
*/
@ApiModel(description="流程总表")
@Data
@TableName(value = "process_all")
public class ProcessAll {
@TableId(value = "id", type = IdType.ASSIGN_ID)
@ApiModelProperty(value="")
private String id;
/**
* 流程名称
*/
@ApiModelProperty(value="流程名称")
private String prcName;
/**
* 流程定义id
*/
@ApiModelProperty(value="流程定义id")
private String processDefinitionId;
/**
* 流程实例id
*/
@ApiModelProperty(value="流程实例id")
private String processInstanceId;
/**
* 流程描述
*/
@ApiModelProperty(value="流程描述")
private String prcMes;
/**
* 流程编号
*/
@ApiModelProperty(value="流程编号")
private String prcNum;
/**
* 创建人id
*/
@ApiModelProperty(value="发起人id")
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
private String createUserId;
/**
* 流程类型
*/
@Dict(dicCode = "prc_type")
@ApiModelProperty(value="流程类型")
private Integer prcType;
/**
* 流程状态
*/
@ApiModelProperty(value="流程状态(1未完成,2已完成,3已撤回)")
@Dict(dicCode = "prc_status")
private Integer prcStatus;
/**
* 发起人名称
*/
@ApiModelProperty(value="发起人名称")
private String createUserName;
/**
* json信息
*/
@ApiModelProperty(value="json信息")
private String mes;
/**
* 创建时间
*/
@ApiModelProperty(value="创建时间")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 完成时间
*/
@ApiModelProperty(value="完成时间")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date endTime;
/**
* 耗时
*/
@ApiModelProperty(value="耗时")
private String overTime;
/**
* 截止时间
*/
@ApiModelProperty(value="截止时间")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date dueTime;
/**
* 项目id
*/
@ApiModelProperty(value="项目id")
private String projectId;
/**
* 项目名称
*/
@ApiModelProperty(value="项目名称")
private String projectName;
/**
* 流程名称(英文)
*/
@ApiModelProperty(value="流程名称(英文)")
private String prcNameEn;
/**
* 处理人id
*/
@TableField(exist = false)
@ApiModelProperty(value="处理人id")
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
private String handleUserId;
/**
* 任务id
*/
@TableField(exist = false)
@ApiModelProperty(value="任务id")
private String taskId;
/**
* 任务id
*/
@TableField(exist = false)
@ApiModelProperty(value="任务节点名称")
private String taskName;
/**
* 接收任务时间
*/
@ApiModelProperty(value="接收任务时间")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date receivedTaskTime;
/**
* 接收任务时间
*/
@ApiModelProperty(value="完成任务时间")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date completedTaskTime;
/**
* 节点id
*/
@TableField(exist = false)
@ApiModelProperty(value="节点id")
private String nodeId;
/**
* 超期标识(0:未超期 1:已超期)
*/
@TableField(exist = false)
@ApiModelProperty(value = "超期标识(0:未超期 1:已超期)")
private String overDue;
}
@@ -0,0 +1,202 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Date;
/**
*流程审批记录表
*@author liJiaRao
*@date 2023-10-20 16:42
*/
@ApiModel(description = "流程审批记录表")
@Data
@TableName(value = "process_approval_record")
public class ProcessApprovalRecord {
/**
* 主键
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键")
private String id;
/**
* 任务id
*/
@TableField(value = "task_id")
@ApiModelProperty(value = "任务id")
private String taskId;
/**
* 任务名称
*/
@TableField(value = "task_name")
@ApiModelProperty(value = "任务名称")
private String taskName;
/**
* 流程实例id
*/
@TableField(value = "process_instance_id")
@ApiModelProperty(value = "流程实例id")
private String processInstanceId;
/**
* 资源类型
*/
@TableField(value = "msg_type")
@ApiModelProperty(value = "资源类型")
private String msgType;
/**
* 处理人id
*/
@TableField(value = "origin_user_id")
@ApiModelProperty(value = "原始处理人id")
private String originUserId;
/**
* 处理人id
*/
@TableField(value = "user_id")
@ApiModelProperty(value = "当前处理人id")
private String userId;
/**
* 任务受理人
*/
@TableField(exist = false)
@ApiModelProperty(value = "任务受理人")
private String taskAcceptor;
/**
* 信息
*/
@TableField(value = "mesg")
@ApiModelProperty(value = "信息")
private String mesg;
/**
* 完成注记(1进行中,2已完成,3未处理,4已撤回)
*/
@Dict(dicCode = "prc_node_status")
@TableField(value = "finish_flag")
@ApiModelProperty(value = "完成注记(1进行中,2已完成,3未处理,4已撤回,null是会签审批节点特殊处理)")
private Integer finishFlag;
/**
* 项目id
*/
@TableField(value = "project_id")
@ApiModelProperty(value = "项目id")
private String projectId;
/**
* 审批意见(1通过,2驳回,3未处理)
*/
@Dict(dicCode = "commit_flag")
@TableField(value = "commit_flag")
@ApiModelProperty(value = "审批意见(1通过,2驳回,3未处理)")
private Integer commitFlag;
/**
* 审批内容
*/
@TableField(value = "commit_text")
@ApiModelProperty(value = "审批内容")
private String commitText;
/**
* 审批附件
*/
@TableField(value = "commit_file")
@ApiModelProperty(value = "审批附件")
private String commitFile;
/**
* 流程名称
*/
@TableField(value = "prc_name")
@ApiModelProperty(value = "流程名称")
private String prcName;
/**
* 创建时间
*/
@TableField(value = "create_time")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新时间
*/
@TableField(value = "update_time")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 完成时间
*/
@TableField(value = "end_time")
@ApiModelProperty(value = "完成时间")
private Date endTime;
/**
* 耗时
*/
@ApiModelProperty(value="耗时")
private String overTime;
/**
* 是否派发过加签任务
*/
@TableField(value = "has_delegate_task")
@ApiModelProperty(value = "是否派发过加签任务")
private Integer hasDelegateTask;
/**
* 是否加签任务
*/
@TableField(value = "is_delegate_task")
@ApiModelProperty(value = "是否加签任务")
private Integer isDelegateTask;
/**
* 加签人
*/
@TableField(value = "delegate_by")
@ApiModelProperty(value = "加签人")
private String delegateBy;
/**
* 转办人
*/
@TableField(value = "transfer_by")
@ApiModelProperty(value = "转办人")
private String transferBy;
/**
* 节点id
*/
@ApiModelProperty(value = "节点id")
private String nodeId;
/**
* 完成注记 搜索用
*/
@TableField(exist = false)
@ApiModelProperty(value = "完成注记 搜索用")
private String finishFlagSearch;
/**
* 超期标识(0:未超期 1:已超期)
*/
@ApiModelProperty(value = "超期标识(0:未超期 1:已超期)")
private String overDue;
}
@@ -0,0 +1,157 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import lombok.Data;
/**
*
*@author liJiaRao
*@date 2023-10-16 10:09
*/
/**
* 流程模型节点表
*/
@ApiModel(description = "流程模型节点表")
@Data
@TableName(value = "process_model_node")
public class ProcessModelNode {
/**
* 主键id
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键id")
private String id;
/**
* process_key
*/
@TableField(value = "process_key")
@ApiModelProperty(value = "process_key")
private String processKey;
/**
* 模型id
*/
@TableField(value = "model_id")
@ApiModelProperty(value = "模型id")
private String modelId;
/**
* 节点名称
*/
@TableField(value = "node_name")
@ApiModelProperty(value = "节点名称")
private String nodeName;
/**
* 节点类型
*/
@TableField(value = "node_type")
@ApiModelProperty(value = "节点类型")
private String nodeType;
/**
* 子流程id
*/
@TableField(value = "xml_sub_node_id")
@ApiModelProperty(value = "子流程id")
private String xmlSubNodeId;
/**
* xml节点Id
*/
@TableField(value = "xml_node_id")
@ApiModelProperty(value = "xml节点Id")
private String xmlNodeId;
/**
* xml来源节点id
*/
@TableField(value = "xml_source_ref")
@ApiModelProperty(value = "xml来源节点id")
private String xmlSourceRef;
/**
* xml目标节点id
*/
@TableField(value = "xml_target_ref")
@ApiModelProperty(value = "xml目标节点id")
private String xmlTargetRef;
/**
* 变量类型
*/
@TableField(value = "variable_type")
@ApiModelProperty(value = "变量类型")
private String variableType;
/**
* 变量名称
*/
@TableField(value = "variable_name")
@ApiModelProperty(value = "变量名称")
private String variableName;
/**
* 是否审批节点
*/
@TableField(value = "is_approval_node")
@ApiModelProperty(value = "是否审批节点")
private Integer isApprovalNode;
/**
* 是否可删除
*/
@TableField(value = "is_can_deleted")
@ApiModelProperty(value = "是否可删除")
private Integer isCanDeleted;
/**
* 排序
*/
@TableField(value = "sort")
@ApiModelProperty(value = "排序")
private Integer sort;
/**
* 创建人
*/
@TableField(value = "create_by")
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@TableField(value = "update_by")
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@TableField(value = "sys_code")
@ApiModelProperty(value = "所属部门")
private String sysCode;
}
@@ -0,0 +1,154 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Date;
/**
*流程节点
*@author liJiaRao
*@date 2023-09-26 15:12
*/
@ApiModel(description = "流程节点")
@Data
@TableName(value = "process_node")
public class ProcessNode {
/**
* 主键id
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键id")
private String id;
/**
* 流程定义id
*/
@TableField(value = "process_definition_id")
@ApiModelProperty(value = "流程定义id")
private String processDefinitionId;
/**
* xml节点Id
*/
@TableField(value = "xml_node_id")
@ApiModelProperty(value = "xml节点Id")
private String xmlNodeId;
/**
* 节点名称
*/
@TableField(value = "node_name")
@ApiModelProperty(value = "节点名称")
private String nodeName;
/**
* 变量类型
*/
@TableField(value = "variable_type")
@ApiModelProperty(value = "变量类型")
private String variableType;
/**
* 变量名称
*/
@TableField(value = "variable_name")
@ApiModelProperty(value = "变量名称")
private String variableName;
/**
* 排序
*/
@TableField(value = "sort")
@ApiModelProperty(value = "排序")
private Integer sort;
/**
* 创建人
*/
@TableField(value = "create_by")
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@TableField(value = "update_by")
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@TableField(value = "sys_code")
@ApiModelProperty(value = "所属部门")
private String sysCode;
@TableField(exist = false)
@ApiModelProperty(value = "关联用户id")
@Dict(dictTable = "sys_user",dicText = "realname",dicCode = "id")
private String linkUserIds;
/**
* 是否禁止输入(0否,1是)
*/
@TableField(value = "can_choose")
@ApiModelProperty(value = "是否禁止输入(0否,1是)")
private Integer canChoose;
/**
* 用户来源(workGroup工作组,contactManage联络人管理,user普通)
*/
@TableField(value = "choose_source")
@ApiModelProperty(value = "用户来源(workGroup工作组,contactManage联络人管理,user普通)")
private String chooseSource;
/**
* 最少处理人个数
*/
@TableField(value = "min_length")
@ApiModelProperty(value = "最少处理人个数")
private Integer minLength;
/**
* 立项变更流程类型
*/
@TableField(value = "branch_type")
@ApiModelProperty(value = "企标立项变更 1 普通立项 2 普通变更 3 责任部门变更")
private String branchType;
/**
* 是否显示(0否,1是)
*/
@TableField(value = "is_view")
@ApiModelProperty(value = "是否显示(0否,1是)")
private Integer isView;
/**
* 是否可跳过节点(0否,1是)
*/
@TableField(value = "is_skip")
@ApiModelProperty(value = "是否可跳过节点(0否,1是)")
private String isSkip;
/**
* 是否可以转办(0否,1是)
*/
@TableField(value = "transfer_flag")
@ApiModelProperty(value = "是否可以转办(0否,1是)")
private String transferFlag;
}
@@ -0,0 +1,58 @@
package com.jero.modules.activiti.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
*
*@author liJiaRao
*@date 2023-10-16 13:43
*/
/**
* 流程实例节点关联用户表
*/
@ApiModel(description = "流程实例节点关联用户表")
@Data
@TableName(value = "process_node_link")
public class ProcessNodeLink {
/**
* 主键id
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键id")
private String id;
/**
* 流程定义id
*/
@TableField(value = "process_definition_id")
@ApiModelProperty(value = "流程定义id")
private String processDefinitionId;
/**
* 流程节点id
*/
@TableField(value = "process_node_id")
@ApiModelProperty(value = "流程节点id")
private String processNodeId;
/**
* 流程实例id
*/
@TableField(value = "process_instance_id")
@ApiModelProperty(value = "流程实例id")
private String processInstanceId;
/**
* 用户id
*/
@TableField(value = "user_id")
@ApiModelProperty(value = "用户id")
private String userId;
}
@@ -0,0 +1,123 @@
package com.jero.modules.activiti.entity;
import lombok.Data;
import java.io.Serializable;
import java.time.Instant;
/**
* @author lqt
* @version 1.0
* @date 2024/2/1 14:47
*/
@Data
public class PushWorkflowIntegration implements Serializable {
/**
* 异构系统标识 固定 SRMS
*/
private String sysCode;
/**
* 标题 流程名称(姓名+时间)
*/
private String noticeTitle;
/**
* 描述
*/
private String noticeDescription;
/**
* 流程编号
*/
private String busiDefCode;
/**
* 流程实例id
*/
private String processId;
/**
* 流程实例名称
*/
private String processName;
/**
* 流程类型,字典 标准法规SRMS
*/
private String processType;
/**
* 任务id
*/
private String taskId;
/**
* 节点名称
*/
private String taskName;
/**
* 是否会签
*/
private Integer multiInstance;
/**
* 节点编号
*/
private String nodeBusiCode;
/**
* 跳转链接
*/
private String businessLink;
/**
* APP跳转链接
*/
private String appBusinessLink;
/**
* 创建人code
*/
private String createUserCode;
/**
* 创建人姓名
*/
private String createUserName;
/**
* 接收人id
*/
private String userId;
/**
* 接收人code 多人待办LIST 方式传输
*/
private String userCode;
/**
* 接收人姓名
*/
private String userName;
/**
* 参与者id
*/
private String participantId;
/**
* 参与者编号
*/
private String participantCode;
/**
* 接收时间
*/
private Instant receiveTime;
/**
* 截止时间
*/
private Long dueTime;
/**
* 业务主键
*/
private String bid;
/**
* 待办、已办 1、待办 2已办 3结束 6 删除 暂停的时候传 3-结束
*/
private String isTodo;
/**
* 是否展示在列表中 钉钉时需要必传
*/
private String isShow;
/**
* 优先级 钉钉时需要必传 非必填 不做处理
*/
private String priority;
/**
* 是否通知消息
*/
private String notifyConfig;
}
@@ -0,0 +1,41 @@
package com.jero.modules.activiti.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author liJiaRao
* @date 2023-10-20 16:34
*/
@Getter
@AllArgsConstructor
public enum CommitFlagEnum {
/**
* A
*/
PASS("通过", 1),
REJECT("驳回", 2),
UNDISPOSED("未处理", 3)
;
private String name;
private Integer value;
public static String getNameByValue(Integer value) {
for (CommitFlagEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getName();
}
}
return null;
}
public static Integer getValueByName(String name) {
for (CommitFlagEnum enumObject : values()) {
if (enumObject.getName().equals(name)) {
return enumObject.getValue();
}
}
return null;
}
}
@@ -0,0 +1,42 @@
package com.jero.modules.activiti.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author liJiaRao
* @date 2023-10-20 16:34
*/
@Getter
@AllArgsConstructor
public enum FinishFlagEnum {
/**
* A
*/
INCOMPLETE("未完成", 1),
COMPLETE("完成", 2),
SUSPEND("暂停", 3),
WITHDRAWN("已撤回", 4)
;
private String name;
private Integer value;
public static String getNameByValue(Integer value) {
for (FinishFlagEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getName();
}
}
return null;
}
public static Integer getValueByName(String name) {
for (FinishFlagEnum enumObject : values()) {
if (enumObject.getName().equals(name)) {
return enumObject.getValue();
}
}
return null;
}
}
@@ -0,0 +1,24 @@
package com.jero.modules.activiti.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 流程状态
* @author liJiaRao
* @date 2023-10-16 16:05
*/
@Getter
@AllArgsConstructor
public enum ProcessStatusEnum {
/**
* A
*/
INCOMPLETE("未完成", 1),
COMPLETED("已完成", 2),
WITHDRAWN("已撤回", 3);
private String name;
private Integer value;
}
@@ -0,0 +1,97 @@
package com.jero.modules.activiti.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author liJiaRao
* @date 2023-10-16 16:05
*/
@Getter
@AllArgsConstructor
public enum ProcessTypeEnum {
FB_ENTRY_CHANGE("标准法规入库/变更流程",1, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbEntryChangeServiceImpl","/workCenter/StandardEntryOrChangeProcess","/workCenter/StandardEntryOrChangeProcess"),
FB_STANDARD_CONSULTATION("标准征求意见流程",2, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbStandardConsultationServiceImpl","/workCenter/StandardConsultationProcess","/workCenter/StandardConsultationProcess"),
PROJECT_ASSESS("项目合规评估流程",3, "com.jero.modules.activiti.process.projectassess.service.ProcessProjectAssessService","/workCenter/ProjectComplianceEvaluationProcess","/workCenter/ProjectComplianceEvaluationProcess"),
PROJECT_NOT_MET("未符合项跟踪流程",4, "com.jero.modules.activiti.process.projectnotmet.service.ProcessProjectNotMetService","/workCenter/NoMatchTrackingProcess","/workCenter/NoMatchTrackingProcess"),
PROJECT_STANDARD("法规合规评估流程",5, "com.jero.modules.activiti.process.projectstandard.service.ProcessProjectStandardService","/workCenter/StandardComplianceProcess","/workCenter/StandardComplianceProcess"),
FB_STANDARD_PURCHASE("法规采购流程",6, "com.jero.modules.activiti.process.fb.service.impl.ProcessFbStandardPurchaseServiceImpl","/workCenter/StandardProcurementProcess","/workCenter/StandardProcurementProcess"),
ES_INIT_CHANGE("企标立项/变更计划",7, "com.jero.modules.activiti.process.esInitChange.service.impl.ProcessEsInitChangeServiceImpl","/workCenter/enterpriseStandardInitChange/planApprovalChangeFlow","/workCenter/enterpriseStandardInitChange"),
ES_ANNUAL_REPORT("年度制修订计划审批流程(各部门主动上报)",8, "com.jero.modules.activiti.process.esAbolish.service.impl.ProcessEsAbolishServiceImpl","/workCenter/annualRevisionPlanActivelyReport/revisionPlanActivelyReportFlow","/workCenter/annualRevisionPlanActivelyReport"),
ES_ANNUAL_INIT("年度制修订计划审批流程(标准化发起)",9, "com.jero.modules.activiti.process.esAnnualReport.service.impl.ProcessEsAnnualReportServiceImpl","/workCenter/annualRevisionPlanStandardizationInit/revisionPlanStandardizationInitFlow","/workCenter/annualRevisionPlanStandardizationInit"),
ES_REVISION("企标制修订流程(草案编写/征求意见/报批)", 10, "com.jero.modules.activiti.process.esRevision.service.impl.EsRevisionServiceImpl","/workCenter/enterpriseStandardRevision/enterpriseStandardRevisionFlow","/workCenter/enterpriseStandardRevision"),
ES_CHANGE("企标更改流程",11, "com.jero.modules.activiti.process.esChange.service.impl.ProcessEsChangeServiceImpl","/workCenter/enterpriseStandardChange/enterpriseStandardChangeFlow","/workCenter/enterpriseStandardChange/enterpriseStandardChangeFlow"),
ES_RECHECK("企标复审流程",12, "com.jero.modules.activiti.process.esRecheck.service.impl.ProcessEsRecheckServiceImpl","/workCenter/enterpriseStandardRecheck/enterpriseStandardRecheckFlow","/workCenter/enterpriseStandardRecheck"),
ES_ABOLISH("企标废止流程",13, "com.jero.modules.activiti.process.esAbolish.service.impl.ProcessEsAbolishServiceImpl","/workCenter/enterpriseStandardAnnul/enterpriseStandardAnnulFlow","/workCenter/enterpriseStandardAnnul"),
ES_ARCHIVE("企标封存流程",14, "com.jero.modules.activiti.process.esArchive.service.impl.ProcessEsArchiveServiceImpl","/workCenter/enterpriseStandardSealSave/enterpriseStandardSealSaveFlow","/workCenter/enterpriseStandardSealSave"),
ES_ENABLE("已封存企标启用流程",15, "com.jero.modules.activiti.process.esEnable.service.impl.ProcessEsEnableServiceImpl","/workCenter/enterpriseStandardStartUse/enterpriseStandardStartUseFlow","/workCenter/enterpriseStandardStartUse"),
ES_INSPECT_PLAN("企标稽查计划", 16, "com.jero.modules.activiti.process.esinspectplan.service.impl.EsInspectPlanFlow","/workCenter/EnterpriseStandardInspectionPlan","/workCenter/EnterpriseStandardInspectionPlan"),
ES_INSPECT("企标稽查流程", 17, "com.jero.modules.activiti.process.esinspect.service.impl.EsInspectFlow","/workCenter/EnterpriseStandardInspectionProcess","/workCenter/EnterpriseStandardInspectionProcess"),
ES_INSPECT_DELAY_APPLY("稽查延期申请流程", 18, "com.jero.modules.activiti.process.esinspectdelayapply.service.impl.EsInspectDelayApplyFlow","/workCenter/InspectionExtensionRequestProcess","/workCenter/InspectionExtensionRequestProcess"),
ES_INSPECT_REPORT("企标稽查整改", 19, "com.jero.modules.activiti.process.esinspectrectify.service.impl.EsInspectRectifyFlow","/workCenter/EnterpriseStandardInspectionRectification","/workCenter/EnterpriseStandardInspectionRectification"),
PERMISSION_APPLY_PROCESS("权限申请流程", 20, "com.jero.modules.activiti.process.espermissionapply.service.impl.EsPermissionApplyFlow","/workCenter/PermissionApplicationProcess","/workCenter/PermissionApplicationProcess"),
STANDARD_DECLARE("标准宣贯流程", 21, "com.jero.modules.activiti.process.esdeclare.service.impl.EsDeclareFlow","/workCenter/StandardPromotionProcess","/noMobile"),
MEETING_MANAGE("会后管理流程", 22, "com.jero.modules.activiti.process.meetingmanage.service.impl.MeetingManageFlow","/workCenter/PostMeetingManageProcess","/noMobile")
;
private String name;
private Integer value;
private String implClass;
/**
* PC端跳转链接 (统一待办集成使用)
*/
private String fontReturnUrlPc;
/**
* APP端跳转链接(统一待办集成使用)
*/
private String fontReturnUrlApp;
public static String getNameByValue(Integer value) {
for (ProcessTypeEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getName();
}
}
return null;
}
public static String getClassByValue(Integer value) {
for (ProcessTypeEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getImplClass();
}
}
return null;
}
public static Integer getValueByName(String name, String processDefinitionId) {
for (ProcessTypeEnum enumObject : values()) {
if (enumObject.getName().equals(name)) {
return enumObject.getValue();
}
if (processDefinitionId.contains(enumObject.toString().toLowerCase().replace("_", "-"))) {
return enumObject.getValue();
}
}
return null;
}
public static String getFontReturnUrlPc(Integer value) {
for (ProcessTypeEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getFontReturnUrlPc();
}
}
return null;
}
public static String getFontReturnUrlApp(Integer value) {
for (ProcessTypeEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getFontReturnUrlApp();
}
}
return null;
}
}
@@ -0,0 +1,39 @@
package com.jero.modules.activiti.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author liJiaRao
* @date 2023-10-16 11:53
*/
@Getter
@AllArgsConstructor
public enum VariableTypeEnum {
/**
* A
*/
STRING("string", 1),
LIST("list", 1);
private String name;
private Integer value;
public static String getNameByValue(Integer value) {
for (VariableTypeEnum enumObject : values()) {
if (enumObject.getValue().equals(value)) {
return enumObject.getName();
}
}
return null;
}
public static Integer getValueByName(String name) {
for (VariableTypeEnum enumObject : values()) {
if (enumObject.getName().equals(name)) {
return enumObject.getValue();
}
}
return null;
}
}
@@ -0,0 +1,39 @@
package com.jero.modules.activiti.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.util.SpringContextUtil;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
/**
* @author liJiaRao
* @date 2023-10-15 17:02
*/
public class CompleteListener implements TaskListener {
@Override
public void notify(DelegateTask delegateTask) {
//流程审批信息转办
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
String taskId = delegateTask.getId();
String assignee = delegateTask.getAssignee();
//更新审批信息为完成
LambdaQueryWrapper<ProcessApprovalRecord> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessApprovalRecord::getTaskId,taskId);
wrapper.eq(ProcessApprovalRecord::getUserId,assignee);
ProcessApprovalRecord approvalRecord = recordService.getOne(wrapper);
approvalRecord.setFinishFlag(FinishFlagEnum.COMPLETE.getValue());
recordService.updateById(approvalRecord);
System.out.println(taskId);
System.out.println(delegateTask.getName());
System.out.println(delegateTask.getEventName());
System.out.println(assignee);
}
}
@@ -0,0 +1,51 @@
package com.jero.modules.activiti.listener;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.util.SpringContextUtil;
import org.activiti.bpmn.model.ActivitiListener;
import java.util.Date;
import org.activiti.engine.delegate.DelegateExecution;
import java.util.Set;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.task.DelegationState;
import org.activiti.engine.task.IdentityLink;
/**
* @author liJiaRao
* @date 2023-10-13 16:43
*/
public class CreateListener implements TaskListener {
@Override
public void notify(DelegateTask delegateTask) {
//流程信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
//流程审批信息
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
String id = delegateTask.getId();
String name = delegateTask.getName();
String processInstanceId = delegateTask.getProcessInstanceId();
Date createTime = delegateTask.getCreateTime();
String assignee = delegateTask.getAssignee();
String taskDefinitionKey = delegateTask.getTaskDefinitionKey();
//新增待审批记录
ProcessApprovalRecord approvalRecord = new ProcessApprovalRecord();
approvalRecord.setTaskId(id);
approvalRecord.setTaskName(name);
approvalRecord.setProcessInstanceId(processInstanceId);
approvalRecord.setUserId(assignee);
approvalRecord.setFinishFlag(FinishFlagEnum.INCOMPLETE.getValue());
approvalRecord.setCreateTime(createTime);
approvalRecord.setNodeId(taskDefinitionKey);
recordService.save(approvalRecord);
}
}
@@ -0,0 +1,43 @@
package com.jero.modules.activiti.listener;
import cn.hutool.core.date.DateBetween;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.util.SpringContextUtil;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import java.util.Date;
/**
* @author liJiaRao
* @date 2023-10-13 16:43
*/
public class EndListener implements ExecutionListener {
@Override
public void notify(DelegateExecution execution) {
//流程信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
String processInstanceId = execution.getProcessInstanceId();
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
Date createTime = processAll.getCreateTime();
DateTime date = DateUtil.date();
DateBetween between = date.between(createTime);
//更新流程总表信息为已完成
LambdaUpdateWrapper<ProcessAll> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(ProcessAll::getProcessInstanceId,processInstanceId);
wrapper.set(ProcessAll::getPrcStatus, ProcessStatusEnum.COMPLETED.getValue());
wrapper.set(ProcessAll::getEndTime,date);
wrapper.set(ProcessAll::getOverTime,between.toString());
processAllService.update(wrapper);
}
}
@@ -0,0 +1,348 @@
package com.jero.modules.activiti.listener;
import cn.hutool.core.date.DateBetween;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.common.api.PushWorkflowIntegrationAPI;
import com.jero.common.api.dto.message.HiworkTodoAdd;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.system.vo.LoginUser;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.entity.ProcessNode;
import com.jero.modules.activiti.enums.CommitFlagEnum;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.service.ProcessNodeService;
import com.jero.modules.activiti.util.SpringContextUtil;
import com.jero.modules.laws.common.util.CurrentUserUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.event.ActivitiEvent;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.engine.delegate.event.impl.ActivitiEntityEventImpl;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ExecutionEntityImpl;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.springframework.stereotype.Component;
import java.util.*;
/**
* @author liJiaRao
* @date 2023-11-27 10:57
*/
@Slf4j
@Component("myGlobalEventListener")
public class MyGlobalEventListener implements ActivitiEventListener {
@Override
public void onEvent(ActivitiEvent event) {
//log.info("========================MyGlobalEventListener========================");
switch (event.getType()) {
case TASK_CREATED:
this.taskCreate(event);
break;
case TASK_ASSIGNED:
this.taskAssigned(event);
break;
case TASK_COMPLETED:
this.taskComplete(event);
break;
case PROCESS_STARTED:
this.activityStarted(event);
break;
case PROCESS_COMPLETED:
this.activityComplete(event);
break;
default:
//log.info("Event received: " + event.getType());
}
}
/**
* 上面的 onEvent 方法抛出异常的后续处理动作
* false :表示忽略onEvent()方法方法中抛出的异常
* true :表示onEvent()方法中抛出的异常继续向上传播,导致当前操作失败
*/
@Override
public boolean isFailOnException() {
return false;
}
private void activityStarted(ActivitiEvent event) {
log.info("===================流程开始事件===================");
ActivitiEntityEventImpl activitiEntityEvent = (ActivitiEntityEventImpl) event;
ExecutionEntityImpl execution = (ExecutionEntityImpl) activitiEntityEvent.getEntity();
//流程信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
String processInstanceId = execution.getProcessInstanceId();
String processDefinitionId = execution.getProcessDefinitionId();
ExecutionEntityImpl parent = execution.getParent();
String name = parent.getProcessDefinitionName();
//新增流程总表信息(剩余的内容在启动流程时填充)
ProcessAll processAll = new ProcessAll();
DateTime date = DateUtil.date();
processAll.setPrcNum(DateUtil.format(date, DatePattern.PURE_DATETIME_MS_PATTERN));
LoginUser loginUser = CurrentUserUtil.getLoginUser();
processAll.setCreateUserId(loginUser == null ? null : loginUser.getId());
processAll.setProcessDefinitionId(processDefinitionId);
processAll.setProcessInstanceId(processInstanceId);
processAll.setPrcType(ProcessTypeEnum.getValueByName(name, processDefinitionId));
processAll.setPrcStatus(ProcessStatusEnum.INCOMPLETE.getValue());
processAllService.save(processAll);
log.info("id = " + execution.getId());
log.info("name = " + name);
log.info("taskEntity.getActivityName() = " + execution.getActivityName());
log.info("taskEntity.getDeploymentId() = " + execution.getDeploymentId());
log.info("taskEntity.getProcessDefinitionId() = " + execution.getProcessDefinitionId());
}
private void taskCreate(ActivitiEvent event) {
log.info("===================任务创建事件===================");
ActivitiEntityEventImpl activitiEntityEvent = (ActivitiEntityEventImpl) event;
TaskEntity delegateTask = (TaskEntity) activitiEntityEvent.getEntity();
ExecutionEntity execution = delegateTask.getExecution();
//任务创建时,清除pass
delegateTask.removeVariable("pass");
//流程审批信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
ProcessNodeService processNodeService = SpringContextUtil.getBean(ProcessNodeService.class);
log.info("id = " + delegateTask.getId());
log.info("name = " + delegateTask.getName());
log.info("taskEntity.getAssignee() = " + delegateTask.getAssignee());
log.info("taskEntity.getIdentityLinks() = " + delegateTask.getIdentityLinks());
log.info("taskEntity.getVariables() = " + delegateTask.getVariables());
log.info("execution.getActivityId() = " + execution.getActivityId());
String id = delegateTask.getId();
String name = delegateTask.getName();
String processInstanceId = delegateTask.getProcessInstanceId();
Date createTime = delegateTask.getCreateTime();
String assignee = delegateTask.getAssignee();
String taskDefinitionKey = delegateTask.getTaskDefinitionKey();
String processDefinitionId = delegateTask.getProcessDefinitionId();
//判断是否需要创建待办
LambdaQueryWrapper<ProcessNode> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessNode::getProcessDefinitionId,processDefinitionId);
wrapper.eq(ProcessNode::getNodeName,name);
wrapper.eq(ProcessNode::getIsView, YesOrNoEnum.YES.getValue());
int count = processNodeService.count(wrapper);
if (count == 0 || "123".equals(assignee)){
// 标准化发起流程不走这个逻辑
if (!processDefinitionId.contains("es-annual-init")) {
return;
}
}
//新增待审批记录
ProcessApprovalRecord approvalRecord = new ProcessApprovalRecord();
approvalRecord.setTaskId(id);
approvalRecord.setTaskName(name);
approvalRecord.setProcessInstanceId(processInstanceId);
approvalRecord.setUserId(assignee);
approvalRecord.setOriginUserId(assignee);
approvalRecord.setFinishFlag(FinishFlagEnum.INCOMPLETE.getValue());
approvalRecord.setCreateTime(createTime);
approvalRecord.setNodeId(taskDefinitionKey);
recordService.save(approvalRecord);
//更新最新接受任务时间
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
LambdaUpdateWrapper<ProcessAll> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ProcessAll::getId,processAll.getId());
updateWrapper.set(ProcessAll::getReceivedTaskTime,createTime);
processAllService.update(updateWrapper);
// 对接统一平台生成待办任务
PushWorkflowIntegrationAPI pushWorkflowIntegrationAPI = SpringContextUtil.getBean(PushWorkflowIntegrationAPI.class);
List<HiworkTodoAdd> list = new ArrayList<>();
HiworkTodoAdd hiworkTodoAdd = new HiworkTodoAdd();
hiworkTodoAdd.setRecordId(approvalRecord.getId());
hiworkTodoAdd.setProcessDefinitionId(processDefinitionId);
list.add(hiworkTodoAdd);
pushWorkflowIntegrationAPI.sendTodoTask(list);
}
private void taskAssigned(ActivitiEvent event) {
log.info("===================任务分配事件===================");
ActivitiEntityEventImpl activitiEntityEvent = (ActivitiEntityEventImpl) event;
TaskEntity delegateTask = (TaskEntity) activitiEntityEvent.getEntity();
String taskId = delegateTask.getId();
String assignee = delegateTask.getAssignee();
String processDefinitionId = delegateTask.getProcessDefinitionId();
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
LambdaQueryWrapper<ProcessApprovalRecord> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessApprovalRecord::getTaskId,taskId);
ProcessApprovalRecord approvalRecord = recordService.getOne(wrapper);
if (approvalRecord == null){
return;
}
String userId = approvalRecord.getUserId();
if (!Objects.equals(assignee,userId)) {
log.info(""+userId+"转办给"+assignee);
// 对接统一平台生成完成任务
PushWorkflowIntegrationAPI pushWorkflowIntegrationAPI = SpringContextUtil.getBean(PushWorkflowIntegrationAPI.class);
List<HiworkTodoAdd> list = new ArrayList<>();
HiworkTodoAdd hiworkTodoAdd = new HiworkTodoAdd();
hiworkTodoAdd.setRecordId(approvalRecord.getId());
hiworkTodoAdd.setType("2");
hiworkTodoAdd.setProcessDefinitionId(processDefinitionId);
list.add(hiworkTodoAdd);
pushWorkflowIntegrationAPI.sendTodoTask(list);
// 对接统一平台生成办结
pushWorkflowIntegrationAPI.sendActivityComplete(list);
// 生成被转办人的待办
list.clear();
hiworkTodoAdd.setToUserId(assignee);
hiworkTodoAdd.setType("1");
list.add(hiworkTodoAdd);
pushWorkflowIntegrationAPI.sendTodoTask(list);
}
}
private void taskComplete(ActivitiEvent event) {
log.info("===================任务完成事件===================");
ActivitiEntityEventImpl activitiEntityEvent = (ActivitiEntityEventImpl) event;
TaskEntity delegateTask = (TaskEntity) activitiEntityEvent.getEntity();
ExecutionEntity execution = delegateTask.getExecution();
log.info("流程实例总数:" + execution.getVariable("nrOfInstances"));
log.info("当前活动的流程实例总数:" + execution.getVariable("nrOfActiveInstances"));
log.info("已经完成实例的数目:" + execution.getVariable("nrOfCompletedInstances"));
log.info("id = " + delegateTask.getId());
log.info("name = " + delegateTask.getName());
log.info("taskEntity.getAssignee() = " + delegateTask.getAssignee());
log.info("taskEntity.getIdentityLinks() = " + delegateTask.getIdentityLinks());
log.info("execution.getActivityId() = " + execution.getActivityId());
log.info("taskEntity.getVariables() = " + delegateTask.getVariables());
//流程审批信息转办
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
String taskId = delegateTask.getId();
String assignee = delegateTask.getAssignee();
String processDefinitionId = delegateTask.getProcessDefinitionId();
//更新审批信息为完成
LambdaQueryWrapper<ProcessApprovalRecord> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessApprovalRecord::getTaskId,taskId);
ProcessApprovalRecord approvalRecord = recordService.getOne(wrapper);
if (approvalRecord == null){
return;
}
Date createTime = approvalRecord.getCreateTime();
DateTime date = DateUtil.date();
// 如果date小于createTime+一秒,说明是在同一秒内完成的,需要加一秒,解决流程审批信息发起节点和下一节点创建时间一致,排序错乱问题
if (date.isBeforeOrEquals(DateUtil.offsetSecond(createTime, 1))) {
date.setTime(createTime.getTime() + 1000);
}
DateBetween between = date.between(createTime);
// 征求意见流程 超期待办特殊处理
if (YesOrNoEnum.NO.getValue().equals(approvalRecord.getOverDue())){
approvalRecord.setFinishFlag(FinishFlagEnum.COMPLETE.getValue());
approvalRecord.setEndTime(date);
approvalRecord.setOverTime(between.toString());
}
Map<String, Object> variables = delegateTask.getVariables();
// 第一个节点不需要设置commitFlag 非审批节点也不需要设置commitFlag
String taskName = approvalRecord.getTaskName();
if (variables.containsKey("pass") &&
!isFirstNodeTask(approvalRecord) &&
(taskName.contains("审批") ||
taskName.contains("会签") ||
"模块责任人评审".equals(taskName) ||
"部所联络人校对".equals(taskName) ||
"其它起草人校对".equals(taskName))) {
if ((Boolean) variables.get("pass")) {
approvalRecord.setCommitFlag(CommitFlagEnum.PASS.getValue());
} else {
approvalRecord.setCommitFlag(CommitFlagEnum.REJECT.getValue());
}
}
// 如果是第一个节点需要把第一个节点的创建时间改小一秒
if (isFirstNodeTask(approvalRecord)) {
approvalRecord.setCreateTime(DateUtil.offsetSecond(createTime, -1));
}
recordService.updateById(approvalRecord);
//更新最新完成任务时间
ProcessAll processAll = processAllService.getByProcessInstanceId(delegateTask.getProcessInstanceId());
LambdaUpdateWrapper<ProcessAll> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ProcessAll::getId,processAll.getId());
updateWrapper.set(ProcessAll::getCompletedTaskTime,date);
processAllService.update(updateWrapper);
// 对接统一平台生成完成任务
PushWorkflowIntegrationAPI pushWorkflowIntegrationAPI = SpringContextUtil.getBean(PushWorkflowIntegrationAPI.class);
List<HiworkTodoAdd> list = new ArrayList<>();
HiworkTodoAdd hiworkTodoAdd = new HiworkTodoAdd();
hiworkTodoAdd.setRecordId(approvalRecord.getId());
hiworkTodoAdd.setProcessDefinitionId(processDefinitionId);
list.add(hiworkTodoAdd);
pushWorkflowIntegrationAPI.sendTodoTask(list);
// 对接统一平台生成办结
pushWorkflowIntegrationAPI.sendActivityComplete(list);
}
private void activityComplete(ActivitiEvent event) {
log.info("===================流程完成事件===================");
ActivitiEntityEventImpl activitiEntityEvent = (ActivitiEntityEventImpl) event;
ExecutionEntityImpl execution = (ExecutionEntityImpl) activitiEntityEvent.getEntity();
//流程信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
String processInstanceId = execution.getProcessInstanceId();
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
Date createTime = processAll.getCreateTime();
DateTime date = DateUtil.date();
DateBetween between = date.between(createTime);
//更新流程总表信息为已完成
LambdaUpdateWrapper<ProcessAll> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(ProcessAll::getProcessInstanceId, processInstanceId);
wrapper.set(ProcessAll::getPrcStatus, ProcessStatusEnum.COMPLETED.getValue());
wrapper.set(ProcessAll::getEndTime, date);
wrapper.set(ProcessAll::getOverTime, between.toString());
processAllService.update(wrapper);
log.info("id = " + execution.getId());
log.info("name = " + execution.getName());
log.info("taskEntity.getActivityName() = " + execution.getActivityName());
log.info("taskEntity.getDeploymentId() = " + execution.getDeploymentId());
log.info("taskEntity.getProcessDefinitionId() = " + execution.getProcessDefinitionId());
}
private boolean isFirstNodeTask(ProcessApprovalRecord record) {
String processInstanceId = record.getProcessInstanceId();
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
ProcessAll process = processAllService.getOne(new LambdaQueryWrapper<ProcessAll>()
.eq(ProcessAll::getProcessInstanceId, processInstanceId));
ProcessNodeService processNodeService = SpringContextUtil.getBean(ProcessNodeService.class);
// 企标复审流程前两个节点都要视为第一个节点
if (process.getPrcType() != null && process.getPrcType().equals(ProcessTypeEnum.ES_RECHECK.getValue())) {
List<ProcessNode> nodeList = processNodeService.list(new LambdaQueryWrapper<ProcessNode>()
.eq(ProcessNode::getProcessDefinitionId, process.getProcessDefinitionId())
.eq(ProcessNode::getSort, 2));
for (ProcessNode node : nodeList) {
if (record.getNodeId().equals(node.getXmlNodeId()) && record.getTaskName().equals(node.getNodeName())) {
return true;
}
}
}
ProcessNode node = processNodeService.getOne(new LambdaQueryWrapper<ProcessNode>()
.eq(ProcessNode::getProcessDefinitionId, process.getProcessDefinitionId())
.eq(ProcessNode::getSort, 1));
return record.getNodeId().equals(node.getXmlNodeId()) && record.getTaskName().equals(node.getNodeName());
}
}
@@ -0,0 +1,56 @@
package com.jero.modules.activiti.listener;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
/**
* @author liJiaRao
* @date 2023-08-04 10:53
*/
@Slf4j
public class SignListener implements TaskListener {
@Override
public void notify(DelegateTask delegateTask) {
/**
*
*/
//获取流程id
String taskId = delegateTask.getExecutionId();
//获取流程参数pass,会签人员完成自己的审批任务时会添加流程参数pass,false为拒绝,true为同意
// 1、创建ProcessEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、获取RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
boolean pass = (Boolean) runtimeService.getVariable(taskId, "pass");
/* ${nrOfCompletedInstances/nrOfInstances==1}
* false:有一个人拒绝,整个流程就结束了,
* 因为Complete condition的值为pass == false,即,当流程参数为pass时会签就结束开始下一个任务
* 所以,当pass == false时,直接设置下一个流程跳转需要的参数
* true:审批人同意,同时要判断是不是所有的人都已经完成了,而不是由一个人同意该会签就结束
* 值得注意的是如果一个审批人完成了审批进入到该监听时nrOfCompletedInstances的值还没有更新,因此需要+1
*/
Integer complete = (Integer) runtimeService.getVariable(taskId, "nrOfCompletedInstances");
Integer all = (Integer) runtimeService.getVariable(taskId, "nrOfInstances");
// 这里的test对应的是第一个节点中的对应的参数
String username= (String) runtimeService.getVariable(delegateTask.getExecutionId(), "test");
if(!pass){
//会签结束,返回发起人节点
runtimeService.setVariable(taskId, "countersignState", 0);
runtimeService.setVariable(taskId, "test", username);
}else{
//说明都完成了并且没有人拒绝
if((complete + 1) / all == 1){
// 流程流向下个节点 test2为下个节点人的参数
runtimeService.setVariable(taskId, "countersignState", 1);
runtimeService.setVariable(taskId, "test2", "xiaowang");
}
}
}
}
@@ -0,0 +1,44 @@
package com.jero.modules.activiti.listener;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.util.SpringContextUtil;
import org.activiti.engine.*;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.repository.ProcessDefinition;
/**
* @author liJiaRao
* @date 2023-10-13 16:43
*/
public class StartListener implements ExecutionListener {
@Override
public void notify(DelegateExecution execution) {
//流程信息
ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class);
//流程审批信息
ProcessApprovalRecordService recordService = SpringContextUtil.getBean(ProcessApprovalRecordService.class);
String id = execution.getId();
String processInstanceId = execution.getProcessInstanceId();
String processDefinitionId = execution.getProcessDefinitionId();
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RepositoryService repositoryService = processEngine.getRepositoryService();
ProcessDefinition processDefinition = repositoryService.getProcessDefinition(processDefinitionId);
String name = processDefinition.getName();
String key = processDefinition.getKey();
//新增流程总表信息(剩余的内容在启动流程时填充)
ProcessAll processAll = new ProcessAll();
processAll.setProcessInstanceId(processInstanceId);
processAll.setPrcType(ProcessTypeEnum.getValueByName(name, processDefinitionId));
processAll.setPrcStatus(ProcessStatusEnum.INCOMPLETE.getValue());
processAllService.save(processAll);
}
}
@@ -0,0 +1,17 @@
package com.jero.modules.activiti.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.entity.ActGeBytearray;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author liJiaRao
* @date 2023-08-04 16:04
*/
@Mapper
public interface ActGeBytearrayMapper extends BaseMapper<ActGeBytearray> {
List<ActGeBytearray> getActGeBytearrayList(@Param("processDefinitionId") String processDefinitionId);
}
@@ -0,0 +1,28 @@
package com.jero.modules.activiti.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jero.modules.activiti.entity.ProcessAll;
import org.apache.ibatis.annotations.Param;
/**
*
*@author liJiaRao
*@date 2023-10-16 15:49
*/
public interface ProcessAllMapper extends BaseMapper<ProcessAll> {
IPage<ProcessAll> getTodoList(Page<ProcessAll> page, @Param(Constants.WRAPPER) QueryWrapper<ProcessAll> queryWrapper, @Param("column") String column, @Param("order") String order);
IPage<ProcessAll> getCompletedList(Page<ProcessAll> page, @Param(Constants.WRAPPER) QueryWrapper<ProcessAll> queryWrapper, @Param("column") String column, @Param("order") String order);
IPage<ProcessAll> getSentList(Page<ProcessAll> page, @Param(Constants.WRAPPER) QueryWrapper<ProcessAll> queryWrapper, @Param("column") String column, @Param("order") String order);
IPage<ProcessAll> getAllList(Page<ProcessAll> page, @Param(Constants.WRAPPER) QueryWrapper<ProcessAll> queryWrapper, @Param("column") String column, @Param("order") String order);
int physicalDeleteByProjectId(@Param("tableName") String tableName, @Param("projectId") String projectId);
int physicalDeleteById(@Param("tableName") String tableName, @Param("id") String id);
}
@@ -0,0 +1,12 @@
package com.jero.modules.activiti.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
/**
*
*@author liJiaRao
*@date 2023-10-16 15:49
*/
public interface ProcessApprovalRecordMapper extends BaseMapper<ProcessApprovalRecord> {
}
@@ -0,0 +1,19 @@
package com.jero.modules.activiti.mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.entity.ProcessModelNode;
/**
*
*@author liJiaRao
*@date 2023-10-08 14:08
*/
public interface ProcessModelNodeMapper extends BaseMapper<ProcessModelNode> {
int deleteByModelId(@Param("modelId")String modelId);
void updateSortByInsertNode(@Param("modelId") String modelId, @Param("sort") Integer sort);
void updateSortByDeleteNode(@Param("modelId") String modelId, @Param("sort") Integer sort);
}
@@ -0,0 +1,19 @@
package com.jero.modules.activiti.mapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.entity.ProcessNodeLink;
/**
* @author liJiaRao
* @date 2023-09-26 15:12
*/
public interface ProcessNodeLinkMapper extends BaseMapper<ProcessNodeLink> {
}
@@ -0,0 +1,15 @@
package com.jero.modules.activiti.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.entity.ProcessNode;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author liJiaRao
* @date 2023-09-26 15:12
*/
public interface ProcessNodeMapper extends BaseMapper<ProcessNode> {
List<ProcessNode> selectByIdPdIdAndPiId(@Param("processDefinitionId") String processDefinitionId, @Param("processInstanceId") String processInstanceId);
}
@@ -0,0 +1,24 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ActGeBytearrayMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.entity.ActGeBytearray">
<!--@mbg.generated-->
<!--@Table act_ge_bytearray-->
<id column="ID_" jdbcType="VARCHAR" property="id" />
<result column="REV_" jdbcType="INTEGER" property="rev" />
<result column="NAME_" jdbcType="VARCHAR" property="name" />
<result column="DEPLOYMENT_ID_" jdbcType="VARCHAR" property="deploymentId" />
<result column="BYTES_" jdbcType="BLOB" property="bytes" />
<result column="GENERATED_" jdbcType="TINYINT" property="generated" />
</resultMap>
<sql id="Base_Column_List">
<!--@mbg.generated-->
ID_, REV_, NAME_, DEPLOYMENT_ID_, BYTES_, GENERATED_
</sql>
<select id="getActGeBytearrayList" resultType="com.jero.modules.activiti.entity.ActGeBytearray">
select a.*
from act_ge_bytearray a
inner join act_re_procdef b ON a.DEPLOYMENT_ID_ = b.DEPLOYMENT_ID_
where b.ID_ = #{processDefinitionId}
</select>
</mapper>
@@ -0,0 +1,115 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ProcessAllMapper">
<sql id="order">
<!--@sql select create_time as received_task_time from process_all pa -->
<if test="column == 'receivedTaskTime'">
order by received_task_time
<if test="order == 'desc'">
desc
</if>
</if>
</sql>
<sql id="order1">
<!--@sql select create_time as received_task_time from process_all par -->
<if test="column == 'receivedTaskTime'">
order by par.create_time
<if test="order == 'desc'">
desc
</if>
</if>
</sql>
<delete id="physicalDeleteByProjectId">
delete from ${tableName} where project_id = #{projectId}
</delete>
<delete id="physicalDeleteById">
delete from ${tableName} where id = #{id}
</delete>
<select id="getTodoList" resultType="com.jero.modules.activiti.entity.ProcessAll">
select par.create_time as received_task_time,
par.task_id,
par.task_name,
par.node_id,
par.over_due,
pa.id,
pa.prc_name,
pa.process_definition_id,
pa.process_instance_id,
pa.prc_mes,
pa.prc_num,
pa.create_user_id,
pa.prc_type,
pa.prc_status,
pa.end_time,
pa.over_time,
pa.project_id
from process_approval_record par
left join process_all pa on pa.process_instance_id = par.process_instance_id
${ew.customSqlSegment}
<include refid="order1"/>
</select>
<select id="getCompletedList" resultType="com.jero.modules.activiti.entity.ProcessAll">
select pa.id,
pa.prc_name,
pa.process_definition_id,
pa.process_instance_id,
pa.prc_mes,
pa.prc_num,
pa.create_user_id,
pa.prc_type,
pa.prc_status,
pa.end_time,
pa.over_time,
pa.project_id,
pa.received_task_time,
pa.completed_task_time
from process_all pa
left join process_approval_record par on pa.process_instance_id = par.process_instance_id
${ew.customSqlSegment}
<include refid="order"/>
</select>
<select id="getSentList" resultType="com.jero.modules.activiti.entity.ProcessAll">
select pa.id,
pa.prc_name,
pa.process_definition_id,
pa.process_instance_id,
pa.prc_mes,
pa.prc_num,
pa.create_user_id,
pa.prc_type,
pa.prc_status,
pa.end_time,
pa.over_time,
pa.project_id,
pa.received_task_time,
pa.completed_task_time
from process_all pa
${ew.customSqlSegment}
<include refid="order"/>
</select>
<select id="getAllList" resultType="com.jero.modules.activiti.entity.ProcessAll">
select pa.id,
pa.prc_name,
pa.process_definition_id,
pa.process_instance_id,
pa.prc_mes,
pa.prc_num,
pa.create_user_id,
pa.prc_type,
pa.prc_status,
pa.end_time,
pa.over_time,
pa.project_id,
pa.received_task_time,
pa.completed_task_time
from process_all pa
${ew.customSqlSegment}
<include refid="order"/>
</select>
</mapper>
@@ -0,0 +1,28 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ProcessApprovalRecordMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.entity.ProcessApprovalRecord">
<!--@mbg.generated-->
<!--@Table process_approval_record-->
<id column="id" jdbcType="VARCHAR" property="id" />
<result column="task_id" jdbcType="VARCHAR" property="taskId" />
<result column="task_name" jdbcType="VARCHAR" property="taskName" />
<result column="process_instance_id" jdbcType="VARCHAR" property="processInstanceId" />
<result column="msg_type" jdbcType="VARCHAR" property="msgType" />
<result column="user_id" jdbcType="VARCHAR" property="userId" />
<result column="mesg" jdbcType="LONGVARCHAR" property="mesg" />
<result column="finish_flag" jdbcType="TINYINT" property="finishFlag" />
<result column="project_id" jdbcType="VARCHAR" property="projectId" />
<result column="commit_flag" jdbcType="TINYINT" property="commitFlag" />
<result column="commit_text" jdbcType="VARCHAR" property="commitText" />
<result column="prc_name" jdbcType="VARCHAR" property="prcName" />
<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
<result column="end_time" jdbcType="TIMESTAMP" property="endTime" />
</resultMap>
<sql id="Base_Column_List">
<!--@mbg.generated-->
id, task_id, task_name, process_instance_id, msg_type, user_id, mesg, finish_flag,
project_id, commit_flag, commit_text, prc_name, create_time, update_time, end_time
</sql>
</mapper>
@@ -0,0 +1,59 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ProcessModelNodeMapper">
<!--auto generated by MybatisCodeHelper on 2023-10-08-->
<sql id="Base_Column_List">
id,
model_id,
node_name,
node_type,
xml_node_id,
xml_source_ref,
xml_target_ref,
is_approval_node,
is_can_deleted,
sort,
create_by,
create_time,
update_by,
update_time,
sys_code
</sql>
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.entity.ProcessModelNode">
<result column="id" property="id"/>
<result column="model_id" property="modelId"/>
<result column="node_name" property="nodeName"/>
<result column="node_type" property="nodeType"/>
<result column="xml_node_id" property="xmlNodeId"/>
<result column="xml_source_ref" property="xmlSourceRef"/>
<result column="xml_target_ref" property="xmlTargetRef"/>
<result column="is_approval_node" property="isApprovalNode"/>
<result column="is_can_deleted" property="isCanDeleted"/>
<result column="sort" property="sort"/>
<result column="create_by" property="createBy"/>
<result column="create_time" property="createTime"/>
<result column="update_by" property="updateBy"/>
<result column="update_time" property="updateTime"/>
<result column="sys_code" property="sysCode"/>
</resultMap>
<!--auto generated by MybatisCodeHelper on 2023-10-08-->
<delete id="deleteByModelId">
delete from process_model_node
where model_id=#{modelId}
</delete>
<update id="updateSortByInsertNode">
update process_model_node
set sort = sort + 1
where model_id = #{modelId}
and sort > #{sort}
</update>
<update id="updateSortByDeleteNode">
update process_model_node
set sort = sort - 1
where model_id = #{modelId}
and sort > #{sort}
</update>
</mapper>
@@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ProcessNodeLinkMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.entity.ProcessNodeLink">
<!--@mbg.generated-->
<!--@Table process_node_link-->
<id column="id" jdbcType="VARCHAR" property="id" />
<result column="process_node_id" jdbcType="VARCHAR" property="processNodeId" />
<result column="type" jdbcType="INTEGER" property="type" />
<result column="user_depart_id" jdbcType="VARCHAR" property="userDepartId" />
</resultMap>
<sql id="Base_Column_List">
<!--@mbg.generated-->
id, process_node_id, `type`, user_depart_id
</sql>
</mapper>
@@ -0,0 +1,24 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.mapper.ProcessNodeMapper">
<select id="selectByIdPdIdAndPiId" resultType="com.jero.modules.activiti.entity.ProcessNode">
select pn.*
<if test="processInstanceId != null and processInstanceId != ''">
,group_concat(DISTINCT pnl.user_id) as link_user_ids
</if>
from process_node pn
<if test="processInstanceId != null and processInstanceId != ''">
left join (select * from process_node_link where process_instance_id = #{processInstanceId}) pnl
on pn.id = pnl.process_node_id
</if>
<where>
pn.process_definition_id = #{processDefinitionId}
and pn.is_view = 1
</where>
<if test="processInstanceId != null and processInstanceId != ''">
group by pn.id
</if>
ORDER BY pn.sort
</select>
</mapper>
@@ -0,0 +1,379 @@
package com.jero.modules.activiti.process.aspect;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.common.constant.enums.LanguageEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.common.system.vo.LoginUser;
import com.jero.common.util.MessageUtils;
import com.jero.common.util.SnowflakeUtils;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.entity.ProcessNode;
import com.jero.modules.activiti.enums.CommitFlagEnum;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.enums.VariableTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.service.ProcessDraftService;
import com.jero.modules.activiti.process.esinspectdelayapply.common.EsInspectDelayApplyCommon;
import com.jero.modules.activiti.process.esinspectdelayapply.entity.ProcessEsInspectDelayApply;
import com.jero.modules.activiti.process.esinspectdelayapply.service.IProcessEsInspectDelayApplyService;
import com.jero.modules.activiti.process.esinspectplan.common.EsInspectPlanCommon;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.service.ProcessNodeService;
import com.jero.modules.activiti.util.SpringContextUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.HistoryService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.BeanUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
/**
* @ClassName: 流程aop
* @Description:
* @Author: yjz
* @Date: 2023-12-07 15:45
* @Version: 1.0
**/
@Aspect
@Component
@Slf4j
@Transactional(rollbackFor = RuntimeException.class)
public class ProcessAspect {
@Resource
private TaskService taskService;
@Resource
private HistoryService historyService;
@Resource
private RepositoryService repositoryService;
@Resource
private ProcessApprovalRecordService processApprovalRecordService;
@Resource
private ProcessDraftService processDraftService;
@Resource
private RuntimeService runtimeService;
@Resource
private ProcessAllService processAllService;
@Resource
private ProcessNodeService processNodeService;
private static final String PROCESS_ALL = "processAll";
private static final List<String> SPECIAL_NODE = Arrays.asList(EsInspectPlanCommon.PROCESS_NODE_3);
private static final String SAVE_BY_DRAFT = "2";
/**
* 强制撤回
*/
private static final String REVOCATION = "3";
// 流程发起
@Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowStart(..))")
public void processServiceFlowStart() {
}
// 流程保存
@Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowSave(..))")
public void processServiceFlowSave() {
}
// 流程审批
@Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowApproval(..))")
public void processServiceFlowApproval() {
}
// 流程转办
@Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowTransfer(..))")
public void processServiceFlowTransfer() {
}
// 流程驳回
@Pointcut("execution(public * com.jero.modules.activiti.process..*Controller.flowReject(..))")
public void processServiceFlowReject() {
}
@Before("processServiceFlowApproval() || processServiceFlowReject()")
public void doBefore(JoinPoint jp) {
log.info("==========流程合法性校验前置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
Object object = map.get(PROCESS_ALL);
ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
if (checkTaskExistence(processAll.getTaskId())){
if (LanguageEnum.CN.getValue().equals(MessageUtils.getLanguage().getValue())){
throw new JeroBootException("任务不存在!");
}else {
throw new JeroBootException("The task does not exist!");
}
}
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if (!getTaskAssignee(processAll.getTaskId()).equals(loginUser.getId())){
if (LanguageEnum.CN.getValue().equals(MessageUtils.getLanguage().getValue())){
throw new JeroBootException("非当前节点处理人!");
}else {
throw new JeroBootException("Not the current node processor!");
}
}
}
log.info("==========流程合法性校验前置方法结束==========");
}
@Before("processServiceFlowReject()")
public void doBeforeCountersignReject(JoinPoint jp){
log.info("==========流程会签节点驳回一票否决前置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
Object object = map.get(PROCESS_ALL);
ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
Object objectMap = map.get("map");
Map<String, Object> stringObjectMap = JSON.parseObject(JSON.toJSONString(objectMap), Map.class);
if ((stringObjectMap.containsKey("pass") && !(boolean) stringObjectMap.get("pass")) && isMultiTask(processAll.getTaskId())){
// 所有会签人数
Integer all = (Integer) taskService.getVariable(processAll.getTaskId(), "nrOfInstances");
taskService.setVariable(processAll.getTaskId(), "nrOfCompletedInstances", all);
// 其他会签人员审批信息,更新状态为未处理
processApprovalRecordService.update(
new LambdaUpdateWrapper<ProcessApprovalRecord>()
.eq(ProcessApprovalRecord::getProcessInstanceId, processAll.getProcessInstanceId())
.eq(ProcessApprovalRecord::getNodeId, processAll.getNodeId())
.isNull(ProcessApprovalRecord::getEndTime)
.ne(ProcessApprovalRecord::getTaskId, processAll.getTaskId())
.set(ProcessApprovalRecord::getCommitText, CommitFlagEnum.UNDISPOSED.getName())
.set(ProcessApprovalRecord::getFinishFlag, FinishFlagEnum.SUSPEND.getValue()));
}
}
log.info("==========流程会签节点驳回一票否决前置方法结束==========");
}
@AfterReturning("processServiceFlowReject()")
@Order(1)
public void doAfter(JoinPoint jp) {
log.info("==========流程驳回,若驳回到的节点之前经过转办,则驳回到转办人手里后置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
Object object = map.get(PROCESS_ALL);
ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
Object objectMap = map.get("map");
Map<String, Object> stringObjectMap = JSON.parseObject(JSON.toJSONString(objectMap), Map.class);
// 特殊节点排除
if ((stringObjectMap.containsKey("pass") && !(boolean) stringObjectMap.get("pass")) && !SPECIAL_NODE.contains(processAll.getNodeId())){
// 驳回的节点
List<ProcessApprovalRecord> processApprovalRecordList = processApprovalRecordService.list(
new LambdaQueryWrapper<ProcessApprovalRecord>()
.eq(ProcessApprovalRecord::getProcessInstanceId, processAll.getProcessInstanceId())
.orderByDesc(ProcessApprovalRecord::getCreateTime));
if (!processApprovalRecordList.isEmpty()){
ProcessApprovalRecord processApprovalRecord = processApprovalRecordList.get(0);
processApprovalRecordList.remove(0);
Optional<ProcessApprovalRecord> optional = processApprovalRecordList.stream().filter(v ->
v.getTaskName().equals(processApprovalRecord.getTaskName())
&& v.getNodeId().equals(processApprovalRecord.getNodeId())).findFirst();
optional.ifPresent(v -> {
// 是否转办过
if (StringUtils.isNotBlank(v.getTransferBy())){
// 转办给转办人
taskService.setAssignee(processApprovalRecord.getTaskId(), v.getUserId());
// 更新流程审批记录表
processApprovalRecordService.update(
new LambdaUpdateWrapper<ProcessApprovalRecord>()
.eq(ProcessApprovalRecord::getTaskId, processApprovalRecord.getTaskId())
.set(ProcessApprovalRecord::getUserId, v.getUserId())
.set(ProcessApprovalRecord::getOriginUserId, v.getUserId()));
}
});
}
}
}
log.info("==========流程驳回,若驳回到的节点之前经过转办,则驳回到转办人手里后置方法结束==========");
}
@AfterReturning("processServiceFlowSave() || processServiceFlowStart()")
public void doAfterFlowSave(JoinPoint jp) {
log.info("==========流程保存到草稿后置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
Object processApprovalRecordObject = map.get("processApprovalRecord");
String infoJsonStr = String.valueOf(map.get("infoJsonStr"));
String saveSource = String.valueOf(map.get("saveSource"));
Object processAllObject = map.get(PROCESS_ALL);
if (!Objects.isNull(processApprovalRecordObject) && !Objects.isNull(processAllObject)){
ProcessApprovalRecord processApprovalRecord = JSON.parseObject(JSON.toJSONString(processApprovalRecordObject), ProcessApprovalRecord.class);
ProcessAll processAll = JSON.parseObject(JSON.toJSONString(processAllObject), ProcessAll.class);
if (StringUtils.isBlank(processAll.getNodeId()) || SAVE_BY_DRAFT.equals(saveSource)){
ProcessDraft processDraft = new ProcessDraft();
setProperty(loginUser, infoJsonStr, processApprovalRecord, processAll, processDraft);
// 删除旧草稿
processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
.eq(ProcessDraft::getProjectId, processAll.getProjectId())
.eq(ProcessDraft::getUserId, loginUser.getId()));
// 保存新草稿
processDraftService.save(processDraft);
// 保存新草稿(强制撤回用)
processDraft.setId(String.valueOf(SnowflakeUtils.snowflake()));
processDraft.setSaveSource(REVOCATION);
processDraft.setInfoJsonStr(processDraft.getInfoJsonStr().replaceFirst("\\{", "{\"revocation\": true,"));
processDraftService.save(processDraft);
if (jp.getSignature().getName().equals("flowStart")){
// 发起后删除草稿
processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
.eq(ProcessDraft::getProjectId, processAll.getProjectId())
.eq(ProcessDraft::getUserId, loginUser.getId())
.and(qw -> qw.ne(ProcessDraft::getSaveSource, REVOCATION)
.or().isNull(ProcessDraft::getSaveSource)));
}
}
}
}
log.info("==========流程保存到草稿后置方法结束==========");
}
@AfterReturning("processServiceFlowStart() || processServiceFlowApproval() || processServiceFlowReject()")
public void doAfterRemoveDraft(JoinPoint jp) {
log.info("==========流程发起、审批、驳回。删除草稿后置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
Map<String, Objects> map = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), Map.class);
Object object = map.get(PROCESS_ALL);
if (!Objects.isNull(object)){
// 发起、审批、驳回
ProcessAll processAll = JSON.parseObject(JSON.toJSONString(object), ProcessAll.class);
// 删除草稿
processDraftService.remove(new LambdaQueryWrapper<ProcessDraft>()
.eq(ProcessDraft::getProjectId, processAll.getProjectId())
.eq(ProcessDraft::getUserId, loginUser.getId())
.and(qw -> qw.ne(ProcessDraft::getSaveSource, REVOCATION)
.or().isNull(ProcessDraft::getSaveSource)));
}
}
log.info("==========流程发起、审批、驳回。删除草稿后置方法结束==========");
}
@AfterReturning("processServiceFlowTransfer()")
public void doAfterFlowTransfer(JoinPoint jp) {
log.info("==========流程转办后置方法开始==========");
if (!Objects.isNull(jp.getArgs())) {
String taskId = JSON.parseObject(JSON.toJSONString(jp.getArgs()[0]), String.class);
String toUserId = JSON.parseObject(JSON.toJSONString(jp.getArgs()[1]), String.class);
ProcessApprovalRecord processApprovalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
String processInstanceId = processApprovalRecord.getProcessInstanceId();
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
TaskService taskService = SpringContextUtil.getBean(TaskService.class);
Task task = taskService.createTaskQuery().taskId(processApprovalRecord.getTaskId()).singleResult();
// 查询节点信息
ProcessNode processNode = processNodeService.getOne(
new LambdaQueryWrapper<ProcessNode>()
.eq(ProcessNode::getProcessDefinitionId, processAll.getProcessDefinitionId())
.eq(ProcessNode::getXmlNodeId, processApprovalRecord.getNodeId()));
if (!Objects.isNull(processNode) && VariableTypeEnum.STRING.getName().equals(processNode.getVariableType())){
runtimeService.setVariable(task.getExecutionId(), processNode.getVariableName(), toUserId);
}
// 稽查延期申请流程 稽查联络人评估 节点特殊处理
if (ProcessTypeEnum.ES_INSPECT_DELAY_APPLY.getValue().equals(processAll.getPrcType())
&& EsInspectDelayApplyCommon.PROCESS_NODE_3.equals(processApprovalRecord.getNodeId())){
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
IProcessEsInspectDelayApplyService processEsInspectDelayApplyService = SpringContextUtil.getBean(IProcessEsInspectDelayApplyService.class);
processEsInspectDelayApplyService.update(
new LambdaUpdateWrapper<ProcessEsInspectDelayApply>()
.eq(ProcessEsInspectDelayApply::getProjectId, processAll.getProjectId())
.eq(ProcessEsInspectDelayApply::getLiaisons, loginUser.getId())
.set(ProcessEsInspectDelayApply::getLiaisons, toUserId));
}
}
log.info("==========流程转办后置方法结束==========");
}
private static void setProperty(LoginUser loginUser, String infoJsonStr, ProcessApprovalRecord processApprovalRecord, ProcessAll processAll, ProcessDraft processDraft) {
// 属性拷贝
BeanUtils.copyProperties(processAll, processDraft);
processDraft.setCreateBy("");
processDraft.setId("");
processDraft.setUpdateBy("");
Date date = new Date();
if (Objects.isNull(processAll.getCreateTime())){
processDraft.setCreateTime(date);
}else {
processDraft.setCreateTime(processAll.getCreateTime());
}
processDraft.setUpdateBy("");
processDraft.setUpdateTime(date);
// 保存草稿表
if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processApprovalRecord.getCommitFile())){
processDraft.setHandleFile(processApprovalRecord.getCommitFile());
}
if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processApprovalRecord.getCommitText())){
processDraft.setHandleText(processApprovalRecord.getCommitText());
}
if (!Objects.isNull(processAll.getDueTime())){
processDraft.setProcessDueDate(processAll.getDueTime());
}
if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(processAll.getPrcMes())){
processDraft.setProcessDescription(processAll.getPrcMes());
}
if (com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(infoJsonStr)){
processDraft.setInfoJsonStr(infoJsonStr);
}
processDraft.setUserId(loginUser.getId());
}
/**
* 是否会签节点
* @param taskId
* @return
*/
public boolean isMultiTask(String taskId){
// 根据流程实例id查询
Task task = taskService.createTaskQuery()
.taskId(taskId)
.singleResult();
// 获取流程实例对象
HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
.processInstanceId(task.getProcessInstanceId())
.singleResult();
// 获取流程定义对象,主要用于判断流程任务结点是否为会签结点
Process process = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId())
.getProcessById(historicProcessInstance.getProcessDefinitionKey());
// 获取当前任务结点
Optional<UserTask> userTask = process.getFlowElements().stream()
.filter(flowElement -> task.getTaskDefinitionKey().equals(flowElement.getId()))
.map(UserTask.class::cast)
.findAny();
return userTask.isPresent() && !Objects.isNull(userTask.get().getLoopCharacteristics());
}
public boolean checkTaskExistence(String taskId) {
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
return Objects.isNull(task);
}
public String getTaskAssignee(String taskId) {
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
return task.getAssignee();
}
}
@@ -0,0 +1,10 @@
package com.jero.modules.activiti.process.common.common;
/**
* @author liJiaRao
* @date 2024-01-11 10:36
*/
public class DraftCommon {
//初始
public static final String INITIAL_SOURCE = "3";
}
@@ -0,0 +1,45 @@
package com.jero.modules.activiti.process.common.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.Translation;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
* @author: Mzaxd
* @Date: 2023/11/21 14:27
*/
@Slf4j
@RestController
@Api(tags = "企标通用流程接口")
@RequestMapping("/process/common")
public class ESProcessCommonController {
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 根据企标编号获取企标计划的标准类型字段
*
* @param standardNo
*/
@AutoLog(value = "根据企标编号获取企标计划的标准类型字段")
@ApiOperation(value="根据企标编号获取企标计划的标准类型字段", notes="根据企标编号获取企标计划的标准类型字段")
@GetMapping("/getStandType")
@Translation
@Deprecated
public Result<?> getStandType(@RequestParam("standardNo") @ApiParam("企标编号") String standardNo) {
return Result.OK(actFlowCommonService.getStandTypeByStandNo(standardNo));
}
}
@@ -0,0 +1,27 @@
package com.jero.modules.activiti.process.common.entity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* @author: Mzaxd
* @Date: 2023/10/11 9:37
*/
@Data
public class CenterQueryVO {
@ApiModelProperty(value = "流程名称")
private String prcName;
@ApiModelProperty(value = "流程编号")
private String prcNum;
@ApiModelProperty(value = "流程类型")
private String prcType;
@ApiModelProperty(value = "流程状态")
private String prcState;
}
@@ -0,0 +1,100 @@
package com.jero.modules.activiti.process.common.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* @author: Mzaxd
* @Date: 2023/10/26 7:46
*/
@Data
@ApiModel(value="流程通用信息对象", description="流程通用信息对象")
public class CommonVO {
/**
* 流程定义ID
*/
@ApiModelProperty("流程定义ID")
private String processDefinitionId;
/**
* 流程实例ID
*/
@ApiModelProperty("流程实例ID")
private String processInstanceId;
/**
* 任务ID
*/
@ApiModelProperty("任务ID")
private String taskId;
/**
* 备注
*/
@ApiModelProperty("备注")
private String commitText;
/**
* 附件
*/
@ApiModelProperty("附件")
private String commitFile;
/**
* 同意驳回标识
*/
@ApiModelProperty("同意驳回标识")
private Integer commitFlag;
/**
* 同意驳回标识
*/
@ApiModelProperty("同意驳回标识")
private boolean pass;
/**
* 流程名称
*/
@ApiModelProperty("流程名称")
private String prcName;
/**
* 截止日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty("截止日期")
private Date dueTime;
/**
* 流程描述
*/
@ApiModelProperty("流程描述")
private String prcMes;
/**
* 节点Id
*/
@ApiModelProperty("节点Id")
private String nodeId;
/**
* 制修订计划说明
*/
@ApiModelProperty("制修订计划说明")
private String processDescription;
/**
* 草稿Id
*/
@ApiModelProperty("草稿Id")
private String draftId;
}
@@ -0,0 +1,20 @@
package com.jero.modules.activiti.process.common.entity;
/**
* @author: Mzaxd
* @Date: 2023/11/28 16:44
*/
public class CounterSignNodeNameConstants {
public static final String COUNTER_SIGN_NODE_NAME = "相关人员会签";
public static final String ES_CHANGE_COUNTER_SIGN_NODE_NAME = "相关人员校对";
public static final String ES_INIT_CHANGE_EXPERT_NODE_NAME = "专家审批";
public static final String ES_REVISION_OTHER_DRAFT_USER_CHECK_NODE_NAME = "其它起草人校对";
public static final String ES_REVISION_LEADER_APPROVAL_NODE_NAME = "主管级领导审批";
public static final String ES_REVISION_RELATED_LEADER_APPROVAL_NODE_NAME = "相关部门领导会签";
}
@@ -0,0 +1,67 @@
package com.jero.modules.activiti.process.common.entity;
import lombok.Data;
/**
* @author: Mzaxd
* @Date: 2023/10/12 13:52
*/
@Data
public class ProcessCenterListVO {
/**
* 流程编号
*/
private String processNum;
/**
* 流程类型
*/
private String processType;
/**
* 流程名称
*/
private String processName;
/**
* 发起人
*/
private String createUser;
/**
* 创建时间
*/
private String createTime;
/**
* 任务Id
*/
private String taskId;
/**
* 当前处理人
*/
private String currentUser;
/**
* 接收任务时间
*/
private String acceptTime;
/**
* 完成时间
*/
private String completeTime;
/**
* 流程状态
*/
private String processStatus;
/**
* 流程耗时
*/
private String processTime;
}
@@ -0,0 +1,133 @@
package com.jero.modules.activiti.process.common.entity;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
*
* @TableName process_draft
*/
@TableName(value ="process_draft")
@Data
public class ProcessDraft implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 创建人ID
*/
@ApiModelProperty(value = "创建人ID")
private String createBy;
/**
* 创建时间
*/
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 修改人ID
*/
@ApiModelProperty(value = "修改人ID")
private String updateBy;
/**
* 修改时间
*/
@ApiModelProperty(value = "修改时间")
private Date updateTime;
/**
* 部门code
*/
@ApiModelProperty(value = "部门code")
private String orgCode;
/**
* 流程类型
*/
@ApiModelProperty(value = "流程类型")
private String prcName;
/**
* 流程实例id
*/
@ApiModelProperty(value = "流程实例id")
private String processInstanceId;
/**
* 项目类型
*/
@Dict(dicCode = "prc_type")
@ApiModelProperty(value = "项目类型")
private Integer prcType;
/**
* 项目id
*/
@ApiModelProperty(value = "项目id")
private String projectId;
/**
* 节点id
*/
@TableField(exist = false)
@ApiModelProperty(value = "节点id")
private String nodeId;
/**任务id*/
@ApiModelProperty(value = "任务id")
private java.lang.String taskId;
/**流程审批信息-备注*/
@ApiModelProperty(value = "流程审批信息-备注")
private java.lang.String handleText;
/**流程审批信息-附件*/
@ApiModelProperty(value = "流程审批信息-附件")
private java.lang.String handleFile;
/**用户id*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "用户id")
private java.lang.String userId;
/**节点名称*/
@ApiModelProperty(value = "节点名称")
@TableField(exist = false)
private java.lang.String nodeName;
/**流程信息-截止日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "流程信息-截止日期")
private java.util.Date processDueDate;
/**流程信息-流程说明*/
@ApiModelProperty(value = "流程信息-流程说明")
private java.lang.String processDescription;
/**草稿信息json字符串*/
@ApiModelProperty(value = "草稿信息json字符串")
private String infoJsonStr;
/**
* 保存来源
*/
@ApiModelProperty(value="保存来源(3:强制撤回使用)")
private String saveSource;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -0,0 +1,22 @@
package com.jero.modules.activiti.process.common.entity;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author: Mzaxd
* @Date: 2023/11/21 14:30
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class StandTypeVO {
@ApiModelProperty("企标计划-标准类型")
@Dict(dicCode = "esp_standard_type")
private String standardType;
}
@@ -0,0 +1,17 @@
package com.jero.modules.activiti.process.common.entity;
import lombok.Data;
/**
* @author: Mzaxd
* @Date: 2023/10/17 10:35
*/
@Data
public class TransferVO {
String taskId;
String userId;
String projectId;
}
@@ -0,0 +1,59 @@
package com.jero.modules.activiti.process.common.enums;
import lombok.Getter;
/**
* @author: Mzaxd
* @Date: 2023/10/12 9:37
* 流程类型
*/
@Getter
public enum ProcessType {
/**
* 企标立项变更
*/
ES_INIT_CHANGE("企标立项/变更计划", "1", "es-init-change", "processEsInitChangeServiceImpl"),
ES_ANNUAL_REPORT("年度制修订-各部门主动上报", "2", "es-annual-report", "processEsAnnualReportServiceImpl"),
ES_ANNUAL_INIT("年度制修订-标准化部门主动发起", "3", "es-annual-init", "processEsAnnualInitServiceImpl"),
FB_ENTRY_CHANGE("标准法规入库/变更流程", "4", "fb-entry-change", "ProcessFbEntryChangeServiceImpl"),
ES_ABOLISH("企标废止流程", "5", "es-abolish", "ProcessEsAbolishServiceImpl"),
ES_ARCHIVE("企标封存流程", "6", "es-archive", "ProcessEsArchiveServiceImpl"),
ES_CHANGE("企标变更流程", "7", "es-change", "ProcessEsChangeServiceImpl"),
ES_RECHECK("企标复审流程", "8", "es-recheck", "ProcessEsRecheckServiceImpl"),
ES_ENABLE("已封存企标启用流程", "9", "es-enable", "ProcessEsEnableServiceImpl"),
ES_REVISION("企标制修订流程", "10", "es-revision", "ProcessEsRevisionServiceImpl"),
ES_INSPECT_PLAN("企标稽查计划", "16", "inspect_plan", "ProcessEsInspectPlanServiceImpl"),
ES_INSPECT("企标稽查流程", "17", "inspect_process", "ProcessEsInspectServiceImpl"),
ES_INSPECT_DELAY_APPLY("稽查延期申请流程", "18", "inspect_delay_apply_process", "ProcessEsInspectDelayApplyServiceImpl"),
ES_INSPECT_REPORT("企标稽查整改", "19", "inspect_report", "ProcessEsInspectReportServiceImpl"),
PERMISSION_APPLY_PROCESS("权限申请流程", "20", "permission_apply_process", "ProcessEsPermissionApplyServiceImpl"),
STANDARD_DECLARE("标准宣贯流程", "21", "standard_declare", "ProcessEsDeclareServiceImpl"),
MEETING_MANAGE("会后管理流程", "22", "meeting_manage", "ProcessMeetingManageServiceImpl")
;
private final String name;
private final String value;
private final String processKey;
private final String serviceClassName;
ProcessType(String name, String value, String processKey, String serviceClassName) {
this.name = name;
this.value = value;
this.processKey = processKey;
this.serviceClassName = serviceClassName;
}
public String getProcessTypeNameByProcessKey(String processKey) {
for (ProcessType processType : ProcessType.values()) {
if (processType.getProcessKey().equals(processKey)) {
return processType.getName();
}
}
return null;
}
}
@@ -0,0 +1,38 @@
package com.jero.modules.activiti.process.common.enums;
/**
* @author: Mzaxd
* @Date: 2023/11/20 14:50
*/
public enum StandardStateEnum {
DRAFT("草稿","1"),
SEEK_FOR_OPINIONS("征求意见","2"),
EXAMINE("审查","3"),
APPROVAL("报批","4"),
PRE_RELEASE("预发布","5"),
RELEASE("发布","6"),
TRIAL_OPERATION("试运行","7"),
CURRENTLY_EFFECTIVE("现行有效","8"),
ABOLISH("废止","9"),
ARCHIVE("封存","A"),
;
private final String stateName;
private final String stateValue;
StandardStateEnum(String stateName, String stateValue) {
this.stateName = stateName;
this.stateValue = stateValue;
}
public String getStateName() {
return stateName;
}
public String getStateValue() {
return stateValue;
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.common.mapper;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_draft】的数据库操作Mapper
* @createDate 2023-10-12 10:45:38
* @Entity com.jero.modules.activiti.process.common.entity.ProcessDraft
*/
public interface ProcessDraftMapper extends BaseMapper<ProcessDraft> {
}
@@ -0,0 +1,23 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.process.common.mapper.ProcessDraftMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.common.entity.ProcessDraft">
<id property="id" column="id" jdbcType="VARCHAR"/>
<result property="createBy" column="create_by" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="orgCode" column="org_code" jdbcType="VARCHAR"/>
<result property="draftId" column="draft_id" jdbcType="VARCHAR"/>
<result property="businessId" column="business_id" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,create_by,create_time,
update_by,update_time,org_code,
draft_id,business_id
</sql>
</mapper>
@@ -0,0 +1,568 @@
package com.jero.modules.activiti.process.common.service;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.exception.JeroBootException;
import com.jero.common.system.vo.LoginUser;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.enums.CommitFlagEnum;
import com.jero.modules.activiti.enums.FinishFlagEnum;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.common.DraftCommon;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.StandTypeVO;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.fb.dto.BasicProcessInfoDTO;
import com.jero.modules.activiti.process.fb.dto.BasicTaskInfoDTO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.laws.common.util.CurrentUserUtil;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.apache.shiro.SecurityUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.*;
@Slf4j
@Service
@Transactional
public class ActFlowCommonService {
@Resource
private RepositoryService repositoryService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private ProcessAllService processAllService;
@Resource
private ProcessApprovalRecordService processApprovalRecordService;
@Resource
private ProcessApprovalRecordService approvalRecordService;
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private ProcessDraftService processDraftService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ILawsEnterpriseStandardService esService;
/**
* 启动流程实例
*/
public ProcessInstance startProcess(String processDefinitionKey, Map<String, Object> variables) {
ProcessDefinition latestProcessDefinition = repositoryService.createProcessDefinitionQuery()
.processDefinitionKey(processDefinitionKey)
.orderByProcessDefinitionVersion().desc()
.list()
.get(0); // 获取最新版本的流程定义
// 启动流程
ProcessInstance processInstance = runtimeService.startProcessInstanceById(latestProcessDefinition.getId(), variables);
// 流程定义ID
String processDefinitionId = processInstance.getProcessDefinitionId();
log.info("【启动流程】- 成功,processDefinitionId{}", processDefinitionId);
log.info("启动流程实例成功,流程定义ID为:{}", processDefinitionId);
return processInstance;
}
/**
* Map工具
*
* @param map
* @param key
* @param value
*/
public void putIfNotNull(Map<String, Object> map, String key, Object value) {
Optional.ofNullable(value).ifPresent(v -> map.put(key, v));
}
/**
* 转换逗号拼接为List
*
* @param map
* @param flowUserInfoVO
* @param key
*/
public void convertAndPutList(HashMap<String, Object> map, Map<String, Object> flowUserInfoVO, String key) {
Optional.ofNullable(flowUserInfoVO.get(key))
.map(Object::toString)
.map(s -> Arrays.asList(s.split(",")))
.ifPresent(list -> map.put(key, list));
}
/**
* 系统中保存选人信息 多实例节点需要将List转为逗号拼接
*/
public void convertListToString(Map<String, Object> variables) {
for (Map.Entry<String, Object> entry : variables.entrySet()) {
String key = entry.getKey();
if (key.endsWith("List")) {
List<String> list = (List<String>) entry.getValue();
String s = String.join(",", list);
variables.put(key, s);
}
}
}
/**
* 循环设置流程变量
*
* @param processInstanceId
* @param variables
*/
public void setProcessVariables(String processInstanceId, Map<String, Object> variables) {
for (Map.Entry<String, Object> entry : variables.entrySet()) {
String key = entry.getKey();
runtimeService.setVariable(processInstanceId, key, entry.getValue());
}
}
/**
* 更新审批表为完成,填充数据
*
* @param commonVO
* @param taskId
* @param pass
*/
public void updateApprovalInfo(CommonVO commonVO, String taskId, boolean pass) {
ProcessApprovalRecord approvalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
approvalRecord.setCommitText(commonVO.getCommitText());
approvalRecord.setCommitFile(commonVO.getCommitFile());
approvalRecord.setFinishFlag(FinishFlagEnum.COMPLETE.getValue());
approvalRecord.setEndTime(new Date());
// 使用流程引擎根据TaskId找到NodeId
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String nodeId = task.getTaskDefinitionKey();
approvalRecord.setNodeId(nodeId);
processApprovalRecordService.updateById(approvalRecord);
}
public void updateApprovalInfoWithoutNodeId(String taskId) {
ProcessApprovalRecord approvalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
if (approvalRecord == null) {
return;
}
approvalRecord.setCommitText(null);
approvalRecord.setCommitFile(null);
approvalRecord.setFinishFlag(FinishFlagEnum.COMPLETE.getValue());
approvalRecord.setEndTime(new Date());
processApprovalRecordService.updateById(approvalRecord);
}
public ProcessApprovalRecord getNodeIdByTaskId(String taskId) {
return processApprovalRecordService.getToDoByTaskId(taskId);
}
/**
* 完成提交任务
*/
public void completeTask(String taskId, String userId) {
//任务Id 查询任务对象
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
if (!taskExists(taskId)) {
log.error("找不到对应任务");
throw new JeroBootException("找不到对应任务");
}
//任务对象 获取流程实例Id
String processInstanceId = task.getProcessInstanceId();
//设置审批人的userId
Authentication.setAuthenticatedUserId(userId);
//添加记录
log.info("-----------完成任务操作 开始----------");
log.info("任务Id=" + taskId);
log.info("负责人id=" + userId);
log.info("流程实例id=" + processInstanceId);
//完成办理
taskService.complete(taskId);
log.info("-----------完成任务操作 结束----------");
}
/**
* 查看个人任务列表
*/
public List<Map<String, Object>> myTaskList(String userid) {
TaskQuery taskQuery = taskService.createTaskQuery().taskAssignee(userid);
List<Task> list = taskQuery.orderByTaskCreateTime().desc().list();
List<Map<String, Object>> listMap = new ArrayList<>();
for (Task task : list) {
Map<String, Object> map = new HashMap<>();
map.put("taskId", task.getId());
map.put("taskName", task.getName());
map.put("description", task.getDescription());
map.put("priority", task.getPriority());
map.put("owner", task.getOwner());
map.put("assignee", task.getAssignee());
map.put("delegationState", task.getDelegationState());
map.put("processInstanceId", task.getProcessInstanceId());
map.put("executionId", task.getExecutionId());
map.put("processDefinitionId", task.getProcessDefinitionId());
map.put("createTime", task.getCreateTime());
map.put("taskDefinitionKey", task.getTaskDefinitionKey());
map.put("dueDate", task.getDueDate());
map.put("category", task.getCategory());
map.put("parentTaskId", task.getParentTaskId());
map.put("tenantId", task.getTenantId());
listMap.add(map);
}
return listMap;
}
/**
* 转办
*/
public void transfer(String taskId, String toUserId) {
processHandleService.transfer(taskId, toUserId);
}
/**
* 判断任务是否存在
*
* @param taskId
* @return
*/
public boolean taskExists(String taskId) {
return taskService.createTaskQuery().taskId(taskId).singleResult() != null;
}
public void autoCompleteFirstTask(String userId, String processInstanceId, String processDefinitionId, CommonVO commonVO) {
// 自动完成第一个任务
List<Map<String, Object>> taskList = this.myTaskList(userId);
if (!CollectionUtils.isEmpty(taskList)) {
for (Map<String, Object> map : taskList) {
if (map.get("assignee").toString().equals(userId) &&
map.get("processDefinitionId").toString().equals(processDefinitionId) &&
map.get("processInstanceId").toString().equals(processInstanceId)) { // 添加这一行来进行更精确的匹配
log.info("当前用户ID:{},相关联的流程定义ID:{}", userId, map.get("processDefinitionId").toString());
log.info("匹配到的任务ID{}", map.get("taskId").toString());
String taskId = map.get("taskId").toString();
this.completeTask(taskId, userId);
break;
}
}
}
}
public String getProcessInstanceIdByTaskId(String taskId) {
if (StrUtil.isBlank(taskId)) {
return null;
}
// 使用流程引擎根据taskId找到流程实例Id
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
return task.getProcessInstanceId();
}
public String getProcessDefId(String processInstanceId) {
ProcessInstance processInstance =
runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId)
.singleResult();
// 从ProcessInstance对象中获取processDefId
if (processInstance != null) {
return processInstance.getProcessDefinitionId();
} else {
throw new JeroBootException("未找到流程定义Id");
}
}
/**
* 更新流程主表
*
* @param processInstanceId
* @param userId
* @param prcName
* @param prcMes
* @param prcType
* @param dueTime
*/
public void updateProcessAll(String processInstanceId, String userId, String prcName, String prcMes, Integer prcType, Date dueTime) {
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
process.setPrcName(prcName);
process.setPrcMes(prcMes);
process.setDueTime(dueTime);
process.setPrcType(prcType);
processAllService.updateById(process);
}
/**
* 更新流程主表
*
* @param processInstanceId
* @param userId
* @param prcName
* @param prcMes
* @param prcType
* @param dueTime
*/
public void updateProcessAllWithUserId(String processInstanceId, String userId, String prcName, String prcMes, Integer prcType, Date dueTime) {
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
process.setCreateUserId(userId);
process.setPrcName(prcName);
process.setPrcMes(prcMes);
process.setDueTime(dueTime);
process.setPrcType(prcType);
processAllService.updateById(process);
}
public void updateProcessAllWithProjectId(String processInstanceId, String prcName, String prcMes,
Integer prcType, Date dueTime, String projectId) {
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
process.setPrcName(prcName);
process.setPrcMes(prcMes);
process.setDueTime(dueTime);
process.setPrcType(prcType);
process.setProjectId(projectId);
processAllService.updateById(process);
}
public StandTypeVO getStandTypeByStandNo(String standardNo) {
LambdaUpdateWrapper<EnterpriseStandardPlan> espWrapper = new LambdaUpdateWrapper<>();
espWrapper.eq(EnterpriseStandardPlan::getNewEnStandardNo, standardNo);
EnterpriseStandardPlan one = espService.getOne(espWrapper);
StandTypeVO standTypeVO = new StandTypeVO();
if (one != null) {
standTypeVO.setStandardType(one.getStandardType());
}
return standTypeVO;
}
public ProcessDraft getExistDraft(String draftId, ProcessTypeEnum processTypeEnum) {
String userId = UserUtils.getUserId();
LambdaQueryWrapper<ProcessDraft> draftWrapper = new LambdaQueryWrapper<>();
draftWrapper.eq(ProcessDraft::getPrcType, processTypeEnum.getValue());
draftWrapper.eq(ProcessDraft::getUserId, userId);
draftWrapper.eq(ProcessDraft::getId, draftId);
return processDraftService.getOne(draftWrapper);
}
public ProcessDraft getExistDraftByTaskId(String taskId, ProcessTypeEnum processTypeEnum) {
String userId = UserUtils.getUserId();
LambdaQueryWrapper<ProcessDraft> draftWrapper = new LambdaQueryWrapper<>();
draftWrapper.eq(ProcessDraft::getPrcType, processTypeEnum.getValue());
draftWrapper.eq(ProcessDraft::getUserId, userId);
draftWrapper.eq(ProcessDraft::getTaskId, taskId);
draftWrapper.orderByDesc(ProcessDraft::getCreateTime);
List<ProcessDraft> list = processDraftService.list(draftWrapper);
if (list != null && !list.isEmpty()) {
return list.get(0);
}
return null;
}
public void getExistDraftAndRemove(CommonVO common, ProcessTypeEnum processTypeEnum) {
// 删除草稿表数据
if (StrUtil.isNotBlank(common.getDraftId())) {
processDraftService.removeById(common.getDraftId());
}
}
public CommonVO getHandleCommon(String taskId) {
String processInstanceId = this.getProcessInstanceIdByTaskId(taskId);
String processDefinitionId = this.getProcessDefId(processInstanceId);
// 获取流程通用数据
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
CommonVO commonVO = new CommonVO();
commonVO.setPrcName(process.getPrcName());
commonVO.setTaskId(process.getTaskId());
commonVO.setPrcMes(process.getPrcMes());
commonVO.setDueTime(process.getDueTime());
commonVO.setProcessDefinitionId(processDefinitionId);
commonVO.setProcessInstanceId(processInstanceId);
// 获取节点ID
ProcessApprovalRecord record = this.getNodeIdByTaskId(taskId);
commonVO.setNodeId(record.getNodeId());
return commonVO;
}
public void removeDraft(CommonVO commonVO) {
String userId = UserUtils.getUserId();
String taskId = commonVO.getTaskId();
String processInstanceId = commonVO.getProcessInstanceId();
LambdaQueryWrapper<ProcessDraft> draftWrapper = new LambdaQueryWrapper<>();
draftWrapper.eq(ProcessDraft::getUserId, userId);
draftWrapper.eq(StrUtil.isNotBlank(taskId), ProcessDraft::getTaskId, taskId);
draftWrapper.ne(ProcessDraft::getSaveSource, DraftCommon.INITIAL_SOURCE);
draftWrapper.eq(StrUtil.isNotBlank(processInstanceId), ProcessDraft::getProcessInstanceId, processInstanceId);
processDraftService.remove(draftWrapper);
}
/**
* 会签节点驳回后,将其余节点recode设置为 未处理 状态
*
* @param prcId
* @param nodeName
*/
public void updateOtherCountersignRecodeStatus(String prcId, String nodeName) {
LambdaUpdateWrapper<ProcessApprovalRecord> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ProcessApprovalRecord::getProcessInstanceId, prcId);
updateWrapper.eq(ProcessApprovalRecord::getFinishFlag, FinishFlagEnum.INCOMPLETE.getValue());
updateWrapper.eq(ProcessApprovalRecord::getTaskName, nodeName);
updateWrapper.set(ProcessApprovalRecord::getCommitText, CommitFlagEnum.UNDISPOSED.getName());
updateWrapper.set(ProcessApprovalRecord::getFinishFlag, null);
processApprovalRecordService.update(updateWrapper);
}
/**
* 根据指定的执行Id递归获取所有子执行Id
*
* @param executionId 指定的执行Id
* @return 所有子执行Id的列表
*/
public List<String> getAllChildExecutionIds(String executionId) {
List<String> childExecutionIds = new ArrayList<>();
Execution execution = runtimeService.createExecutionQuery().executionId(executionId).singleResult();
if (execution != null) {
String processInstanceId = execution.getProcessInstanceId();
collectChildExecutionIds(processInstanceId, executionId, childExecutionIds);
}
return childExecutionIds;
}
private void collectChildExecutionIds(String processInstanceId, String parentExecutionId, List<String> collectedIds) {
List<Execution> childExecutions = runtimeService.createExecutionQuery()
.processInstanceId(processInstanceId)
.list();
for (Execution childExecution : childExecutions) {
if (childExecution.getSuperExecutionId() != null && childExecution.getSuperExecutionId().equals(parentExecutionId)) {
collectedIds.add(childExecution.getId());
// 递归调用,以获取更深层次的子流程执行Id
collectChildExecutionIds(processInstanceId, childExecution.getId(), collectedIds);
}
}
}
public String getOriginTaskAssignee(String taskId) {
ProcessApprovalRecord approvalRecord = processApprovalRecordService.getToDoByTaskId(taskId);
return approvalRecord.getOriginUserId();
}
/**
* 强制撤回流程-保存草稿
*
* @param common
* @param processTypeEnum
* @param jsonData
*/
public void saveFirstNodeDraft(CommonVO common, ProcessTypeEnum processTypeEnum, Object data) {
ProcessInfoVO processInfoVo = this.getProcessInfoVo(common, processTypeEnum, data);
processHandleService.saveToDraft(processInfoVo);
}
public void saveFirstNodeDraft(CommonVO common, ProcessTypeEnum processTypeEnum, String jsonData) {
ProcessInfoVO processInfoVo = this.getProcessInfoVo(common, processTypeEnum, jsonData);
processHandleService.saveToDraft(processInfoVo);
}
public void saveFirstNodeDraftCustomUserId(CommonVO common, ProcessTypeEnum processTypeEnum, String jsonData, String userId) {
ProcessInfoVO processInfoVo = this.getProcessInfoVo(common, processTypeEnum, jsonData);
processHandleService.saveToDraftCustomUserId(processInfoVo, userId);
}
private ProcessInfoVO getProcessInfoVo(CommonVO common, ProcessTypeEnum processTypeEnum, Object data) {
// 将archiveData转为Json
String dataJson = JSON.toJSONString(data);
ProcessInfoVO<ESArchiveDataVO> processInfoVO = new ProcessInfoVO<>();
processInfoVO.setSaveSource(DraftCommon.INITIAL_SOURCE);
BasicTaskInfoDTO basicTaskInfoDTO = new BasicTaskInfoDTO();
basicTaskInfoDTO.setHandleFile(common.getCommitFile());
basicTaskInfoDTO.setHandleText(common.getCommitText());
BasicProcessInfoDTO basicProcessInfoDTO = new BasicProcessInfoDTO();
basicProcessInfoDTO.setProcessName(common.getPrcName());
basicProcessInfoDTO.setProcessDescription(common.getPrcMes());
basicProcessInfoDTO.setProcessType(processTypeEnum.getValue());
basicProcessInfoDTO.setProcessDueDate(common.getDueTime());
basicProcessInfoDTO.setProcessInstanceId(common.getProcessInstanceId());
processInfoVO.setInfoJsonStr(dataJson);
processInfoVO.setBasicTaskInfoDTO(basicTaskInfoDTO);
processInfoVO.setBasicProcessInfoDTO(basicProcessInfoDTO);
return processInfoVO;
}
private ProcessInfoVO getProcessInfoVo(CommonVO common, ProcessTypeEnum processTypeEnum, String jsonData) {
ProcessInfoVO<ESArchiveDataVO> processInfoVO = new ProcessInfoVO<>();
processInfoVO.setSaveSource(DraftCommon.INITIAL_SOURCE);
BasicTaskInfoDTO basicTaskInfoDTO = new BasicTaskInfoDTO();
basicTaskInfoDTO.setHandleFile(common.getCommitFile());
basicTaskInfoDTO.setHandleText(common.getCommitText());
BasicProcessInfoDTO basicProcessInfoDTO = new BasicProcessInfoDTO();
basicProcessInfoDTO.setProcessName(common.getPrcName());
basicProcessInfoDTO.setProcessDescription(common.getPrcMes());
basicProcessInfoDTO.setProcessType(processTypeEnum.getValue());
basicProcessInfoDTO.setProcessDueDate(common.getDueTime());
basicProcessInfoDTO.setProcessInstanceId(common.getProcessInstanceId());
processInfoVO.setInfoJsonStr(jsonData);
processInfoVO.setBasicTaskInfoDTO(basicTaskInfoDTO);
processInfoVO.setBasicProcessInfoDTO(basicProcessInfoDTO);
return processInfoVO;
}
public void checkStandardState(String standardId) {
LawsEnterpriseStandard es = esService.getById(standardId);
if (es != null) {
String standardState = es.getStandardState();
if (StandardStateEnum.ABOLISH.getStateValue().equals(standardState) ||
StandardStateEnum.ARCHIVE.getStateValue().equals(standardState)) {
log.error("企标编号为{}的企标已经废止或者封存,无法进行复审流程", es.getStandardNumber());
throw new JeroBootException(ResultCommon.CAN_NOT_EDIT_ABOLISH_OR_ARCHIVE_ES);
}
}
}
public String getFirstTaskId(String processInstanceId, String userId, String processDefinitionId) {
// 自动完成第一个任务
List<Map<String, Object>> taskList = this.myTaskList(userId);
if (!CollectionUtils.isEmpty(taskList)) {
for (Map<String, Object> map : taskList) {
if (map.get("assignee").toString().equals(userId) &&
map.get("processDefinitionId").toString().equals(processDefinitionId) &&
map.get("processInstanceId").toString().equals(processInstanceId)) { // 添加这一行来进行更精确的匹配
log.info("当前用户ID:{},相关联的流程定义ID:{}", userId, map.get("processDefinitionId").toString());
log.info("匹配到的任务ID{}", map.get("taskId").toString());
return map.get("taskId").toString();
}
}
}
return null;
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.common.service;
import com.jero.modules.activiti.process.common.entity.CenterQueryVO;
import com.jero.modules.activiti.process.common.entity.ProcessCenterListVO;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* @author ThinkBook
* @description 针对表【process_draft】的数据库操作Service
* @createDate 2023-10-12 10:45:38
*/
public interface ProcessDraftService extends IService<ProcessDraft> {
List<ProcessCenterListVO> getDraftList(CenterQueryVO centerQueryVO);
}
@@ -0,0 +1,36 @@
package com.jero.modules.activiti.process.common.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.modules.activiti.process.common.entity.CenterQueryVO;
import com.jero.modules.activiti.process.common.entity.ProcessCenterListVO;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.service.ProcessDraftService;
import com.jero.modules.activiti.process.common.mapper.ProcessDraftMapper;
import com.jero.modules.sys.utils.UserUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author ThinkBook
* @description 针对表【process_draft】的数据库操作Service实现
* @createDate 2023-10-12 10:45:38
*/
@Service
public class ProcessDraftServiceImpl extends ServiceImpl<ProcessDraftMapper, ProcessDraft>
implements ProcessDraftService {
@Override
public List<ProcessCenterListVO> getDraftList(CenterQueryVO centerQueryVO) {
String userId = UserUtils.getUserId();
LambdaQueryWrapper<ProcessDraft> draftWrapper = new LambdaQueryWrapper<>();
draftWrapper.eq(ProcessDraft::getCreateBy, userId);
List<ProcessDraft> list = list(draftWrapper);
return null;
}
}
@@ -0,0 +1,137 @@
package com.jero.modules.activiti.process.esAbolish.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.Translation;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.TransferVO;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esAbolish.entity.vo.ESAbolishDataVO;
import com.jero.modules.activiti.process.esAbolish.service.ProcessEsAbolishService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.process.projectassess.vo.ProcessProjectAssessVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
* @author: Mzaxd
* @Date: 2023/10/18 10:44
*/
@Slf4j
@RestController
@Api(tags = "企标废止发起流程")
@RequestMapping("/process/es/abolish")
public class ESAbolishController {
@Resource
private ProcessEsAbolishService abolishService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增立项变更申请
*
* @param abolishData
*/
@AutoLog(value = "企标废止发起流程-发起流程")
@ApiOperation(value="企标废止发起流程-发起流程", notes="企标废止发起流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESAbolishDataVO abolishData) {
abolishService.startProcess(abolishData);
return Result.OK();
}
/**
* 保存到草稿
* @param processInfoVO
*/
@AutoLog(value = "企标废止发起流程-保存")
@ApiOperation(value="企标废止发起流程-保存", notes="企标废止发起流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESAbolishDataVO> processInfoVO) {
abolishService.saveToDraft(processInfoVO);
return Result.OK();
}
/**
* 草稿办理
* @param draftId
*/
@AutoLog(value = "企标废止发起流程-草稿办理")
@ApiOperation(value="企标废止发起流程-草稿办理", notes="企标废止发起流程-草稿办理")
@GetMapping("/draftHandle")
@Translation
public Result<?> draftHandle(@RequestParam("draftId") @ApiParam("草稿Id") String draftId) {
return Result.OK(actFlowCommonService.getExistDraft(draftId, ProcessTypeEnum.ES_ABOLISH));
}
/**
* 保存到待办
* @param taskId
*/
@AutoLog(value = "企标废止发起流程-办理")
@ApiOperation(value="企标废止发起流程-办理", notes="企标废止发起流程-办理")
@GetMapping("/handle/{taskId}")
@Translation
public Result<?> handle(@PathVariable("taskId") String taskId) {
ProcessDraft draft = actFlowCommonService.getExistDraftByTaskId(taskId, ProcessTypeEnum.ES_ABOLISH);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(abolishService.getHandleData(taskId));
}
/**
* 同意
*
* @param abolishData
*/
@AutoLog(value = "企标废止发起流程-同意")
@ApiOperation(value="企标废止发起流程-同意", notes="企标废止发起流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESAbolishDataVO abolishData) {
abolishService.approval(abolishData, true);
return Result.OK();
}
/**
* 驳回
*
* @param abolishData
*/
@AutoLog(value = "企标废止发起流程-驳回")
@ApiOperation(value="企标废止发起流程-驳回", notes="企标废止发起流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESAbolishDataVO abolishData) {
abolishService.approval(abolishData, false);
return Result.OK();
}
/**
* 转办
*
*/
@AutoLog(value = "企标废止发起流程-转办")
@ApiOperation(value="企标废止发起流程-转办", notes="企标废止发起流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
}
@@ -0,0 +1,137 @@
package com.jero.modules.activiti.process.esAbolish.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 企业标准
* @TableName process_es_abolish
*/
@TableName(value ="process_es_abolish")
@Data
public class ProcessEsAbolish implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 企标编号
*/
@ApiModelProperty(value = "企标编号")
private String standardNumber;
/**
* 企标名称
*/
@ApiModelProperty(value = "企标名称")
private String standardName;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String englishName;
/**
* 企标类型
*/
@Dict(dicCode = "esp_standard_type")
@ApiModelProperty(value = "企标类型")
private String standardCategory;
/**
* 代替标准号
*/
@ApiModelProperty(value = "代替标准号")
private String substituteStandardNumber;
/**
* 被代替标准号
*/
@ApiModelProperty(value = "被代替标准号")
private String replacedByStandardNumber;
/**
* 发布日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "发布日期")
private Date releaseDate;
/**
* 实施日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "实施日期")
private Date implementationDate;
/**
* 废止理由
*/
@ApiModelProperty(value = "废止理由")
private String abolishReason;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -0,0 +1,27 @@
package com.jero.modules.activiti.process.esAbolish.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 8:13
*/
@Data
public class ESAbolishDataVO {
@JsonProperty("common")
private CommonVO common;
@JsonProperty("data")
private ProcessEsAbolish data;
@JsonProperty("flowUser")
private Map<String, Object> flowUser;
}
@@ -0,0 +1,76 @@
package com.jero.modules.activiti.process.esAbolish.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esAbolish.service.ProcessEsAbolishService;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
import com.jero.modules.activiti.process.esEnable.service.ProcessEsEnableService;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPApplicationCategoryEnum;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPChangeType;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.bindPart.docking.DockingService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.BeanCopyUtils;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.tag.enums.TableNameEnum;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
import static com.jero.modules.bindPart.docking.DockingServiceImpl.STANDARD_ABOLISH;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESAbolishEndListener implements ExecutionListener {
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private ProcessEsAbolishService esAbolishService;
@Resource
private DockingService dockingService;
/**
* 企标废止流程结束之后需要把标准状态设为废止
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标废止流程结束 监听执行器开始执行");
// 找到流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsAbolish> abolishLambdaQueryWrapper = new LambdaQueryWrapper<>();
abolishLambdaQueryWrapper.eq(ProcessEsAbolish::getProcessInstanceId, processInstanceId);
ProcessEsAbolish abolish = esAbolishService.getOne(abolishLambdaQueryWrapper);
String standNo = abolish.getStandardNumber();
LambdaQueryWrapper<LawsEnterpriseStandard> esWrapper = new LambdaQueryWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getStandardNumber, standNo);
LawsEnterpriseStandard one = esService.getOne(esWrapper);
log.info("企标废止流程监听执行器开始执行,企标编号为:{}", standNo);
esService.update(new LambdaUpdateWrapper<LawsEnterpriseStandard>()
.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.ABOLISH.getStateValue())
.eq(LawsEnterpriseStandard::getStandardNumber, standNo));
try {
dockingService.sendStandardChangeToSCM(one.getId(), TableNameEnum.ENTERPRISE_STANDARDS.getValue(), STANDARD_ABOLISH, null);
} catch (Exception e) {
log.error("E采通同步标准信息出错", e);
}
log.info("企标废止流程结束监听执行器执行结束");
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.esAbolish.mapper;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_abolish(企业标准)】的数据库操作Mapper
* @createDate 2023-10-29 21:02:55
* @Entity com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish
*/
public interface ProcessEsAbolishMapper extends BaseMapper<ProcessEsAbolish> {
}
@@ -0,0 +1,35 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.process.esAbolish.mapper.ProcessEsAbolishMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish">
<id property="id" column="id" jdbcType="VARCHAR"/>
<result property="createBy" column="create_by" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="orgCode" column="org_code" jdbcType="VARCHAR"/>
<result property="delFlag" column="del_flag" jdbcType="TINYINT"/>
<result property="processInstanceId" column="process_instance_id" jdbcType="VARCHAR"/>
<result property="standardNumber" column="standard_number" jdbcType="VARCHAR"/>
<result property="standardName" column="standard_name" jdbcType="VARCHAR"/>
<result property="englishName" column="english_name" jdbcType="VARCHAR"/>
<result property="standardCategory" column="standard_category" jdbcType="VARCHAR"/>
<result property="substituteStandardNumber" column="substitute_standard_number" jdbcType="VARCHAR"/>
<result property="replacedByStandardNumber" column="replaced_by_standard_number" jdbcType="VARCHAR"/>
<result property="releaseDate" column="release_date" jdbcType="TIMESTAMP"/>
<result property="implementationDate" column="implementation_date" jdbcType="TIMESTAMP"/>
<result property="abolishReason" column="abolish_reason" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,create_by,create_time,
update_by,update_time,org_code,
del_flag,process_instance_id,standard_number,
standard_name,english_name,standard_category,
substitute_standard_number,replaced_by_standard_number,release_date,
implementation_date,abolish_reason
</sql>
</mapper>
@@ -0,0 +1,23 @@
package com.jero.modules.activiti.process.esAbolish.service;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esAbolish.entity.vo.ESAbolishDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_abolish(企业标准)】的数据库操作Service
* @createDate 2023-10-29 21:02:55
*/
public interface ProcessEsAbolishService extends IService<ProcessEsAbolish> {
void startProcess(ESAbolishDataVO annualInitData);
void saveToDraft(ProcessInfoVO<ESAbolishDataVO> annualInitData);
ESAbolishDataVO getHandleData(String taskId);
void approval(ESAbolishDataVO annualInitData, boolean pass);
}
@@ -0,0 +1,254 @@
package com.jero.modules.activiti.process.esAbolish.service.impl;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.aspect.TranslationAspect;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.common.entity.CounterSignNodeNameConstants;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.enums.ProcessType;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esAbolish.entity.vo.ESAbolishDataVO;
import com.jero.modules.activiti.process.esAbolish.service.ProcessEsAbolishService;
import com.jero.modules.activiti.process.esAbolish.mapper.ProcessEsAbolishMapper;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
import com.jero.modules.activiti.process.fb.dto.BasicProcessInfoDTO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.process.projectassess.entity.ProcessProjectAssess;
import com.jero.modules.activiti.process.projectassess.vo.ProcessProjectAssessVO;
import com.jero.modules.activiti.service.ProcessNodeLinkService;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
/**
* @author ThinkBook
* @description 针对表【process_es_abolish(企业标准)】的数据库操作Service实现
* @createDate 2023-10-29 21:02:55
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsAbolishServiceImpl extends ServiceImpl<ProcessEsAbolishMapper, ProcessEsAbolish>
implements ProcessEsAbolishService {
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private RuntimeService runtimeService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private TaskService taskService;
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private TranslationAspect translationAspect;
@Override
public void startProcess(ESAbolishDataVO abolishData) {
// 执行流程发起前的操作
this.startRunTask(abolishData);
// 流程Key
String processDefinitionKey = ProcessType.ES_ABOLISH.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
ProcessEsAbolish esAbolish = abolishData.getData();
// 通用数据
CommonVO commonVO = abolishData.getCommon();
// 人员数据
Map<String, Object> variables = abolishData.getFlowUser();
// 流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(commonVO, ProcessTypeEnum.ES_ABOLISH);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esAbolish.setProcessInstanceId(processInstanceId);
// 保存到业务流程表
saveOrUpdate(esAbolish);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(variables));
// 获取第一个任务的taskId
String taskId = actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.manualParseDictText(this.getHandleData(taskId), this.getUserMap(variables));
// 强制撤回
commonVO.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_ABOLISH, jsonData);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, true);
// 自动完成第一个任务
actFlowCommonService.completeTask(taskId, userId);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ABOLISH.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(Map<String, Object> flowUser) {
Map<String, Object> actVariables = new HashMap<>();
if (flowUser.get("relatedUserList") == null || StrUtil.isBlank((String) flowUser.get("relatedUserList"))) {
actFlowCommonService.putIfNotNull(actVariables, "countersign", false);
} else {
actFlowCommonService.putIfNotNull(actVariables, "countersign", true);
String relatedUsers = (String) flowUser.get("relatedUserList");
// 将relatedUserList从逗号拼接转为List
List<String> relatedUserList = StrUtil.split(relatedUsers, ',');
actFlowCommonService.putIfNotNull(actVariables, "relatedUserList", relatedUserList);
}
for (Map.Entry<String, Object> entry : flowUser.entrySet()) {
String key = entry.getKey();
if (!key.equals("relatedUserList")) {
actVariables.put(key, entry.getValue());
}
}
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
variables.remove("countersign");
return variables;
}
@Override
public void saveToDraft(ProcessInfoVO<ESAbolishDataVO> processInfoVO) {
ESAbolishDataVO businessInfoDTO = processInfoVO.getBusinessInfoDTO();
if (businessInfoDTO != null) {
ProcessEsAbolish data = businessInfoDTO.getData();
if (data != null) {
processInfoVO.setBusinessId(data.getId());
}
}
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_ABOLISH.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
public void startRunTask(ESAbolishDataVO abolishData) {
// do nothing now
}
@Override
public ESAbolishDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ESAbolishDataVO abolishData = new ESAbolishDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
abolishData.setCommon(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsAbolish> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsAbolish::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsAbolish::getDelFlag, YesOrNoEnum.NO.getValue());
ProcessEsAbolish data = getOne(lambdaQueryWrapper);
abolishData.setData(data);
return abolishData;
}
@Override
public void approval(ESAbolishDataVO abolishData, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = abolishData.getCommon();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
Map<String, Object> flowUser = abolishData.getFlowUser();
// 获取流程实例ID
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId).singleResult();
// 获取流程定义ID
String processDefinitionId = processInstance.getProcessDefinitionId();
// 如果是最后一个节点的审批则需要判断是否可以通过
String taskName = taskService.createTaskQuery().taskId(taskId).singleResult().getName();
if (pass && taskName.equals("标准化审批")) {
ProcessEsAbolish data = this.getOne(new LambdaQueryWrapper<ProcessEsAbolish>()
.eq(ProcessEsAbolish::getProcessInstanceId, processInstanceId));
String standardNumber = data.getStandardNumber();
LawsEnterpriseStandard es = esService.getOne(new LambdaQueryWrapper<LawsEnterpriseStandard>()
.eq(LawsEnterpriseStandard::getStandardNumber, standardNumber));
if (StandardStateEnum.ABOLISH.getStateValue().equals(es.getStandardState())) {
throw new JeroBootException("该标准已废止,需要驳回重新选择");
}
}
ProcessEsAbolish data = abolishData.getData();
if (data != null) {
updateById(data);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ABOLISH.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
if (flowUser != null) {
Map<String, Object> variables = setVariables(flowUser);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
// 获取执行id
String executionId = task.getExecutionId();
// 设置流程变量
runtimeService.setVariables(executionId, variables);
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(flowUser));
}
// 设置流程变量
runtimeService.setVariable(processInstanceId, "pass", pass);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, userId);
// 删除草稿
actFlowCommonService.removeDraft(commonVO);
// 如果是会签节点,驳回后要将其余节点recode设置为 未处理 状态
if (!pass) {
actFlowCommonService.updateOtherCountersignRecodeStatus(processInstanceId, CounterSignNodeNameConstants.COUNTER_SIGN_NODE_NAME);
}
}
}
@@ -0,0 +1,211 @@
package com.jero.modules.activiti.process.esAnnualInit.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.Translation;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.util.IntekeyUtils;
import com.jero.common.util.MessageUtils;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.TransferVO;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.jero.modules.activiti.process.esAnnualInit.entity.vo.AnnualInitDataVO;
import com.jero.modules.activiti.process.esAnnualInit.service.ProcessEsAnnualInitService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.IOUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpHeaders;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/18 10:44
*/
@Slf4j
@RestController
@Api(tags = "企标年度制修订标准化发起流程")
@RequestMapping("/process/es/annualInit")
public class ESAnnualInitController {
@Resource
private ProcessEsAnnualInitService annualInitService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增立项变更申请
*
* @param annualInitData
*/
@AutoLog(value = "企标年度制修订标准化发起流程-发起立项变更申请")
@ApiOperation(value="企标年度制修订标准化发起流程-发起立项变更申请", notes="企标年度制修订标准化发起流程-发起立项变更申请")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody AnnualInitDataVO annualInitData) {
annualInitService.startProcess(annualInitData);
return Result.OK();
}
/**
* 保存到待办
* @param processInfoVO
*/
@AutoLog(value = "企标年度制修订标准化发起流程-保存")
@ApiOperation(value="企标年度制修订标准化发起流程-保存", notes="企标年度制修订标准化发起流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<AnnualInitDataVO> processInfoVO) {
annualInitService.saveToDraft(processInfoVO);
return Result.OK();
}
/**
* 草稿办理
* @param draftId
*/
@AutoLog(value = "企标封存流程-草稿办理")
@ApiOperation(value="企标封存流程-草稿办理", notes="企标封存流程-草稿办理")
@GetMapping("/draftHandle")
@Translation
public Result<?> draftHandle(@RequestParam("draftId") @ApiParam("草稿Id") String draftId) {
return Result.OK(actFlowCommonService.getExistDraft(draftId, ProcessTypeEnum.ES_ANNUAL_INIT));
}
/**
* 待办回显
* @param taskId
*/
@AutoLog(value = "企标年度制修订标准化发起流程-办理")
@ApiOperation(value="企标年度制修订标准化发起流程-办理", notes="企标年度制修订标准化发起流程-办理")
@GetMapping("/handle/{taskId}")
@Translation
public Result<?> handle(@PathVariable("taskId") String taskId) {
ProcessDraft draft = actFlowCommonService.getExistDraftByTaskId(taskId, ProcessTypeEnum.ES_ANNUAL_INIT);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(annualInitService.getHandleData(taskId));
}
/**
* 同意
*
* @param annualInitData
*/
@AutoLog(value = "企标年度制修订标准化发起流程-同意")
@ApiOperation(value="企标年度制修订标准化发起流程-同意", notes="企标年度制修订标准化发起流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody AnnualInitDataVO annualInitData) {
annualInitService.approvalProcess(annualInitData, true);
return Result.OK();
}
/**
* 驳回
*
* @param annualInitData
*/
@AutoLog(value = "企标年度制修订标准化发起流程-驳回")
@ApiOperation(value="企标年度制修订标准化发起流程-驳回", notes="企标年度制修订标准化发起流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody AnnualInitDataVO annualInitData) {
annualInitService.approvalProcess(annualInitData, false);
return Result.OK();
}
/**
* 批量驳回
*
* @param annualInitData
*/
@AutoLog(value = "企标年度制修订标准化发起流程-批量驳回")
@ApiOperation(value="企标年度制修订标准化发起流程-批量驳回", notes="企标年度制修订标准化发起流程-批量驳回")
@PostMapping("/batchReject")
public Result<?> batchReject(@RequestBody AnnualInitDataVO annualInitData) {
annualInitService.batchReject(annualInitData, annualInitData.getBatchRejectIds());
return Result.OK();
}
/**
* 导入模板下载
*/
@GetMapping("/templateDownload")
@ApiOperation(value = "企标年度制修订标准化发起流程-导入模板下载", notes = "企标年度制修订标准化发起流程-导入模板下载"
,produces = "application/octet-stream")
@AutoLog(value = "企标年度制修订标准化发起流程-导入模板下载")
public void templateDownload(HttpServletResponse response) {
try {
ClassPathResource resource = new ClassPathResource("excelTemplate/年度制修订计划(标准化发起)导入模板.xls");
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("UTF-8"); // 这行确保响应流使用UTF-8编码
// 处理文件名乱码问题
String encodedFileName = URLEncoder.encode("年度制修订计划(标准化发起)导入模板", StandardCharsets.UTF_8.name()).replace("+", "%20");
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encodedFileName + ".xls");
try (InputStream in = resource.getInputStream(); OutputStream out = response.getOutputStream()) {
IOUtils.copy(in, out);
}
response.flushBuffer();
} catch (Exception e) {
// 记录错误或执行其他处理
e.printStackTrace();
}
}
/**
* 通过excel导入数据
*
* @return
*/
@PostMapping("/importExcel")
@ApiOperation(value = "企标年度制修订标准化发起流程-导入", notes = "企标年度制修订标准化发起流程-导入")
@AutoLog(value = "企标年度制修订标准化发起流程-导入")
@Translation
public Result<?> importExcel(@ApiParam(value = "要上传的文件", required = true) @RequestParam("file") MultipartFile file) {
file = IntekeyUtils.autoDecryptFile(file);
Map<String, Object> resultMap = annualInitService.importData(file);
Object flag = resultMap.get("flag");
if (flag == YesOrNoEnum.YES.getValue()) {
List<ProcessEsAnnualInit> dataList = (List<ProcessEsAnnualInit>) resultMap.get("dataList");
return Result.OK(dataList);
} else {
List<String> msg = (List<String>) resultMap.get("msg");
return Result.error(MessageUtils.getMessage(ResultCommon.IMPORT_ERROR), msg);
}
}
/**
* 转办
*
*/
@AutoLog(value = "企标年度制修订标准化发起流程-转办")
@ApiOperation(value="企标年度制修订标准化发起流程-转办", notes="企标年度制修订标准化发起流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
}
@@ -0,0 +1,19 @@
package com.jero.modules.activiti.process.esAnnualInit.entity;
/**
* @author: Mzaxd
* @Date: 2023/10/27 7:32
*/
public class AnnualInitTaskNameConstant {
public static final String STANDARD_ENGINEER_INIT = "标准化工程师发起";
public static final String CONTACT_USER_SELECT = "部所联络人选取审批人";
public static final String STANDARD_ENGINEER_EDIT = "标准化工程师修改调整";
public static final String STANDARD_ENGINEER_SECOND_EDIT = "标准化工程师二次修改调整";
public static final String MAIN_DRAFT_LEADER_APPROVAL_DISTRIBUTE = "主起草单位主管级领导审批下发";
public static final String CONTACT_USER_EDIT = "部所联络人修改调整";
public static final String MAIN_DRAFT_WRITE = "主起草人填写信息";
public static final String CONTACT_USER_COLLECT = "部所联络人汇总";
public static final String MAIN_DRAFT_LEADER_APPROVAL = "主起草单位主管级领导审批";
public static final String STANDARD_ENGINEER_COLLECT = "标准化归档";
}
@@ -0,0 +1,392 @@
package com.jero.modules.activiti.process.esAnnualInit.entity;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import com.jero.common.constant.enums.YesOrNoEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 企标-年度制修订计划-标准化发起
* @TableName process_es_annual_init
*/
@TableName(value ="process_es_annual_init")
@Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="process_es_annual_init", description="企标-年度制修订计划-标准化发起")
public class ProcessEsAnnualInit implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 企标计划Id
*/
@ApiModelProperty(value = "企标计划Id")
private String espId;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 申请类别
*/
@Dict(dicCode = "esp_application_category")
@ApiModelProperty(value = "申请类别")
private String applicationCategory;
/**
* 制修订类型
*/
@Excel(name = "*制修订类型", width = 15, orderNum = "1")
@Dict(dicCode = "esp_revision_type")
@ApiModelProperty(value = "制修订类型")
private String projectType;
/**
* 原企标编号
*/
@Excel(name = "原企标编号", width = 15, orderNum = "2")
@ApiModelProperty(value = "原企标编号")
private String originEnStandardNo;
/**
* 新企标编号
*/
@ApiModelProperty(value = "新企标编号")
private String newEnStandardNo;
/**
* 原企标名称
*/
@ApiModelProperty(value = "原企标名称")
private String originEnStandardName;
/**
* 新企标名称
*/
@Excel(name = "新企标名称", width = 15, orderNum = "3")
@ApiModelProperty(value = "新企标名称")
private String newEnStandardName;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String enStandardEnglishName;
/**
* 企业标准代号
*/
@Excel(name = "企业标准代号", width = 15, orderNum = "4")
@ApiModelProperty(value = "企业标准代号")
@Dict(dicCode = "enterprise_standard_code")
private String enStandardCode;
/**
* 企业名称代号
*/
@Excel(name = "企业名称代号", width = 15, orderNum = "5")
@Dict(dicCode = "enterprise_name_code")
@ApiModelProperty(value = "企业名称代号")
private String enNameCode;
/**
* 标准类别代号
*/
@Excel(name = "标准类别代号", width = 15, orderNum = "6")
@Dict(dicCode = "standard_category_code")
@ApiModelProperty(value = "标准类别代号")
private String standardCategoryCode;
/**
* 企标体系
*/
@Excel(name = "标准体系", width = 25, orderNum = "7")
@Dict(dictTable = "laws_tree_node", dicCode = "id", dicText = "node_name")
@ApiModelProperty(value = "企标体系")
private String enStandardSystem;
/**
* 年代号
*/
@ApiModelProperty(value = "年代号")
private String decadeCode;
/**
* 标准类型
*/
@Excel(name = "标准类型", width = 15, orderNum = "8")
@Dict(dicCode = "esp_standard_type")
@ApiModelProperty(value = "标准类型")
private String standardType;
/**
* 企标等级分类
*/
@Excel(name = "标准等级分类", width = 15, orderNum = "9")
@Dict(dicCode = "standard_grade_classify")
@ApiModelProperty(value = "企标等级分类")
private String enStandardClassification;
/**
* 草稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "草稿计划完成日期")
private Date draftPlannedCompleteDate;
@Excel(name = "草稿计划完成日期", width = 20, orderNum = "10")
@TableField(exist = false)
private String draftPlannedCompleteDateString;
@ApiModelProperty(value = "草稿计划完成日期是否可以编辑")
private String draftPlannedCompleteDateEditFlag;
/**
* 征求意见稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿计划完成日期")
private Date solicitationDraftPlanCompleteDate;
@Excel(name = "征求意见稿计划完成日期", width = 24, orderNum = "11")
@TableField(exist = false)
private String solicitationDraftPlanCompleteDateString;
@ApiModelProperty(value = "征求意见稿计划完成日期是否可以编辑")
private String solicitationDraftPlanCompleteDateEditFlag;
/**
* 计划报批日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "计划报批日期")
private Date planApprovalDate;
@Excel(name = "计划报批日期", width = 15, orderNum = "12")
@TableField(exist = false)
private String planApprovalDateString;
@ApiModelProperty(value = "计划报批日期是否可以编辑")
private String planApprovalDateEditFlag;
/**
* 项目状态
*/
@ApiModelProperty(value = "项目状态")
private String projectStatus;
/**
* 编制说明
*/
@ApiModelProperty(value = "编制说明")
private String compilationDescription;
/**
* 零部件名称
*/
@Excel(name = "零部件名称", width = 15, orderNum = "13")
@Dict(dictTable = "laws_part_name", dicCode = "code", dicText = "name")
@ApiModelProperty(value = "零部件名称")
private String componentName;
/**
* 授权部门
*/
@Excel(name = "授权部门", width = 15, orderNum = "14")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "授权部门")
private String authDept;
/**
* 主起草人
*/
@Excel(name = "*主起草人", width = 15, orderNum = "15")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "主起草人")
private String mainDraftingUser;
/**
* 主起草单位
*/
@Excel(name = "*主起草单位", width = 15, orderNum = "16")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "主起草单位")
private String mainDraftingUnit;
/**
* 主起草单位责任人
*/
@Excel(name = "*主起草单位责任人", width = 20, orderNum = "17")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "主起草单位责任人")
private String mainDraftingUnitResponsiblePerson;
/**
* 标准推进人
*/
@Excel(name = "*标准推进人", width = 15, orderNum = "18")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "标准推进人")
private String standardPromoter;
/**
* 征求意见稿完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿完成日期")
private Date solicitationDraftCompletionDate;
/**
* 变更状态
*/
@Dict(dicCode = "esp_change_status")
@ApiModelProperty(value = "变更状态")
private String changeStatus;
/**
* 上传附件
*/
@ApiModelProperty(value = "上传附件")
private String uploadAttachment;
/**
* 变更原因
*/
@ApiModelProperty(value = "变更原因")
private String changeReason;
/**
* 配合单位
*/
@Excel(name = "配合单位", width = 15, orderNum = "19")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "配合单位")
private String cooperationUnit;
/**
* 联络人
*/
@Excel(name = "*联络人", width = 15, orderNum = "20")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "联络人")
private String contactUser;
/**
* 流程中的主起草人
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "流程中的主起草人")
private String prcMainDraftUser;
/**
* 驳回标识
*/
@ApiModelProperty(value = "驳回标识")
@Dict(dicCode = "YN")
private String rejectFlag;
@ApiModelProperty(value = "二级驳回标识")
@Dict(dicCode = "YN")
private String rejectSecondFlag;
/**
* 执行id
*/
@ApiModelProperty(value = "执行id")
private String executionId;
/**
* 审批人
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "审批人")
private String approvalUser;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
@TableField(exist = false)
private String sort;
public void setDateEditFlag() {
if (this.getDraftPlannedCompleteDate() != null) {
this.setDraftPlannedCompleteDateEditFlag(YesOrNoEnum.NO.getValue());
} else {
this.setDraftPlannedCompleteDateEditFlag(YesOrNoEnum.YES.getValue());
}
if (this.getSolicitationDraftPlanCompleteDate() != null) {
this.setSolicitationDraftPlanCompleteDateEditFlag(YesOrNoEnum.NO.getValue());
} else {
this.setSolicitationDraftPlanCompleteDateEditFlag(YesOrNoEnum.YES.getValue());
}
if (this.getPlanApprovalDate() != null) {
this.setPlanApprovalDateEditFlag(YesOrNoEnum.NO.getValue());
} else {
this.setPlanApprovalDateEditFlag(YesOrNoEnum.YES.getValue());
}
}
}
@@ -0,0 +1,30 @@
package com.jero.modules.activiti.process.esAnnualInit.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import lombok.Data;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 17:28
*/
@Data
public class AnnualInitDataVO {
@JsonProperty("common")
private CommonVO commonVO;
@JsonProperty("dataList")
private List<ProcessEsAnnualInit> dataList;
@JsonProperty("flowUser")
private Map<String, Object> flowUser;
@JsonProperty("batchRejectIds")
private String batchRejectIds;
}
@@ -0,0 +1,54 @@
package com.jero.modules.activiti.process.esAnnualInit.entity.vo;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* @author: Mzaxd
* @Date: 2023/10/26 17:29
*/
@Data
public class AnnualInitFlowUserVO {
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("标准化工程师")
private String standardEngineer;
// 部所联络人
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("各部所联络人")
private String contactUser;
// 部所联络人
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("各部所联络人集合")
@JsonIgnore
private List<String> contactUserList;
// 主起草单位主管
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("主起草单位主管")
private String approvalUser;
// 主起草单位主管
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("主起草单位主管集合")
private List<String> approvalUserList;
// 主起草人
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("主起草人")
private String mainDraftUser;
// 主起草人
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty("主起草人集合")
@JsonIgnore
private List<String> mainDraftUserList;
}
@@ -0,0 +1,41 @@
package com.jero.modules.activiti.process.esAnnualInit.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.jero.modules.activiti.process.esAnnualInit.service.impl.ProcessEsAnnualInitServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component("contactUserDistributeCreateListener")
public class ContactUserDistributeCreateListener implements TaskListener {
@Resource
private ProcessEsAnnualInitServiceImpl annualInitService;
/**
* 流程结束之后需要把数据存入企标计划数据库
*
* @param delegateTask task
*/
@Override
public void notify(DelegateTask delegateTask) {
String executionId = delegateTask.getExecutionId();
String contactUser = (String) delegateTask.getVariable("contactUser");
LambdaQueryWrapper<ProcessEsAnnualInit> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsAnnualInit::getContactUser, contactUser);
wrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, delegateTask.getProcessInstanceId());
List<ProcessEsAnnualInit> list = annualInitService.list(wrapper);
list.forEach(l -> l.setExecutionId(executionId));
annualInitService.updateBatchById(list);
}
}
@@ -0,0 +1,48 @@
package com.jero.modules.activiti.process.esAnnualInit.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.jero.modules.activiti.process.esAnnualInit.service.impl.ProcessEsAnnualInitServiceImpl;
import com.jero.modules.activiti.util.ThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.TaskService;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component("mainDraftLeaderDistributeCreateListener")
public class MainDraftLeaderDistributeCreateListener implements TaskListener {
@Resource
private ProcessEsAnnualInitServiceImpl annualInitService;
@Resource
private TaskService taskService;
/**
* 流程结束之后需要把数据存入企标计划数据库
*
* @param delegateTask task
*/
@Override
public void notify(DelegateTask delegateTask) {
String contactExecutionId = (String) taskService.getVariable(delegateTask.getId(), "contactExecutionId");
String executionId = delegateTask.getExecutionId();
String approvalUser = (String) delegateTask.getVariable("approvalUser");
LambdaQueryWrapper<ProcessEsAnnualInit> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsAnnualInit::getApprovalUser, approvalUser);
wrapper.eq(ProcessEsAnnualInit::getExecutionId, contactExecutionId);
wrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, delegateTask.getProcessInstanceId());
List<ProcessEsAnnualInit> list = annualInitService.list(wrapper);
list.forEach(l -> l.setExecutionId(executionId));
annualInitService.updateBatchById(list);
}
}
@@ -0,0 +1,37 @@
package com.jero.modules.activiti.process.esAnnualInit.listener;
import com.jero.modules.activiti.util.ThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.runtime.Execution;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component("mainDraftWriteCreateListener")
public class MainDraftWriteCreateListener implements TaskListener {
@Resource
private TaskService taskService;
/**
* 流程结束之后需要把数据存入企标计划数据库
*
* @param delegateTask task
*/
@Override
public void notify(DelegateTask delegateTask) {
String parentExecutionId = (String) taskService.getVariable(delegateTask.getId(), "parentExecutionId");
delegateTask.setVariableLocal("parentExecutionId", parentExecutionId);
}
}
@@ -0,0 +1,125 @@
package com.jero.modules.activiti.process.esAnnualInit.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.jero.modules.activiti.process.esAnnualInit.service.impl.ProcessEsAnnualInitServiceImpl;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPRevisionType;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import com.jero.modules.activiti.process.esRevision.entity.vo.ESRevisionDataVO;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.laws.common.constant.FieldCommon;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.BeanCopyUtils;
import com.jero.modules.laws.enterprise.util.EnterpriseStandardUtil;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESAnnualInitEndListener implements ExecutionListener {
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private ProcessEsAnnualInitServiceImpl annualInitService;
@Resource
private EsRevisionService esRevisionService;
@Resource
private EnterpriseStandardUtil esUtil;
@Resource
private ProcessAllService processAllService;
/**
* 流程结束之后需要把数据存入企标计划数据库
*
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("年度制修订标准化发起流程结束 监听执行器开始执行");
// 获取流程实例ID
String processInstanceId = delegateExecution.getProcessInstanceId();
// 根据流程实例Id找到所有流程业务数据
LambdaQueryWrapper<ProcessEsAnnualInit> esAnnualInitWrapper = new LambdaQueryWrapper<>();
esAnnualInitWrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, processInstanceId);
List<ProcessEsAnnualInit> annualInits = annualInitService.list(esAnnualInitWrapper);
if (annualInits == null || annualInits.isEmpty()) {
log.info("年度制修订标准化发起流程结束 监听执行器未找到流程业务数据");
return;
}
List<EnterpriseStandardPlan> enterpriseStandardPlans;
// 立项新增-Id置空
annualInits.forEach(annualInit -> annualInit.setId(null));
// 转换为企标计划数据并入库
enterpriseStandardPlans = BeanCopyUtils.copyBeanList(annualInits, EnterpriseStandardPlan.class);
// 设置一些字段
// 制修订类型字段
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
esp.setApplicationCategory(esp.getProjectType());
}
// 生成企标编号
Map<String, Object> map = new HashMap<>();
String newStandardNumber;
// 获取当前年份
Calendar date = Calendar.getInstance();
String curYearNumber = String.valueOf(date.get(Calendar.YEAR));
List<EnterpriseStandardPlan> needValidList = new ArrayList<>();
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
// 修订只改年代号
if (esp.getApplicationCategory().equals(ESPRevisionType.MODIFY.getValue())) {
newStandardNumber = esUtil.changeStandardNumberYearNumber(esp.getOriginEnStandardNo(), curYearNumber);
esp.setNewEnStandardNo(newStandardNumber);
needValidList.add(esp);
}
}
if (!needValidList.isEmpty()) {
List<String> duplicateStandardNumbers = esUtil.verifyEsNumberByPlans(needValidList);
if (duplicateStandardNumbers != null && !duplicateStandardNumbers.isEmpty()) {
throw new JeroBootException("原企标编号" + String.join(",", duplicateStandardNumbers) + "修订后,与已存在的企标编号重复,请删除后重新提交");
}
}
// 判断修订的新标准号是否有效
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
// 制定生成新企标编号
if (esp.getApplicationCategory().equals(ESPRevisionType.ENACT.getValue())) {
map.put(FieldCommon.ENTERPRISE_STANDARD_CODE, esp.getEnStandardCode());
map.put(FieldCommon.ENTERPRISE_NAME_CODE, esp.getEnNameCode());
map.put(FieldCommon.STANDARD_CATEGORY_CODE, esp.getStandardCategoryCode());
map.put(FieldCommon.YEAR_NUMBER, curYearNumber);
newStandardNumber = esUtil.generateStandardNumber(map);
esp.setNewEnStandardNo(newStandardNumber);
}
espService.save(esp);
log.info("数据存入企标计划数据库");
ESRevisionDataVO revisionDataVO = new ESRevisionDataVO();
ProcessEsRevision revision = new ProcessEsRevision();
revision.setEspId(esp.getId());
revisionDataVO.setData(revision);
esRevisionService.autoStartProcess(revisionDataVO);
log.info("自动发起企标制修订流程");
}
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.esAnnualInit.mapper;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_init(企标立项变更流程)】的数据库操作Mapper
* @createDate 2023-10-18 10:01:44
* @Entity com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit
*/
public interface ProcessEsAnnualInitMapper extends BaseMapper<ProcessEsAnnualInit> {
}
@@ -0,0 +1,68 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.process.esAnnualInit.mapper.ProcessEsAnnualInitMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit">
<id property="id" column="id" jdbcType="VARCHAR"/>
<result property="espId" column="esp_id" jdbcType="VARCHAR"/>
<result property="createBy" column="create_by" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="orgCode" column="org_code" jdbcType="VARCHAR"/>
<result property="delFlag" column="del_flag" jdbcType="TINYINT"/>
<result property="processInstanceId" column="process_instance_id" jdbcType="VARCHAR"/>
<result property="applicationCategory" column="application_category" jdbcType="VARCHAR"/>
<result property="projectType" column="project_type" jdbcType="VARCHAR"/>
<result property="originEnStandardNo" column="origin_en_standard_no" jdbcType="VARCHAR"/>
<result property="newEnStandardNo" column="new_en_standard_no" jdbcType="VARCHAR"/>
<result property="originEnStandardName" column="origin_en_standard_name" jdbcType="VARCHAR"/>
<result property="newEnStandardName" column="new_en_standard_name" jdbcType="VARCHAR"/>
<result property="enStandardEnglishName" column="en_standard_english_name" jdbcType="VARCHAR"/>
<result property="enStandardSystem" column="en_standard_system" jdbcType="VARCHAR"/>
<result property="enStandardCode" column="en_standard_code" jdbcType="VARCHAR"/>
<result property="enNameCode" column="en_name_code" jdbcType="VARCHAR"/>
<result property="standardCategoryCode" column="standard_category_code" jdbcType="VARCHAR"/>
<result property="decadeCode" column="decade_code" jdbcType="VARCHAR"/>
<result property="standardType" column="standard_type" jdbcType="VARCHAR"/>
<result property="enStandardClassification" column="en_standard_classification" jdbcType="VARCHAR"/>
<result property="draftPlannedCompleteDate" column="draft_planned_complete_date" jdbcType="TIMESTAMP"/>
<result property="solicitationDraftPlanCompleteDate" column="solicitation_draft_plan_complete_date" jdbcType="TIMESTAMP"/>
<result property="planApprovalDate" column="plan_approval_date" jdbcType="TIMESTAMP"/>
<result property="projectStatus" column="project_status" jdbcType="VARCHAR"/>
<result property="compilationDescription" column="compilation_description" jdbcType="VARCHAR"/>
<result property="componentName" column="component_name" jdbcType="VARCHAR"/>
<result property="mainDraftingUser" column="main_drafting_user" jdbcType="VARCHAR"/>
<result property="mainDraftingUnit" column="main_drafting_unit" jdbcType="VARCHAR"/>
<result property="mainDraftingUnitResponsiblePerson" column="main_drafting_unit_responsible_person" jdbcType="VARCHAR"/>
<result property="standardPromoter" column="standard_promoter" jdbcType="VARCHAR"/>
<result property="solicitationDraftCompletionDate" column="solicitation_draft_completion_date" jdbcType="TIMESTAMP"/>
<result property="changeStatus" column="change_status" jdbcType="VARCHAR"/>
<result property="remarks" column="remarks" jdbcType="VARCHAR"/>
<result property="uploadAttachment" column="upload_attachment" jdbcType="VARCHAR"/>
<result property="changeReason" column="change_reason" jdbcType="VARCHAR"/>
<result property="authDept" column="auth_dept" jdbcType="VARCHAR"/>
<result property="cooperationUnit" column="cooperation_unit" jdbcType="VARCHAR"/>
<result property="contactUser" column="contact_user" jdbcType="VARCHAR"/>
<result property="approvalUser" column="approval_user" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,esp_id,create_by,
create_time,update_by,update_time,
org_code,del_flag,process_instance_id,
application_category,project_type,origin_en_standard_no,
new_en_standard_no,origin_en_standard_name,new_en_standard_name,
en_standard_english_name,en_standard_system,en_standard_code,
en_name_code,standard_category_code,decade_code,
standard_type,en_standard_classification,draft_planned_complete_date,
solicitation_draft_plan_complete_date,plan_approval_date,project_status,
compilation_description,component_name,main_drafting_user,
main_drafting_unit,main_drafting_unit_responsible_person,standard_promoter,
solicitation_draft_completion_date,change_status,remarks,
upload_attachment,change_reason,auth_dept,
cooperation_unit,contact_user,approval_user
</sql>
</mapper>
@@ -0,0 +1,33 @@
package com.jero.modules.activiti.process.esAnnualInit.service;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esAnnualInit.entity.vo.AnnualInitDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import org.springframework.web.multipart.MultipartFile;
import java.util.Map;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_init(企标立项变更流程)】的数据库操作Service
* @createDate 2023-10-18 10:01:44
*/
public interface ProcessEsAnnualInitService extends IService<ProcessEsAnnualInit> {
/**
* 导入数据,返回数据列表
* @return
*/
Map<String, Object> importData(MultipartFile file);
void startProcess(AnnualInitDataVO annualInitData);
void saveToDraft(ProcessInfoVO<AnnualInitDataVO> annualInitData);
AnnualInitDataVO getHandleData(String taskId);
void approvalProcess(AnnualInitDataVO annualInitData, boolean b);
void batchReject(AnnualInitDataVO ids, String prcId);
}
@@ -0,0 +1,709 @@
package com.jero.modules.activiti.process.esAnnualInit.service.impl;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.common.api.CommonAPI;
import com.jero.common.aspect.TranslationAspect;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.common.system.vo.SysDictItemCore;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.common.enums.ProcessType;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualInit;
import com.jero.modules.activiti.process.esAnnualInit.entity.vo.AnnualInitDataVO;
import com.jero.modules.activiti.process.esAnnualInit.service.ProcessEsAnnualInitService;
import com.jero.modules.activiti.process.esAnnualInit.mapper.ProcessEsAnnualInitMapper;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPChangeType;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.fb.dto.BasicProcessInfoDTO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessNodeLinkService;
import com.jero.modules.activiti.util.ExcelUtils;
import com.jero.modules.laws.common.util.ImportUtil;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import lombok.Cleanup;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;
import static com.jero.modules.activiti.process.esAnnualInit.entity.AnnualInitTaskNameConstant.*;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_init(企标立项变更流程)】的数据库操作Service实现
* @createDate 2023-10-18 10:01:44
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsAnnualInitServiceImpl extends ServiceImpl<ProcessEsAnnualInitMapper, ProcessEsAnnualInit>
implements ProcessEsAnnualInitService {
@Resource
private CommonAPI commonAPI;
@Resource
private ExcelUtils excelUtils;
@Resource
private ILawsEnterpriseStandardService enterpriseStandardService;
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private ProcessAllService processAllService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private ImportUtil importUtil;
@Resource
private IProcessHandleService processHandleService;
@Resource
private TranslationAspect translationAspect;
@Resource
private ILawsEnterpriseStandardService esService;
@Override
public void startProcess(AnnualInitDataVO annualInitData) {
// 流程Key
String processDefinitionKey = ProcessType.ES_ANNUAL_INIT.getProcessKey();
// 通用数据
CommonVO commonVO = annualInitData.getCommonVO();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
List<ProcessEsAnnualInit> dataList = annualInitData.getDataList();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(annualInitData);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(commonVO, ProcessTypeEnum.ES_ANNUAL_INIT);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 保存数据
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
dataList.forEach(ProcessEsAnnualInit::setDateEditFlag);
saveOrUpdateBatch(dataList);
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(actVariables));
// 获取第一个任务的taskId
String taskId = actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.manualParseDictText(this.getHandleData(taskId), actVariables);
// 强制撤回
commonVO.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_ANNUAL_INIT, jsonData);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, true);
// 自动完成第一个任务
actFlowCommonService.completeTask(taskId, userId);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ANNUAL_INIT.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
/**
* 驳回以后重新发起流程
*/
public void restartProcess(AnnualInitDataVO annualInitData, String originTaskId) {
Task task = taskService.createTaskQuery().taskId(originTaskId).singleResult();
// 获取流程相关信息
ProcessAll processAll = processAllService.getByProcessInstanceId(task.getProcessInstanceId());
String standardEngineer = (String) taskService.getVariable(originTaskId, "standardEngineer");
Map<String, Object> actVariables = new HashMap<>();
actVariables.put("standardEngineer", standardEngineer);
// 流程Key
String processDefinitionKey = ProcessType.ES_ANNUAL_INIT.getProcessKey();
// 业务数据
List<ProcessEsAnnualInit> dataList = annualInitData.getDataList();
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(actVariables));
// 保存数据
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
dataList.forEach(ProcessEsAnnualInit::setDateEditFlag);
saveOrUpdateBatch(dataList);
// 强制撤回
CommonVO commonVO = annualInitData.getCommonVO();
String prcName = processAll.getPrcName();
String prcMes = processAll.getPrcMes();
Date dueTime = processAll.getDueTime();
commonVO.setProcessInstanceId(processInstanceId);
commonVO.setPrcName(prcName);
commonVO.setPrcMes(prcMes);
commonVO.setDueTime(dueTime);
commonVO.setCommitText(null);
commonVO.setCommitFile(null);
// 手动翻译
String jsonData = translationAspect.autoParseDictText(annualInitData, actVariables);
// 强制撤回
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_ANNUAL_INIT, jsonData);
// 根据流程实例id更新流程总表
Integer prcType = ProcessTypeEnum.ES_ANNUAL_INIT.getValue();
// 更新流程信息
actFlowCommonService.updateProcessAll(processInstanceId, standardEngineer, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(AnnualInitDataVO annualInitData) {
Map<String, Object> actVariables = new HashMap<>();
Map<String, Object> flowUser = annualInitData.getFlowUser();
List<ProcessEsAnnualInit> dataList = annualInitData.getDataList();
Set<String> contactUserSet = dataList.stream().map(ProcessEsAnnualInit::getContactUser).collect(Collectors.toSet());
actVariables.put("contactUserList", contactUserSet);
actVariables.put("passFinalCollect", true);
actVariables.put("standardEngineer", flowUser.get("standardEngineer"));
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("passFinalCollect");
// 转成逗号拼接
variables.put("contactUserList", Optional.ofNullable((HashSet<String>) variables.get("contactUserList"))
.map(list -> String.join(",", list))
.orElse(""));
return variables;
}
@Override
public void saveToDraft(ProcessInfoVO<AnnualInitDataVO> processInfoVO) {
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_ANNUAL_INIT.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
@Override
public AnnualInitDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException("任务不存在");
}
String userId = actFlowCommonService.getOriginTaskAssignee(taskId);
String executionId = taskService.createTaskQuery().taskId(taskId).singleResult().getExecutionId();
// 根据当前执行Id获取所有子执行Id
List<String> executionIdList = actFlowCommonService.getAllChildExecutionIds(executionId);
executionIdList.add(executionId);
AnnualInitDataVO annualInitDataVO = new AnnualInitDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程通用数据
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
CommonVO commonVO = new CommonVO();
commonVO.setPrcName(process.getPrcName());
commonVO.setTaskId(process.getTaskId());
commonVO.setPrcMes(process.getPrcMes());
commonVO.setDueTime(process.getDueTime());
commonVO.setNodeId(process.getNodeId());
annualInitDataVO.setCommonVO(commonVO);
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsAnnualInit> wrapper = new LambdaQueryWrapper<>();
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String taskName = task.getName();
String parentExecutionId = (String) taskService.getVariableLocal(taskId, "parentExecutionId");
switch (taskName) {
case CONTACT_USER_SELECT:
case MAIN_DRAFT_LEADER_APPROVAL_DISTRIBUTE:
case CONTACT_USER_COLLECT:
case MAIN_DRAFT_LEADER_APPROVAL:
wrapper.eq(ProcessEsAnnualInit::getExecutionId, executionId);
break;
case CONTACT_USER_EDIT:
wrapper.eq(ProcessEsAnnualInit::getRejectFlag, YesOrNoEnum.YES.getValue());
wrapper.eq(ProcessEsAnnualInit::getExecutionId, executionId);
break;
case MAIN_DRAFT_WRITE:
wrapper.eq(ProcessEsAnnualInit::getPrcMainDraftUser, userId);
wrapper.eq(ProcessEsAnnualInit::getExecutionId, parentExecutionId);
break;
case STANDARD_ENGINEER_COLLECT:
// do nothing now
break;
}
wrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, processInstanceId);
wrapper.eq(ProcessEsAnnualInit::getDelFlag, YesOrNoEnum.NO.getInteger());
annualInitDataVO.setDataList(list(wrapper));
return annualInitDataVO;
}
@Override
public void approvalProcess(AnnualInitDataVO annualInitData, boolean pass) {
CommonVO commonVO = annualInitData.getCommonVO();
String taskId = commonVO.getTaskId();
// 获取task
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException("taskId为空或任务不存在");
}
String userId = actFlowCommonService.getOriginTaskAssignee(taskId);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
// 获取执行id
String executionId = task.getExecutionId();
String taskName = task.getName();
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
List<ProcessEsAnnualInit> dataList;
LambdaQueryWrapper<ProcessEsAnnualInit> wrapper = new LambdaQueryWrapper<>();
LambdaUpdateWrapper<ProcessEsAnnualInit> updateWrapper = new LambdaUpdateWrapper<>();
wrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, processInstanceId);
wrapper.eq(ProcessEsAnnualInit::getDelFlag, YesOrNoEnum.NO.getValue());
updateWrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, processInstanceId);
updateWrapper.eq(ProcessEsAnnualInit::getDelFlag, YesOrNoEnum.NO.getValue());
// 获取当前流程
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
String processDefinitionId = processInstance.getProcessDefinitionId();
Map<String, Object> userMap = new HashMap<>();
AnnualInitDataVO handleData = this.getHandleData(taskId);
List<ProcessEsAnnualInit> dbDataList = handleData.getDataList();
String curUserId = UserUtils.getUserId();
String contactUser = (String) runtimeService.getVariable(executionId, "contactUser");
switch (taskName) {
case STANDARD_ENGINEER_INIT:
dataList = annualInitData.getDataList();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(annualInitData);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(commonVO, ProcessTypeEnum.ES_ANNUAL_INIT);
// 删除原来的数据
remove(wrapper);
// 保存数据
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
dataList.forEach(ProcessEsAnnualInit::setDateEditFlag);
saveOrUpdateBatch(dataList);
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(actVariables));
// 强制撤回
commonVO.setProcessInstanceId(processInstanceId);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ANNUAL_INIT.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
break;
case CONTACT_USER_SELECT:
dataList = annualInitData.getDataList();
// 处理驳回
if (pass) {
dataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.NO.getValue()));
Set<String> approvalUserSet = new HashSet<>();
dataList.forEach(d -> approvalUserSet.add(d.getApprovalUser()));
taskService.setVariable(taskId, "approvalUserList", approvalUserSet);
// 保存人员
userMap.put("approvalUserList", String.join(",", approvalUserSet));
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userMap);
dataList.forEach(data -> data.setExecutionId(executionId));
saveOrUpdateBatch(dataList);
taskService.setVariable(taskId, "contactExecutionId", executionId);
} else {
// 找到所有被驳回的数据,发起新流程
annualInitData.setDataList(dbDataList);
this.restartProcess(annualInitData, taskId);
}
break;
case MAIN_DRAFT_LEADER_APPROVAL_DISTRIBUTE:
dataList = annualInitData.getDataList();
// 如果不驳回
if (pass) {
dataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.NO.getValue()));
// 设置本地变量
Set<String> mainDraftUserSet = new HashSet<>();
dataList.forEach(d -> mainDraftUserSet.add(d.getPrcMainDraftUser()));
dataList.forEach(data -> data.setExecutionId(executionId));
saveOrUpdateBatch(dataList);
taskService.setVariable(taskId, "mainDraftUserList", mainDraftUserSet);
taskService.setVariable(taskId, "parentExecutionId", executionId);
// 保存人员
userMap.put("mainDraftUserList", String.join(",", mainDraftUserSet));
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userMap);
} else {
// 找到对应数据,然后设置驳回标志位
dbDataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.YES.getValue()));
runtimeService.setVariable(executionId, "contactEditUser", contactUser);
// 保存人员
userMap.put("contactEditUser", contactUser);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userMap);
updateBatchById(dbDataList);
}
// 转办
runtimeService.setVariableLocal(executionId, "approvalUser", curUserId);
break;
case CONTACT_USER_EDIT:
dataList = annualInitData.getDataList();
if (pass) {
dataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.NO.getValue()));
taskService.setVariable(taskId, "approvalUser", annualInitData.getDataList().get(0).getApprovalUser());
dataList.forEach(data -> data.setExecutionId(executionId));
dataList.forEach(data -> data.setApprovalUser(annualInitData.getDataList().get(0).getApprovalUser()));
saveOrUpdateBatch(dataList);
// 保存人员
userMap.put("approvalUserList", annualInitData.getDataList().get(0).getApprovalUser());
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userMap);
} else {
// 找到所有被驳回的数据,发起新流程
annualInitData.setDataList(dbDataList);
this.restartProcess(annualInitData, taskId);
}
// 转办
runtimeService.setVariableLocal(executionId, "contactUser", curUserId);
break;
case MAIN_DRAFT_WRITE:
dataList = annualInitData.getDataList();
dataList.forEach(d -> d.setMainDraftingUser(userId));
updateBatchById(dataList);
// 找出所有主起草人
Set<String> mainDraftUserSet = new HashSet<>();
dataList.forEach(d -> mainDraftUserSet.add(d.getMainDraftingUser()));
// 保存人员
userMap.put("mainDraftUser", String.join(",", mainDraftUserSet));
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userMap);
// 能走到这个节点则不需要跳过最终汇总
taskService.setVariable(taskId, "passFinalCollect", false);
break;
case CONTACT_USER_COLLECT:
dataList = annualInitData.getDataList();
dataList.forEach(d -> d.setExecutionId(executionId));
saveOrUpdateBatch(dataList);
// 转办
runtimeService.setVariableLocal(executionId, "contactUser", curUserId);
break;
case MAIN_DRAFT_LEADER_APPROVAL:
// 如果不驳回
if (pass) {
dbDataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.NO.getValue()));
} else {
dbDataList.forEach(d -> d.setRejectFlag(YesOrNoEnum.YES.getValue()));
}
dbDataList.forEach(d -> d.setExecutionId(executionId));
updateBatchById(dbDataList);
// 转办
runtimeService.setVariableLocal(executionId, "approvalUser", curUserId);
break;
case STANDARD_ENGINEER_COLLECT:
// 根据流程ID删除所有数据后新增
dataList = annualInitData.getDataList();
remove(wrapper);
saveBatch(dataList);
break;
}
if (pass) {
runtimeService.setVariable(processInstanceId, "pass", true);
} else {
// 设置流程变量
runtimeService.setVariable(processInstanceId, "pass", false);
}
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, userId);
}
@Override
public void batchReject(AnnualInitDataVO annualInitData, String ids) {
CommonVO commonVO = annualInitData.getCommonVO();
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(commonVO.getTaskId());
String taskId = commonVO.getTaskId();
// 获取task
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
// 获取执行id
String executionId = task.getExecutionId();
if (StrUtil.isBlank(taskId) && !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException("taskId为空或任务不存在");
}
String userId = actFlowCommonService.getOriginTaskAssignee(taskId);
LambdaQueryWrapper<ProcessEsAnnualInit> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsAnnualInit::getProcessInstanceId, processInstanceId);
wrapper.eq(ProcessEsAnnualInit::getDelFlag, YesOrNoEnum.NO.getValue());
wrapper.eq(ProcessEsAnnualInit::getContactUser, userId);
wrapper.in(ProcessEsAnnualInit::getId, Arrays.asList(ids.split(",")));
if (STANDARD_ENGINEER_SECOND_EDIT.equals(task.getName())) {
wrapper.eq(ProcessEsAnnualInit::getExecutionId, executionId);
}
List<ProcessEsAnnualInit> list = list(wrapper);
annualInitData.setDataList(list);
if (list.isEmpty()) {
throw new JeroBootException("无法获取数据,请重试。");
}
// 将对应数据找出来
this.approvalProcess(annualInitData, false);
}
@Override
@SneakyThrows
public Map<String, Object> importData(MultipartFile file) {
List<SysDictItemCore> listDict = commonAPI.getDictItemAll();
Map<String, Object> resultMap = new HashMap<>();
List<String> errorMsgs = new ArrayList<>();
// 获取Excel的header
List<String> headers;
try {
headers = ExcelUtils.getHeaderFromExcel(file.getInputStream(), 0);
} catch (Exception e) {
errorMsgs.add("模板错误,请按照系统模板导入!");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
log.error(e.getMessage(), e);
return resultMap; // 返回错误信息
}
// 使用静态方法验证header
boolean isMatched = headers.equals(ExcelUtils.getSortedHeadersFromClass(ProcessEsAnnualInit.class));
if (!isMatched) {
errorMsgs.add("模板错误,请按照系统模板导入!");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
return resultMap; // 返回错误信息
}
ImportParams params = new ImportParams();
params.setTitleRows(0);
params.setHeadRows(1);
params.setNeedSave(true);
try {
@Cleanup
InputStream inputStream = file.getInputStream();
List<ProcessEsAnnualInit> list = ExcelImportUtil.importExcel(inputStream, ProcessEsAnnualInit.class, params);
list.remove(0);
list.remove(0);
if (list.isEmpty()) {
errorMsgs.add("文件暂无数据,请检查后重试。");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
return resultMap; // 返回错误信息
}
// 批量检查数据是否有效
errorMsgs = this.validationList(list, listDict);
if (!errorMsgs.isEmpty()) {
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
} else {
resultMap.put("flag", YesOrNoEnum.YES.getValue());
// 转换为字典值
this.transToDictValue(list, listDict);
// 清洗
this.cleanData(list);
resultMap.put("dataList", list);
}
} catch (Exception e) {
errorMsgs.add("文件导入异常:" + e.getMessage());
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
log.error(e.getMessage(), e);
}
return resultMap;
}
private void cleanData(List<ProcessEsAnnualInit> list) {
// 查找所有企标 并转换成key为标准编号的map
LambdaQueryWrapper<LawsEnterpriseStandard> esWrapper = new LambdaQueryWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getDelFlag, YesOrNoEnum.NO.getValue());
Map<String, List<LawsEnterpriseStandard>> esMap =
esService.list(esWrapper).stream().collect(Collectors.groupingBy(LawsEnterpriseStandard::getStandardNumber));
list.forEach(item -> {
// 如果是制定则去除掉所有的原企标名称 原企标编号
if (ESPProjectType.ENACT.getValue().equals(item.getProjectType())) {
item.setOriginEnStandardName(null);
item.setOriginEnStandardNo(null);
String decadeCode = item.getDecadeCode();
if (StrUtil.isBlank(decadeCode)) {
// 获取当前年份
Calendar date = Calendar.getInstance();
String curYearNumber = String.valueOf(date.get(Calendar.YEAR));
item.setDecadeCode(curYearNumber);
}
} else {
List<LawsEnterpriseStandard> esList = esMap.get(item.getOriginEnStandardNo());
if (esList != null && !esList.isEmpty()) {
item.setOriginEnStandardName(esList.get(0).getStandardName());
}
}
item.setChangeStatus(ESPChangeType.ADD.getValue());
});
}
private void transToDictValue(List<ProcessEsAnnualInit> list, List<SysDictItemCore> listDict) {
list.forEach(item -> {
item.setProjectType(excelUtils.translateDictValue("esp_revision_type", item.getProjectType(), listDict));
item.setEnStandardCode(excelUtils.translateDictValue("enterprise_standard_code", item.getEnStandardCode(), listDict));
item.setAuthDept(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getAuthDept(), listDict));
item.setCooperationUnit(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getCooperationUnit(), listDict));
item.setMainDraftingUser(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getMainDraftingUser(), listDict));
item.setMainDraftingUnit(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getMainDraftingUnit(), listDict));
item.setMainDraftingUnitResponsiblePerson(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getMainDraftingUnitResponsiblePerson(), listDict));
item.setStandardPromoter(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getStandardPromoter(), listDict));
item.setEnStandardSystem(importUtil.convertStandardSystem(item.getEnStandardSystem(), "3"));
item.setContactUser(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getContactUser(), listDict));
item.setStandardType(excelUtils.translateDictValue("esp_standard_type", item.getStandardType(), listDict));
item.setEnStandardClassification(excelUtils.translateDictValue("standard_grade_classify", item.getEnStandardClassification(), listDict));
item.setDraftPlannedCompleteDate(importUtil.convertDate(item.getDraftPlannedCompleteDateString()));
item.setSolicitationDraftPlanCompleteDate(importUtil.convertDate(item.getSolicitationDraftPlanCompleteDateString()));
item.setPlanApprovalDate(importUtil.convertDate(item.getPlanApprovalDateString()));
item.setComponentName(excelUtils.translateDictValue("name", "code", "laws_part_name", item.getComponentName(), listDict));
});
}
private List<String> validationList(List<ProcessEsAnnualInit> list, List<SysDictItemCore> listDict) {
// 找到各标准等级的授权部门
Map<String, List<String>> authDeptMap = excelUtils.getAllLevelAuthDeptMap();
List<LawsEnterpriseStandard> esList = enterpriseStandardService.list();
List<String> errorMsgs = new ArrayList<>();
int i = 4;
Iterator<ProcessEsAnnualInit> iterator = list.iterator();
while (iterator.hasNext()) {
ProcessEsAnnualInit plan = iterator.next();
if (ExcelUtils.isEmptyRow(plan)) {
iterator.remove();
if (list.isEmpty()) {
errorMsgs.add("文件暂无数据,请检查后重试。");
}
continue;
}
plan.setSort(String.valueOf(i++));
String authDept = plan.getAuthDept();
String cooperationUnit = plan.getCooperationUnit();
String mainDraftingUnit = plan.getMainDraftingUnit();
String mainDraftingUser = plan.getMainDraftingUser();
String mainDraftingUnitResponsiblePerson = plan.getMainDraftingUnitResponsiblePerson();
String standardPromoter = plan.getStandardPromoter();
String contactUser = plan.getContactUser();
String standardSystem = plan.getEnStandardSystem();
String standardType = plan.getStandardType();
String standardClassification = plan.getEnStandardClassification();
String enStandardCode = plan.getEnStandardCode();
String partName = plan.getComponentName();
String draftPlannedCompleteDateString = plan.getDraftPlannedCompleteDateString();
String solicitationDraftPlanCompleteDateString = plan.getSolicitationDraftPlanCompleteDateString();
String planApprovalDateString = plan.getPlanApprovalDateString();
StringBuilder errMsgHeader = new StringBuilder();
StringBuilder errMsg = new StringBuilder();
errMsgHeader.append("").append(plan.getSort()).append("");
// 检查制修订类型 编号 名称
errMsg.append(validProjectType(plan, listDict, esList));
// 检查标准等级分类和授权部门
errMsg.append(excelUtils.validAuthDept(authDept, listDict, mainDraftingUnit, standardClassification, authDeptMap, false));
// 检查所有数据字典校验的字段
errMsg.append(excelUtils.validCooperateUnit(cooperationUnit, listDict));
errMsg.append(excelUtils.validMainDraftingUser(mainDraftingUser, listDict));
errMsg.append(excelUtils.validMainDraftingUnitResponsiblePerson(mainDraftingUnitResponsiblePerson, listDict));
errMsg.append(excelUtils.validStandardPromoter(standardPromoter, listDict));
errMsg.append(excelUtils.validStandardSystem(standardSystem, listDict, false));
errMsg.append(excelUtils.validContactUser(contactUser, listDict));
errMsg.append(excelUtils.validStandardType(standardType, listDict, false));
errMsg.append(excelUtils.validPartName(partName, listDict, false));
errMsg.append(excelUtils.validSingleDateNotBeforeToday(draftPlannedCompleteDateString, "草稿计划完成日期"));
errMsg.append(excelUtils.validSingleDateNotBeforeToday(solicitationDraftPlanCompleteDateString, "征求意见稿计划完成日期"));
errMsg.append(excelUtils.validSingleDateNotBeforeToday(planApprovalDateString, "计划报批日期"));
// 如果数据有问题,则将提示信息添加到 errorMsgs 中
if (errMsg.length() > 0) {
errorMsgs.add(errMsgHeader.append(errMsg).toString());
}
}
return errorMsgs;
}
private String validProjectType(ProcessEsAnnualInit plan, List<SysDictItemCore> listDict, List<LawsEnterpriseStandard> esList) {
StringBuilder errMsg = new StringBuilder();
String projectType = plan.getProjectType();
String originEnStandardNo = plan.getOriginEnStandardNo();
String newEnStandardName = plan.getNewEnStandardName();
errMsg.append(excelUtils.validStandardName(newEnStandardName));
if (StrUtil.isBlank(projectType)) {
return "'制修订类型'不能为空。";
}
if (!excelUtils.validDict("esp_revision_type", projectType, null, null, true, listDict)) {
return "'制修订类型'无效。";
}
// 修订
if (projectType.equals(ESPProjectType.MODIFY.getName())) {
// 检查企标编号是否有效
if (StrUtil.isBlank(originEnStandardNo)) {
errMsg.append("'原企标编号'不能为空。");
} else {
if (!esList.stream().map(LawsEnterpriseStandard::getStandardNumber).collect(Collectors.toList()).contains(originEnStandardNo)) {
return "'原企标编号'无效。";
}
}
} else {
// 制定校验三个代号
String enStandardCode = plan.getEnStandardCode();
String enNameCode = plan.getEnNameCode();
String standardCategoryCode = plan.getStandardCategoryCode();
// 检查企标编号是否有效
if (StrUtil.isNotBlank(enStandardCode)) {
// 检查企业标准代号
if (!excelUtils.validDict("enterprise_standard_code", enStandardCode, null, null, true, listDict)) {
errMsg.append("'企业标准代号'无效。");
}
}
if (StrUtil.isNotBlank(enNameCode)) {
// 检查企业标准代号
if (!excelUtils.validDict("enterprise_name_code", enNameCode, null, null, true, listDict)) {
errMsg.append("'企业名称代号'无效。");
}
}
if (StrUtil.isNotBlank(standardCategoryCode)) {
// 检查企业标准代号
if (!excelUtils.validDict("standard_category_code", standardCategoryCode, null, null, true, listDict)) {
errMsg.append("'标准类别代号'无效。");
}
}
}
return errMsg.toString();
}
}
@@ -0,0 +1,201 @@
package com.jero.modules.activiti.process.esAnnualReport.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.DictPoint;
import com.jero.common.aspect.annotation.Translation;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.util.IntekeyUtils;
import com.jero.common.util.MessageUtils;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.TransferVO;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
import com.jero.modules.activiti.process.esAnnualReport.entity.vo.AnnualReportDataVO;
import com.jero.modules.activiti.process.esAnnualReport.service.ProcessEsAnnualReportService;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.IOUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpHeaders;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import javax.annotation.Resource;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/18 10:44
*/
@Slf4j
@RestController
@Api(tags = "企标年度制修订主动上报流程")
@RequestMapping("/process/es/annualReport")
public class ESAnnualReportController {
@Resource
private ProcessEsAnnualReportService annualReportService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 导入模板下载
*/
@GetMapping("/templateDownload")
@ApiOperation(value = "企标年度制修订主动上报流程-导入模板下载", notes = "企标年度制修订主动上报流程-导入模板下载"
,produces = "application/octet-stream")
@AutoLog(value = "企标年度制修订主动上报流程-导入模板下载")
public void templateDownload(HttpServletResponse response) {
try {
ClassPathResource resource = new ClassPathResource("excelTemplate/年度制修订计划(各部门主动上报)导入模板.xls");
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("UTF-8"); // 这行确保响应流使用UTF-8编码
// 处理文件名乱码问题
String encodedFileName = URLEncoder.encode("年度制修订计划(各部门主动上报)导入模板", StandardCharsets.UTF_8.name()).replace("+", "%20");
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encodedFileName + ".xls");
try (InputStream in = resource.getInputStream(); OutputStream out = response.getOutputStream()) {
IOUtils.copy(in, out);
}
response.flushBuffer();
} catch (Exception e) {
// 记录错误或执行其他处理
e.printStackTrace();
}
}
/**
* 通过excel导入数据
*
* @return
*/
@PostMapping("/importExcel")
@ApiOperation(value = "企标年度制修订主动上报流程-导入", notes = "企标年度制修订主动上报流程-导入")
@AutoLog(value = "企标年度制修订主动上报流程-导入")
@Translation
public Result<?> importExcel(@ApiParam(value = "要上传的文件", required = true) @RequestParam("file") MultipartFile file) {
file = IntekeyUtils.autoDecryptFile(file);
Map<String, Object> resultMap = annualReportService.importData(file);
Object flag = resultMap.get("flag");
if (flag == YesOrNoEnum.YES.getValue()) {
List<ProcessEsAnnualReport> dataList = (List<ProcessEsAnnualReport>) resultMap.get("dataList");
return Result.OK(dataList);
} else {
List<String> msg = (List<String>) resultMap.get("msg");
return Result.error(MessageUtils.getMessage(ResultCommon.IMPORT_ERROR), msg);
}
}
/**
* 新增主动上报申请
*
* @param
*/
@AutoLog(value = "企标年度制修订主动上报流程-发起流程")
@ApiOperation(value="企标年度制修订主动上报流程-发起流程", notes="企标年度制修订主动上报流程-发起流程")
@PostMapping("/start")
public Result<?> startInitChange(@RequestBody AnnualReportDataVO annualReportDataVO) {
annualReportService.startProcess(annualReportDataVO);
return Result.OK();
}
/**
* 保存到待办
* @param processInfoVO
*/
@AutoLog(value = "企标立项变更流程-保存")
@ApiOperation(value="企标立项变更流程-保存", notes="企标立项变更流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<AnnualReportDataVO> processInfoVO) {
annualReportService.saveToDraft(processInfoVO);
return Result.OK();
}
/**
* 保存到待办
* @param taskId
*/
@AutoLog(value = "企标年度制修订主动上报流程-办理")
@ApiOperation(value="企标年度制修订主动上报流程-办理", notes="企标年度制修订主动上报流程-办理")
@GetMapping("/handle/{taskId}")
@Translation
public Result<?> handle(@PathVariable(value = "taskId") String taskId) {
ProcessDraft draft = actFlowCommonService.getExistDraftByTaskId(taskId, ProcessTypeEnum.ES_ANNUAL_REPORT);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(annualReportService.getHandleData(taskId));
}
/**
* 同意
*
* @param annualReportDataVO
*/
@AutoLog(value = "企标年度制修订主动上报流程-同意")
@ApiOperation(value="企标年度制修订主动上报流程-同意", notes="企标年度制修订主动上报流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody AnnualReportDataVO annualReportDataVO) {
annualReportService.approvalProcess(annualReportDataVO, true);
return Result.OK();
}
/**
* 驳回
*
* @param annualReportDataVO
*/
@AutoLog(value = "企标年度制修订主动上报流程-驳回")
@ApiOperation(value="企标年度制修订主动上报流程-驳回", notes="企标年度制修订主动上报流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody AnnualReportDataVO annualReportDataVO) {
annualReportService.approvalProcess(annualReportDataVO, false);
return Result.OK();
}
/**
* 转办
*
*/
@AutoLog(value = "企标年度制修订主动上报流程-转办")
@ApiOperation(value="企标年度制修订主动上报流程-转办", notes="企标年度制修订主动上报流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
/**
* 草稿办理
* @param draftId
*/
@AutoLog(value = "企标年度制修订主动上报流程-草稿办理")
@ApiOperation(value="企标年度制修订主动上报流程-草稿办理", notes="企标年度制修订主动上报流程-草稿办理")
@GetMapping("/draftHandle")
@Translation
public Result<?> draftHandle(@RequestParam("draftId") @ApiParam("草稿Id") String draftId) {
return Result.OK(actFlowCommonService.getExistDraft(draftId, ProcessTypeEnum.ES_ANNUAL_REPORT));
}
}
@@ -0,0 +1,15 @@
package com.jero.modules.activiti.process.esAnnualReport.entity;
/**
* @author: Mzaxd
* @Date: 2023/10/27 7:32
*/
public class AnnualReportTaskNameConstant {
public static final String STANDARD_ENGINEER_INIT = "标准化工程师发起";
public static final String CONTACT_USER_DISTRIBUTE = "各部所联络人 填写/下发任务";
public static final String WORK_GROUP_COLLECT = "工作组/所联络人填写企标";
public static final String COLLECT_LEADER_APPROVAL = "收集联络人主管级领导审批";
public static final String CONTACT_USER_COLLECT = "各部所联络人汇总";
public static final String CONTACT_USER_LEADER_APPROVAL = "联络人主管级上一级领导审批";
public static final String STANDARD_ENGINEER_COLLECT = "标准化工程师归档";
}
@@ -0,0 +1,388 @@
package com.jero.modules.activiti.process.esAnnualReport.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 企标-年度制修订计划-各部门主动上报
* @TableName process_es_annual_report
*/
@Data
@TableName(value ="process_es_annual_report")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="process_es_annual_report对象", description="企标-年度制修订计划-各部门主动上报")
public class ProcessEsAnnualReport implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 企标计划Id
*/
@ApiModelProperty(value = "企标计划Id")
private String espId;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 申请类别
*/
@Dict(dicCode = "esp_application_category")
@ApiModelProperty(value = "申请类别")
private String applicationCategory;
/**
* 项目类型
*/
@Excel(name = "*制修订类型", width = 15, orderNum = "1")
@Dict(dicCode = "esp_revision_type")
@ApiModelProperty(value = "制修订类型")
private String projectType;
/**
* 原企标编号
*/
@Excel(name = "原企标编号", width = 15, orderNum = "2")
@ApiModelProperty(value = "原企标编号")
private String originEnStandardNo;
/**
* 新企标编号
*/
@ApiModelProperty(value = "新企标编号")
private String newEnStandardNo;
/**
* 原企标名称
*/
@ApiModelProperty(value = "原企标名称")
private String originEnStandardName;
/**
* 新企标名称
*/
@Excel(name = "*新企标名称", width = 15, orderNum = "4")
@ApiModelProperty(value = "新企标名称")
private String newEnStandardName;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String enStandardEnglishName;
/**
* 标准体系
*/
@Excel(name = "*标准体系", width = 25, orderNum = "6")
@Dict(dictTable = "laws_tree_node", dicCode = "id", dicText = "node_name")
@ApiModelProperty(value = "企标体系")
private String enStandardSystem;
/**
* 企业标准代号
*/
@Excel(name = "企业标准代号", width = 15, orderNum = "6")
@Dict(dicCode = "enterprise_standard_code")
@ApiModelProperty(value = "企业标准代号")
private String enStandardCode;
/**
* 企业名称代号
*/
@Excel(name = "企业名称代号", width = 15, orderNum = "6")
@Dict(dicCode = "enterprise_name_code")
@ApiModelProperty(value = "企业名称代号")
private String enNameCode;
/**
* 标准类别代号
*/
@Excel(name = "标准类别代号", width = 15, orderNum = "6")
@Dict(dicCode = "standard_category_code")
@ApiModelProperty(value = "标准类别代号")
private String standardCategoryCode;
/**
* 年代号
*/
@ApiModelProperty(value = "年代号")
private String decadeCode;
/**
* 标准类型
*/
@Excel(name = "*标准类型", width = 15, orderNum = "10")
@Dict(dicCode = "esp_standard_type")
@ApiModelProperty(value = "标准类型")
private String standardType;
/**
* 企标等级分类
*/
@Excel(name = "标准等级分类", width = 15, orderNum = "10")
@Dict(dicCode = "standard_grade_classify")
@ApiModelProperty(value = "企标等级分类")
private String enStandardClassification;
/**
* 草稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "草稿计划完成日期")
private Date draftPlannedCompleteDate;
@Excel(name = "*草稿计划完成日期", width = 20, orderNum = "12")
@TableField(exist = false)
private String draftPlannedCompleteDateString;
/**
* 征求意见稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿计划完成日期")
private Date solicitationDraftPlanCompleteDate;
@Excel(name = "*征求意见稿计划完成日期", width = 24, orderNum = "13")
@TableField(exist = false)
private String solicitationDraftPlanCompleteDateString;
/**
* 计划报批日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "计划报批日期")
private Date planApprovalDate;
@Excel(name = "*计划报批日期", width = 15, orderNum = "14")
@TableField(exist = false)
private String planApprovalDateString;
/**
* 项目状态
*/
@ApiModelProperty(value = "项目状态")
private String projectStatus;
/**
* 编制说明
*/
@ApiModelProperty(value = "编制说明")
private String compilationDescription;
/**
* 零部件名称
*/
@Excel(name = "零部件名称", width = 15, orderNum = "15")
@Dict(dictTable = "laws_part_name", dicCode = "code", dicText = "name")
@ApiModelProperty(value = "零部件名称")
private String componentName;
/**
* 主起草人
*/
@Excel(name = "*主起草人", width = 15, orderNum = "8")
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "主起草人")
private String mainDraftingUser;
/**
* 主起草单位
*/
@Excel(name = "*主起草单位", width = 15, orderNum = "8")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "主起草单位")
private String mainDraftingUnit;
/**
* 主起草单位责任人
*/
@Excel(name = "*起草单位责任人", width = 20, orderNum = "9")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "主起草单位责任人")
private String mainDraftingUnitResponsiblePerson;
/**
* 标准推进人
*/
@Excel(name = "*标准推进人", width = 15, orderNum = "11")
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "标准推进人")
private String standardPromoter;
/**
* 草稿完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "草稿完成日期")
private Date draftCompletionDate;
/**
* 提交草稿日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "提交草稿日期")
private Date draftSubmissionDate;
/**
* 征求意见稿完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿完成日期")
private Date solicitationDraftCompletionDate;
/**
* 变更状态
*/
@Dict(dicCode = "esp_change_status")
@ApiModelProperty(value = "变更状态")
private String changeStatus;
/**
* 上传附件
*/
@ApiModelProperty(value = "上传附件")
private String uploadAttachment;
/**
* 变更原因
*/
@ApiModelProperty(value = "变更原因")
private String changeReason;
/**
* 授权部门
*/
@Excel(name = "授权部门", width = 15, orderNum = "5")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "授权部门")
private String authDept;
/**
* 配合单位
*/
@Excel(name = "配合单位", width = 15, orderNum = "7")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "配合单位")
private String cooperationUnit;
/**
* 隶属工作组
*/
@Excel(name = "隶属工作组", width = 15, orderNum = "10")
@Dict(dictTable = "laws_working_group", dicCode = "id", dicText = "name")
@ApiModelProperty(value = "隶属工作组")
private String workGroup;
/**
* 是否下发联络人标识 0不下发 1下发
*/
@Dict(dicCode = "YN")
@ApiModelProperty(value = "是否下发联络人标识 0不下发 1下发")
private String distributeFlag;
/**
* 部门联络人
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "部门联络人")
private String contactUser;
/**
* 工作组所联络人
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "工作组所联络人")
private String workGroupUser;
/**
* 联络人主管级上一级领导
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "联络人主管级上一级领导")
private String contactUserLeaderLeader;
/**
* 收集联络人主管级领导
*/
@Dict(dicCode = "id", dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "收集联络人主管级领导")
private String collectUserLeader;
/**
* 执行Id
*/
@ApiModelProperty(value = "执行Id")
private String executionId;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
@TableField(exist = false)
private String sort;
}
@@ -0,0 +1,27 @@
package com.jero.modules.activiti.process.esAnnualReport.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 17:28
*/
@Data
public class AnnualReportDataVO {
@JsonProperty("common")
private CommonVO commonVO;
@JsonProperty("dataList")
private List<ProcessEsAnnualReport> dataList;
@JsonProperty("flowUser")
private Map<String, Object> flowUser;
}
@@ -0,0 +1,110 @@
package com.jero.modules.activiti.process.esAnnualReport.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.exception.JeroBootException;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
import com.jero.modules.activiti.process.esAnnualReport.service.impl.ProcessEsAnnualReportServiceImpl;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPRevisionType;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import com.jero.modules.activiti.process.esRevision.entity.vo.ESRevisionDataVO;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
import com.jero.modules.laws.common.constant.FieldCommon;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.BeanCopyUtils;
import com.jero.modules.laws.enterprise.util.EnterpriseStandardUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESAnnualReportEndListener implements ExecutionListener {
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private ProcessEsAnnualReportServiceImpl annualReportService;
@Resource
private EsRevisionService esRevisionService;
@Resource
private EnterpriseStandardUtil esUtil;
/**
* 流程结束之后需要把数据存入企标计划数据库
*
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("年度制修订各部门主动上报流程结束 监听执行器开始执行");
// 获取流程实例ID
String processInstanceId = delegateExecution.getProcessInstanceId();
// 根据流程实例Id找到所有流程业务数据
LambdaQueryWrapper<ProcessEsAnnualReport> esAnnualReportWrapper = new LambdaQueryWrapper<>();
esAnnualReportWrapper.eq(ProcessEsAnnualReport::getProcessInstanceId, processInstanceId);
List<ProcessEsAnnualReport> annualReports = annualReportService.list(esAnnualReportWrapper);
List<EnterpriseStandardPlan> enterpriseStandardPlans;
// 立项新增-Id置空
annualReports.forEach(annualReport -> annualReport.setId(null));
// 转换为企标计划数据并入库
enterpriseStandardPlans = BeanCopyUtils.copyBeanList(annualReports, EnterpriseStandardPlan.class);
// 设置一些字段
// 制修订类型字段
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
esp.setApplicationCategory(esp.getProjectType());
}
// 生成企标编号
Map<String, Object> map = new HashMap<>();
String newStandardNumber;
// 获取当前年份
Calendar date = Calendar.getInstance();
String curYearNumber = String.valueOf(date.get(Calendar.YEAR));
List<EnterpriseStandardPlan> needValidList = new ArrayList<>();
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
// 修订只改年代号
if (esp.getApplicationCategory().equals(ESPRevisionType.MODIFY.getValue())) {
newStandardNumber = esUtil.changeStandardNumberYearNumber(esp.getOriginEnStandardNo(), curYearNumber);
esp.setNewEnStandardNo(newStandardNumber);
needValidList.add(esp);
}
}
if (!needValidList.isEmpty()) {
List<String> duplicateStandardNumbers = esUtil.verifyEsNumberByPlans(needValidList);
if (duplicateStandardNumbers != null && !duplicateStandardNumbers.isEmpty()) {
throw new JeroBootException("原企标编号" + String.join(",", duplicateStandardNumbers) + "修订后,与已存在的企标编号重复,请删除后重新提交");
}
}
// 判断修订的新标准号是否有效
for (EnterpriseStandardPlan esp : enterpriseStandardPlans) {
// 制定生成新企标编号
if (esp.getApplicationCategory().equals(ESPRevisionType.ENACT.getValue())) {
map.put(FieldCommon.ENTERPRISE_STANDARD_CODE, esp.getEnStandardCode());
map.put(FieldCommon.ENTERPRISE_NAME_CODE, esp.getEnNameCode());
map.put(FieldCommon.STANDARD_CATEGORY_CODE, esp.getStandardCategoryCode());
map.put(FieldCommon.YEAR_NUMBER, curYearNumber);
newStandardNumber = esUtil.generateStandardNumber(map);
esp.setNewEnStandardNo(newStandardNumber);
}
espService.save(esp);
log.info("数据存入企标计划数据库");
ESRevisionDataVO revisionDataVO = new ESRevisionDataVO();
ProcessEsRevision revision = new ProcessEsRevision();
revision.setEspId(esp.getId());
revisionDataVO.setData(revision);
esRevisionService.autoStartProcess(revisionDataVO);
log.info("自动发起企标制修订流程");
}
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.esAnnualReport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_report(企标-年度制修订计划-各部门主动上报)】的数据库操作Mapper
* @createDate 2023-10-18 09:52:41
* @Entity com.jero.modules.activiti.process.esAnnualInit.entity.ProcessEsAnnualReport
*/
public interface ProcessEsAnnualReportMapper extends BaseMapper<ProcessEsAnnualReport> {
}
@@ -0,0 +1,27 @@
package com.jero.modules.activiti.process.esAnnualReport.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
import com.jero.modules.activiti.process.esAnnualReport.entity.vo.AnnualReportDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import org.springframework.web.multipart.MultipartFile;
import java.util.Map;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_report(企标-年度制修订计划-各部门主动上报)】的数据库操作Service
* @createDate 2023-10-18 09:52:41
*/
public interface ProcessEsAnnualReportService extends IService<ProcessEsAnnualReport> {
Map<String, Object> importData(MultipartFile file);
void startProcess(AnnualReportDataVO annualReportDataVO);
void approvalProcess(AnnualReportDataVO annualReportDataVO, boolean b);
void saveToDraft(ProcessInfoVO<AnnualReportDataVO> annualReportDataVO);
AnnualReportDataVO getHandleData(String taskId);
}
@@ -0,0 +1,625 @@
package com.jero.modules.activiti.process.esAnnualReport.service.impl;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.common.api.CommonAPI;
import com.jero.common.api.dto.message.SendMessageDTO;
import com.jero.common.api.vo.SendMessageAPI;
import com.jero.common.aspect.TranslationAspect;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.common.system.vo.SysDictItemCore;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.common.enums.ProcessType;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAnnualReport.entity.ProcessEsAnnualReport;
import com.jero.modules.activiti.process.esAnnualReport.entity.vo.AnnualReportDataVO;
import com.jero.modules.activiti.process.esAnnualReport.mapper.ProcessEsAnnualReportMapper;
import com.jero.modules.activiti.process.esAnnualReport.service.ProcessEsAnnualReportService;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPChangeType;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.fb.dto.BasicProcessInfoDTO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.activiti.service.ProcessNodeLinkService;
import com.jero.modules.activiti.util.ExcelUtils;
import com.jero.modules.laws.common.constant.MessageTemplateCodeCommon;
import com.jero.modules.laws.common.util.ImportUtil;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import lombok.Cleanup;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;
import static com.jero.modules.activiti.process.esAnnualReport.entity.AnnualReportTaskNameConstant.*;
/**
* @author ThinkBook
* @description 针对表【process_es_annual_report(企标-年度制修订计划-各部门主动上报)】的数据库操作Service实现
* @createDate 2023-10-18 09:52:41
*/
@Slf4j
@Service
@Transactional(rollbackFor = JeroBootException.class)
public class ProcessEsAnnualReportServiceImpl extends ServiceImpl<ProcessEsAnnualReportMapper, ProcessEsAnnualReport>
implements ProcessEsAnnualReportService {
@Resource
private CommonAPI commonAPI;
@Resource
private ExcelUtils excelUtils;
@Resource
private ILawsEnterpriseStandardService enterpriseStandardService;
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private ProcessAllService processAllService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private ImportUtil importUtil;
@Resource
private IProcessHandleService processHandleService;
@Resource
private TranslationAspect translationAspect;
@Resource
private SendMessageAPI sendMessageAPI;
@Resource
private ILawsEnterpriseStandardService esService;
@Override
public void startProcess(AnnualReportDataVO annualReportData) {
// 流程Key
String processDefinitionKey = ProcessType.ES_ANNUAL_REPORT.getProcessKey();
// 通用数据
CommonVO commonVO = annualReportData.getCommonVO();
// 当前用户Id
String userId = UserUtils.getUserId();
// 人员数据
Map<String, Object> variables = annualReportData.getFlowUser();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(annualReportData);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(commonVO, ProcessTypeEnum.ES_ANNUAL_REPORT);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(variables));
// 获取第一个任务的taskId
String taskId = actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.manualParseDictText(this.getHandleData(taskId), variables);
// 强制撤回
commonVO.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_ANNUAL_REPORT, jsonData);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, true);
// 自动完成第一个任务
actFlowCommonService.completeTask(taskId, userId);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ANNUAL_REPORT.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
// 执行流程发起前的操作
this.startRunTask(annualReportData, processInstanceId);
}
public Map<String, Object> setVariables(AnnualReportDataVO annualReportData) {
Map<String, Object> actVariables = new HashMap<>();
CommonVO commonVO = annualReportData.getCommonVO();
Map<String, Object> flowUser = annualReportData.getFlowUser();
actFlowCommonService.putIfNotNull(actVariables, "contactUserList",
Optional.ofNullable((String) flowUser.get("contactUserList"))
.map(s -> Arrays.asList(s.split(",")))
.orElse(null));
actVariables.put("standardEngineer", flowUser.get("standardEngineer"));
actVariables.put("processDescription", commonVO.getProcessDescription());
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
variables.remove("processDescription");
return variables;
}
public void startRunTask(AnnualReportDataVO annualReportDataVO, String processInstanceId) {
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
// 发消息
CommonVO commonVO = annualReportDataVO.getCommonVO();
Map<String, Object> flowUser = annualReportDataVO.getFlowUser();
String contactUsers = (String) flowUser.get("contactUserList");
String processDescription = commonVO.getProcessDescription();
String[] contactUserList = contactUsers.split(",");
for (String contactUser : contactUserList) {
SendMessageDTO sendMessageDTO = new SendMessageDTO();
sendMessageDTO.setTemplateCode(MessageTemplateCodeCommon.ES_ANNUAL_REPORT_CONTACT_USER);
sendMessageDTO.setToUserId(contactUser);
Map<String, String> sendMap = new HashMap<>();
sendMap.put("prcNum", processAll.getPrcNum());
sendMap.put("prcName", processAll.getPrcName());
sendMap.put("description", processDescription);
sendMessageDTO.setMap(sendMap);
sendMessageAPI.sendMessage(sendMessageDTO);
}
}
@Override
public void approvalProcess(AnnualReportDataVO annualReportDataVO, boolean pass) {
CommonVO commonVO = annualReportDataVO.getCommonVO();
List<ProcessEsAnnualReport> dataList = annualReportDataVO.getDataList();
String taskId = commonVO.getTaskId();
// 获取task
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException("taskId为空或任务不存在");
}
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String taskName = task.getName();
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程实例
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
String processDefinitionId = processInstance.getProcessDefinitionId();
ProcessEsAnnualReport annualReport;
String executionId = task.getExecutionId();
String contactUser = (String) runtimeService.getVariable(executionId, "contactUser");
String workGroupUser = (String) runtimeService.getVariable(executionId, "workGroupUser");
String contactUserLeaderLeader;
LambdaQueryWrapper<ProcessEsAnnualReport> wrapper = new LambdaQueryWrapper<>();
Map<String, Object> userVariable = new HashMap<>();
runtimeService.setVariableLocal(processInstanceId, "pass", pass);
switch (taskName) {
case CONTACT_USER_DISTRIBUTE:
annualReport = annualReportDataVO.getDataList().get(0);
boolean distribute = annualReport.getDistributeFlag().equals("1");
contactUserLeaderLeader = annualReport.getContactUserLeaderLeader();
taskService.setVariable(taskId, "distribute", distribute);
String curContactUser = UserUtils.getUserId();
// 获取是否分发
if (distribute) {
String workGroupUsers = annualReport.getWorkGroupUser();
// 将workGroupUserList从逗号拼接转为List
List<String> workGroupUserList = StrUtil.split(workGroupUsers, ',');
// 设置流程变量
taskService.setVariable(taskId, "workGroupUserList", workGroupUserList);
// 将联络人主管级上一级领导保存到流程变量中
userVariable.put("workGroupUserList", workGroupUsers);
userVariable.put("contactUser", contactUser);
} else {
// 保存联络人主管级上级领导
dataList.forEach(data -> data.setContactUserLeaderLeader(contactUserLeaderLeader));
dataList.forEach(data -> data.setExecutionId(executionId));
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
dataList.forEach(data -> data.setContactUser(curContactUser));
// 不分发,入库存表
saveBatch(dataList);
taskService.setVariable(taskId, "contactUserLeaderLeader", contactUserLeaderLeader);
}
taskService.setVariable(taskId, curContactUser + "-ContactUserLeaderLeader", contactUserLeaderLeader);
userVariable.put("contactUserLeaderLeader", contactUserLeaderLeader);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userVariable);
// 转办
runtimeService.setVariable(executionId, "contactUser", curContactUser);
break;
case WORK_GROUP_COLLECT:
// 先删后增
AnnualReportDataVO handleData = this.getHandleData(taskId);
List<ProcessEsAnnualReport> handaleDataList = handleData.getDataList();
List<String> idList = new ArrayList<>();
handaleDataList.forEach(h -> idList.add(h.getId()));
wrapper.eq(ProcessEsAnnualReport::getWorkGroupUser, workGroupUser);
removeByIds(idList);
annualReport = annualReportDataVO.getDataList().get(0);
String collectUserLeader = annualReport.getCollectUserLeader();
contactUserLeaderLeader = annualReport.getContactUserLeaderLeader();
dataList.forEach(data -> data.setContactUser(contactUser));
dataList.forEach(data -> data.setExecutionId(executionId));
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
// 保存收集联络人主管级领导
dataList.forEach(data -> data.setCollectUserLeader(collectUserLeader));
dataList.forEach(data -> data.setContactUserLeaderLeader(contactUserLeaderLeader));
String curWorkGroupUser = UserUtils.getUserId();
dataList.forEach(data -> data.setWorkGroupUser(curWorkGroupUser));
saveBatch(dataList);
// 转办
runtimeService.setVariable(executionId, "workGroupUser", curWorkGroupUser);
// 设置下一个节点的审批人流程变量
taskService.setVariable(taskId, "collectUserLeader", collectUserLeader);
userVariable.put("collectUserLeader", collectUserLeader);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userVariable);
break;
case COLLECT_LEADER_APPROVAL:
// 转办
runtimeService.setVariable(executionId, "collectUserLeader", UserUtils.getUserId());
break;
case CONTACT_USER_COLLECT:
// 先删后增
wrapper.eq(ProcessEsAnnualReport::getContactUser, contactUser);
wrapper.eq(ProcessEsAnnualReport::getProcessInstanceId, processInstanceId);
remove(wrapper);
contactUserLeaderLeader = (String) runtimeService.getVariable(executionId, contactUser + "-ContactUserLeaderLeader");
dataList.forEach(data -> data.setContactUser(contactUser));
dataList.forEach(data -> data.setExecutionId(executionId));
dataList.forEach(data -> data.setProcessInstanceId(processInstanceId));
dataList.forEach(data -> data.setContactUserLeaderLeader(contactUserLeaderLeader));
taskService.setVariable(taskId, "contactUserLeaderLeader", contactUserLeaderLeader);
userVariable.put("contactUserLeaderLeader", contactUserLeaderLeader);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userVariable);
saveBatch(dataList);
// 转办
runtimeService.setVariable(executionId, "contactUser", UserUtils.getUserId());
break;
case CONTACT_USER_LEADER_APPROVAL:
if (!pass) {
userVariable.put("contactUser", contactUser);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userVariable);
}
// 转办
String curLeader = UserUtils.getUserId();
taskService.setVariable(taskId, contactUser + "-ContactUserLeaderLeader", curLeader);
userVariable.put("contactUserLeaderLeader", curLeader);
processNodeLinkService.incrementSaveNodeUserLink(processDefinitionId, processInstanceId, userVariable);
break;
case STANDARD_ENGINEER_COLLECT:
// 根据流程ID删除所有数据后新增
dataList = annualReportDataVO.getDataList();
wrapper.eq(ProcessEsAnnualReport::getProcessInstanceId, processInstanceId);
wrapper.eq(ProcessEsAnnualReport::getDelFlag, YesOrNoEnum.NO.getValue());
remove(wrapper);
saveBatch(dataList);
break;
}
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, UserUtils.getUserId());
}
@Override
public void saveToDraft(ProcessInfoVO<AnnualReportDataVO> processInfoVO) {
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_ANNUAL_REPORT.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
@Override
public AnnualReportDataVO getHandleData(String taskId) {
// 判断是否是转办的 找到原始任务办理人
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException("任务不存在");
}
String userId = actFlowCommonService.getOriginTaskAssignee(taskId);
String executionId = taskService.createTaskQuery().taskId(taskId).singleResult().getExecutionId();
AnnualReportDataVO annualReportDataVO = new AnnualReportDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程通用数据
ProcessAll process = processAllService.getByProcessInstanceId(processInstanceId);
CommonVO commonVO = new CommonVO();
commonVO.setPrcName(process.getPrcName());
commonVO.setTaskId(process.getTaskId());
commonVO.setPrcMes(process.getPrcMes());
commonVO.setDueTime(process.getDueTime());
commonVO.setTaskId(taskId);
commonVO.setNodeId(process.getNodeId());
String processDescription = (String) runtimeService.getVariable(processInstanceId, "processDescription");
commonVO.setProcessDescription(processDescription);
annualReportDataVO.setCommonVO(commonVO);
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsAnnualReport> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsAnnualReport::getProcessInstanceId, processInstanceId);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String taskName = task.getName();
switch (taskName) {
case STANDARD_ENGINEER_INIT:
// do nothing now
break;
case CONTACT_USER_DISTRIBUTE:
// do nothing now
break;
case WORK_GROUP_COLLECT:
wrapper.eq(ProcessEsAnnualReport::getWorkGroupUser, userId);
wrapper.eq(ProcessEsAnnualReport::getExecutionId, executionId);
break;
case COLLECT_LEADER_APPROVAL:
wrapper.eq(ProcessEsAnnualReport::getCollectUserLeader, userId);
wrapper.eq(ProcessEsAnnualReport::getExecutionId, executionId);
break;
case CONTACT_USER_COLLECT:
wrapper.eq(ProcessEsAnnualReport::getContactUser, userId);
break;
case CONTACT_USER_LEADER_APPROVAL:
wrapper.eq(ProcessEsAnnualReport::getContactUserLeaderLeader, userId);
wrapper.in(ProcessEsAnnualReport::getExecutionId, executionId);
break;
case STANDARD_ENGINEER_COLLECT:
break;
}
wrapper.eq(ProcessEsAnnualReport::getProcessInstanceId, processInstanceId);
wrapper.eq(ProcessEsAnnualReport::getDelFlag, YesOrNoEnum.NO.getInteger());
annualReportDataVO.setDataList(list(wrapper));
return annualReportDataVO;
}
@Override
public Map<String, Object> importData(MultipartFile file) {
List<SysDictItemCore> listDict = commonAPI.getDictItemAll();
Map<String, Object> resultMap = new HashMap<>();
List<String> errorMsgs = new ArrayList<>();
// 获取Excel的header
List<String> headers;
try {
headers = ExcelUtils.getHeaderFromExcel(file.getInputStream(), 0);
} catch (Exception e) {
errorMsgs.add("模板错误,请按照系统模板导入!");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
log.error(e.getMessage(), e);
return resultMap; // 返回错误信息
}
// 使用静态方法验证header
boolean isMatched = headers.equals(ExcelUtils.getSortedHeadersFromClass(ProcessEsAnnualReport.class));
if (!isMatched) {
errorMsgs.add("模板错误,请按照系统模板导入!");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
return resultMap; // 返回错误信息
}
ImportParams params = new ImportParams();
params.setTitleRows(0);
params.setHeadRows(1);
params.setNeedSave(true);
try {
@Cleanup
InputStream inputStream = file.getInputStream();
List<ProcessEsAnnualReport> list = ExcelImportUtil.importExcel(inputStream, ProcessEsAnnualReport.class, params);
list.remove(0);
list.remove(0);
if (list.isEmpty()) {
errorMsgs.add("文件暂无数据,请检查后重试。");
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
return resultMap; // 返回错误信息
}
// 批量检查数据是否有效
errorMsgs = this.validationList(list, listDict);
if (!errorMsgs.isEmpty()) {
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
} else {
resultMap.put("flag", YesOrNoEnum.YES.getValue());
// 转换为字典值
this.transToDictValue(list, listDict);
// 清洗
this.cleanData(list);
resultMap.put("dataList", list);
}
} catch (Exception e) {
errorMsgs.add("文件导入异常:" + e.getMessage());
resultMap.put("msg", errorMsgs);
resultMap.put("flag", YesOrNoEnum.NO.getValue());
log.error(e.getMessage(), e);
}
return resultMap;
}
private void cleanData(List<ProcessEsAnnualReport> list) {
// 查找所有企标 并转换成key为标准编号的map
LambdaQueryWrapper<LawsEnterpriseStandard> esWrapper = new LambdaQueryWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getDelFlag, YesOrNoEnum.NO.getValue());
Map<String, List<LawsEnterpriseStandard>> esMap =
esService.list(esWrapper).stream().collect(Collectors.groupingBy(LawsEnterpriseStandard::getStandardNumber));
list.forEach(item -> {
// 如果是制定则去除掉所有的原企标名称 原企标编号
if (ESPProjectType.ENACT.getValue().equals(item.getProjectType())) {
item.setOriginEnStandardName(null);
item.setOriginEnStandardNo(null);
String decadeCode = item.getDecadeCode();
if (StrUtil.isBlank(decadeCode)) {
// 获取当前年份
Calendar date = Calendar.getInstance();
String curYearNumber = String.valueOf(date.get(Calendar.YEAR));
item.setDecadeCode(curYearNumber);
}
} else {
List<LawsEnterpriseStandard> esList = esMap.get(item.getOriginEnStandardNo());
if (esList != null && !esList.isEmpty()) {
item.setOriginEnStandardName(esList.get(0).getStandardName());
}
}
item.setChangeStatus(ESPChangeType.ADD.getValue());
});
}
private void transToDictValue(List<ProcessEsAnnualReport> list, List<SysDictItemCore> listDict) {
list.forEach(item -> {
item.setProjectType(excelUtils.translateDictValue("esp_revision_type", item.getProjectType(), listDict));
item.setEnStandardCode(excelUtils.translateDictValue("enterprise_standard_code", item.getEnStandardCode(), listDict));
item.setAuthDept(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getAuthDept(), listDict));
item.setCooperationUnit(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getCooperationUnit(), listDict));
item.setMainDraftingUser(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getMainDraftingUser(), listDict));
item.setMainDraftingUnit(excelUtils.translateDictValue("depart_name", "id", "sys_depart", item.getMainDraftingUnit(), listDict));
item.setMainDraftingUnitResponsiblePerson(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getMainDraftingUnitResponsiblePerson(), listDict));
item.setStandardPromoter(excelUtils.translateDictValue("CONCAT(realname, '(', username, ')')", "id", "sys_user", item.getStandardPromoter(), listDict));
item.setEnStandardSystem(importUtil.convertStandardSystem(item.getEnStandardSystem(), "3"));
item.setWorkGroup(excelUtils.translateDictValue("name", "id", "laws_working_group", item.getWorkGroup(), listDict));
item.setStandardType(excelUtils.translateDictValue("esp_standard_type", item.getStandardType(), listDict));
item.setEnStandardClassification(excelUtils.translateDictValue("standard_grade_classify", item.getEnStandardClassification(), listDict));
item.setDraftPlannedCompleteDate(importUtil.convertDate(item.getDraftPlannedCompleteDateString()));
item.setSolicitationDraftPlanCompleteDate(importUtil.convertDate(item.getSolicitationDraftPlanCompleteDateString()));
item.setPlanApprovalDate(importUtil.convertDate(item.getPlanApprovalDateString()));
item.setComponentName(excelUtils.translateDictValue("name", "code", "laws_part_name", item.getComponentName(), listDict));
});
}
private List<String> validationList(List<ProcessEsAnnualReport> list, List<SysDictItemCore> listDict) {
// 找到各标准等级的授权部门
Map<String, List<String>> authDeptMap = excelUtils.getAllLevelAuthDeptMap();
List<LawsEnterpriseStandard> esList = enterpriseStandardService.list();
List<String> errorMsgs = new ArrayList<>();
int i = 4;
Iterator<ProcessEsAnnualReport> iterator = list.iterator();
while (iterator.hasNext()) {
ProcessEsAnnualReport plan = iterator.next();
if (ExcelUtils.isEmptyRow(plan)) {
iterator.remove();
if (list.isEmpty()) {
errorMsgs.add("文件暂无数据,请检查后重试。");
}
continue;
}
plan.setSort(String.valueOf(i++));
String authDept = plan.getAuthDept();
String cooperationUnit = plan.getCooperationUnit();
String mainDraftingUnit = plan.getMainDraftingUnit();
String mainDraftingUser = plan.getMainDraftingUser();
String mainDraftingUnitResponsiblePerson = plan.getMainDraftingUnitResponsiblePerson();
String standardPromoter = plan.getStandardPromoter();
String workGroup = plan.getWorkGroup();
String standardSystem = plan.getEnStandardSystem();
String standardType = plan.getStandardType();
String standardClassification = plan.getEnStandardClassification();
String draftPlannedCompleteDateString = plan.getDraftPlannedCompleteDateString();
String solicitationDraftPlanCompleteDateString = plan.getSolicitationDraftPlanCompleteDateString();
String planApprovalDateString = plan.getPlanApprovalDateString();
String partName = plan.getComponentName();
StringBuilder errMsgHeader = new StringBuilder();
StringBuilder errMsg = new StringBuilder();
errMsgHeader.append("").append(plan.getSort()).append("");
// 检查制修订类型 编号 名称
errMsg.append(validProjectType(plan, listDict, esList));
// 检查标准等级分类和授权部门
errMsg.append(excelUtils.validAuthDept(authDept, listDict, mainDraftingUnit, standardClassification, authDeptMap, false));
// 检查所有数据字典校验的字段
errMsg.append(excelUtils.validCooperateUnit(cooperationUnit, listDict));
errMsg.append(excelUtils.validMainDraftingUser(mainDraftingUser, listDict));
errMsg.append(excelUtils.validMainDraftingUnitResponsiblePerson(mainDraftingUnitResponsiblePerson, listDict));
errMsg.append(excelUtils.validStandardPromoter(standardPromoter, listDict));
errMsg.append(excelUtils.validWorkGroup(workGroup, listDict));
errMsg.append(excelUtils.validStandardSystem(standardSystem, listDict, true));
errMsg.append(excelUtils.validStandardType(standardType, listDict, true));
errMsg.append(excelUtils.validSingleDateMustInputNotBeforeToday(draftPlannedCompleteDateString, "草稿计划完成日期"));
errMsg.append(excelUtils.validSingleDateMustInputNotBeforeToday(solicitationDraftPlanCompleteDateString, "征求意见稿计划完成日期"));
errMsg.append(excelUtils.validSingleDateMustInputNotBeforeToday(planApprovalDateString, "计划报批日期"));
errMsg.append(excelUtils.validPartName(partName, listDict, false));
// 如果数据有问题,则将提示信息添加到 errorMsgs 中
if (errMsg.length() > 0) {
errorMsgs.add(errMsgHeader.append(errMsg).toString());
}
}
return errorMsgs;
}
private String validProjectType(ProcessEsAnnualReport plan, List<SysDictItemCore> listDict, List<LawsEnterpriseStandard> esList) {
StringBuilder errMsg = new StringBuilder();
String projectType = plan.getProjectType();
String originEnStandardNo = plan.getOriginEnStandardNo();
String newEnStandardName = plan.getNewEnStandardName();
if (StrUtil.isBlank(projectType)) {
return "'制修订类型'不能为空。";
}
if (!excelUtils.validDict("esp_revision_type", projectType, null, null, true, listDict)) {
return "'制修订类型'无效。";
}
// 新企标名称不能为空
if (StrUtil.isBlank(newEnStandardName)) {
errMsg.append("'新企标名称'不能为空。");
}
// 修订
if (projectType.equals(ESPProjectType.MODIFY.getName())) {
// 检查企标编号是否有效
if (StrUtil.isBlank(originEnStandardNo)) {
errMsg.append("'原企标编号'不能为空。");
} else {
if (!esList.stream().map(LawsEnterpriseStandard::getStandardNumber).collect(Collectors.toList()).contains(originEnStandardNo)) {
return "'原企标编号'无效。";
}
}
} else {
// 制定校验三个代号
String enStandardCode = plan.getEnStandardCode();
String enNameCode = plan.getEnNameCode();
String standardCategoryCode = plan.getStandardCategoryCode();
// 检查企标编号是否有效
if (StrUtil.isBlank(enStandardCode)) {
errMsg.append("'企业标准代号'不能为空。");
} else {
// 检查企业标准代号
if (!excelUtils.validDict("enterprise_standard_code", enStandardCode, null, null, true, listDict)) {
errMsg.append("'企业标准代号'无效。");
}
}
if (StrUtil.isBlank(enNameCode)) {
errMsg.append("'企业名称代号'不能为空。");
} else {
// 检查企业标准代号
if (!excelUtils.validDict("enterprise_name_code", enNameCode, null, null, true, listDict)) {
errMsg.append("'企业名称代号'无效。");
}
}
if (StrUtil.isBlank(standardCategoryCode)) {
errMsg.append("'标准类别代号'不能为空。");
} else {
// 检查企业标准代号
if (!excelUtils.validDict("standard_category_code", standardCategoryCode, null, null, true, listDict)) {
errMsg.append("'标准类别代号'无效。");
}
}
}
errMsg.append(excelUtils.validStandardName(newEnStandardName));
return errMsg.toString();
}
}
@@ -0,0 +1,134 @@
package com.jero.modules.activiti.process.esArchive.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.Translation;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.TransferVO;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.esArchive.service.ProcessEsArchiveService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
* @author: Mzaxd
* @Date: 2023/10/18 10:44
*/
@Slf4j
@RestController
@Api(tags = "企标封存流程")
@RequestMapping("/process/es/archive")
public class ESArchiveController {
@Resource
private ProcessEsArchiveService archiveService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增企标封存申请
*
* @param archiveData
*/
@AutoLog(value = "企标封存流程-发起流程")
@ApiOperation(value="企标封存流程-发起流程", notes="企标封存流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESArchiveDataVO archiveData) {
archiveService.startProcess(archiveData);
return Result.OK();
}
/**
* 保存到待办
* @param processInfoVO
*/
@AutoLog(value = "企标封存流程-保存")
@ApiOperation(value="企标封存流程-保存", notes="企标封存流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESArchiveDataVO> processInfoVO) {
archiveService.saveToDraft(processInfoVO);
return Result.OK();
}
/**
* 保存到待办
* @param taskId
*/
@AutoLog(value = "企标封存流程-办理")
@ApiOperation(value="企标封存流程-办理", notes="企标封存流程-办理")
@GetMapping("/handle/{taskId}")
@Translation
public Result<?> handle(@PathVariable("taskId") String taskId) {
ProcessDraft draft = actFlowCommonService.getExistDraftByTaskId(taskId, ProcessTypeEnum.ES_ARCHIVE);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(archiveService.getHandleData(taskId));
}
/**
* 草稿办理
* @param draftId
*/
@AutoLog(value = "企标封存流程-草稿办理")
@ApiOperation(value="企标封存流程-草稿办理", notes="企标封存流程-草稿办理")
@GetMapping("/draftHandle")
@Translation
public Result<?> draftHandle(@RequestParam("draftId") @ApiParam("草稿Id") String draftId) {
return Result.OK(actFlowCommonService.getExistDraft(draftId, ProcessTypeEnum.ES_ARCHIVE));
}
/**
* 同意
*
* @param archiveData
*/
@AutoLog(value = "企标封存流程-同意")
@ApiOperation(value="企标封存流程-同意", notes="企标封存流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESArchiveDataVO archiveData) {
archiveService.approval(archiveData, true);
return Result.OK();
}
/**
* 驳回
*
* @param archiveData
*/
@AutoLog(value = "企标封存流程-驳回")
@ApiOperation(value="企标封存流程-驳回", notes="企标封存流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESArchiveDataVO archiveData) {
archiveService.approval(archiveData, false);
return Result.OK();
}
/**
* 转办
*
*/
@AutoLog(value = "企标封存流程-转办")
@ApiOperation(value="企标封存流程-转办", notes="企标封存流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
}
@@ -0,0 +1,138 @@
package com.jero.modules.activiti.process.esArchive.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 企业标准
* @TableName process_es_archive
*/
@TableName(value ="process_es_archive")
@Data
public class ProcessEsArchive implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 企标编号
*/
@ApiModelProperty(value = "企标编号")
private String standardNumber;
/**
* 企标名称
*/
@ApiModelProperty(value = "企标名称")
private String standardName;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String englishName;
/**
* 企标类型
*/
@Dict(dicCode = "esp_standard_type")
@ApiModelProperty(value = "企标类型")
private String standardCategory;
/**
* 代替标准号
*/
@ApiModelProperty(value = "代替标准号")
private String substituteStandardNumber;
/**
* 被代替标准号
*/
@ApiModelProperty(value = "被代替标准号")
private String replacedByStandardNumber;
/**
* 发布日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "发布日期")
private Date releaseDate;
/**
* 实施日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "实施日期")
private Date implementationDate;
/**
* 封存理由
*/
@ApiModelProperty(value = "封存理由")
private String archiveReason;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -0,0 +1,27 @@
package com.jero.modules.activiti.process.esArchive.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 8:13
*/
@Data
public class ESArchiveDataVO {
@JsonProperty("common")
private CommonVO common;
@JsonProperty("data")
private ProcessEsArchive data;
@JsonProperty("flowUser")
private Map<String, Object> flowUser;
}
@@ -0,0 +1,60 @@
package com.jero.modules.activiti.process.esArchive.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive;
import com.jero.modules.activiti.process.esArchive.service.ProcessEsArchiveService;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPApplicationCategoryEnum;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPChangeType;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.BeanCopyUtils;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESArchiveEndListener implements ExecutionListener {
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private ProcessEsArchiveService esArchiveService;
/**
* 企标立项变更流程结束之后需要把数据存入企标计划数据库 然后自动发起企标制修订流程
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标封存流程结束 监听执行器开始执行");
// 找到流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsArchive> archiveLambdaQueryWrapper = new LambdaQueryWrapper<>();
archiveLambdaQueryWrapper.eq(ProcessEsArchive::getProcessInstanceId, processInstanceId);
ProcessEsArchive archive = esArchiveService.getOne(archiveLambdaQueryWrapper);
String standNo = archive.getStandardNumber();
log.info("企标封存流程监听执行器开始执行,企标编号为:{}", standNo);
esService.update(new LambdaUpdateWrapper<LawsEnterpriseStandard>()
.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.ARCHIVE.getStateValue())
.eq(LawsEnterpriseStandard::getStandardNumber, standNo));
log.info("企标封存流程结束监听执行器执行结束");
}
}
@@ -0,0 +1,18 @@
package com.jero.modules.activiti.process.esArchive.mapper;
import com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_archive(企业标准)】的数据库操作Mapper
* @createDate 2023-10-29 21:00:37
* @Entity com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive
*/
public interface ProcessEsArchiveMapper extends BaseMapper<ProcessEsArchive> {
}
@@ -0,0 +1,35 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jero.modules.activiti.process.esArchive.mapper.ProcessEsArchiveMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive">
<id property="id" column="id" jdbcType="VARCHAR"/>
<result property="createBy" column="create_by" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="orgCode" column="org_code" jdbcType="VARCHAR"/>
<result property="delFlag" column="del_flag" jdbcType="TINYINT"/>
<result property="processInstanceId" column="process_instance_id" jdbcType="VARCHAR"/>
<result property="standardNumber" column="standard_number" jdbcType="VARCHAR"/>
<result property="standardName" column="standard_name" jdbcType="VARCHAR"/>
<result property="englishName" column="english_name" jdbcType="VARCHAR"/>
<result property="standardCategory" column="standard_category" jdbcType="VARCHAR"/>
<result property="substituteStandardNumber" column="substitute_standard_number" jdbcType="VARCHAR"/>
<result property="replacedByStandardNumber" column="replaced_by_standard_number" jdbcType="VARCHAR"/>
<result property="releaseDate" column="release_date" jdbcType="TIMESTAMP"/>
<result property="implementationDate" column="implementation_date" jdbcType="TIMESTAMP"/>
<result property="archiveReason" column="archive_reason" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,create_by,create_time,
update_by,update_time,org_code,
del_flag,process_instance_id,standard_number,
standard_name,english_name,standard_category,
substitute_standard_number,replaced_by_standard_number,release_date,
implementation_date,archive_reason
</sql>
</mapper>
@@ -0,0 +1,23 @@
package com.jero.modules.activiti.process.esArchive.service;
import com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_archive(企业标准)】的数据库操作Service
* @createDate 2023-10-29 21:00:37
*/
public interface ProcessEsArchiveService extends IService<ProcessEsArchive> {
void startProcess(ESArchiveDataVO annualInitData);
void saveToDraft(ProcessInfoVO<ESArchiveDataVO> processInfoVO);
ESArchiveDataVO getHandleData(String taskId);
void approval(ESArchiveDataVO archiveData, boolean pass);
}
@@ -0,0 +1,259 @@
package com.jero.modules.activiti.process.esArchive.service.impl;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.common.api.vo.ResultCommon;
import com.jero.common.aspect.TranslationAspect;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.common.exception.JeroBootException;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.common.DraftCommon;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.common.entity.CounterSignNodeNameConstants;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.enums.ProcessType;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esAbolish.entity.ProcessEsAbolish;
import com.jero.modules.activiti.process.esAbolish.entity.vo.ESAbolishDataVO;
import com.jero.modules.activiti.process.esArchive.entity.ProcessEsArchive;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.esArchive.service.ProcessEsArchiveService;
import com.jero.modules.activiti.process.esArchive.mapper.ProcessEsArchiveMapper;
import com.jero.modules.activiti.process.fb.dto.BasicProcessInfoDTO;
import com.jero.modules.activiti.process.fb.dto.BasicTaskInfoDTO;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.activiti.service.ProcessNodeLinkService;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
/**
* @author ThinkBook
* @description 针对表【process_es_archive(企业标准)】的数据库操作Service实现
* @createDate 2023-10-29 21:00:37
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsArchiveServiceImpl extends ServiceImpl<ProcessEsArchiveMapper, ProcessEsArchive>
implements ProcessEsArchiveService{
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private TranslationAspect translationAspect;
@Override
public void startProcess(ESArchiveDataVO archiveData) {
// 执行流程发起前的操作
this.startRunTask(archiveData);
// 流程Key
String processDefinitionKey = ProcessType.ES_ARCHIVE.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
ProcessEsArchive esArchive = archiveData.getData();
// 通用数据
CommonVO common = archiveData.getCommon();
// 人员数据
Map<String, Object> variables = archiveData.getFlowUser();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(common, ProcessTypeEnum.ES_ARCHIVE);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esArchive.setProcessInstanceId(processInstanceId);
// 保存到业务流程表
saveOrUpdate(esArchive);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(variables));
// 获取第一个任务的taskId
String taskId = actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.manualParseDictText(this.getHandleData(taskId), this.getUserMap(variables));
// 强制撤回
common.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraft(common, ProcessTypeEnum.ES_ARCHIVE, jsonData);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(common, taskId, true);
// 自动完成第一个任务
actFlowCommonService.completeTask(taskId, userId);
// 根据流程实例id更新流程总表
String prcName = common.getPrcName();
String prcMes = common.getPrcMes();
Date dueTime = common.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ARCHIVE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(Map<String, Object> flowUser) {
HashMap<String, Object> actVariables = new HashMap<>();
if (flowUser.get("relatedUserList") == null || StrUtil.isBlank((String)flowUser.get("relatedUserList"))) {
actFlowCommonService.putIfNotNull(actVariables, "countersign", false);
} else {
actFlowCommonService.putIfNotNull(actVariables, "countersign", true);
String relatedUsers = (String) flowUser.get("relatedUserList");
// 将relatedUserList从逗号拼接转为List
List<String> relatedUserList = StrUtil.split(relatedUsers, ',');
actFlowCommonService.putIfNotNull(actVariables, "relatedUserList", relatedUserList);
}
for (Map.Entry<String, Object> entry : flowUser.entrySet()) {
String key = entry.getKey();
if (!key.equals("relatedUserList")) {
actVariables.put(key, entry.getValue());
}
}
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
variables.remove("countersign");
return variables;
}
@Override
public void saveToDraft(ProcessInfoVO<ESArchiveDataVO> processInfoVO) {
ESArchiveDataVO businessInfoDTO = processInfoVO.getBusinessInfoDTO();
if (businessInfoDTO != null) {
ProcessEsArchive data = businessInfoDTO.getData();
if (data != null) {
processInfoVO.setBusinessId(data.getId());
}
}
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_ARCHIVE.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
public void startRunTask(ESArchiveDataVO archiveData) {
// do nothing now
}
@Override
public ESArchiveDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ESArchiveDataVO archiveData = new ESArchiveDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
archiveData.setCommon(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsArchive> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsArchive::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsArchive::getDelFlag, YesOrNoEnum.NO.getValue());
ProcessEsArchive data = getOne(lambdaQueryWrapper);
archiveData.setData(data);
return archiveData;
}
@Override
public void approval(ESArchiveDataVO archiveDataVO, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = archiveDataVO.getCommon();
Map<String, Object> flowUser = archiveDataVO.getFlowUser();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
// 获取流程实例ID
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId).singleResult();
// 获取流程定义ID
String processDefinitionId = processInstance.getProcessDefinitionId();
// 如果是最后一个节点的审批则需要判断是否可以通过
String taskName = taskService.createTaskQuery().taskId(taskId).singleResult().getName();
if (pass && taskName.equals("标准化审批")) {
ProcessEsArchive data = this.getOne(new LambdaQueryWrapper<ProcessEsArchive>()
.eq(ProcessEsArchive::getProcessInstanceId, processInstanceId));
String standardNumber = data.getStandardNumber();
LawsEnterpriseStandard es = esService.getOne(new LambdaQueryWrapper<LawsEnterpriseStandard>()
.eq(LawsEnterpriseStandard::getStandardNumber, standardNumber));
if (StandardStateEnum.ARCHIVE.getStateValue().equals(es.getStandardState())) {
throw new JeroBootException("该标准已封存,需要驳回重新选择");
}
if (StandardStateEnum.ABOLISH.getStateValue().equals(es.getStandardState())) {
throw new JeroBootException("该标准已废止,需要驳回重新选择");
}
}
ProcessEsArchive data = archiveDataVO.getData();
if (data != null) {
updateById(data);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ARCHIVE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
if (flowUser != null) {
Map<String, Object> variables = setVariables(flowUser);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
// 获取执行id
String executionId = task.getExecutionId();
// 设置流程变量
runtimeService.setVariables(executionId, variables);
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(flowUser));
}
// 设置流程变量
runtimeService.setVariable(processInstanceId, "pass", pass);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, userId);
// 删除草稿
actFlowCommonService.removeDraft(commonVO);
// 如果是会签节点,驳回后要将其余节点recode设置为 未处理 状态
if (!pass) {
actFlowCommonService.updateOtherCountersignRecodeStatus(processInstanceId, CounterSignNodeNameConstants.COUNTER_SIGN_NODE_NAME);
}
}
}
@@ -0,0 +1,149 @@
package com.jero.modules.activiti.process.esChange.controller;
import com.jero.common.api.vo.Result;
import com.jero.common.aspect.annotation.AutoLog;
import com.jero.common.aspect.annotation.Translation;
import com.jero.modules.activiti.enums.ProcessTypeEnum;
import com.jero.modules.activiti.process.common.entity.ProcessDraft;
import com.jero.modules.activiti.process.common.entity.TransferVO;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import com.jero.modules.activiti.process.esChange.entity.vo.ESChangeDataVO;
import com.jero.modules.activiti.process.esChange.listener.ProcessESChangeEndListener;
import com.jero.modules.activiti.process.esChange.service.ProcessEsChangeService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
/**
* @author: Mzaxd
* @Date: 2023/10/18 10:44
*/
@Slf4j
@RestController
@Api(tags = "企标更改流程")
@RequestMapping("/process/es/change")
public class ESChangeController {
@Resource
private ProcessEsChangeService changeService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增企标更改流程
*
* @param changeData
*/
@AutoLog(value = "企标更改流程-发起流程")
@ApiOperation(value = "企标更改流程-发起流程", notes = "企标更改流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESChangeDataVO changeData) {
changeService.startProcess(changeData);
return Result.OK();
}
/**
* 保存到待办
*
* @param processInfoVO
*/
@AutoLog(value = "企标更改流程-保存")
@ApiOperation(value = "企标更改流程-保存", notes = "企标更改流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESChangeDataVO> processInfoVO) {
String draftId = changeService.saveToDraft(processInfoVO);
return Result.OK((Object) draftId);
}
/**
* 保存到待办
*
* @param taskId
*/
@AutoLog(value = "企标更改流程-办理")
@ApiOperation(value = "企标更改流程-办理", notes = "企标更改流程-办理")
@GetMapping("/handle/{taskId}")
@Translation
public Result<?> handle(@PathVariable("taskId") String taskId) {
ProcessDraft draft = actFlowCommonService.getExistDraftByTaskId(taskId, ProcessTypeEnum.ES_CHANGE);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(changeService.getHandleData(taskId));
}
/**
* 同意
*
* @param changeData
*/
@AutoLog(value = "企标更改流程-同意")
@ApiOperation(value = "企标更改流程-同意", notes = "企标更改流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESChangeDataVO changeData) {
changeService.approval(changeData, true);
return Result.OK();
}
@AutoLog(value = "企标更改流程-测试修改单生成")
@ApiOperation(value = "企标更改流程-测试修改单生成", notes = "企标更改流程-测试修改单生成", produces = "application/octet-stream")
@PostMapping("/test")
public Result<?> testModifyGen(HttpServletResponse response) throws Exception {
// processESChangeEndListener.genModificationOrder(new ProcessEsChange(), response);
return Result.OK();
}
/**
* 驳回
*
* @param changeData
*/
@AutoLog(value = "企标更改流程-驳回")
@ApiOperation(value = "企标更改流程-驳回", notes = "企标更改流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESChangeDataVO changeData) {
changeService.approval(changeData, false);
return Result.OK();
}
/**
* 转办
*/
@AutoLog(value = "企标更改流程-转办")
@ApiOperation(value = "企标更改流程-转办", notes = "企标更改流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
/**
* 草稿办理
*
* @param draftId
* @param projectId
*/
@AutoLog(value = "企标更改流程-草稿办理")
@ApiOperation(value = "企标更改流程-草稿办理", notes = "企标更改流程-草稿办理")
@GetMapping("/draftHandle")
@Translation
public Result<?> draftHandle(@RequestParam("draftId") @ApiParam("草稿Id") String draftId) {
return Result.OK(actFlowCommonService.getExistDraft(draftId, ProcessTypeEnum.ES_CHANGE));
}
}
@@ -0,0 +1,16 @@
package com.jero.modules.activiti.process.esChange.entity;
public class ESChangeTaskNodeIdConstant {
/** 主起草人发起 */
public static final String MAIN_DRAFT_USER_START = "sid-030A34BF-65B2-460C-BCAB-4BFEE0F77987";
/** 相关人员校对 */
public static final String OTHER_USER_CHECK= "sid-109C6F14-FB23-4A90-A462-F10F344BECD1";
/** 主起草人主管级领导审批 */
public static final String MAIN_DRAFT_LEADER_APPROVAL = "sid-8A8307F2-20BB-423C-80AA-F426F5F612C3";
/** 标准化审批 */
public static final String STANDARDIZATION_APPROVAL = "sid-F0B237E0-1D97-455B-BE15-C3796429B412";
/** 起草人主管级上一级领导审批 */
public static final String MAIN_DRAFT_LEADER_LEADER_APPROVAL = "sid-05CC5BD1-2451-45AF-9453-74AE93D026EF";
}
@@ -0,0 +1,116 @@
package com.jero.modules.activiti.process.esChange.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 企标修改流程意见内容列表
* @TableName process_es_change_opinion
*/
@TableName(value ="process_es_change_opinion")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EsChangeOpinion implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 业务id
*/
@ApiModelProperty(value = "业务id")
private String businessId;
/**
* 条款号
*/
@ApiModelProperty(value = "条款号")
private String clauseNumber;
/**
* 条款名称
*/
@ApiModelProperty(value = "条款名称")
private String clauseName;
/**
* 修改前
*/
@ApiModelProperty(value = "修改前")
private String beforeUpdate;
/**
* 修改后
*/
@ApiModelProperty(value = "修改后")
private String afterUpdate;
/**
* 修改理由
*/
@ApiModelProperty(value = "修改理由")
private String updateReason;
/**
* 提出人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "提出人")
private String createUser;
/**
* 提出部门
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "提出部门")
private String createUnit;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -0,0 +1,15 @@
package com.jero.modules.activiti.process.esChange.entity;
/**
* @author: Mzaxd
* @Date: 2023/10/27 7:32
*/
public class EsChangeTaskNameConstant {
public static final String MAIN_DRAFTER_INIT = "主起草人发起";
public static final String RELATED_USER_CHECK = "相关人员校对";
public static final String MAIN_DRAFTER_LEADER_APPROVAL = "主起草人主管级领导审批";
public static final String STANDARDIZATION_APPROVAL = "标准化审批";
public static final String MAIN_DRAFTER_LEADER_LEADER_APPROVAL = "起草人主管级上一级领导审批";
}
@@ -0,0 +1,306 @@
package com.jero.modules.activiti.process.esChange.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.jero.common.aspect.annotation.Dict;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 企业标准
* @TableName process_es_change
*/
@TableName(value ="process_es_change")
@Data
public class ProcessEsChange implements Serializable {
/**
* 主键ID
*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/**
* 创建人
*/
@ApiModelProperty(value = "创建人")
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "创建时间")
private Date createTime;
/**
* 更新人
*/
@ApiModelProperty(value = "更新人")
private String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "更新时间")
private Date updateTime;
/**
* 所属部门
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "所属部门")
private String orgCode;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 企标Id
*/
@ApiModelProperty(value = "企标Id")
private String standardId;
/**
* 企标编号
*/
@ApiModelProperty(value = "企标编号")
private String standardNumber;
/**
* 企标名称
*/
@ApiModelProperty(value = "企标名称")
private String standardName;
/**
* 企标体系
*/
@ApiModelProperty(value = "企标体系")
private String standardSystem;
/**
* 企标类型
*/
@ApiModelProperty(value = "企标类型")
private String standardCategory;
/**
* 标准等级分类
*/
@ApiModelProperty(value = "标准等级分类")
private String gradeClassification;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String standardEnglishName;
/**
* 发布日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "发布日期")
private Date releaseDate;
/**
* 实施日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "实施日期")
private Date implementationDate;
/**
* 是否试行(0代表不试行,1代表试行)
*/
@ApiModelProperty(value = "是否试行(0代表不试行,1代表试行)")
private String tryFlag;
/**
* 试行周期
*/
@ApiModelProperty(value = "试行周期")
private String trialPeriod;
/**
* 零部件名称
*/
@Dict(dictTable = "laws_part_name", dicCode = "code", dicText = "name")
@ApiModelProperty(value = "零部件名称")
private String partName;
/**
* 主起草人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "主起草人")
private String mainDraftingUser;
/**
* 主起草单位
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "主起草单位")
private String mainDraftingUnit;
/**
* 标准适用范围
*/
@ApiModelProperty(value = "标准适用范围")
private String standardScope;
/**
* 代替标准号
*/
@ApiModelProperty(value = "代替标准号")
private String substituteStandardNumber;
/**
* 引用标准
*/
@ApiModelProperty(value = "引用标准")
private String referenceStandard;
/**
* 关联文件
*/
@ApiModelProperty(value = "关联文件")
private String associatedFile;
/**
* 采标程度
*/
@ApiModelProperty(value = "采标程度")
private String acquisitionDegree;
/**
* 采用国际标准号
*/
@ApiModelProperty(value = "采用国际标准号")
private String internationalStandardNum;
/**
* 授权部门
*/
@ApiModelProperty(value = "授权部门")
private String authDept;
/**
* 授权部门
*/
@ApiModelProperty(value = "更改级别代号")
@Dict(dicCode = "change_level_code")
private String levelCode;
/**
* 有无二维或三维图
*/
@ApiModelProperty(value = "有无二维或三维图")
private String has2d3dGraph;
/**
* 顾客确认
*/
@ApiModelProperty(value = "顾客确认")
private String customerConfirmation;
/**
* 刷新文件号
*/
@ApiModelProperty(value = "刷新文件号")
private String refreshFileNumber;
/**
* 库存
*/
@ApiModelProperty(value = "库存")
private String inventory;
/**
* 在制品
*/
@ApiModelProperty(value = "在制品")
private String workInProgress;
/**
* 备件
*/
@ApiModelProperty(value = "备件")
private String spareParts;
/**
* 关联更改项
*/
@ApiModelProperty(value = "关联更改项")
private String relatedChanges;
/**
* 更改标记
*/
@ApiModelProperty(value = "更改标记")
private String changeTag;
/**
* 处数
*/
@ApiModelProperty(value = "处数")
private String treatmentCount;
/**
* 生效日期
*/
@ApiModelProperty(value = "生效日期")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date effectiveDate;
/**
* 更改单号
*/
@ApiModelProperty(value = "更改单号")
private String modifyOrderNum;
/**
* 在线编辑文件id
*/
@ApiModelProperty(value = "在线编辑文件id")
private String onEditFile;
/**
* 需要替换的fileId
*/
@ApiModelProperty(value = "需要替换的fileId")
private String replaceFileId;
/**
* 修改意见内容列表
*/
@TableField(exist = false)
private List<EsChangeOpinion> list;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -0,0 +1,26 @@
package com.jero.modules.activiti.process.esChange.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import lombok.Data;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 8:13
*/
@Data
public class ESChangeDataVO {
@JsonProperty("common")
CommonVO common;
@JsonProperty("data")
ProcessEsChange data;
@JsonProperty("flowUser")
Map<String, Object> flowUser;
}
@@ -0,0 +1,442 @@
package com.jero.modules.activiti.process.esChange.listener;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.api.CommonAPI;
import com.jero.common.api.vo.Result;
import com.jero.common.exception.JeroBootException;
import com.jero.common.system.vo.DictModel;
import com.jero.common.system.vo.SysDictItemCore;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion;
import com.jero.modules.activiti.process.esChange.entity.EsChangeTaskNameConstant;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import com.jero.modules.activiti.process.esChange.service.EsChangeOpinionService;
import com.jero.modules.activiti.process.esChange.service.ProcessEsChangeService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import com.jero.modules.activiti.util.ExcelUtils;
import com.jero.modules.laws.common.constant.FieldCommon;
import com.jero.modules.laws.common.service.ILawsCommonService;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.onlyoffice.service.IBusProcessModelHisService;
import com.jero.modules.oss.entity.OSSFile;
import com.jero.modules.oss.service.IOSSFileService;
import com.jero.modules.system.controller.CommonController;
import com.jero.modules.system.entity.SysDepart;
import com.jero.modules.system.service.*;
import com.jero.modules.tag.enums.TableNameEnum;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.apache.poi.xwpf.usermodel.*;
import org.springframework.core.io.ClassPathResource;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.mock.web.MockMultipartHttpServletRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.nio.file.Files;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESChangeEndListener implements ExecutionListener {
/**
* 企标更改流程结束之后需要把数据存入企标数据库
* @param delegateExecution
*/
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private ProcessEsChangeService esChangeService;
@Resource
private ILawsCommonService commonService;
@Resource
private ISysDepartService sysDepartService;
@Resource
private ISysDictService dictService;
@Resource
private ProcessApprovalRecordService approvalRecordService;
@Resource
private CommonController commonController;
@Resource
private IOSSFileService ossFileService;
@Resource
private EsChangeOpinionService changeOpinionService;
@Resource
private ExcelUtils excelUtils;
@Resource
private CommonAPI commonAPI;
@Resource
private IBusProcessModelHisService busProcessModelHisService;
@Resource
private ILawsCommonService lawsCommonService;
private static final String MODULE_VALUE = TableNameEnum.ENTERPRISE_STANDARDS.getValue();
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标更改流程结束 监听执行器开始执行");
// 找到流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsChange> changeLambdaQueryWrapper = new LambdaQueryWrapper<>();
changeLambdaQueryWrapper.eq(ProcessEsChange::getProcessInstanceId, processInstanceId);
ProcessEsChange change = esChangeService.getOne(changeLambdaQueryWrapper);
String standNo = change.getStandardNumber();
log.info("企标更改流程结束 监听执行器开始执行,企标编号为:{}", standNo);
// 根据标准编号找到标准Id
LawsEnterpriseStandard es = esService.getOne(new LambdaQueryWrapper<LawsEnterpriseStandard>()
.eq(LawsEnterpriseStandard::getStandardNumber, standNo));
Map<String, Object> esDataMap = lawsCommonService.getByIdAndModule(es.getId(), MODULE_VALUE, "2", null);
// 转换成Map 然后走commonEdit接口
Map<String, Object> parameterMap = new HashMap<>();
this.buildMap(parameterMap, change);
String onEditFileId = change.getOnEditFile();
String replaceFileId = change.getReplaceFileId();
if (StrUtil.isNotBlank(onEditFileId)) {
if (StrUtil.isNotBlank(replaceFileId)) {
busProcessModelHisService.replaceFile(onEditFileId, replaceFileId);
} else {
String fileId = busProcessModelHisService.saveProcessFileToOss(onEditFileId);
String existFileIds = (String) esDataMap.get(FieldCommon.FILE_PUBLISH_OF_ORIGINAL);
if (StrUtil.isNotBlank(existFileIds)) {
fileId += "," + existFileIds;
}
parameterMap.put(FieldCommon.FILE_PUBLISH_OF_ORIGINAL, fileId);
}
}
// 保存修改的文件
commonService.commonEdit(parameterMap);
// 生成修改单号
this.genModificationOrderNumber(change);
esChangeService.updateById(change);
// 生成修改单
try {
this.genModificationOrder(change);
} catch (Exception e) {
log.error("生成企标编号为{}的更改单失败", es.getStandardNumber());
log.error(e.getMessage());
throw new JeroBootException("生成企标编号为" + es.getStandardNumber() + "的更改单失败");
}
log.info("企标更改流程监听执行器执行结束");
}
public void genModificationOrder(ProcessEsChange change) throws Exception {
String esNo = change.getStandardNumber();
ClassPathResource resource = new ClassPathResource("wordTemplate/企标更改单模板.docx");
// 使用ClassPathResource来读取模板文件
try (InputStream fis = resource.getInputStream()) {
XWPFDocument document = new XWPFDocument(fis);
// 获取并修改文档中的表格
List<XWPFTable> tables = document.getTables();
if (!tables.isEmpty()) {
XWPFTable firstTable = tables.get(0);
setFirstTableContents(firstTable, change);
}
// 循环遍历所有页脚
for (XWPFFooter footer : document.getFooterList()) {
// 获取页脚中的所有表格
List<XWPFTable> footerTables = footer.getTables();
// 假设您想要修改第一个表格
if (!footerTables.isEmpty()) {
XWPFTable footerTable = footerTables.get(0);
// 在这里调用您的方法来修改页脚中的表格
setSecondTableContents(footerTable, change);
}
}
// 创建临时文件
String fileName = change.getModifyOrderNum() + "-" + esNo + "标准更改单";
fileName = fileName.replaceAll("/", "");
File tempFile = Files.createTempFile(fileName, ".docx").toFile();
// 将更改写入临时文件
try (FileOutputStream fos = new FileOutputStream(tempFile)) {
document.write(fos);
}
// 将文件作为MultipartFile封装
MultipartFile multipartFile = new MockMultipartFile(
"file", // 表单字段名称
tempFile.getName(), // 文件名
"application/vnd.openxmlformats-officedocument.wordprocessingml.document", // 内容类型
Files.newInputStream(tempFile.toPath()) // 文件内容
);
// 创建模拟的MultipartHttpServletRequest
MockMultipartHttpServletRequest mockRequest = new MockMultipartHttpServletRequest();
mockRequest.addFile(multipartFile); // 添加文件
mockRequest.addParameter("biz", "temp"); // 添加其他表单字段
// 调用上传接口
Result<OSSFile> result = commonController.upload(mockRequest, new MockHttpServletResponse());
OSSFile file = result.getResult();
file.setStandardFileType(FieldCommon.FILE_MODIFICATION_LIST);
file.setStandardNumber(esNo);
file.setStandardId(change.getStandardId());
file.setFileName(fileName.substring(0, fileName.lastIndexOf("标准更改单") + 5) + ".docx");
ossFileService.updateById(file);
// 删除临时文件
boolean delete = tempFile.delete();
}
}
private void writeToResponse(HttpServletResponse response, File file) throws IOException {
response.setContentType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
response.setHeader("Content-Disposition", "attachment; filename=" + file.getName());
try (OutputStream out = response.getOutputStream(); FileInputStream fis = new FileInputStream(file)) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
}
}
private void setFirstTableContents(XWPFTable table, ProcessEsChange change) {
List<EsChangeOpinion> opinions = changeOpinionService.list(new LambdaQueryWrapper<EsChangeOpinion>()
.eq(EsChangeOpinion::getBusinessId, change.getId()));
List<String> changeReasonList = opinions.stream().map(EsChangeOpinion::getUpdateReason).collect(Collectors.toList());
List<String> beforeUpdateList = opinions.stream().map(EsChangeOpinion::getBeforeUpdate).collect(Collectors.toList());
List<String> afterUpdateList = opinions.stream().map(EsChangeOpinion::getAfterUpdate).collect(Collectors.toList());
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
// 获取表格的行列表
List<XWPFTableRow> rows = table.getRows();
if (!rows.isEmpty()) {
// 图样文件代号
setContent(rows, 1, 0, change.getStandardNumber(), false, false, false);
// 图样(文件)更改通知单号
setContent(rows, 1, 1, change.getModifyOrderNum(), false, false, false);
// 名称
setContent(rows, 2, 0, change.getStandardName(), false, false, false);
// 更改级别代号
setContent(rows, 2, 1, change.getLevelCode(), false, false, false);
// 有无二维或三维图
setContent(rows, 3, 1, change.getHas2d3dGraph(), false, false, false);
// 更改理由(依据)
setContentList(rows, 4, 0, changeReasonList);
// 更改前
setContentList(rows, 5, 0, beforeUpdateList);
// 更改后
setContentList(rows, 5, 1, afterUpdateList);
// 顾客确认(适用军品)
setContent(rows, 6, 0, change.getCustomerConfirmation(), true, false, false);
// 刷新文件号(三维)
setContent(rows, 6, 1, change.getRefreshFileNumber(), true, false, false);
// 关联更改项
setContent(rows, 7, 1, change.getRelatedChanges(), true, false, false);
// 库存
setContent(rows, 8, 1, change.getInventory(), false, true, true);
// 在制品
setContent(rows, 9, 1, change.getWorkInProgress(), false, true, true);
// 备件
setContent(rows, 10, 1, change.getSpareParts(), false, true, true);
// 更改标记
setContent(rows, 11, 1, change.getChangeTag(), false, true, true);
// 处数
setContent(rows, 11, 3, change.getTreatmentCount(), false, true, true);
// 生效日期
setContent(rows, 11, 5, formatter.format(change.getEffectiveDate()), false, true, true);
}
}
private void setContentList(List<XWPFTableRow> rows, int rowNum, int cellNum, List<String> contentList) {
for (String content : contentList) {
if (StrUtil.isBlank(content)) {
continue;
}
setContent(rows, rowNum, cellNum, content, true, false, false);
}
}
private void genModificationOrderNumber(ProcessEsChange change) {
String deptCode = "";
// 找到单位代号
String deptId = change.getMainDraftingUnit();
SysDepart dept = sysDepartService.getById(deptId);
if (dept != null) {
String deptName = dept.getDepartName();
List<DictModel> dictItems = dictService.queryEnableDictItemsByCode("es_modify_order_dept_code");
for (DictModel dictItem : dictItems) {
if (dictItem.getText().equals(deptName)) {
deptCode = dictItem.getValue();
break;
}
}
}
if (StrUtil.isBlank(deptCode)) {
throw new JeroBootException("生成修改单失败,找不到主起草单位的单位代号,请前往数据字典中添加后再试");
}
// 找到年份
Date effectiveDate = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy");
String year = formatter.format(effectiveDate);
// 找到月份
formatter = new SimpleDateFormat("MM");
String month = formatter.format(effectiveDate);
// 获取顺序号
LambdaQueryWrapper<ProcessEsChange> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(ProcessEsChange::getModifyOrderNum, "B" + deptCode + year + month);
queryWrapper.orderByDesc(ProcessEsChange::getModifyOrderNum);
List<ProcessEsChange> changes = esChangeService.list(queryWrapper);
String modifyOrderNum;
if (changes.isEmpty()) {
modifyOrderNum = "B" + deptCode + year + month + "001";
change.setModifyOrderNum(modifyOrderNum);
return;
}
String lastModifyOrderNum = changes.get(0).getModifyOrderNum().substring(9);
String newModifyOrderNum = String.format("%03d", Integer.parseInt(lastModifyOrderNum) + 1);
modifyOrderNum = "B" + deptCode + year + month + newModifyOrderNum;
change.setModifyOrderNum(modifyOrderNum);
}
private void setSecondTableContents(XWPFTable table, ProcessEsChange change) {
List<SysDictItemCore> listDict = commonAPI.getDictItemAll();
// 找到所有节点审批记录
LambdaQueryWrapper<ProcessApprovalRecord> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ProcessApprovalRecord::getProcessInstanceId, change.getProcessInstanceId());
List<ProcessApprovalRecord> records = approvalRecordService.list(queryWrapper);
Map<String, List<ProcessApprovalRecord>> userMap = records.stream()
.collect(Collectors.groupingBy(ProcessApprovalRecord::getTaskName));
// 获取表格的行列表
List<XWPFTableRow> rows = table.getRows();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
if (!rows.isEmpty()) {
List<ProcessApprovalRecord> recordListOne = userMap.get(EsChangeTaskNameConstant.MAIN_DRAFTER_INIT);
List<ProcessApprovalRecord> recordListTwo = userMap.get(EsChangeTaskNameConstant.RELATED_USER_CHECK);
List<ProcessApprovalRecord> recordListThree = userMap.get(EsChangeTaskNameConstant.MAIN_DRAFTER_LEADER_APPROVAL);
List<ProcessApprovalRecord> recordListFour = userMap.get(EsChangeTaskNameConstant.STANDARDIZATION_APPROVAL);
List<ProcessApprovalRecord> recordListFive = userMap.get(EsChangeTaskNameConstant.MAIN_DRAFTER_LEADER_LEADER_APPROVAL);
recordListOne = recordListOne.stream().sorted((o1, o2) -> o2.getEndTime().compareTo(o1.getEndTime())).collect(Collectors.toList());
recordListTwo = recordListTwo.stream().sorted((o1, o2) -> o2.getEndTime().compareTo(o1.getEndTime())).collect(Collectors.toList());
recordListThree = recordListThree.stream().sorted((o1, o2) -> o2.getEndTime().compareTo(o1.getEndTime())).collect(Collectors.toList());
recordListFour = recordListFour.stream().sorted((o1, o2) -> o2.getEndTime().compareTo(o1.getEndTime())).collect(Collectors.toList());
recordListFive = recordListFive.stream().sorted((o1, o2) -> o2.getEndTime().compareTo(o1.getEndTime())).collect(Collectors.toList());
ProcessApprovalRecord recordOne = recordListOne.get(0);
ProcessApprovalRecord recordTwo = recordListTwo.get(0);
ProcessApprovalRecord recordThree = recordListThree.get(0);
ProcessApprovalRecord recordFour = recordListFour.get(0);
ProcessApprovalRecord recordFive = recordListFive.get(0);
String recordOneUser = excelUtils.translateDictValue("id", "CONCAT(realname, '(', username, ')')", "sys_user", recordOne.getUserId(), listDict);
String recordTwoUser = excelUtils.translateDictValue("id", "CONCAT(realname, '(', username, ')')", "sys_user", recordTwo.getUserId(), listDict);
String recordThreeUser = excelUtils.translateDictValue("id", "CONCAT(realname, '(', username, ')')", "sys_user", recordThree.getUserId(), listDict);
String recordFourUser = excelUtils.translateDictValue("id", "CONCAT(realname, '(', username, ')')", "sys_user", recordFour.getUserId(), listDict);
String recordFiveUser = excelUtils.translateDictValue("id", "CONCAT(realname, '(', username, ')')", "sys_user", recordFive.getUserId(), listDict);
// 设计
setContent(rows, 0, 1, recordOneUser, false, true, true);
setContent(rows, 1, 1, formatter.format(recordOne.getEndTime()), false, true, true);
// 校对
setContent(rows, 0, 3, recordTwoUser, false, true, true);
setContent(rows, 1, 3, formatter.format(recordTwo.getEndTime()), false, true, true);
// 审核
setContent(rows, 0, 5, recordThreeUser, false, true, true);
setContent(rows, 1, 5, formatter.format(recordThree.getEndTime()), false, true, true);
// 标准化
setContent(rows, 0, 7, recordFourUser, false, true, true);
setContent(rows, 1, 7, formatter.format(recordFour.getEndTime()), false, true, true);
// 批准
setContent(rows, 0, 11, recordFiveUser, false, true, true);
setContent(rows, 1, 11, formatter.format(recordFive.getEndTime()), false, true, true);
}
}
private void setContent(List<XWPFTableRow> rows, int rowNum, int cellNum, String content,
boolean newLine, boolean alignCenter, boolean verCenter) {
if (StrUtil.isBlank(content)) {
return;
}
XWPFTableRow row = rows.get(rowNum);
List<XWPFTableCell> cells = row.getTableCells();
if (!cells.isEmpty()) {
XWPFTableCell cell = cells.get(cellNum);
XWPFParagraph paragraph;
if (newLine) {
paragraph = cell.addParagraph();
} else {
paragraph = cell.getParagraphs().get(0);
}
XWPFRun run = paragraph.createRun();
// 设置段落居中(水平)
if (alignCenter) {
paragraph.setAlignment(ParagraphAlignment.CENTER);
}
run.setText(content);
run.setFontSize(12);
run.setFontFamily("新宋体");
// 设置单元格垂直居中
if (verCenter) {
cell.setVerticalAlignment(XWPFTableCell.XWPFVertAlign.CENTER);
}
}
}
private void buildMap(Map<String, Object> parameterMap, ProcessEsChange change) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
parameterMap.put(FieldCommon.MODULE, TableNameEnum.ENTERPRISE_STANDARDS.getValue());
parameterMap.put(FieldCommon.ID, change.getStandardId());
parameterMap.put(FieldCommon.STANDARD_NUMBER, change.getStandardNumber());
parameterMap.put(FieldCommon.STANDARD_NAME, change.getStandardName());
parameterMap.put(FieldCommon.GRADE_CLASSIFICATION, change.getGradeClassification());
parameterMap.put(FieldCommon.AUTH_DEPT, change.getAuthDept());
parameterMap.put(FieldCommon.STANDARD_SYSTEM, change.getStandardSystem());
parameterMap.put(FieldCommon.STANDARD_ENGLISH_NAME, change.getStandardEnglishName());
parameterMap.put(FieldCommon.IMPLEMENTATION_DATE, formatter.format(change.getImplementationDate()));
parameterMap.put(FieldCommon.PART_NAME, change.getPartName());
parameterMap.put(FieldCommon.MAIN_DRAFT_USER, change.getMainDraftingUser());
parameterMap.put(FieldCommon.MAIN_DRAFTING_UNIT, change.getMainDraftingUnit());
parameterMap.put(FieldCommon.STANDARD_SCOPE, change.getStandardScope());
parameterMap.put(FieldCommon.REPLACED_STANDARD, change.getSubstituteStandardNumber());
parameterMap.put(FieldCommon.REFERENCE_STANDARD, change.getReferenceStandard());
parameterMap.put(FieldCommon.ASSOCIATED_FILE, change.getAssociatedFile());
parameterMap.put(FieldCommon.ACQUISITION_DEGREE, change.getAcquisitionDegree());
parameterMap.put(FieldCommon.INTERNATIONAL_STANDARD_NUM, change.getInternationalStandardNum());
// 是否试行
Date releaseDate = change.getReleaseDate();
boolean tryFlag = !change.getTryFlag().equals("0");
String trialPeriod = change.getTrialPeriod();
if (tryFlag) {
parameterMap.put(FieldCommon.TRY_FLAG, change.getTryFlag());
parameterMap.put(FieldCommon.STANDARD_STATE, StandardStateEnum.TRIAL_OPERATION.getStateValue());
parameterMap.put(FieldCommon.TRIAL_PERIOD,trialPeriod);
}
parameterMap.put(FieldCommon.RELEASE_DATE, formatter.format(releaseDate));
}
}

Some files were not shown because too many files have changed in this diff Show More