From e86cb2566117bd143a26aaae88d7d51889bc39ae Mon Sep 17 00:00:00 2001 From: yjz <3131811435@qq.com> Date: Fri, 5 Jul 2024 11:16:49 +0800 Subject: [PATCH] =?UTF-8?q?fix(=E6=A0=87=E5=87=86=E8=A7=A3=E8=AF=BB?= =?UTF-8?q?=E6=B5=81=E7=A8=8B):=20=E5=9F=BA=E7=A1=80=E6=80=A7=E8=B0=83?= =?UTF-8?q?=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../activiti/enums/ProcessTypeEnum.java | 24 +- .../process/aspect/ProcessAspect.java | 373 ++++++++++++++++++ .../process/common/utility/FlowUtility.java | 76 ++++ .../StandardInterpretFlowController.java | 38 ++ ...ProcessStandardInterpretClauseSublist.java | 7 +- .../service/StandardInterpretFlowService.java | 14 + .../service/impl/StandardInterpretFlow.java | 47 +++ .../StandardInterpretFlowServiceImpl.java | 167 +++++++- .../standardinterpret/vo/FlowApproveInfo.java | 28 ++ 9 files changed, 734 insertions(+), 40 deletions(-) create mode 100644 laws-modules/src/main/java/com/jero/modules/activiti/process/aspect/ProcessAspect.java create mode 100644 laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlow.java create mode 100644 laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/vo/FlowApproveInfo.java diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/enums/ProcessTypeEnum.java b/laws-modules/src/main/java/com/jero/modules/activiti/enums/ProcessTypeEnum.java index c07fe55b..1d44120a 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/enums/ProcessTypeEnum.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/enums/ProcessTypeEnum.java @@ -11,28 +11,8 @@ import lombok.Getter; @AllArgsConstructor public enum ProcessTypeEnum { DEMO("测试流程", 0, "com.jero.modules.activiti.process.demo.service.ProcessDemoService", "/workCenter/StandardEntryOrChangeProcess", "/workCenter/StandardEntryOrChangeProcess"), - 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"), - STANDARD_COMPLIANCE_CHECK("法规符合性排查流程", 4, "com.jero.modules.activiti.process.standardComplianceCheck.service.ProcessStandardComplianceCheckService", "/workCenter/StandardComplianceCheckProcess", "/workCenter/StandardComplianceCheckProcess"), - 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"); + STANDARD_INTERPRET("标准解读流程", 2, "com.jero.modules.activiti.process.standardinterpret.service.impl.StandardInterpretFlow", "", ""), + ; private final String name; private final Integer value; diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/aspect/ProcessAspect.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/aspect/ProcessAspect.java new file mode 100644 index 00000000..a93ea27d --- /dev/null +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/aspect/ProcessAspect.java @@ -0,0 +1,373 @@ +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.VariableTypeEnum; +import com.jero.modules.activiti.process.common.entity.ProcessDraft; +import com.jero.modules.activiti.process.common.service.ProcessDraftService; +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 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 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 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 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() + .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 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 stringObjectMap = JSON.parseObject(JSON.toJSONString(objectMap), Map.class); + // 特殊节点排除 + if ((stringObjectMap.containsKey("pass") && !(boolean) stringObjectMap.get("pass"))){ + // 驳回的节点 + List processApprovalRecordList = processApprovalRecordService.list( + new LambdaQueryWrapper() + .eq(ProcessApprovalRecord::getProcessInstanceId, processAll.getProcessInstanceId()) + .orderByDesc(ProcessApprovalRecord::getCreateTime)); + if (!processApprovalRecordList.isEmpty()){ + ProcessApprovalRecord processApprovalRecord = processApprovalRecordList.get(0); + processApprovalRecordList.remove(0); + Optional 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() + .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 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() + .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() + .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 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() + .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() + .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() +// .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 = 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(); + } +} diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/common/utility/FlowUtility.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/common/utility/FlowUtility.java index 32414e89..d2153536 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/process/common/utility/FlowUtility.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/common/utility/FlowUtility.java @@ -1,22 +1,29 @@ package com.jero.modules.activiti.process.common.utility; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.toolkit.StringUtils; import com.jero.common.exception.JeroBootException; import com.jero.common.system.vo.LoginUser; +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.enums.FinishFlagEnum; +import com.jero.modules.activiti.process.common.entity.ProcessDraft; +import com.jero.modules.activiti.process.common.service.ProcessDraftService; +import com.jero.modules.activiti.process.standardinterpret.vo.FlowApproveInfo; import com.jero.modules.activiti.service.ProcessAllService; import com.jero.modules.activiti.service.ProcessApprovalRecordService; import lombok.RequiredArgsConstructor; import org.apache.shiro.SecurityUtils; +import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import java.util.Date; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.stream.Collectors; /** @@ -33,6 +40,7 @@ public class FlowUtility { private final ProcessAllService processAllService; private final ProcessApprovalRecordService processApprovalRecordService; + private final ProcessDraftService processDraftService; public void flowApprovalUpdate(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord){ LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); @@ -51,6 +59,74 @@ public class FlowUtility { .set(ProcessApprovalRecord::getEndTime, new Date())); } + public void flowSaveUpdate(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord){ + // 更新流程信息 + processAllService.update(new LambdaUpdateWrapper() + .eq(ProcessAll::getId, processAll.getId()) + .set(ProcessAll::getPrcName, processAll.getPrcName()) + .set(ProcessAll::getPrcMes, processAll.getPrcMes()) + .set(ProcessAll::getDueTime, processAll.getDueTime())); + // 更新流程审批信息 + processApprovalRecordService.update(new LambdaUpdateWrapper() + .eq(ProcessApprovalRecord::getTaskId, processAll.getTaskId()) + .set(ProcessApprovalRecord::getCommitText, processApprovalRecord.getCommitText()) + .set(ProcessApprovalRecord::getCommitFile, processApprovalRecord.getCommitFile())); + } + + public FlowApproveInfo queryFlowApproveInfo(String projectId, String taskId){ + FlowApproveInfo flowApproveInfo = new FlowApproveInfo(); + LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + ProcessAll processAll = processAllService.getOne(new LambdaQueryWrapper() + .eq(ProcessAll::getProjectId, projectId) + .orderByDesc(ProcessAll::getCreateTime), false); + ProcessApprovalRecord processApprovalRecord = new ProcessApprovalRecord(); + // 是否存在草稿 + List processDraftList = processDraftService.list(new LambdaQueryWrapper() + .eq(ProcessDraft::getProjectId, projectId) + .eq(ProcessDraft::getUserId, loginUser.getId()) + .and(qw -> qw.ne(ProcessDraft::getSaveSource, "3") + .or().isNull(ProcessDraft::getSaveSource))); + if (!processDraftList.isEmpty()){ + String id = ""; + if(Objects.isNull(processAll)){ + processAll = new ProcessAll(); + id = String.valueOf(SnowflakeUtils.snowflake()); + }else { + id = processAll.getId(); + } + // 存在草稿 + ProcessDraft processDraft = processDraftList.get(0); + // 属性拷贝 + BeanUtils.copyProperties(processDraft, processAll); + processAll.setId(id); + if (StringUtils.isNotBlank(processDraft.getHandleFile())){ + processApprovalRecord.setCommitFile(processDraft.getHandleFile()); + } + if (StringUtils.isNotBlank(processDraft.getHandleText())){ + processApprovalRecord.setCommitText(processDraft.getHandleText()); + } + if (!Objects.isNull(processDraft.getProcessDueDate())){ + processAll.setDueTime(processDraft.getProcessDueDate()); + } + if (StringUtils.isNotBlank(processDraft.getProcessDescription())){ + processAll.setPrcMes(processDraft.getProcessDescription()); + } + if (StringUtils.isNotBlank(processDraft.getInfoJsonStr())){ + flowApproveInfo.setInfoJsonStr(processDraft.getInfoJsonStr()); + } + }else { + // 不存在草稿 + processApprovalRecord = processApprovalRecordService.getOne(new LambdaQueryWrapper() + .eq(ProcessApprovalRecord::getUserId, loginUser.getId()) + .eq(ProcessApprovalRecord::getTaskId, taskId) + , false); + } + + flowApproveInfo.setProcessAll(processAll); + flowApproveInfo.setProcessApprovalRecord(processApprovalRecord); + return flowApproveInfo; + } + /** * 将Map中值为List类型的元素转换为以逗号分隔的字符串。 * 这样做的目的是为了简化Map的表示，尤其是当List中包含多个元素时。 diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/controller/StandardInterpretFlowController.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/controller/StandardInterpretFlowController.java index 1fa6665d..496e6f57 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/controller/StandardInterpretFlowController.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/controller/StandardInterpretFlowController.java @@ -62,6 +62,19 @@ public class StandardInterpretFlowController { return Result.OK(MessageUtils.getMessage(ResultCommon.OK)); } + /** + * 标准解读流程-流程保存 + * @param standardInterpretFlowDTO 标准解读流程对象 + * @return 结果对象 + */ + @AutoLog(value = "标准解读流程-流程保存") + @ApiOperation(value="标准解读流程-流程保存", notes="标准解读流程-流程保存") + @PostMapping(value = "/flowSave") + public Result flowSave(@RequestBody StandardInterpretFlowDTO standardInterpretFlowDTO) { + standardInterpretFlowService.flowSave(standardInterpretFlowDTO); + return Result.OK(MessageUtils.getMessage(ResultCommon.OK)); + } + /** * 标准解读流程-流程审批 * @param standardInterpretFlowDTO 标准解读流程对象 @@ -89,6 +102,31 @@ public class StandardInterpretFlowController { return Result.OK(standardInterpretFlowService.queryDetail(projectId, taskId)); } + /** + * 标准解读流程-驳回 + * @param standardInterpretFlowDTO 标准解读流程对象 + * @return 结果对象 + */ + @AutoLog(value = "标准解读流程-驳回") + @ApiOperation(value="标准解读流程-驳回", notes="标准解读流程-驳回") + @PostMapping(value = "/flowReject") + public Result flowReject(@RequestBody StandardInterpretFlowDTO standardInterpretFlowDTO) { + standardInterpretFlowService.flowApproval(standardInterpretFlowDTO); + return Result.OK(MessageUtils.getMessage(ResultCommon.OK)); + } + + /** + * 标准解读流程-流程转办 + * @return 结果对象 + */ + @AutoLog(value = "标准解读流程-流程转办") + @ApiOperation(value="标准解读流程-流程转办", notes="标准解读流程-流程转办") + @GetMapping(value = "/flowTransfer") + public Result flowTransfer(@ApiParam("任务id") String taskId, @ApiParam("用户id") String userId) { + standardInterpretFlowService.flowTransfer(taskId, userId); + return Result.OK(MessageUtils.getMessage(ResultCommon.OK)); + } + /** * 标准解读流程-生成项目id * @return 项目id diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/entity/ProcessStandardInterpretClauseSublist.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/entity/ProcessStandardInterpretClauseSublist.java index cd0fedb8..6ae8f5ae 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/entity/ProcessStandardInterpretClauseSublist.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/entity/ProcessStandardInterpretClauseSublist.java @@ -50,9 +50,12 @@ public class ProcessStandardInterpretClauseSublist extends BaseEntity { /**法规注释*/ @ApiModelProperty(value = "法规注释") private String regulatoryNotes; - /**关键词*/ - @ApiModelProperty(value = "关键词") + /**涉及系统/部件）*/ + @ApiModelProperty(value = "涉及系统/部件）") private String keywords; + /**涉及系统/部件）*/ + @ApiModelProperty(value = "关键控制器）") + private String keyController; /**适用零部件*/ @ApiModelProperty(value = "适用零部件") private String applicableComponents; diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/StandardInterpretFlowService.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/StandardInterpretFlowService.java index 3f2a7f3b..60f11576 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/StandardInterpretFlowService.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/StandardInterpretFlowService.java @@ -40,6 +40,20 @@ public interface StandardInterpretFlowService { */ void flowApproval(StandardInterpretFlowDTO standardInterpretFlowDTO); + + /** + * 流程保存 + * @param standardInterpretFlowDTO + */ + void flowSave(StandardInterpretFlowDTO standardInterpretFlowDTO); + + /** + * 流程转办 + * @param taskId + * @param userId + */ + void flowTransfer(String taskId, String userId); + /** * 流程监听 * @param delegateTask diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlow.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlow.java new file mode 100644 index 00000000..3313f092 --- /dev/null +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlow.java @@ -0,0 +1,47 @@ +package com.jero.modules.activiti.process.standardinterpret.service.impl; + +import com.jero.common.exception.JeroBootException; +import com.jero.modules.activiti.entity.ProcessAll; +import com.jero.modules.activiti.entity.ProcessApprovalRecord; +import com.jero.modules.activiti.service.ProcessAllService; +import com.jero.modules.activiti.service.WorkCenterService; +import com.jero.modules.activiti.util.SpringContextUtil; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +/** + * @ClassName: EsInspectPlanFlowService + * @Description: + * @Author: yjz + * @Date: 2024-01-11 21:19 + * @Version: 1.0 + **/ +@Slf4j +@Transactional(rollbackFor = {Exception.class, JeroBootException.class}) +@Service +public class StandardInterpretFlow implements WorkCenterService { + /** + * 强制撤回 + * @param processAll 流程总表 + */ + @Override + public void changeToDraft(ProcessAll processAll) { + // 删除业务表数据 + ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class); + processAllService.physicalDeleteByProjectId("process_standard_interpret", processAll.getProjectId()); + } + + /** + * 转办 + * @param processAll + * @param processApprovalRecord + * @param toUserId + * @param userId + */ + @Override + public void handleTransfer(ProcessAll processAll, ProcessApprovalRecord processApprovalRecord, String toUserId, String userId) { + ProcessAllService processAllService = SpringContextUtil.getBean(ProcessAllService.class); + processAllService.specialTransfer(processAll, processApprovalRecord, toUserId, userId); + } +} diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlowServiceImpl.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlowServiceImpl.java index 7096e46a..bd8e973a 100644 --- a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlowServiceImpl.java +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/service/impl/StandardInterpretFlowServiceImpl.java @@ -16,6 +16,7 @@ import com.jero.modules.activiti.enums.FinishFlagEnum; import com.jero.modules.activiti.enums.ProcessStatusEnum; import com.jero.modules.activiti.process.common.enums.ProcessType; import com.jero.modules.activiti.process.common.utility.FlowUtility; +import com.jero.modules.activiti.process.fb.service.IProcessHandleService; import com.jero.modules.activiti.process.standardinterpret.common.StandardInterpretCommon; import com.jero.modules.activiti.process.standardinterpret.controller.ProcessStandardInterpretClauseSublistController; import com.jero.modules.activiti.process.standardinterpret.dto.StandardInterpretDTO; @@ -27,6 +28,7 @@ import com.jero.modules.activiti.process.standardinterpret.service.ProcessStanda import com.jero.modules.activiti.process.standardinterpret.service.ProcessStandardInterpretClauseSublistService; import com.jero.modules.activiti.process.standardinterpret.service.ProcessStandardInterpretService; import com.jero.modules.activiti.process.standardinterpret.service.StandardInterpretFlowService; +import com.jero.modules.activiti.process.standardinterpret.vo.FlowApproveInfo; import com.jero.modules.activiti.process.standardinterpret.vo.StandardInterpretFlowVO; import com.jero.modules.activiti.service.ProcessAllService; import com.jero.modules.activiti.service.ProcessApprovalRecordService; @@ -73,6 +75,7 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe private final ProcessStandardInterpretClauseSublistService processStandardInterpretClauseSublistService; private final ILawsDomesticStandardService lawsDomesticStandardService; private final ProcessStandardInterpretClauseSublistController processStandardInterpretClauseSublist; + private final IProcessHandleService processHandleService; @Override public void flowStart(StandardInterpretFlowDTO standardInterpretFlowDTO) { @@ -229,32 +232,150 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe log.info("发起 标准解读流程（子解读人流程）"); }else if (StandardInterpretCommon.MASTER_INTERPRET_SUMMARY.equals(taskDefinitionKey)){ // 标准主解读汇总 合并条款 - + ProcessStandardInterpret processStandardInterpret = processStandardInterpretService.getOne( + new LambdaQueryWrapper() + .eq(ProcessStandardInterpret::getProjectId, processAlls.getProjectId())); + if (!Objects.isNull(processStandardInterpret)) { + String id = processStandardInterpret.getId(); + List processStandardInterpretClauseList = + processStandardInterpretClauseService.list( + new LambdaQueryWrapper() + .eq(ProcessStandardInterpretClause::getStandardInterpretId, id)); + if (!processStandardInterpretClauseList.isEmpty()) { + List standardInterpretClauseIdList = processStandardInterpretClauseList.stream() + .map(ProcessStandardInterpretClause::getId).collect(Collectors.toList()); + List processStandardInterpretClauseSublistList = + processStandardInterpretClauseSublistService.list( + new LambdaQueryWrapper() + .in(ProcessStandardInterpretClauseSublist::getStandardInterpretClauseId + , standardInterpretClauseIdList)); + // 根据条款分组 + Map> listMap = + processStandardInterpretClauseSublistList.stream() + .collect(Collectors.groupingBy(ProcessStandardInterpretClauseSublist::getClauseId)); + listMap.forEach((k, v) -> { + ProcessStandardInterpretClauseSublist first = v.get(0); + v.remove(0); + for (ProcessStandardInterpretClauseSublist standardInterpretClauseSublist : v) { + // 合并 + first.setInterpretPersonId(first.getInterpretPersonId() + + "," + standardInterpretClauseSublist.getInterpretPersonId()); + first.setTranslation(first.getTranslation() + + "," + standardInterpretClauseSublist.getTranslation()); + first.setIsSameAsPrevVersion(first.getIsSameAsPrevVersion() + + "," + standardInterpretClauseSublist.getIsSameAsPrevVersion()); + first.setChangeDescription(first.getChangeDescription() + + "," + standardInterpretClauseSublist.getChangeDescription()); + first.setRegulatoryNotes(first.getRegulatoryNotes() + + "," + standardInterpretClauseSublist.getRegulatoryNotes()); + first.setKeywords(first.getKeywords() + + "," + standardInterpretClauseSublist.getKeywords()); + first.setKeyController(first.getKeyController() + + "," + standardInterpretClauseSublist.getKeyController()); + first.setApplicableComponents(first.getApplicableComponents() + + "," + standardInterpretClauseSublist.getApplicableComponents()); + first.setRelatedDepartment(first.getRelatedDepartment() + + "," + standardInterpretClauseSublist.getRelatedDepartment()); + first.setResponsibleModule(first.getResponsibleModule() + + "," + standardInterpretClauseSublist.getResponsibleModule()); + first.setRelatedModule(first.getRelatedModule() + + "," + standardInterpretClauseSublist.getRelatedModule()); + first.setApplications(first.getApplications() + + "," + standardInterpretClauseSublist.getApplications()); + first.setPowerType(first.getPowerType() + + "," + standardInterpretClauseSublist.getPowerType()); + first.setDomainArea(first.getDomainArea() + + "," + standardInterpretClauseSublist.getDomainArea()); + first.setConfigurationRequirements(first.getConfigurationRequirements() + + "," + standardInterpretClauseSublist.getConfigurationRequirements()); + first.setNewCerImplementDate(first.getNewCerImplementDate() + + "," + standardInterpretClauseSublist.getNewCerImplementDate()); + first.setNewCerImplementDate(first.getNewCerImplementDate() + + "," + standardInterpretClauseSublist.getNewCerImplementDate()); + first.setEnterpriseStandard(first.getEnterpriseStandard() + + "," + standardInterpretClauseSublist.getEnterpriseStandard()); + first.setTechnicalSpecificationDesignGuide(first.getTechnicalSpecificationDesignGuide() + + "," + standardInterpretClauseSublist.getTechnicalSpecificationDesignGuide()); + first.setDrawingTemplate(first.getDrawingTemplate() + + "," + standardInterpretClauseSublist.getDrawingTemplate()); + first.setTechnicalAgreementTemplate(first.getTechnicalAgreementTemplate() + + "," + standardInterpretClauseSublist.getTechnicalAgreementTemplate()); + first.setVerificationReportTemplateChecklist(first.getVerificationReportTemplateChecklist() + + "," + standardInterpretClauseSublist.getVerificationReportTemplateChecklist()); + first.setDvpTemplate(first.getDvpTemplate() + + "," + standardInterpretClauseSublist.getDvpTemplate()); + first.setDfema(first.getDfema() + + "," + standardInterpretClauseSublist.getDfema()); + first.setKeyTechnologyDecompositionTable(first.getKeyTechnologyDecompositionTable() + + "," + standardInterpretClauseSublist.getKeyTechnologyDecompositionTable()); + first.setOtherDocumentsTemplates(first.getOtherDocumentsTemplates() + + "," + standardInterpretClauseSublist.getOtherDocumentsTemplates()); + first.setP3(first.getP3() + + "," + standardInterpretClauseSublist.getP3()); + first.setP5(first.getP5() + + "," + standardInterpretClauseSublist.getP5()); + first.setRemarks(first.getRemarks() + + "," + standardInterpretClauseSublist.getRemarks()); + processStandardInterpretClauseSublistService + .removeById(standardInterpretClauseSublist.getId()); + } + // 去重 + distinct(first); + }); + } + } } log.info("标准解读流程-流程监听器 结束"); } + private void distinct(ProcessStandardInterpretClauseSublist data) { + data.setKeywords(toDistinct(data.getKeywords())); + data.setKeyController(toDistinct(data.getKeyController())); + data.setIsSameAsPrevVersion(toDistinct(data.getIsSameAsPrevVersion())); + data.setResponsibleDepartment(toDistinct(data.getResponsibleDepartment())); + data.setResponsibleModule(toDistinct(data.getResponsibleModule())); + data.setRelatedDepartment(toDistinct(data.getResponsibleDepartment())); + data.setRelatedModule(toDistinct(data.getRelatedModule())); + data.setApplications(toDistinct(data.getApplications())); + data.setPowerType(toDistinct(data.getPowerType())); + data.setDomainArea(toDistinct(data.getDomainArea())); + data.setConfigurationRequirements(toDistinct(data.getConfigurationRequirements())); + data.setNewCerImplementDate(toDistinct(data.getNewCerImplementDate())); + data.setNewProductionImplementation(toDistinct(data.getNewProductionImplementation())); + data.setEnterpriseStandard(toDistinct(data.getEnterpriseStandard())); + data.setTechnicalSpecificationDesignGuide(toDistinct(data.getTechnicalSpecificationDesignGuide())); + data.setDrawingTemplate(toDistinct(data.getDrawingTemplate())); + data.setTechnicalAgreementTemplate(toDistinct(data.getTechnicalAgreementTemplate())); + data.setVerificationReportTemplateChecklist(toDistinct(data.getVerificationReportTemplateChecklist())); + data.setDvpTemplate(toDistinct(data.getDvpTemplate())); + data.setDfema(toDistinct(data.getDfema())); + data.setKeyTechnologyDecompositionTable(toDistinct(data.getKeyTechnologyDecompositionTable())); + data.setOtherDocumentsTemplates(toDistinct(data.getOtherDocumentsTemplates())); + data.setP3(toDistinct(data.getP3())); + data.setP5(toDistinct(data.getP5())); + } + + private static String toDistinct(String str) { + if (StringUtils.isNotBlank(str)){ + List list = Arrays.asList(str.split(",")); + return list.stream().distinct().collect(Collectors.joining(",")); + } + return ""; + } + @Override public StandardInterpretFlowVO queryDetail(String projectId, String taskId) { StandardInterpretFlowVO standardInterpretFlowVO = new StandardInterpretFlowVO(); - LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); // 查询流程信息 - ProcessAll processAll = processAllService.getOne( - new LambdaQueryWrapper() - .eq(ProcessAll::getProjectId, projectId) - .orderByDesc(ProcessAll::getCreateTime), false); - standardInterpretFlowVO.setProcessAll(processAll); - - // 查询流程审批信息 - ProcessApprovalRecord processApprovalRecord = processApprovalRecordService.getOne( - new LambdaQueryWrapper() - .eq(ProcessApprovalRecord::getUserId, loginUser.getId()) - .eq(ProcessApprovalRecord::getTaskId, taskId), false); - standardInterpretFlowVO.setProcessApprovalRecord(processApprovalRecord); + FlowApproveInfo flowApproveInfo = flowUtility.queryFlowApproveInfo(projectId, taskId); + standardInterpretFlowVO.setProcessAll(flowApproveInfo.getProcessAll()); + standardInterpretFlowVO.setProcessApprovalRecord(flowApproveInfo.getProcessApprovalRecord()); // 查询业务信息 - standardInterpretFlowVO.setData(queryBusinessData(processAll, processApprovalRecord)); + StandardInterpretDTO data = queryBusinessData(flowApproveInfo.getProcessAll(), + flowApproveInfo.getProcessApprovalRecord()); + standardInterpretFlowVO.setData(data); return standardInterpretFlowVO; } @@ -323,6 +444,20 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe .list(); } + @Override + public void flowSave(StandardInterpretFlowDTO standardInterpretFlowDTO) { + // 处理业务数据 + handleBusinessData(standardInterpretFlowDTO); + // 保存流程信息 + flowUtility.flowSaveUpdate(standardInterpretFlowDTO.getProcessAll(), + standardInterpretFlowDTO.getProcessApprovalRecord()); + } + + @Override + public void flowTransfer(String taskId, String userId) { + processHandleService.transfer(taskId, userId); + } + private void handleBusinessData(StandardInterpretFlowDTO standardInterpretFlowDTO) { // map（参数） Map map = standardInterpretFlowDTO.getMap(); @@ -403,7 +538,7 @@ public class StandardInterpretFlowServiceImpl implements StandardInterpretFlowSe // 设置未分配数量 map.put(StandardInterpretCommon.UNALLOCATED_QUANTITY, unallocatedQuantity); // 设置子解读人 - map.put(StandardInterpretCommon.INTERPRETING_PEOPLE, interpretPersonIdList); + map.put(StandardInterpretCommon.INTERPRETING_PEOPLE, new ArrayList<>(interpretPersonIdList)); processStandardInterpretClauseSublistService.saveBatch(processStandardInterpretClauseSublists); }else { // 不分发 diff --git a/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/vo/FlowApproveInfo.java b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/vo/FlowApproveInfo.java new file mode 100644 index 00000000..df8c7ec6 --- /dev/null +++ b/laws-modules/src/main/java/com/jero/modules/activiti/process/standardinterpret/vo/FlowApproveInfo.java @@ -0,0 +1,28 @@ +package com.jero.modules.activiti.process.standardinterpret.vo; + +import com.jero.modules.activiti.entity.ProcessAll; +import com.jero.modules.activiti.entity.ProcessApprovalRecord; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @ClassName: FlowApproveInfo + * @Description: + * @Author: yjz + * @Date: 2024-07-05 11:02 + * @Version: 1.0 + **/ +@Data +public class FlowApproveInfo { + /**流程信息*/ + @ApiModelProperty(value = "流程信息") + private ProcessAll processAll; + + /**流程审批信息*/ + @ApiModelProperty(value = "流程审批信息") + private ProcessApprovalRecord processApprovalRecord; + + /**草稿信息json字符串*/ + @ApiModelProperty(value = "草稿信息json字符串") + private String infoJsonStr; +}