diff --git a/src/main/java/neatlogic/framework/process/constvalue/ProcessTaskOperationType.java b/src/main/java/neatlogic/framework/process/constvalue/ProcessTaskOperationType.java index e27e742803b67770116312535f7aaed4b7fae21a..7045a70394c1fc4ecac55ef32f2009f228453970 100644 --- a/src/main/java/neatlogic/framework/process/constvalue/ProcessTaskOperationType.java +++ b/src/main/java/neatlogic/framework/process/constvalue/ProcessTaskOperationType.java @@ -78,6 +78,7 @@ public enum ProcessTaskOperationType implements IOperationType { STEP_RETREAT("retreatcurrentstep", new I18n("撤回"), Arrays.asList(ProcessTaskGroupSearch.PROCESSUSERTYPE.getValuePlugin() + ProcessUserType.MAJOR.getValue()), Arrays.asList(GroupSearch.COMMON.getValue(), ProcessTaskGroupSearch.PROCESSUSERTYPE.getValue(), GroupSearch.USER.getValue(), GroupSearch.TEAM.getValue(), GroupSearch.ROLE.getValue())), STEP_HANG("hang", new I18n("挂起")), STEP_HANDLE("handle", new I18n("自动处理")), + STEP_REDO("redo", new I18n("重做")), TASK_CREATE("createtask", new I18n("创建任务")), TASK_EDIT("edittask", new I18n("编辑任务")), TASK_DELETE("deletetask", new I18n("删除任务")), diff --git a/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostVo.java b/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostVo.java new file mode 100644 index 0000000000000000000000000000000000000000..b6221f795b88948f02250ea056e75a4f18263e39 --- /dev/null +++ b/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostVo.java @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2024 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.framework.process.dto; + +import java.util.Date; + +public class ProcessTaskStepCostVo { + private Long id; + private Long processTaskId; + private Long processTaskStepId; + + private String startOperate; + private String startStatus; + private Date startTime; + private String startUserUuid; + + private String endOperate; + private String endStatus; + private Date endTime; + private String endUserUuid; + + private Long timeCost; + private Long realTimeCost; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public Long getProcessTaskId() { + return processTaskId; + } + + public void setProcessTaskId(Long processTaskId) { + this.processTaskId = processTaskId; + } + + public Long getProcessTaskStepId() { + return processTaskStepId; + } + + public void setProcessTaskStepId(Long processTaskStepId) { + this.processTaskStepId = processTaskStepId; + } + + public String getStartOperate() { + return startOperate; + } + + public void setStartOperate(String startOperate) { + this.startOperate = startOperate; + } + + public String getStartStatus() { + return startStatus; + } + + public void setStartStatus(String startStatus) { + this.startStatus = startStatus; + } + + public Date getStartTime() { + return startTime; + } + + public void setStartTime(Date startTime) { + this.startTime = startTime; + } + + public String getStartUserUuid() { + return startUserUuid; + } + + public void setStartUserUuid(String startUserUuid) { + this.startUserUuid = startUserUuid; + } + + public String getEndOperate() { + return endOperate; + } + + public void setEndOperate(String endOperate) { + this.endOperate = endOperate; + } + + public String getEndStatus() { + return endStatus; + } + + public void setEndStatus(String endStatus) { + this.endStatus = endStatus; + } + + public Date getEndTime() { + return endTime; + } + + public void setEndTime(Date endTime) { + this.endTime = endTime; + } + + public String getEndUserUuid() { + return endUserUuid; + } + + public void setEndUserUuid(String endUserUuid) { + this.endUserUuid = endUserUuid; + } + + public Long getTimeCost() { + return timeCost; + } + + public void setTimeCost(Long timeCost) { + this.timeCost = timeCost; + } + + public Long getRealTimeCost() { + return realTimeCost; + } + + public void setRealTimeCost(Long realTimeCost) { + this.realTimeCost = realTimeCost; + } +} diff --git a/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostWorkerVo.java b/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostWorkerVo.java new file mode 100644 index 0000000000000000000000000000000000000000..6d4a0b700ec012cf8711a9a2117dd46822fe48f7 --- /dev/null +++ b/src/main/java/neatlogic/framework/process/dto/ProcessTaskStepCostWorkerVo.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2024 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.framework.process.dto; + +public class ProcessTaskStepCostWorkerVo { + private Long id; + private String operateType; + private Long costId; + private String type; + private String uuid; + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getOperateType() { + return operateType; + } + + public void setOperateType(String operateType) { + this.operateType = operateType; + } + + public Long getCostId() { + return costId; + } + + public void setCostId(Long costId) { + this.costId = costId; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } +} diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/IProcessTaskOperatePostProcessor.java b/src/main/java/neatlogic/framework/process/stephandler/core/IProcessTaskOperatePostProcessor.java new file mode 100644 index 0000000000000000000000000000000000000000..1d957c26a2d2e6a77b1b5541332ca13a643b059b --- /dev/null +++ b/src/main/java/neatlogic/framework/process/stephandler/core/IProcessTaskOperatePostProcessor.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2024 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.framework.process.stephandler.core; + +import neatlogic.framework.process.constvalue.IOperationType; +import neatlogic.framework.process.dto.ProcessTaskStepVo; + +/** + * 工单步骤操作后处理器接口 + */ +public interface IProcessTaskOperatePostProcessor { + + /** + * 该方法在步骤操作完成后执行 + * @param currentProcessTaskStepVo 步骤信息 + * @param operationType 操作类型 + */ + default void postProcessAfterProcessTaskStepOperate(ProcessTaskStepVo currentProcessTaskStepVo, IOperationType operationType) { + + } +} diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java index 9690d8a463dfc8917b420874c46ca6aebe425bce..ff77a2c45e456999006df0c3ac9e3df7bdee447e 100644 --- a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java +++ b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java @@ -267,7 +267,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { if (processStepUtilHandler != null) { processStepUtilHandler.updateProcessTaskStepUserAndWorker(currentProcessTaskStepVo.getProcessTaskId(), currentProcessTaskStepVo.getId()); } - + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_ACTIVE); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_ACTIVE); if (currentProcessTaskStepVo.getStatus().equals(ProcessTaskStepStatus.RUNNING.getValue())) { @@ -794,6 +795,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { updateProcessTaskStepStatus(currentProcessTaskStepVo); processStepUtilHandler.updateProcessTaskStepUserAndWorker(currentProcessTaskStepVo.getProcessTaskId(), currentProcessTaskStepVo.getId()); + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_START); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_START); @@ -1067,6 +1070,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { myCompleteAudit(currentProcessTaskStepVo); if (this.getMode().equals(ProcessStepMode.MT)) { + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, operationType); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, operationType); /* 计算SLA **/ @@ -1315,6 +1320,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { myReapprovalAudit(currentProcessTaskStepVo); if (this.getMode().equals(ProcessStepMode.MT)) { + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_REAPPROVAL); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_REAPPROVAL); /* 计算SLA **/ @@ -1360,6 +1367,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { currentProcessTaskStepVo.setIsActive(1); updateProcessTaskStepStatus(currentProcessTaskStepVo); + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_RETREAT); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_RETREAT); if (currentProcessTaskStepVo.getStatus().equals(ProcessTaskStepStatus.RUNNING.getValue())) { @@ -1567,6 +1576,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { currentProcessTaskStepVo.setStatus(ProcessTaskStepStatus.RUNNING.getValue()); updateProcessTaskStepStatus(currentProcessTaskStepVo); + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_RECOVER); /* 触发通知 **/ processStepHandlerCrossoverUtil.notify(currentProcessTaskStepVo, ProcessTaskStepNotifyTriggerType.RECOVER); @@ -1609,7 +1620,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { updateProcessTaskStepStatus(currentProcessTaskStepVo); // processStepUtilHandler.updateProcessTaskStepUserAndWorker(currentProcessTaskStepVo.getProcessTaskId(), // currentProcessTaskStepVo.getId()); - + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_PAUSE); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_PAUSE); @@ -1671,6 +1683,8 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { processTaskStepUserVo.setStatus(ProcessTaskStepUserStatus.DOING.getValue()); processTaskCrossoverMapper.insertProcessTaskStepUser(processTaskStepUserVo); + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_ACCEPT); /* 处理历史记录 **/ // processStepHandlerUtilService.audit(currentProcessTaskStepVo, ProcessTaskStepAction.ACCEPT); @@ -1788,6 +1802,9 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { updateProcessTaskStepStatus(processTaskStepVo); myAfterTransfer(processTaskStepVo); + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_TRANSFER); + /* 触发通知 **/ processStepHandlerCrossoverUtil.notify(currentProcessTaskStepVo, ProcessTaskStepNotifyTriggerType.TRANSFER); @@ -2911,6 +2928,9 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { updateProcessTaskStepStatus(currentProcessTaskStepVo); IProcessTaskScoreCrossoverMapper processTaskScoreCrossoverMapper = CrossoverServiceFactory.getApi(IProcessTaskScoreCrossoverMapper.class); processTaskScoreCrossoverMapper.deleteProcessTaskAutoScoreByProcessTaskId(currentProcessTaskStepVo.getProcessTaskId()); + + currentProcessTaskStepVo.getParamObj().put("operateTime", new Date()); + ProcessTaskOperatePostProcessorFactory.invokePostProcessorsAfterProcessTaskStepOperate(currentProcessTaskStepVo, ProcessTaskOperationType.STEP_REDO); /* 写入时间审计 **/ processStepHandlerCrossoverUtil.timeAudit(currentProcessTaskStepVo, ProcessTaskOperationType.PROCESSTASK_REDO); if (currentProcessTaskStepVo.getStatus().equals(ProcessTaskStepStatus.RUNNING.getValue())) { diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskOperatePostProcessorFactory.java b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskOperatePostProcessorFactory.java new file mode 100644 index 0000000000000000000000000000000000000000..151fabcaaa4f9c50d35cc7f40ae4b4262442311a --- /dev/null +++ b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskOperatePostProcessorFactory.java @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2024 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.framework.process.stephandler.core; + +import neatlogic.framework.applicationlistener.core.ModuleInitializedListenerBase; +import neatlogic.framework.bootstrap.NeatLogicWebApplicationContext; +import neatlogic.framework.common.RootComponent; +import neatlogic.framework.process.constvalue.IOperationType; +import neatlogic.framework.process.dto.ProcessTaskStepVo; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@RootComponent +public class ProcessTaskOperatePostProcessorFactory extends ModuleInitializedListenerBase { + + private static final List postProcessorList = new ArrayList<>(); + + public static void invokePostProcessorsAfterProcessTaskStepOperate(ProcessTaskStepVo currentProcessTaskStepVo, IOperationType operationType) { + for (IProcessTaskOperatePostProcessor postProcessor : postProcessorList) { + postProcessor.postProcessAfterProcessTaskStepOperate(currentProcessTaskStepVo, operationType); + } + } + + @Override + protected void onInitialized(NeatLogicWebApplicationContext context) { + Map map = context.getBeansOfType(IProcessTaskOperatePostProcessor.class); + for (Map.Entry entry : map.entrySet()) { + postProcessorList.add(entry.getValue()); + } + } + + @Override + protected void myInit() { + + } +}