style: 删除无用模块

This commit is contained in:
2024-06-04 17:15:28 +08:00
parent f5e8d8f3bb
commit 1a91c7cb92
244 changed files with 0 additions and 29154 deletions
@@ -1,137 +0,0 @@
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();
}
}
@@ -1,137 +0,0 @@
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;
}
@@ -1,27 +0,0 @@
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;
}
@@ -1,76 +0,0 @@
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("企标废止流程结束监听执行器执行结束");
}
}
@@ -1,18 +0,0 @@
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> {
}
@@ -1,35 +0,0 @@
<?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>
@@ -1,23 +0,0 @@
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);
}
@@ -1,254 +0,0 @@
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);
}
}
}
@@ -1,211 +0,0 @@
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();
}
}
@@ -1,19 +0,0 @@
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 = "标准化归档";
}
@@ -1,392 +0,0 @@
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());
}
}
}
@@ -1,30 +0,0 @@
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;
}
@@ -1,54 +0,0 @@
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;
}
@@ -1,41 +0,0 @@
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);
}
}
@@ -1,48 +0,0 @@
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);
}
}
@@ -1,37 +0,0 @@
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);
}
}
@@ -1,125 +0,0 @@
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("自动发起企标制修订流程");
}
}
}
@@ -1,18 +0,0 @@
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> {
}
@@ -1,68 +0,0 @@
<?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>
@@ -1,33 +0,0 @@
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);
}
@@ -1,709 +0,0 @@
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();
}
}
@@ -1,201 +0,0 @@
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));
}
}
@@ -1,15 +0,0 @@
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 = "标准化工程师归档";
}
@@ -1,388 +0,0 @@
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;
}
@@ -1,27 +0,0 @@
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;
}
@@ -1,110 +0,0 @@
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("自动发起企标制修订流程");
}
}
}
@@ -1,18 +0,0 @@
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> {
}
@@ -1,27 +0,0 @@
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);
}
@@ -1,625 +0,0 @@
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();
}
}
@@ -1,134 +0,0 @@
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();
}
}
@@ -1,138 +0,0 @@
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;
}
@@ -1,27 +0,0 @@
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;
}
@@ -1,60 +0,0 @@
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("企标封存流程结束监听执行器执行结束");
}
}
@@ -1,18 +0,0 @@
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> {
}
@@ -1,35 +0,0 @@
<?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>
@@ -1,23 +0,0 @@
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);
}
@@ -1,259 +0,0 @@
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);
}
}
}
@@ -1,149 +0,0 @@
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));
}
}
@@ -1,16 +0,0 @@
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";
}
@@ -1,116 +0,0 @@
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;
}
@@ -1,15 +0,0 @@
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 = "起草人主管级上一级领导审批";
}
@@ -1,306 +0,0 @@
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;
}
@@ -1,26 +0,0 @@
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;
}
@@ -1,442 +0,0 @@
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));
}
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esChange.mapper;
import com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_change_opinion(企标修改流程意见内容列表)】的数据库操作Mapper
* @createDate 2023-12-04 15:22:36
* @Entity com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion
*/
public interface EsChangeOpinionMapper extends BaseMapper<EsChangeOpinion> {
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esChange.mapper;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_change(企业标准)】的数据库操作Mapper
* @createDate 2023-10-29 21:00:13
* @Entity com.jero.modules.activiti.process.esChange.entity.ProcessEsChange
*/
public interface ProcessEsChangeMapper extends BaseMapper<ProcessEsChange> {
}
@@ -1,13 +0,0 @@
package com.jero.modules.activiti.process.esChange.service;
import com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author ThinkBook
* @description 针对表【process_es_change_opinion(企标修改流程意见内容列表)】的数据库操作Service
* @createDate 2023-12-04 15:22:36
*/
public interface EsChangeOpinionService extends IService<EsChangeOpinion> {
}
@@ -1,28 +0,0 @@
package com.jero.modules.activiti.process.esChange.service;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esChange.entity.vo.ESChangeDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_change(企业标准)】的数据库操作Service
* @createDate 2023-10-29 21:00:13
*/
public interface ProcessEsChangeService extends IService<ProcessEsChange> {
void startProcess(ESChangeDataVO changeData);
String saveToDraft(ProcessInfoVO<ESChangeDataVO> changeData);
ESChangeDataVO getHandleData(String taskId);
void approval(ESChangeDataVO changeData, boolean pass);
/**
* 检查是否在流程中,如果在流程中则不允许删除
* @param ids
*/
void delCheck(String ids);
}
@@ -1,22 +0,0 @@
package com.jero.modules.activiti.process.esChange.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion;
import com.jero.modules.activiti.process.esChange.service.EsChangeOpinionService;
import com.jero.modules.activiti.process.esChange.mapper.EsChangeOpinionMapper;
import org.springframework.stereotype.Service;
/**
* @author ThinkBook
* @description 针对表【process_es_change_opinion(企标修改流程意见内容列表)】的数据库操作Service实现
* @createDate 2023-12-04 15:22:36
*/
@Service
public class EsChangeOpinionServiceImpl extends ServiceImpl<EsChangeOpinionMapper, EsChangeOpinion>
implements EsChangeOpinionService{
}
@@ -1,382 +0,0 @@
package com.jero.modules.activiti.process.esChange.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.common.system.vo.DictModel;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.entity.ProcessApprovalRecord;
import com.jero.modules.activiti.enums.ProcessStatusEnum;
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.esArchive.entity.ProcessEsArchive;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.esChange.entity.EsChangeOpinion;
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.service.EsChangeOpinionService;
import com.jero.modules.activiti.process.esChange.service.ProcessEsChangeService;
import com.jero.modules.activiti.process.esChange.mapper.ProcessEsChangeMapper;
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.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.sys.utils.UserUtils;
import com.jero.modules.system.entity.SysDepart;
import com.jero.modules.system.service.ISysDepartService;
import com.jero.modules.system.service.ISysDictService;
import com.jero.modules.system.service.ISysUserDepartService;
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.*;
import java.util.stream.Collectors;
import static com.jero.modules.activiti.process.esChange.entity.ESChangeTaskNodeIdConstant.MAIN_DRAFT_USER_START;
/**
* @author ThinkBook
* @description 针对表【process_es_change(企业标准)】的数据库操作Service实现
* @createDate 2023-10-29 21:00:13
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsChangeServiceImpl extends ServiceImpl<ProcessEsChangeMapper, ProcessEsChange>
implements ProcessEsChangeService {
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private RuntimeService runtimeService;
@Resource
private EsChangeOpinionService esChangeOpinionService;
@Resource
private ISysUserDepartService userDepartService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private TaskService taskService;
@Resource
private TranslationAspect translationAspect;
@Resource
private ProcessAllService processAllService;
@Resource
private IBusProcessModelHisService busProcessModelHisService;
@Resource
private ISysDepartService sysDepartService;
@Resource
private ISysDictService dictService;
@Override
public void startProcess(ESChangeDataVO changeData) {
// 执行流程发起前的操作
this.startRunTask(changeData);
// 流程Key
String processDefinitionKey = ProcessType.ES_CHANGE.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
ProcessEsChange esChange = changeData.getData();
List<EsChangeOpinion> opinionList = esChange.getList();
// 通用数据
CommonVO common = changeData.getCommon();
// 人员数据
Map<String, Object> variables = changeData.getFlowUser();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(common, ProcessTypeEnum.ES_CHANGE);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esChange.setProcessInstanceId(processInstanceId);
// 设置替换文件id
OSSFile lastDocFileByStandardNo = busProcessModelHisService.findLastDocFileByStandardNo(esChange.getStandardNumber());
if (lastDocFileByStandardNo != null) {
esChange.setReplaceFileId(lastDocFileByStandardNo.getId());
} else {
esChange.setReplaceFileId(null);
}
// 保存到业务流程表
saveOrUpdate(esChange);
if (opinionList != null && !opinionList.isEmpty()) {
String deptId = userDepartService.getFirstDeptIdByUserId(userId);
// 遍历 opinionList,设置 opinion 的 BusinessId
opinionList.forEach(opinion -> {
opinion.setBusinessId(esChange.getId());
if (StrUtil.isBlank(opinion.getCreateUser())) opinion.setCreateUser(userId);
if (StrUtil.isBlank(opinion.getCreateUnit())) opinion.setCreateUnit(deptId);
});
esChangeOpinionService.saveOrUpdateBatch(opinionList);
}
// 保存选人信息
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_CHANGE, 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_CHANGE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(Map<String, Object> flowUser) {
Map<String, Object> actVariables = new HashMap<>();
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());
}
}
actVariables.put("pass", true);
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
return variables;
}
@Override
public String saveToDraft(ProcessInfoVO<ESChangeDataVO> processInfoVO) {
ESChangeDataVO businessInfoDTO = processInfoVO.getBusinessInfoDTO();
if (businessInfoDTO != null) {
ProcessEsChange data = businessInfoDTO.getData();
if (data != null) {
processInfoVO.setBusinessId(data.getId());
}
}
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_CHANGE.getValue()); // 流程类型
return processHandleService.saveToDraft(processInfoVO);
}
public void startRunTask(ESChangeDataVO changeData) {
// 如果标准当前状态是废止或封存,不能发起变更流程
ProcessEsChange data = changeData.getData();
if (data != null) {
actFlowCommonService.checkStandardState(data.getStandardId());
// 判断主起草部门是否有对应的修改单代码
if (StrUtil.isBlank(data.getMainDraftingUnit())) {
throw new JeroBootException("主起草单位不能为空");
}
this.validDepartCode(changeData.getData().getMainDraftingUnit());
}
}
public void validDepartCode(String deptId) {
String deptCode = "";
// 找到单位代号
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("发起失败,找不到主起草单位对应的单位代号,请前往数据字典中添加后再试");
}
}
@Override
public ESChangeDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ESChangeDataVO changeData = new ESChangeDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
changeData.setCommon(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsChange> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsChange::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsChange::getDelFlag, YesOrNoEnum.NO.getValue());
ProcessEsChange data = getOne(lambdaQueryWrapper);
// 获取修改意见列表
LambdaQueryWrapper<EsChangeOpinion> opinionLambdaQueryWrapper = new LambdaQueryWrapper<>();
opinionLambdaQueryWrapper.eq(EsChangeOpinion::getBusinessId, data.getId());
List<EsChangeOpinion> opinionList = esChangeOpinionService.list(opinionLambdaQueryWrapper);
data.setList(opinionList);
changeData.setData(data);
return changeData;
}
@Override
public void approval(ESChangeDataVO changeData, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = changeData.getCommon();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
Map<String, Object> flowUser = changeData.getFlowUser();
// 获取流程实例ID
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
// 获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId).singleResult();
// 获取流程定义ID
String processDefinitionId = processInstance.getProcessDefinitionId();
ProcessEsChange data = changeData.getData();
if (data != null) {
updateById(data);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_CHANGE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
// 第一个节点更新修改意见
ProcessApprovalRecord record = actFlowCommonService.getNodeIdByTaskId(taskId);
String xmlNodeId = record.getNodeId();
if (xmlNodeId.equals(MAIN_DRAFT_USER_START)) {
// 判断主起草单位
actFlowCommonService.checkStandardState(data.getStandardId());
// 判断主起草部门是否有对应的修改单代码
if (StrUtil.isBlank(data.getMainDraftingUnit())) {
throw new JeroBootException("主起草单位不能为空");
}
this.validDepartCode(changeData.getData().getMainDraftingUnit());
// 清理原来的修改意见
LambdaQueryWrapper<EsChangeOpinion> esChangeOpinionLambdaQueryWrapper = new LambdaQueryWrapper<>();
esChangeOpinionLambdaQueryWrapper.eq(EsChangeOpinion::getBusinessId, data.getId());
esChangeOpinionService.remove(esChangeOpinionLambdaQueryWrapper);
// 新增修改意见
List<EsChangeOpinion> opinionList = data.getList();
if (opinionList != null && !opinionList.isEmpty()) {
String deptId = userDepartService.getFirstDeptIdByUserId(userId);
// 遍历 opinionList,设置 opinion 的 BusinessId
opinionList.forEach(opinion -> {
opinion.setBusinessId(data.getId());
if (StrUtil.isBlank(opinion.getCreateUser())) opinion.setCreateUser(userId);
if (StrUtil.isBlank(opinion.getCreateUnit())) opinion.setCreateUnit(deptId);
});
esChangeOpinionService.saveOrUpdateBatch(opinionList);
}
}
}
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.ES_CHANGE_COUNTER_SIGN_NODE_NAME);
}
}
@Override
public void delCheck(String ids) {
String[] idsList = ids.split(",");
// 找到所有进行中的企标修改流程
LambdaQueryWrapper<ProcessAll> processAllWrapper = new LambdaQueryWrapper<>();
processAllWrapper.eq(ProcessAll::getPrcType, ProcessTypeEnum.ES_CHANGE.getValue());
processAllWrapper.eq(ProcessAll::getPrcStatus, ProcessStatusEnum.INCOMPLETE.getValue());
List<ProcessAll> processAllList = processAllService.list(processAllWrapper);
if (processAllList.isEmpty()) {
return;
}
// 获取所有流程实例ID
List<String> processInstanceIdList = new ArrayList<>();
for (ProcessAll processAll : processAllList) {
processInstanceIdList.add(processAll.getProcessInstanceId());
}
// 根据所有流程实例Id找到相应的企标修改流程
LambdaQueryWrapper<ProcessEsChange> processEsChangeWrapper = new LambdaQueryWrapper<>();
processEsChangeWrapper.in(ProcessEsChange::getProcessInstanceId, processInstanceIdList);
List<ProcessEsChange> processEsChangeList = list(processEsChangeWrapper);
Map<String, List<ProcessEsChange>> processEsChangeMap = processEsChangeList.stream()
.filter(e -> e.getStandardId() != null)
.collect(Collectors.groupingBy(ProcessEsChange::getStandardId));
// 判断是否有进行中的企标修改流程
for (String id : idsList) {
if (processEsChangeMap.containsKey(id)) {
List<ProcessEsChange> processEsChanges = processEsChangeMap.get(id);
throw new JeroBootException("标准编号为:" + processEsChanges.get(0).getStandardNumber() + "已在企标更改流程进行中,不可删除!");
}
}
}
}
@@ -1,135 +0,0 @@
package com.jero.modules.activiti.process.esEnable.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.esEnable.entity.vo.ESEnableDataVO;
import com.jero.modules.activiti.process.esEnable.service.ProcessEsEnableService;
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/enable")
public class ESEnableController {
@Resource
private ProcessEsEnableService enableService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增立项变更申请
*
* @param enableData
*/
@AutoLog(value = "企标启用发起流程-发起流程")
@ApiOperation(value="企标启用发起流程-发起流程", notes="企标启用发起流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESEnableDataVO enableData) {
enableService.startProcess(enableData);
return Result.OK();
}
/**
* 保存到草稿
* @param enableData
*/
@AutoLog(value = "企标启用发起流程-保存")
@ApiOperation(value="企标启用发起流程-保存", notes="企标启用发起流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESEnableDataVO> processInfoVO) {
enableService.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_ENABLE));
}
/**
* 保存到待办
* @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_ENABLE);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(enableService.getHandleData(taskId));
}
/**
* 同意
*
* @param enableData
*/
@AutoLog(value = "企标启用发起流程-同意")
@ApiOperation(value="企标启用发起流程-同意", notes="企标启用发起流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESEnableDataVO enableData) {
enableService.approval(enableData, true);
return Result.OK();
}
/**
* 驳回
*
* @param enableData
*/
@AutoLog(value = "企标启用发起流程-驳回")
@ApiOperation(value="企标启用发起流程-驳回", notes="企标启用发起流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESEnableDataVO enableData) {
enableService.approval(enableData, 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();
}
}
@@ -1,138 +0,0 @@
package com.jero.modules.activiti.process.esEnable.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_enable
*/
@TableName(value ="process_es_enable")
@Data
public class ProcessEsEnable 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 = "所属部门")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
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;
}
@@ -1,27 +0,0 @@
package com.jero.modules.activiti.process.esEnable.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
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 ESEnableDataVO {
@JsonProperty("common")
CommonVO common;
@JsonProperty("data")
ProcessEsEnable data;
@JsonProperty("flowUser")
Map<String, Object> flowUser;
}
@@ -1,63 +0,0 @@
package com.jero.modules.activiti.process.esEnable.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.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.activiti.process.esRecheck.entity.ProcessEsRecheck;
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;
import static com.jero.modules.activiti.process.esRecheck.entity.ProcessRecheckConstants.*;
import static com.jero.modules.activiti.process.esRecheck.entity.ProcessRecheckConstants.RECHECK_ARCHIVE;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESEnableEndListener implements ExecutionListener {
@Resource
private ProcessEsEnableService esEnableService;
@Resource
private ILawsEnterpriseStandardService esService;
/**
* 企标立项变更流程结束之后需要把数据存入企标计划数据库 然后自动发起企标制修订流程
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标封存启用流程结束 监听执行器开始执行");
// 找到流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsEnable> enableLambdaQueryWrapper = new LambdaQueryWrapper<>();
enableLambdaQueryWrapper.eq(ProcessEsEnable::getProcessInstanceId, processInstanceId);
ProcessEsEnable enable = esEnableService.getOne(enableLambdaQueryWrapper);
String standNo = enable.getStandardNumber();
log.info("企标封存启用监听执行器开始执行,企标编号为:{}", standNo);
esService.update(new LambdaUpdateWrapper<LawsEnterpriseStandard>()
.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.CURRENTLY_EFFECTIVE.getStateValue())
.eq(LawsEnterpriseStandard::getStandardNumber, standNo));
log.info("企标封存启用流程监听执行器执行结束");
}
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esEnable.mapper;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_enable(企业标准)】的数据库操作Mapper
* @createDate 2023-10-29 21:00:26
* @Entity com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable
*/
public interface ProcessEsEnableMapper extends BaseMapper<ProcessEsEnable> {
}
@@ -1,35 +0,0 @@
<?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.esEnable.mapper.ProcessEsEnableMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable">
<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>
@@ -1,23 +0,0 @@
package com.jero.modules.activiti.process.esEnable.service;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esEnable.entity.vo.ESEnableDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_enable(企业标准)】的数据库操作Service
* @createDate 2023-10-29 21:00:26
*/
public interface ProcessEsEnableService extends IService<ProcessEsEnable> {
void startProcess(ESEnableDataVO enableData);
void saveToDraft(ProcessInfoVO<ESEnableDataVO> enableData);
ESEnableDataVO getHandleData(String taskId);
void approval(ESEnableDataVO enableData, boolean pass);
}
@@ -1,256 +0,0 @@
package com.jero.modules.activiti.process.esEnable.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.esArchive.entity.ProcessEsArchive;
import com.jero.modules.activiti.process.esArchive.entity.vo.ESArchiveDataVO;
import com.jero.modules.activiti.process.esEnable.entity.ProcessEsEnable;
import com.jero.modules.activiti.process.esEnable.entity.vo.ESEnableDataVO;
import com.jero.modules.activiti.process.esEnable.service.ProcessEsEnableService;
import com.jero.modules.activiti.process.esEnable.mapper.ProcessEsEnableMapper;
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.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_enable(企业标准)】的数据库操作Service实现
* @createDate 2023-10-29 21:00:26
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsEnableServiceImpl extends ServiceImpl<ProcessEsEnableMapper, ProcessEsEnable>
implements ProcessEsEnableService{
@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(ESEnableDataVO enableData) {
// 执行流程发起前的操作
this.startRunTask(enableData);
// 流程Key
String processDefinitionKey = ProcessType.ES_ENABLE.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
ProcessEsEnable esEnable = enableData.getData();
// 通用数据
CommonVO common = enableData.getCommon();
// 人员数据
Map<String, Object> variables = enableData.getFlowUser();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(common, ProcessTypeEnum.ES_ENABLE);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esEnable.setProcessInstanceId(processInstanceId);
// 保存到业务流程表
saveOrUpdate(esEnable);
// 保存选人信息
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_ENABLE, 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_ENABLE.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<ESEnableDataVO> processInfoVO) {
ESEnableDataVO businessInfoDTO = processInfoVO.getBusinessInfoDTO();
if (businessInfoDTO != null) {
ProcessEsEnable data = businessInfoDTO.getData();
if (data != null) {
processInfoVO.setBusinessId(data.getId());
}
}
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_ENABLE.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
public void startRunTask(ESEnableDataVO enableData) {
// do nothing now
}
@Override
public ESEnableDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ESEnableDataVO enableData = new ESEnableDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
enableData.setCommon(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsEnable> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsEnable::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsEnable::getDelFlag, YesOrNoEnum.NO.getValue());
ProcessEsEnable data = getOne(lambdaQueryWrapper);
enableData.setData(data);
return enableData;
}
@Override
public void approval(ESEnableDataVO enableData, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = enableData.getCommon();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
Map<String, Object> flowUser = enableData.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("标准化审批")) {
ProcessEsEnable data = this.getOne(new LambdaQueryWrapper<ProcessEsEnable>()
.eq(ProcessEsEnable::getProcessInstanceId, processInstanceId));
String standardNumber = data.getStandardNumber();
LawsEnterpriseStandard es = esService.getOne(new LambdaQueryWrapper<LawsEnterpriseStandard>()
.eq(LawsEnterpriseStandard::getStandardNumber, standardNumber));
if (StandardStateEnum.CURRENTLY_EFFECTIVE.getStateValue().equals(es.getStandardState())) {
throw new JeroBootException("该标准已现行有效,需要驳回重新选择");
}
if (StandardStateEnum.ABOLISH.getStateValue().equals(es.getStandardState())) {
throw new JeroBootException("该标准已废止,需要驳回重新选择");
}
}
ProcessEsEnable data = enableData.getData();
if (data != null) {
updateById(data);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_ENABLE.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);
}
}
}
@@ -1,188 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.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.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.entity.vo.InitChangeDataVO;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.laws.common.constant.FieldCommon;
import com.jero.modules.laws.enterprise.entity.dto.ESPlanQueryDTO;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.EnterpriseStandardUtil;
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 java.util.HashMap;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@RestController
@Api(tags = "企标立项变更流程")
@RequestMapping("/process/es/initChange")
public class ProcessESInitChangeController {
@Resource
private ProcessEsInitChangeService initChangeService;
@Resource
private EnterpriseStandardUtil esUtil;
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 新增立项变更申请
*
* @param initChangeData
*/
@AutoLog(value = "企标立项变更流程-发起立项变更申请")
@ApiOperation(value="企标立项变更流程-发起立项变更申请", notes="企标立项变更流程-发起立项变更申请")
@PostMapping("/start")
public Result<?> startInitChange(@RequestBody InitChangeDataVO initChangeData) {
initChangeService.startProcess(initChangeData);
return Result.OK();
}
/**
* 生成企标编号并返回
* @param esInitChange
*/
@AutoLog(value = "企标立项变更流程-生成企标编号并返回")
@ApiOperation(value="企标立项变更流程-生成企标编号并返回", notes="企标立项变更流程-生成企标编号并返回")
@PostMapping("/getStandardNo")
public Result<?> getStandardNo(@RequestBody ProcessEsInitChange esInitChange) {
// 生成企标编号并返回
Map<String, Object> map = new HashMap<>();
map.put(FieldCommon.ENTERPRISE_STANDARD_CODE, esInitChange.getEnStandardCode());
map.put(FieldCommon.ENTERPRISE_NAME_CODE, esInitChange.getEnNameCode());
map.put(FieldCommon.STANDARD_CATEGORY_CODE, esInitChange.getStandardCategoryCode());
map.put(FieldCommon.YEAR_NUMBER, esInitChange.getDecadeCode());
return Result.OK(esUtil.generateStandardNumber(map));
}
/**
* 保存到待办
* @param processInfoVO
*/
@AutoLog(value = "企标立项变更流程-保存")
@ApiOperation(value="企标立项变更流程-保存", notes="企标立项变更流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<InitChangeDataVO> processInfoVO) {
initChangeService.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_INIT_CHANGE);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(initChangeService.getHandleData(taskId));
}
/**
* 草稿办理
* @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_INIT_CHANGE));
}
/**
* 同意
*
* @param initChangeData
*/
@AutoLog(value = "企标立项变更流程-同意")
@ApiOperation(value="企标立项变更流程-同意", notes="企标立项变更流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody InitChangeDataVO initChangeData) {
initChangeService.approvalInitChange(initChangeData, true);
return Result.OK();
}
/**
* 驳回
*
* @param initChangeData
*/
@AutoLog(value = "企标立项变更流程-驳回")
@ApiOperation(value="企标立项变更流程-驳回", notes="企标立项变更流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody InitChangeDataVO initChangeData) {
initChangeService.approvalInitChange(initChangeData, false);
return Result.OK();
}
/**
* 选择企标编号带出数据
*
* @param espId
*/
@AutoLog(value = "企标立项变更流程-选择企标编号带出数据")
@ApiOperation(value="企标立项变更流程-选择企标编号带出数据", notes="企标立项变更流程-选择企标编号带出数据")
@GetMapping(value = "/getESPDetail")
public Result<?> getESPDetail(@RequestParam("id") String espId) {
return Result.OK(espService.getDetailById(espId));
}
/**
* 企标计划列表
*/
@AutoLog(value = "企标立项变更流程-企标计划列表")
@ApiOperation(value="企标立项变更流程-企标计划列表", notes="企标立项变更流程-企标计划列表")
@GetMapping(value = "/getESPList")
public Result<?> getESPList(@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
ESPlanQueryDTO esPlanQueryDTO,
@RequestParam("projectType") String projectType) {
return Result.OK(espService.getESPList(pageNo, pageSize, esPlanQueryDTO, projectType));
}
/**
* 转办
*
*/
@AutoLog(value = "企标立项变更流程-转办")
@ApiOperation(value="企标立项变更流程-转办", notes="企标立项变更流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
processHandleService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
}
@@ -1,19 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity;
/**
* @author: Mzaxd
* @Date: 2023/10/28 11:47
*/
public class EsInitChangeConstant {
public static final String MAIN_DRAFT_USER_INIT = "主起草人发起";
public static final String CONTACT_USER_CHECK = "部所联络人校对";
public static final String EXPERT_CHECK = "专家审批";
public static final String MAIN_DRAFT_USER_LEADER = "主管级领导审批";
public static final String MAIN_DRAFT_USER_LEADER_LEADER = "主管级上一级领导审批";
public static final String STANDARDIZATION_CHECK = "标准化审批";
public static final String NEW_MAIN_DRAFT_LEADER_LEADER = "新起草部门主管级上一级领导下发";
public static final String NEW_MAIN_DRAFT_LEADER = "新起草部门主管级领导确认";
public static final String RELATE_USER_SIGN = "相关人员会签";
public static final String AUTO_COPY = "主起草人抄送";
}
@@ -1,515 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.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.springframework.format.annotation.DateTimeFormat;
/**
* 企标立项变更计划
* @TableName process_es_init_change
*/
@Data
@TableName(value ="process_es_init_change")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="process_es_init_change对象", description="企标立项变更对象")
public class ProcessEsInitChange implements Serializable {
/** 主键ID */
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value = "主键ID")
private String id;
/** 企标计划ID */
@ApiModelProperty(value = "企标计划ID")
private String espId;
/**
* 标准计划Id1(合并流程字段)
*/
@ApiModelProperty(value = "标准计划Id1(合并流程字段)")
private String standardIdOne;
/**
* 标准编号1(合并流程字段)
*/
@ApiModelProperty(value = "标准编号1(合并流程字段)")
private String standardNoOne;
/**
* 标准名称1(合并流程字段)
*/
@ApiModelProperty(value = "标准名称1(合并流程字段)")
private String standardNameOne;
/**
* 制修订类型1(合并流程字段)
*/
@Dict(dicCode = "esp_project_type")
@ApiModelProperty(value = "制修订类型1(合并流程字段)")
private String projectTypeOne;
/**
* 制修订类型2(合并流程字段)
*/
@Dict(dicCode = "esp_project_type")
@ApiModelProperty(value = "制修订类型2(合并流程字段)")
private String projectTypeTwo;
/**
* 标准计划Id2(合并流程字段)
*/
@ApiModelProperty(value = "标准计划Id2(合并流程字段)")
private String standardIdTwo;
/**
* 标准编号2(合并流程字段)
*/
@ApiModelProperty(value = "标准编号2(合并流程字段)")
private String standardNoTwo;
/**
* 标准名称2(合并流程字段)
*/
@ApiModelProperty(value = "标准名称2(合并流程字段)")
private String standardNameTwo;
/**
* 创建人
*/
@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 String delFlag;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 申请类别
*/
@Dict(dicCode = "esp_application_category")
@ApiModelProperty(value = "申请类别")
private String applicationCategory;
/**
* 项目类型
*/
@Dict(dicCode = "esp_project_type")
@ApiModelProperty(value = "项目类型")
private String projectType;
/**
* 原企标编号
*/
@ApiModelProperty(value = "原企标编号")
private String originEnStandardNo;
/**
* 新企标编号
*/
@ApiModelProperty(value = "新企标编号")
private String newEnStandardNo;
/**
* 原企标名称
*/
@ApiModelProperty(value = "原企标名称")
private String originEnStandardName;
/**
* 新企标名称
*/
@ApiModelProperty(value = "新企标名称")
private String newEnStandardName;
/**
* 企标英文名称
*/
@ApiModelProperty(value = "企标英文名称")
private String enStandardEnglishName;
/**
* 企标体系
*/
@ApiModelProperty(value = "企标体系")
private String enStandardSystem;
/**
* 企业标准代号
*/
@ApiModelProperty(value = "企业标准代号")
private String enStandardCode;
/**
* 企业名称代号
*/
@ApiModelProperty(value = "企业名称代号")
private String enNameCode;
/**
* 标准类别代号
*/
@ApiModelProperty(value = "标准类别代号")
private String standardCategoryCode;
/**
* 年代号
*/
@ApiModelProperty(value = "年代号")
private String decadeCode;
/**
* 标准类型
*/
@ApiModelProperty(value = "标准类型")
private String standardType;
/**
* 企标等级分类
*/
@ApiModelProperty(value = "企标等级分类")
private String enStandardClassification;
/**
* 原草稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "原草稿计划完成日期")
private Date originDraftPlannedCompleteDate;
/**
* 原征求意见稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "原征求意见稿计划完成日期")
private Date originSolicitationDraftPlanCompleteDate;
/**
* 原计划报批日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "原计划报批日期")
private Date originPlanApprovalDate;
/**
* 草稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "草稿计划完成日期")
private Date draftPlannedCompleteDate;
/**
* 征求意见稿计划完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿计划完成日期")
private Date solicitationDraftPlanCompleteDate;
/**
* 计划报批日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "计划报批日期")
private Date planApprovalDate;
/**
* 项目状态
*/
@ApiModelProperty(value = "项目状态")
private String projectStatus;
/**
* 编制说明
*/
@ApiModelProperty(value = "编制说明")
private String compilationDescription;
/**
* 零部件名称
*/
@Dict(dictTable = "laws_part_name", dicCode = "code", dicText = "name")
@ApiModelProperty(value = "零部件名称")
private String componentName;
@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;
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "主起草单位责任人")
private String mainDraftingUnitResponsiblePerson;
/**
* 新主起草单位负责人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "新主起草单位负责人")
private String newMainDraftingUnitResponsiblePerson;
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@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;
/**
* 是否征求意见
*/
@ApiModelProperty(value = "是否征求意见")
private String solicitationOpinionEnabled;
/**
* 征求意见稿完成日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "征求意见稿完成日期")
private Date solicitationDraftCompletionDate;
/**
* 评审日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "评审日期")
private Date reviewDate;
/**
* 报批日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "报批日期")
private Date approvalDate;
/**
* 发布日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "发布日期")
private Date releaseDate;
/**
* 变更状态
*/
@ApiModelProperty(value = "变更状态")
private String changeStatus;
/**
* 立项背景、立项依据
*/
@ApiModelProperty(value = "立项背景、立项依据")
private String projectBackground;
/**
* 国际、国家及行业同类标准分析
*/
@ApiModelProperty(value = "国家及行业同类标准分析")
private String similarNaStandardsAnalysis;
/**
* 企业同类标准对比分析
*/
@ApiModelProperty(value = "企业同类标准对比分析")
private String similarEnStandardsAnalysis;
/**
* 立项标准的领先性与必要性
*/
@ApiModelProperty(value = "立项标准的领先性与必要性")
private String standardLeadingNecessity;
/**
* 立项目的及预期效果等
*/
@ApiModelProperty(value = "立项目的及预期效果等")
private String projectExpectedEffects;
/**
* 上传附件
*/
@Dict(dictTable = "oss_file", dicCode = "id", dicText = "file_name")
@ApiModelProperty(value = "上传附件")
private String uploadAttachment;
/**
* 变更原因
*/
@ApiModelProperty(value = "变更原因")
private String changeReason;
/**
* 新主起草人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "新主起草人")
private String newMainDraftingUser;
/**
* 新主起草单位
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "新主起草单位")
private String newMainDraftingUnit;
/**
* 部所联络人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "部所联络人")
private String contactUser;
/**
* 标准专家
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "标准专家")
private String standardExpert;
/**
* 主起草人主管级领导
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "主起草人主管级领导")
private String mainDraftUserLeader;
/**
* 主起草人主管级领导上级领导
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "主起草人主管级领导上级领导")
private String mainDraftUserLeaderLeader;
/**
* 标准化审批人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "标准化审批人")
private String standardizationApprovalUser;
/**
* 新主起草部门领导的领导
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "新主起草部门领导的领导")
private String newMainDraftUserLeaderLeader;
/**
* 新主起草部门领导
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "新主起草部门领导")
private String newMainDraftUserLeader;
/**
* 相关人员
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "相关人员")
private String relatedUserList;
/**
* 抄送人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
@ApiModelProperty(value = "抄送人")
private String copyUser;
/**
* 授权部门
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "授权部门")
private String authDept;
/**
* 配合单位
*/
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "配合单位")
private String cooperationUnit;
/**
* 隶属工作组
*/
@Dict(dictTable = "laws_working_group", dicCode = "id", dicText = "name")
@ApiModelProperty(value = "隶属工作组")
private String workGroup;
@TableField(exist = false)
private static final long serialVersionUID = 1781238971297838971L;
}
@@ -1,29 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.enums;
/**
* @author: Mzaxd
* @Date: 2023/10/9 16:28
*/
public enum ESPApplicationCategoryEnum {
INITIATION("立项", "3"),
CHANGE("变更", "4")
;
private final String name;
private final String value;
public String getName() {
return name;
}
public String getValue() {
return value;
}
ESPApplicationCategoryEnum(String name, String value) {
this.name = name;
this.value = value;
}
}
@@ -1,48 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.enums;
/**
* @author: Mzaxd
* @Date: 2023/10/13 10:57
*/
public enum ESPChangeType {
ADD("新增", "1", "新增计划入库时"),
CHANGE("变更", "2", "变更类型为完成时间变更、责任部门变更、"),
CANCEL("取消", "3", "项目类型为工作终止为取消"),
;
private final String name;
private final String value;
private final String description;
ESPChangeType(String name, String value, String description) {
this.name = name;
this.value = value;
this.description = description;
}
public String getName() {
return name;
}
public String getValue() {
return value;
}
public String getDescription() {
return description;
}
public static String getValueByName(String name) {
for (ESPChangeType type : ESPChangeType.values()) {
if (type.getName().equals(name)) {
return type.getValue();
}
}
// 如果找不到对应的状态值,则返回“新增”的状态值
return ESPChangeType.ADD.getValue();
}
}
@@ -1,42 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.enums;
/**
* @author: Mzaxd
* @Date: 2023/10/13 14:17
*/
public enum ESPProjectStatus {
NOT_STARTED("未开始", "1"),
IN_PROGRESS("进行中", "2"),
OVERDUE_COMPLETED("逾期完成", "3"),
OVERDUE("逾期", "4"),
COMPLETED("完成", "5");
private final String name;
private final String value;
ESPProjectStatus(String name, String value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public String getValue() {
return value;
}
public static String getValueByName(String name) {
for (ESPProjectStatus status : ESPProjectStatus.values()) {
if (status.getName().equals(name)) {
return status.getValue();
}
}
// 如果找不到对应的状态值,则返回“未开始”的状态值
return ESPProjectStatus.NOT_STARTED.getValue();
}
}
@@ -1,46 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.enums;
/**
* @author: Mzaxd
* @Date: 2023/10/9 16:28
*/
public enum ESPProjectType {
/** 立项 **/
ENACT("制定", "1"),
MODIFY("修订", "2"),
/** 变更 **/
COMPLETE_TIME_CHANGE("完成时间变更", "3"),
WORK_TERMINATE("工作中止", "4"),
RESPONSIBLE_DEPT_CHANGE("责任部门变更", "5"),
MERGE("合并", "6"),
;
private final String name;
private final String value;
public String getName() {
return name;
}
public String getValue() {
return value;
}
ESPProjectType(String name, String value) {
this.name = name;
this.value = value;
}
public static String getValueByName(String name) {
for (ESPProjectType type : ESPProjectType.values()) {
if (type.getName().equals(name)) {
return type.getValue();
}
}
return ESPProjectType.ENACT.getValue(); // 返回ENACT枚举值对应的value值
}
}
@@ -1,31 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.enums;
/**
* @author: Mzaxd
* @Date: 2023/10/13 15:14
*/
public enum ESPRevisionType {
/** 立项 **/
ENACT("制定", "1"),
MODIFY("修订", "2"),
;
private final String name;
private final String value;
public String getName() {
return name;
}
public String getValue() {
return value;
}
ESPRevisionType(String name, String value) {
this.name = name;
this.value = value;
}
}
@@ -1,26 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
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 InitChangeDataVO {
@JsonProperty("common")
private CommonVO commonVO;
@JsonProperty("dataList")
private List<ProcessEsInitChange> dataList;
@JsonProperty("flowUser")
private Map<String, Object> flowUserInfoVO;
}
@@ -1,82 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.api.dto.message.SendMessageDTO;
import com.jero.common.api.vo.SendMessageAPI;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.laws.common.constant.MessageTemplateCodeCommon;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2024/1/26 15:58
*/
@Slf4j
@Component("InitChangeMainDraftUserCopyStartListener")
public class InitChangeMainDraftUserCopyStartListener implements TaskListener {
@Resource
private SendMessageAPI sendMessageAPI;
@Resource
private ProcessEsInitChangeService initChangeService;
@Resource
private ProcessAllService processAllService;
/**
* 责任部门变更,抄送主起草人节点开始监听器
*
* @param delegateExecution
*/
@Override
public void notify(DelegateTask delegateTask) {
log.info("抄送主起草人节点开始监听器开始执行");
// 判断当前变更流程是否是责任部门变更流程
String processInstanceId = delegateTask.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsInitChange> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
List<ProcessEsInitChange> esInitChanges = initChangeService.list(wrapper);
if (esInitChanges.isEmpty()) {
log.error("抄送主起草人节点开始监听器执行错误,未找到相关流程数据");
return;
}
ProcessEsInitChange esInitChange = esInitChanges.get(0);
if (esInitChange.getProjectType().equals(ESPProjectType.RESPONSIBLE_DEPT_CHANGE.getValue())) {
// 获取流程变量
String mainDraftUser = (String) delegateTask.getVariable("createUser");
// 获取流程名称
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
SendMessageDTO sendMessageDTO = getSendMessageDTO(processAll, mainDraftUser, esInitChange);
sendMessageAPI.sendMessage(sendMessageDTO);
}
log.info("抄送主起草人节点开始监听器执行结束");
}
@NotNull
private static SendMessageDTO getSendMessageDTO(ProcessAll processAll, String mainDraftUser, ProcessEsInitChange esInitChange) {
String prcName = processAll.getPrcName();
// 发送消息
SendMessageDTO sendMessageDTO = new SendMessageDTO();
sendMessageDTO.setTemplateCode(MessageTemplateCodeCommon.ES_INIT_CHANGE_MAIN_DRAFT_USER_COPY);
sendMessageDTO.setToUserId(mainDraftUser);
Map<String, String> sendMap = new HashMap<>();
sendMap.put("standardNumber", esInitChange.getOriginEnStandardNo());
sendMap.put("prcName", prcName);
sendMessageDTO.setMap(sendMap);
return sendMessageDTO;
}
}
@@ -1,81 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jero.common.api.dto.message.SendMessageDTO;
import com.jero.common.api.vo.SendMessageAPI;
import com.jero.modules.activiti.entity.ProcessAll;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.activiti.service.ProcessAllService;
import com.jero.modules.laws.common.constant.MessageTemplateCodeCommon;
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 javax.validation.constraints.NotNull;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component("InitChangeNewMainDraftLeaderEndListener")
public class InitChangeNewMainDraftLeaderEndListener implements TaskListener {
@Resource
private SendMessageAPI sendMessageAPI;
@Resource
private ProcessEsInitChangeService initChangeService;
@Resource
private ProcessAllService processAllService;
/**
* 责任部门变更,新起草部门主管级领导确认选择会签人员
*
* @param delegateExecution
*/
@Override
public void notify(DelegateTask delegateTask) {
log.info("新起草部门主管级领导结束监听器开始执行");
// 发送消息
String processInstanceId = delegateTask.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsInitChange> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
List<ProcessEsInitChange> esInitChanges = initChangeService.list(wrapper);
if (esInitChanges.isEmpty()) {
return;
}
ProcessEsInitChange esInitChange = esInitChanges.get(0);
// 获取流程变量
List<String> relatedUserList = (List<String>) delegateTask.getVariable("relatedUserList");
// 发送消息
String relatedUsers = String.join(",", relatedUserList);
// 获取流程名称
ProcessAll processAll = processAllService.getByProcessInstanceId(processInstanceId);
SendMessageDTO sendMessageDTO = getSendMessageDTO(processAll, relatedUsers, esInitChange);
sendMessageAPI.sendMessage(sendMessageDTO);
}
@NotNull
private static SendMessageDTO getSendMessageDTO(ProcessAll processAll, String relatedUsers, ProcessEsInitChange esInitChange) {
String prcName = processAll.getPrcName();
// 发送消息
SendMessageDTO sendMessageDTO = new SendMessageDTO();
sendMessageDTO.setTemplateCode(MessageTemplateCodeCommon.ES_INIT_CHANGE_NEW_MAIN_DRAFT_LEADER_END);
sendMessageDTO.setToUserId(relatedUsers);
Map<String, String> sendMap = new HashMap<>();
sendMap.put("standardNumber", esInitChange.getOriginEnStandardNo());
sendMap.put("prcName", prcName);
sendMessageDTO.setMap(sendMap);
return sendMessageDTO;
}
}
@@ -1,234 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.listener;
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.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.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.ESPProjectStatus;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
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.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.ActivitiObjectNotFoundException;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Collections;
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 ProcessESInitChangeEndListener implements ExecutionListener {
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private ProcessEsInitChangeService esInitChangeService;
@Resource
private EsRevisionService esRevisionService;
@Resource
private EnterpriseStandardUtil esUtil;
@Resource
private ProcessAllService processAllService;
@Resource
private EsRevisionService revisionService;
/**
* 企标立项变更流程结束之后需要把数据存入企标计划数据库 然后自动发起企标制修订流程
* @param delegateExecution
*/
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标立项变更流程结束 监听执行器开始执行");
// 获取流程实例ID
String processInstanceId = delegateExecution.getProcessInstanceId();
// 根据流程实例Id找到所有流程业务数据
LambdaQueryWrapper<ProcessEsInitChange> esInitChangeWrapper = new LambdaQueryWrapper<>();
esInitChangeWrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
List<ProcessEsInitChange> processEsInitChanges = esInitChangeService.list(esInitChangeWrapper);
String applicationCategory = processEsInitChanges.get(0).getApplicationCategory();
String projectType = processEsInitChanges.get(0).getProjectType();
List<EnterpriseStandardPlan> enterpriseStandardPlans;
if (ESPApplicationCategoryEnum.INITIATION.getValue().equals(applicationCategory)) {
// 立项新增-Id置空
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
processEsInitChange.setId(null);
processEsInitChange.setProjectStatus(ESPProjectStatus.IN_PROGRESS.getValue());
processEsInitChange.setChangeStatus(ESPChangeType.ADD.getValue());
if (ESPProjectType.MODIFY.getValue().equals(projectType)) {
processEsInitChange.setApplicationCategory(ESPProjectType.MODIFY.getValue());
if (!this.verifyEnStandardNumberInitChangeLast(processEsInitChanges.get(0).getNewEnStandardNo())) {
throw new JeroBootException(ResultCommon.NEW_EN_STANDARD_NUMBER_CONFLICT);
}
} else {
processEsInitChange.setApplicationCategory(ESPProjectType.ENACT.getValue());
}
// 设置企业标准代号字段值
processEsInitChange.setEnStandardCode(esUtil.getEnStandardCode(processEsInitChange.getNewEnStandardNo()));
}
// 转换为企标计划数据并入库
enterpriseStandardPlans = BeanCopyUtils.copyBeanList(processEsInitChanges, EnterpriseStandardPlan.class);
espService.saveBatch(enterpriseStandardPlans);
log.info("自动发起企标制修订流程");
EnterpriseStandardPlan esp = enterpriseStandardPlans.get(0);
esRevisionService.autoStartProcess(getRevisionDataVO(esp));
} else {
// 如果是变更流程且不是完成时间变更,则需要撤回制修订流程
this.judgeForcedWithdrawal(projectType, processEsInitChanges);
// 将Id设为企标计划的Id
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
processEsInitChange.setId(processEsInitChange.getEspId());
processEsInitChange.setApplicationCategory(null);
}
// 完成时间变更
if (ESPProjectType.COMPLETE_TIME_CHANGE.getValue().equals(projectType)) {
// 将企标计划变更状态设为取消
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
processEsInitChange.setChangeStatus(ESPChangeType.CHANGE.getValue());
}
enterpriseStandardPlans = BeanCopyUtils.copyBeanList(processEsInitChanges, EnterpriseStandardPlan.class);
espService.updateBatchById(enterpriseStandardPlans);
}
// 工作中止
if (ESPProjectType.WORK_TERMINATE.getValue().equals(projectType)) {
LambdaUpdateWrapper<EnterpriseStandardPlan> espWrapper = new LambdaUpdateWrapper<>();
// 将企标计划变更状态设为取消
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
espWrapper.eq(EnterpriseStandardPlan::getId, processEsInitChange.getEspId());
espWrapper.set(EnterpriseStandardPlan::getProjectStatus, ESPProjectStatus.NOT_STARTED.getValue());
espWrapper.set(EnterpriseStandardPlan::getChangeStatus, ESPChangeType.CANCEL.getValue());
espService.update(espWrapper);
espWrapper.clear();
}
}
// 责任部门变更
if (ESPProjectType.RESPONSIBLE_DEPT_CHANGE.getValue().equals(projectType)) {
// 将企标计划变更状态设为变更
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
processEsInitChange.setChangeStatus(ESPChangeType.CHANGE.getValue());
processEsInitChange.setMainDraftingUser(processEsInitChange.getNewMainDraftingUser());
processEsInitChange.setMainDraftingUnitResponsiblePerson(processEsInitChange.getNewMainDraftingUnitResponsiblePerson());
processEsInitChange.setMainDraftingUnit(processEsInitChange.getNewMainDraftingUnit());
}
enterpriseStandardPlans = BeanCopyUtils.copyBeanList(processEsInitChanges, EnterpriseStandardPlan.class);
espService.updateBatchById(enterpriseStandardPlans);
}
// 合并
if (ESPProjectType.MERGE.getValue().equals(projectType)) {
for (ProcessEsInitChange processEsInitChange : processEsInitChanges) {
processEsInitChange.setId(null);
processEsInitChange.setProjectStatus(ESPProjectStatus.IN_PROGRESS.getValue());
processEsInitChange.setChangeStatus(ESPChangeType.CHANGE.getValue());
}
ProcessEsInitChange processEsInitChange = processEsInitChanges.get(0);
// 删除两个老企标计划
espService.deleteById(processEsInitChange.getStandardIdOne());
espService.deleteById(processEsInitChange.getStandardIdTwo());
// 生成新企标计划
EnterpriseStandardPlan plan = BeanCopyUtils.copyBean(processEsInitChange, EnterpriseStandardPlan.class);
plan.setApplicationCategory(ESPProjectType.ENACT.getValue());
espService.save(plan);
//发起制修订流程
esRevisionService.autoStartProcess(getRevisionDataVO(plan));
log.info("自动发起企标制修订流程");
}
}
log.info("数据存入企标计划数据库");
}
/**
* 如果是变更流程且不是完成时间变更,则需要撤回制修订流程
* @param projectType 变更类型
* @param processEsInitChanges 流程业务数据
*/
public void judgeForcedWithdrawal(String projectType, List<ProcessEsInitChange> processEsInitChanges) {
// 如果是变更流程且不是完成时间变更,则需要撤回制修订流程
if (!ESPProjectType.COMPLETE_TIME_CHANGE.getValue().equals(projectType)) {
List<String> espIdList = processEsInitChanges.stream().map(ProcessEsInitChange::getEspId).collect(Collectors.toList());
// 未开始的企标计划不需要强制撤回
espService.listByIds(espIdList).forEach(esp -> {
if (esp.getProjectStatus().equals(ESPProjectStatus.NOT_STARTED.getValue())) {
espIdList.remove(esp.getId());
}
});
if (espIdList.isEmpty()) {
return;
}
LambdaQueryWrapper<ProcessEsRevision> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(ProcessEsRevision::getEspId, espIdList);
lambdaQueryWrapper.eq(ProcessEsRevision::getDelFlag, YesOrNoEnum.NO.getValue());
List<ProcessEsRevision> enactList = revisionService.list(lambdaQueryWrapper);
if (enactList == null || enactList.isEmpty()) {
return;
}
List<String> revisionProcessInstanceIdList = enactList.stream().map(ProcessEsRevision::getProcessInstanceId)
.collect(Collectors.toList());
// 根据流程主表筛选出未完成的流程
LambdaQueryWrapper<ProcessAll> paWrapper = new LambdaQueryWrapper<>();
paWrapper.in(ProcessAll::getProcessInstanceId, revisionProcessInstanceIdList);
paWrapper.eq(ProcessAll::getPrcStatus, ProcessStatusEnum.INCOMPLETE.getValue());
List<ProcessAll> list = processAllService.list(paWrapper);
Map<String, ProcessAll> validProcessAllMap = list.stream()
.collect(Collectors.toMap(ProcessAll::getProcessInstanceId, e -> e));
// 根据流程表
for (ProcessEsRevision esRevision : enactList) {
if (!validProcessAllMap.containsKey(esRevision.getProcessInstanceId())) {
continue;
}
processAllService.forcedWithdrawal(esRevision.getProcessInstanceId());
processAllService.updateDraftStatusByProjectId(esRevision.getId());
}
}
}
public ESRevisionDataVO getRevisionDataVO(EnterpriseStandardPlan esp) {
ESRevisionDataVO revisionDataVO = new ESRevisionDataVO();
ProcessEsRevision revision = new ProcessEsRevision();
revision.setEspId(esp.getId());
revisionDataVO.setData(revision);
return revisionDataVO;
}
/**
* 立项变更流程修订最后一个节点提交的时候需要判断是否已经有另外一个重复的企标编号了, 但此时需要排除掉自己
*/
public boolean verifyEnStandardNumberInitChangeLast(String StandardNumber) {
List<String> duplicateStandardNumbers = esUtil.verifyBatchEsNumber(Collections.singletonList(StandardNumber));
if (duplicateStandardNumbers == null || duplicateStandardNumbers.isEmpty()) {
return true;
} else return duplicateStandardNumbers.size() == 1;
}
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.mapper;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_init_change(企标计划)】的数据库操作Mapper
* @createDate 2023-10-10 13:48:56
* @Entity com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange
*/
public interface ProcessEsInitChangeMapper extends BaseMapper<ProcessEsInitChange> {
}
@@ -1,50 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.service;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esInitChange.entity.vo.InitChangeDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_init_change(企标计划)】的数据库操作Service
* @createDate 2023-10-10 13:48:56
*/
public interface ProcessEsInitChangeService extends IService<ProcessEsInitChange> {
/**
* 新增记录
* @param initChangeData
* @return
*/
void startProcess(InitChangeDataVO initChangeData);
/**
* 审批
* @param pass
* @param initChangeData
*/
void approvalInitChange(InitChangeDataVO initChangeData, boolean pass);
/**
* 保存到草稿
*
* @param initChangeData
*/
void saveToDraft(ProcessInfoVO<InitChangeDataVO> initChangeData);
/**
* 获取办理数据
* @param taskId
* @return
*/
InitChangeDataVO getHandleData(String taskId);
/**
* 复审-继续有效-自动发起立项变更流程
* @param standNo
*/
void autoStartProcessByRecheck(String standardNo);
}
@@ -1,424 +0,0 @@
package com.jero.modules.activiti.process.esInitChange.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.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.enums.ProcessType;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
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.ESPProjectStatus;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectType;
import com.jero.modules.activiti.process.esInitChange.entity.vo.InitChangeDataVO;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.activiti.process.esInitChange.mapper.ProcessEsInitChangeMapper;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
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.laws.common.constant.FieldCommon;
import com.jero.modules.laws.common.service.ILawsCommonService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardAuthDept;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.service.ESSequenceNumberProvider;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardAuthDeptService;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.util.EnterpriseStandardUtil;
import com.jero.modules.laws.standard.entity.LawsEnterpriseStandard;
import com.jero.modules.laws.standard.service.ILawsEnterpriseStandardService;
import com.jero.modules.sys.utils.UserUtils;
import com.jero.modules.tag.enums.TableNameEnum;
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.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import static com.jero.modules.activiti.process.esInitChange.entity.EsInitChangeConstant.*;
/**
* @author ThinkBook
* @description 针对表【process_es_init_change(企标计划)】的数据库操作Service实现
* @createDate 2023-10-10 13:48:56
*/
@Service
@Transactional(rollbackFor = JeroBootException.class)
@Slf4j
public class ProcessEsInitChangeServiceImpl extends ServiceImpl<ProcessEsInitChangeMapper, ProcessEsInitChange> implements ProcessEsInitChangeService, ESSequenceNumberProvider {
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private EnterpriseStandardUtil esUtil;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Resource
private ILawsEnterpriseStandardService esService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private EsRevisionService revisionService;
@Resource
private ProcessAllService processAllService;
@Resource
private ILawsCommonService commonService;
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private TranslationAspect translationAspect;
@Resource
private EnterpriseStandardAuthDeptService esAdService;
@Override
public void startProcess(InitChangeDataVO initChangeData) {
// 发起的时候校验标准编号是是否重复
this.validStandardNumber(initChangeData);
// 执行流程发起前的操作
this.startRunTask(initChangeData);
// 流程Key
String processDefinitionKey = ProcessType.ES_INIT_CHANGE.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
List<ProcessEsInitChange> esInitChangeList = initChangeData.getDataList();
// 通用数据
CommonVO commonVO = initChangeData.getCommonVO();
// 设置流程变量
Map<String, Object> variables = this.setVariables(initChangeData);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(commonVO, ProcessTypeEnum.ES_INIT_CHANGE);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, variables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, variables);
// 设置流程实例Id
esInitChangeList.forEach(e -> e.setProcessInstanceId(processInstanceId));
// 保存到业务流程表
saveOrUpdateBatch(esInitChangeList);
// 保存选人信息
// 人员
Map<String, Object> flowUserInfoVO = initChangeData.getFlowUserInfoVO();
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, flowUserInfoVO);
// 获取第一个任务的taskId
String taskId = actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.manualParseDictText(this.getHandleData(taskId), flowUserInfoVO);
// 强制撤回
commonVO.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_INIT_CHANGE, 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_INIT_CHANGE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(InitChangeDataVO initChangeData) {
Map<String, Object> flowUserInfoVO = initChangeData.getFlowUserInfoVO();
HashMap<String, Object> map = new HashMap<>(flowUserInfoVO);
List<ProcessEsInitChange> initChangeList = initChangeData.getDataList();
if (initChangeList != null && !initChangeList.isEmpty()) {
ProcessEsInitChange initChange = initChangeList.get(0);
// 添加非列表类型的变量
actFlowCommonService.putIfNotNull(map, "applicationCategory", initChange.getApplicationCategory());
actFlowCommonService.putIfNotNull(map, "projectType", initChange.getProjectType());
}
// 添加列表类型的变量
actFlowCommonService.convertAndPutList(map, flowUserInfoVO, "standardExpertList");
actFlowCommonService.convertAndPutList(map, flowUserInfoVO, "relatedUserList");
return map;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
variables.remove("applicationCategory");
variables.remove("projectType");
// 转成逗号拼接
actFlowCommonService.convertListToString(variables);
return variables;
}
@Override
public InitChangeDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
InitChangeDataVO initChangeDataVO = new InitChangeDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
initChangeDataVO.setCommonVO(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsInitChange> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsInitChange::getDelFlag, YesOrNoEnum.NO.getValue());
List<ProcessEsInitChange> dataList = list(lambdaQueryWrapper);
initChangeDataVO.setDataList(dataList);
return initChangeDataVO;
}
@Override
public void autoStartProcessByRecheck(String standardNo) {
// 1. 根据企标编号找到对应企标的主起草人
LambdaQueryWrapper<LawsEnterpriseStandard> esWrapper = new LambdaQueryWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getStandardNumber, standardNo);
esWrapper.eq(LawsEnterpriseStandard::getDelFlag, YesOrNoEnum.NO.getValue());
LawsEnterpriseStandard es = esService.getOne(esWrapper);
String mainDraftUser = es.getMainDraftingUser();
if (StrUtil.isBlank(mainDraftUser)) {
log.info("企标编号为{}的主起草人为空,无法自动发起立项变更流程", es.getStandardNumber());
return;
}
// 流程Key
String processDefinitionKey = ProcessType.ES_INIT_CHANGE.getProcessKey();
// 设置流程变量
Map<String, Object> variables = new HashMap<>();
variables.put("createUser", mainDraftUser);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, variables);
ProcessEsInitChange initChange = new ProcessEsInitChange();
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
this.setInitChangeData(standardNo, initChange, processInstanceId);
// 保存到业务流程表
save(initChange);
// 流程名
String prcName = standardNo + "--立项";
// 保存选人信息
// 人员
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, variables);
// 创建相应数据
CommonVO commonVO = new CommonVO();
commonVO.setPrcName(prcName);
commonVO.setPrcMes(null);
commonVO.setDueTime(null);
commonVO.setProcessInstanceId(processInstanceId);
InitChangeDataVO initChangeDataVO = new InitChangeDataVO();
initChangeDataVO.setDataList(Collections.singletonList(initChange));
initChangeDataVO.setCommonVO(commonVO);
// 获取第一个任务的taskId
actFlowCommonService.getFirstTaskId(processInstanceId, mainDraftUser, processDefinitionId);
// 手动翻译
String jsonData = translationAspect.autoParseDictText(initChangeDataVO, this.getUserMap(variables));
// 强制撤回
actFlowCommonService.saveFirstNodeDraft(commonVO, ProcessTypeEnum.ES_INIT_CHANGE, jsonData);
// 根据流程实例id更新流程总表
Integer prcType = ProcessTypeEnum.ES_INIT_CHANGE.getValue();
actFlowCommonService.updateProcessAllWithUserId(processInstanceId, mainDraftUser, prcName, null, prcType, null);
}
private void setInitChangeData(String standardNo, ProcessEsInitChange initChange, String processInstanceId) {
Map<String, Object> es = commonService.getByIdAndModule(null, TableNameEnum.ENTERPRISE_STANDARDS.getValue(), "1", standardNo);
// 获取当前年份
Calendar date = Calendar.getInstance();
String curYearNumber = String.valueOf(date.get(Calendar.YEAR));
initChange.setProcessInstanceId(processInstanceId)
.setNewEnStandardNo(esUtil.changeStandardNumberYearNumber(standardNo, curYearNumber))
.setApplicationCategory(ESPApplicationCategoryEnum.INITIATION.getValue())
.setProjectType(ESPProjectType.MODIFY.getValue())
.setOriginEnStandardNo((String) es.get(FieldCommon.STANDARD_NUMBER))
.setOriginEnStandardName((String) es.get(FieldCommon.STANDARD_NAME))
.setDecadeCode((String) es.get(FieldCommon.YEAR_NUMBER))
.setEnStandardEnglishName((String) es.get(FieldCommon.STANDARD_ENGLISH_NAME))
.setEnStandardSystem((String) es.get(FieldCommon.STANDARD_SYSTEM))
.setStandardType((String) es.get(FieldCommon.STANDARD_CLASS))
.setStandardCategoryCode((String) es.get(FieldCommon.STANDARD_CATEGORY_CODE))
.setCompilationDescription((String) es.get(FieldCommon.COMP_ILLUSTRATION))
.setComponentName((String) es.get(FieldCommon.PART_NAME))
.setMainDraftingUser((String) es.get(FieldCommon.MAIN_DRAFTING_USER))
.setMainDraftingUnit((String) es.get(FieldCommon.MAIN_DRAFTING_UNIT))
.setMainDraftingUnitResponsiblePerson((String) es.get(FieldCommon.MAIN_DRAFTING_UNIT_RESPONSIBLE_PERSON))
.setStandardPromoter((String) es.get(FieldCommon.STANDARD_PROMOTER))
.setCooperationUnit((String) es.get(FieldCommon.COOPERATION_UNIT))
.setEnStandardClassification((String) es.get(FieldCommon.GRADE_CLASSIFICATION))
.setAuthDept((String) es.get(FieldCommon.AUTH_DEPT));
}
@Override
public void approvalInitChange(InitChangeDataVO initChangeDataVO, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = initChangeDataVO.getCommonVO();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
List<ProcessEsInitChange> initChangeList = initChangeDataVO.getDataList();
Map<String, Object> flowUserInfoVO = initChangeDataVO.getFlowUserInfoVO();
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
String processDefinitionId = actFlowCommonService.getProcessDefId(processInstanceId);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String taskName = task.getName();
if (pass) {
if (initChangeList != null) {
// 先删后增
LambdaUpdateWrapper<ProcessEsInitChange> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
remove(updateWrapper);
initChangeList.forEach(e -> e.setProcessInstanceId(processInstanceId));
saveBatch(initChangeList);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_INIT_CHANGE.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
if (flowUserInfoVO != null && !flowUserInfoVO.isEmpty()) {
Map<String, Object> variables = setVariables(initChangeDataVO);
actFlowCommonService.setProcessVariables(processInstanceId, variables);
Map<String, Object> userMap = getUserMap(variables);
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, userMap);
// 如果是责任部门变更分支,后几个流程需要将部分选人信息保存到业务表中
String newMainDraftUserLeaderLeader = (String) userMap.get("newMainDraftUserLeaderLeader");
String newMainDraftUserLeader = (String) userMap.get("newMainDraftUserLeader");
String relatedUserList = (String) userMap.get("relatedUserList");
LambdaUpdateWrapper<ProcessEsInitChange> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
updateWrapper.set(ProcessEsInitChange::getProcessInstanceId, processInstanceId);
updateWrapper.set(StrUtil.isNotBlank(newMainDraftUserLeaderLeader), ProcessEsInitChange::getNewMainDraftUserLeaderLeader, newMainDraftUserLeaderLeader);
updateWrapper.set(StrUtil.isNotBlank(newMainDraftUserLeader), ProcessEsInitChange::getNewMainDraftUserLeader, newMainDraftUserLeader);
updateWrapper.set(StrUtil.isNotBlank(relatedUserList), ProcessEsInitChange::getRelatedUserList, relatedUserList);
update(updateWrapper);
}
runtimeService.setVariableLocal(processInstanceId, "pass", true);
if (taskName.equals(STANDARDIZATION_CHECK)) {
taskService.setVariable(taskId, "standardizationApprovalUser", userId);
}
} else {
// 设置流程变量
runtimeService.setVariableLocal(processInstanceId, "pass", false);
}
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, userId);
// 删除草稿
actFlowCommonService.removeDraft(commonVO);
if (!pass) {
// 如果是会签节点,驳回后要将其余节点recode设置为 未处理 状态
if (taskName.equals(CounterSignNodeNameConstants.ES_INIT_CHANGE_EXPERT_NODE_NAME)) {
actFlowCommonService.updateOtherCountersignRecodeStatus(processInstanceId, CounterSignNodeNameConstants.ES_INIT_CHANGE_EXPERT_NODE_NAME);
}
if (taskName.equals(CounterSignNodeNameConstants.COUNTER_SIGN_NODE_NAME)) {
actFlowCommonService.updateOtherCountersignRecodeStatus(processInstanceId, CounterSignNodeNameConstants.COUNTER_SIGN_NODE_NAME);
}
}
}
@Override
public void saveToDraft(ProcessInfoVO<InitChangeDataVO> processInfoVO) {
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_INIT_CHANGE.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
private void validStandardNumber(InitChangeDataVO initChangeData) {
List<ProcessEsInitChange> esInitChangeList = initChangeData.getDataList();
// 校验企标编号是否冲突
ProcessEsInitChange initChange = esInitChangeList.get(0);
if (initChange.getProjectType().equals(ESPProjectType.ENACT.getValue())) {
if (!esUtil.verifyEnStandardNumber(initChange.getNewEnStandardNo())) {
throw new JeroBootException(ResultCommon.EN_STANDARD_NUMBER_CONFLICT);
}
}
if (initChange.getProjectType().equals(ESPProjectType.MERGE.getValue())) {
if (!esUtil.verifyEnStandardNumber(initChange.getNewEnStandardNo())) {
throw new JeroBootException(ResultCommon.EN_STANDARD_NUMBER_CONFLICT);
}
}
if (initChange.getProjectType().equals(ESPProjectType.MODIFY.getValue())) {
if (!esUtil.verifyEnStandardNumber(initChange.getNewEnStandardNo())) {
throw new JeroBootException(ResultCommon.NEW_EN_STANDARD_NUMBER_CONFLICT);
}
}
}
public void startRunTask(InitChangeDataVO initChangeData) {
List<ProcessEsInitChange> esInitChangeList = initChangeData.getDataList();
// 校验企标编号是否冲突
ProcessEsInitChange initChange = esInitChangeList.get(0);
if (ESPApplicationCategoryEnum.CHANGE.getValue().equals(initChange.getApplicationCategory())) {
Set<String> espIdSet = new HashSet<>();
// 如果是变更流程,则需要判断计划是否有效
if (ESPProjectType.MERGE.getValue().equals(initChange.getProjectType())) {
espIdSet.add(initChange.getStandardIdOne());
espIdSet.add(initChange.getStandardIdTwo());
} else {
espIdSet = esInitChangeList.stream().map(ProcessEsInitChange::getEspId).collect(Collectors.toSet());
}
List<EnterpriseStandardPlan> esplist = espService.list(new LambdaQueryWrapper<EnterpriseStandardPlan>().in(EnterpriseStandardPlan::getId, espIdSet));
if (esplist == null || esplist.size() != espIdSet.size()) {
throw new JeroBootException(ResultCommon.INVALID_ESP);
}
// 如果是责任部门变更,需要判断计划是否已经逾期
if (ESPProjectType.RESPONSIBLE_DEPT_CHANGE.getValue().equals(initChange.getProjectType())) {
for (EnterpriseStandardPlan esp : esplist) {
if (esp.getProjectStatus().equals(ESPProjectStatus.OVERDUE.getValue())) {
throw new JeroBootException(ResultCommon.INVALID_ESP);
}
}
}
}
}
@Override
public List<String> getSequenceNumbers(String esCodeDictValue, String esNameCodeDictValue, String categoryCodeDictValue) {
// 已经存在的标准
LambdaQueryWrapper<ProcessEsInitChange> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsInitChange::getEnStandardCode, esCodeDictValue);
lambdaQueryWrapper.eq(ProcessEsInitChange::getEnNameCode, esNameCodeDictValue);
lambdaQueryWrapper.eq(ProcessEsInitChange::getStandardCategoryCode, categoryCodeDictValue);
lambdaQueryWrapper.isNotNull(ProcessEsInitChange::getNewEnStandardNo);
List<ProcessEsInitChange> list = this.list(lambdaQueryWrapper);
return list.stream().map(ProcessEsInitChange::getNewEnStandardNo).map(EnterpriseStandardUtil::getSequenceNoFromStandardNo).collect(Collectors.toList());
}
}
@@ -1,157 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.controller;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
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.esRecheck.entity.vo.ESRecheckDataVO;
import com.jero.modules.activiti.process.esRecheck.service.ProcessEsRecheckService;
import com.jero.modules.activiti.process.fb.service.IProcessHandleService;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
import com.jero.modules.laws.enterprise.entity.dto.ESQueryCommonDTO;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardRecheckPlanService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
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/recheck")
public class ESRecheckController {
@Resource
private ProcessEsRecheckService recheckService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private EnterpriseStandardRecheckPlanService recheckPlanService;
/**
* 企标复审申请
*
* @param recheckData
*/
@AutoLog(value = "企标复审流程-发起流程")
@ApiOperation(value="企标复审流程-发起流程", notes="企标复审流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESRecheckDataVO recheckData) {
recheckService.startProcess(recheckData);
return Result.OK();
}
/**
* 保存到草稿
* @param processInfoVO
*/
@AutoLog(value = "企标复审流程-保存")
@ApiOperation(value="企标复审流程-保存", notes="企标复审流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESRecheckDataVO> processInfoVO) {
recheckService.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_RECHECK);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(recheckService.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_RECHECK));
}
/**
* 同意
*
* @param recheckData
*/
@AutoLog(value = "企标复审流程-同意")
@ApiOperation(value="企标复审流程-同意", notes="企标复审流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESRecheckDataVO recheckData) {
recheckService.approval(recheckData, true);
return Result.OK();
}
/**
* 驳回
*
* @param recheckData
*/
@AutoLog(value = "企标复审流程-驳回")
@ApiOperation(value="企标复审流程-驳回", notes="企标复审流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESRecheckDataVO recheckData) {
recheckService.approval(recheckData, 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();
}
/**
* 分页列表查询
*
* @return
*/
@AutoLog(value = "企标复审流程-分页列表查询")
@ApiOperationSupport(order = 1)
@ApiOperation(value="企标复审流程-分页列表查询", notes="企标复审流程-分页列表查询")
@GetMapping(value = "/page")
public Result<?> queryPageList(ESQueryCommonDTO esDeclare,
@RequestParam(name="pageNo", defaultValue="1") @ApiParam("页码") Integer pageNo,
@RequestParam(name="pageSize", defaultValue="10") @ApiParam("页面显示数量") Integer pageSize) {
return Result.OK(recheckPlanService.queryPageList(esDeclare, pageNo, pageSize));
}
}
@@ -1,156 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.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_recheck
*/
@TableName(value ="process_es_recheck")
@Data
public class ProcessEsRecheck 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;
/**
* 企标Id
*/
@ApiModelProperty(value = "企标Id")
private String standardId;
/**
* 企标编号
*/
@ApiModelProperty(value = "企标编号")
private String standardNumber;
/**
* 企标名称
*/
@ApiModelProperty(value = "企标名称")
private String standardName;
/**
* 发布日期
*/
@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;
/**
* 复审日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "复审日期")
private Date recheckDate;
/**
* 主起草人
*/
@ApiModelProperty(value = "主起草人")
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
private String mainDraftingUser;
/**
* 主起草单位
*/
@ApiModelProperty(value = "主起草单位")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
private String mainDraftingUnit;
/**
* 复审意见 继续有效/修订/废止/封存
*/
@Dict(dicCode = "recheck_advice")
@ApiModelProperty(value = "复审意见 继续有效/修订/废止/封存")
private String recheckAdvice;
@ApiModelProperty(value = "复审计划Id")
private String recheckPlanId;
/**
* 是否显示
*/
@ApiModelProperty(value = "0不显示 1显示")
private Integer showFirstNode;
/**
* 联络人
*/
@ApiModelProperty(value = "联络人")
private String standardizationUser;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -1,20 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.entity;
/**
* @author: Mzaxd
* @Date: 2023/11/20 14:17
*/
public class ProcessRecheckConstants {
// 继续有效
public static final String RECHECK_CONTINUE_VALID = "1";
// 修订
public static final String RECHECK_INIT_CHANGE = "2";
// 废止
public static final String RECHECK_ABOLISH = "3";
// 封存
public static final String RECHECK_ARCHIVE = "4";
}
@@ -1,15 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.entity;
/**
* @author: Mzaxd
* @Date: 2024/1/10 10:28
*/
public class RecheckTaskNameConstant {
public static final String STANDARD_ENGINEER_INIT = "标准化发起";
public static final String CONTACT_USER_DISTRIBUTE = "联络人下发";
public static final String DRAFTER_EDIT = "起草人填写意见";
public static final String DRAFTER_LEADER_APPROVAL = "起草人部长审批";
public static final String STANDARDIZATION_APPROVAL = "标准化审批";
}
@@ -1,27 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esInitChange.entity.ProcessEsInitChange;
import com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/10/26 8:13
*/
@Data
public class ESRecheckDataVO {
@JsonProperty("common")
CommonVO common;
@JsonProperty("data")
ProcessEsRecheck data;
@JsonProperty("flowUser")
Map<String, Object> flowUser;
}
@@ -1,110 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.listener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esInitChange.service.ProcessEsInitChangeService;
import com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck;
import com.jero.modules.activiti.process.esRecheck.service.ProcessEsRecheckService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardRecheckPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardRecheckPlanService;
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.Date;
import static com.jero.modules.activiti.process.esRecheck.entity.ProcessRecheckConstants.*;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component
public class ProcessESRecheckEndListener implements ExecutionListener {
/**
* 1.继续有效:更新下次复审时间,不做其他处理。企标属性里留下复审记录(列表)(复审时间更新的逻辑待定)
* 2.修订:自动刚发起企标立项变更流程(修订模式)
* 3.废止:自动把企标的状态改为“废止”
* 4.封存:自动把企标的状态改为“封存”
* @param delegateExecution
*/
@Resource
private ProcessEsRecheckService esRecheckService;
@Resource
private EnterpriseStandardRecheckPlanService esRecheckPlanService;
@Resource
private ProcessEsInitChangeService esInitChangeService;
@Resource
private ILawsEnterpriseStandardService esService;
@Override
public void notify(DelegateExecution delegateExecution) {
log.info("企标复审流程结束 监听执行器开始执行");
// 找到流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
LambdaQueryWrapper<ProcessEsRecheck> recheckLambdaQueryWrapper = new LambdaQueryWrapper<>();
recheckLambdaQueryWrapper.eq(ProcessEsRecheck::getProcessInstanceId, processInstanceId);
ProcessEsRecheck recheck = esRecheckService.getOne(recheckLambdaQueryWrapper);
String recheckAdvice = recheck.getRecheckAdvice();
String recheckPlanId = recheck.getRecheckPlanId();
EnterpriseStandardRecheckPlan recheckPlan = esRecheckPlanService.getById(recheckPlanId);
recheckPlan.setInProcessFlag(YesOrNoEnum.NO.getValue());
esRecheckPlanService.updateById(recheckPlan);
String standNo = recheck.getStandardNumber();
LambdaUpdateWrapper<EnterpriseStandardRecheckPlan> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(EnterpriseStandardRecheckPlan::getStandardNo, standNo);
wrapper.set(EnterpriseStandardRecheckPlan::getInProcessFlag, YesOrNoEnum.NO.getValue());
log.info("企标复审流程结束 监听执行器开始执行,企标编号为:{}", standNo);
if (RECHECK_CONTINUE_VALID.equals(recheckAdvice)) {
// 获取复审计划记录
EnterpriseStandardRecheckPlan plan = esRecheckPlanService.getById(recheck.getRecheckPlanId());
// 继续有效
plan.setRecheckResult(RECHECK_CONTINUE_VALID);
Date recheckDate = plan.getRecheckDate();
// 复审日期再加3年
Date nextRecheckDate = new Date(recheckDate.getTime() + (3 * 365 - 1) * 24 * 60 * 60 * 1000L);
plan.setRecheckDate(nextRecheckDate);
esRecheckPlanService.updateById(plan);
LambdaUpdateWrapper<LawsEnterpriseStandard> esWrapper = new LambdaUpdateWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getStandardNumber, standNo);
esWrapper.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.CURRENTLY_EFFECTIVE.getStateValue());
esService.update(esWrapper);
}
if (RECHECK_INIT_CHANGE.equals(recheckAdvice)) {
// 废止
wrapper.set(EnterpriseStandardRecheckPlan::getRecheckResult, RECHECK_INIT_CHANGE);
// 修订 自动发起企标立项/变更流程(修订模式)
esInitChangeService.autoStartProcessByRecheck(standNo);
}
if (RECHECK_ABOLISH.equals(recheckAdvice)) {
// 废止
wrapper.set(EnterpriseStandardRecheckPlan::getRecheckResult, RECHECK_ABOLISH);
LambdaUpdateWrapper<LawsEnterpriseStandard> esWrapper = new LambdaUpdateWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getStandardNumber, standNo);
esWrapper.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.ABOLISH.getStateValue());
esService.update(esWrapper);
}
if (RECHECK_ARCHIVE.equals(recheckAdvice)) {
// 封存
wrapper.set(EnterpriseStandardRecheckPlan::getRecheckResult, RECHECK_ARCHIVE);
LambdaUpdateWrapper<LawsEnterpriseStandard> esWrapper = new LambdaUpdateWrapper<>();
esWrapper.eq(LawsEnterpriseStandard::getStandardNumber, standNo);
esWrapper.set(LawsEnterpriseStandard::getStandardState, StandardStateEnum.ARCHIVE.getStateValue());
esService.update(esWrapper);
}
esRecheckPlanService.update(wrapper);
log.info("企标复审流程监听执行器执行结束");
}
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.mapper;
import com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_recheck(企业标准)】的数据库操作Mapper
* @createDate 2023-10-29 21:00:54
* @Entity com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck
*/
public interface ProcessEsRecheckMapper extends BaseMapper<ProcessEsRecheck> {
}
@@ -1,32 +0,0 @@
<?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.esRecheck.mapper.ProcessEsRecheckMapper">
<resultMap id="BaseResultMap" type="com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck">
<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="releaseDate" column="release_date" jdbcType="TIMESTAMP"/>
<result property="implementationDate" column="implementation_date" jdbcType="TIMESTAMP"/>
<result property="mainDraftingUser" column="main_drafting_user" jdbcType="VARCHAR"/>
<result property="mainDraftingUnit" column="main_drafting_unit" jdbcType="VARCHAR"/>
<result property="recheckAdvice" column="recheck_advice" 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,release_date,implementation_date,
main_drafting_user,main_drafting_unit,recheck_advice
</sql>
</mapper>
@@ -1,25 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.service;
import com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck;
import com.baomidou.mybatisplus.extension.service.IService;
import com.jero.modules.activiti.process.esRecheck.entity.vo.ESRecheckDataVO;
import com.jero.modules.activiti.process.fb.vo.ProcessInfoVO;
/**
* @author ThinkBook
* @description 针对表【process_es_recheck(企业标准)】的数据库操作Service
* @createDate 2023-10-29 21:00:54
*/
public interface ProcessEsRecheckService extends IService<ProcessEsRecheck> {
void startProcess(ESRecheckDataVO recheckData);
void autoStartProcess(ESRecheckDataVO recheckData);
void saveToDraft(ProcessInfoVO<ESRecheckDataVO> recheckData);
ESRecheckDataVO getHandleData(String taskId);
void approval(ESRecheckDataVO recheckData, boolean pass);
}
@@ -1,318 +0,0 @@
package com.jero.modules.activiti.process.esRecheck.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.enums.ProcessType;
import com.jero.modules.activiti.process.common.service.ActFlowCommonService;
import com.jero.modules.activiti.process.esChange.entity.ProcessEsChange;
import com.jero.modules.activiti.process.esRecheck.entity.ProcessEsRecheck;
import com.jero.modules.activiti.process.esRecheck.entity.vo.ESRecheckDataVO;
import com.jero.modules.activiti.process.esRecheck.service.ProcessEsRecheckService;
import com.jero.modules.activiti.process.esRecheck.mapper.ProcessEsRecheckMapper;
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.ProcessNodeLinkService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardRecheckPlan;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardRecheckPlanService;
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.*;
import static com.jero.modules.activiti.process.esRecheck.entity.RecheckTaskNameConstant.*;
/**
* @author ThinkBook
* @description 针对表【process_es_recheck(企业标准)】的数据库操作Service实现
* @createDate 2023-10-29 21:00:54
*/
@Slf4j
@Transactional(rollbackFor = JeroBootException.class)
@Service
public class ProcessEsRecheckServiceImpl extends ServiceImpl<ProcessEsRecheckMapper, ProcessEsRecheck>
implements ProcessEsRecheckService {
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private ProcessNodeLinkService processNodeLinkService;
@Resource
private RuntimeService runtimeService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private TaskService taskService;
@Resource
private TranslationAspect translationAspect;
@Resource
private EnterpriseStandardRecheckPlanService esRecheckService;
@Override
public void startProcess(ESRecheckDataVO recheckData) {
// 执行流程发起前的操作
this.startRunTask(recheckData);
// 将计划设为流程进行中
String recheckPlanId = recheckData.getData().getRecheckPlanId();
EnterpriseStandardRecheckPlan recheckPlan = esRecheckService.getById(recheckPlanId);
if (recheckPlan == null) {
throw new JeroBootException("企标复审计划无效,请重新提交");
}
recheckPlan.setInProcessFlag(YesOrNoEnum.YES.getValue());
esRecheckService.updateById(recheckPlan);
// 流程Key
String processDefinitionKey = ProcessType.ES_RECHECK.getProcessKey();
// 当前用户Id
String userId = UserUtils.getUserId();
// 业务数据
ProcessEsRecheck esRecheck = recheckData.getData();
// 手动发起不显示第一个节点
esRecheck.setShowFirstNode(YesOrNoEnum.NO.getInteger());
// 通用数据
CommonVO common = recheckData.getCommon();
// 人员数据
Map<String, Object> variables = recheckData.getFlowUser();
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 删除草稿
actFlowCommonService.getExistDraftAndRemove(common, ProcessTypeEnum.ES_RECHECK);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esRecheck.setProcessInstanceId(processInstanceId);
// 保存到业务流程表
saveOrUpdate(esRecheck);
// 保存选人信息
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_RECHECK, 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_RECHECK.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
@Override
public void autoStartProcess(ESRecheckDataVO recheckData) {
// 执行流程发起前的操作
this.startRunTask(recheckData);
// 流程Key
String processDefinitionKey = ProcessType.ES_RECHECK.getProcessKey();
// 业务数据
ProcessEsRecheck esRecheck = recheckData.getData();
// 通用数据
CommonVO common = recheckData.getCommon();
// 人员数据
Map<String, Object> variables = recheckData.getFlowUser();
// 当前数据的标准化工程师
String standardEngineerId = (String) variables.get("standardEngineer");
String standardizationUserId = (String) variables.get("standardizationUser");
String userId = StrUtil.isNotBlank(standardizationUserId) ? standardizationUserId : standardEngineerId;
// 设置流程变量
Map<String, Object> actVariables = this.setVariablesAutoStart(variables);
// 启动流程
ProcessInstance processInstance = actFlowCommonService.startProcess(processDefinitionKey, actVariables);
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 设置流程实例Id
esRecheck.setProcessInstanceId(processInstanceId);
// 保存到业务流程表
saveOrUpdate(esRecheck);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(variables));
// 获取第一个任务的taskId
actFlowCommonService.getFirstTaskId(processInstanceId, userId, processDefinitionId);
recheckData.setFlowUser(null);
// 手动翻译
String jsonData = translationAspect.autoParseDictText(recheckData, this.getUserMap(variables));
// 强制撤回
common.setProcessInstanceId(processInstanceId);
actFlowCommonService.saveFirstNodeDraftCustomUserId(common, ProcessTypeEnum.ES_RECHECK, jsonData, userId);
// 根据流程实例id更新流程总表
String prcName = common.getPrcName();
String prcMes = common.getPrcMes();
Date dueTime = common.getDueTime();
Integer prcType = ProcessTypeEnum.ES_RECHECK.getValue();
actFlowCommonService.updateProcessAllWithUserId(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
public Map<String, Object> setVariables(Map<String, Object> flowUser) {
Map<String, Object> actVariables = new HashMap<>();
for (Map.Entry<String, Object> entry : flowUser.entrySet()) {
String key = entry.getKey();
actFlowCommonService.putIfNotNull(actVariables, key, entry.getValue());
}
return actVariables;
}
public Map<String, Object> setVariablesAutoStart(Map<String, Object> flowUser) {
Map<String, Object> actVariables = new HashMap<>();
for (Map.Entry<String, Object> entry : flowUser.entrySet()) {
String key = entry.getKey();
actFlowCommonService.putIfNotNull(actVariables, key, entry.getValue());
actVariables.put(key, entry.getValue());
}
return actVariables;
}
private Map<String, Object> getUserMap(Map<String, Object> variables) {
variables.remove("pass");
return variables;
}
@Override
public void saveToDraft(ProcessInfoVO<ESRecheckDataVO> processInfoVO) {
ESRecheckDataVO businessInfoDTO = processInfoVO.getBusinessInfoDTO();
if (businessInfoDTO != null) {
ProcessEsRecheck data = businessInfoDTO.getData();
if (data != null) {
processInfoVO.setBusinessId(data.getId());
}
}
// 流程信息
BasicProcessInfoDTO basicProcessInfoDTO = processInfoVO.getBasicProcessInfoDTO();
basicProcessInfoDTO.setProcessType(ProcessTypeEnum.ES_RECHECK.getValue()); // 流程类型
processHandleService.saveToDraft(processInfoVO);
}
public void startRunTask(ESRecheckDataVO recheckData) {
// 如果标准当前状态是废止或封存,不能发起变更流程
ProcessEsRecheck data = recheckData.getData();
if (data != null) {
actFlowCommonService.checkStandardState(data.getStandardId());
}
}
@Override
public ESRecheckDataVO getHandleData(String taskId) {
if (!actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ESRecheckDataVO recheckData = new ESRecheckDataVO();
// 使用流程引擎根据taskId找到流程实例Id
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
recheckData.setCommon(actFlowCommonService.getHandleCommon(taskId));
// 获取流程实例数据
LambdaQueryWrapper<ProcessEsRecheck> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ProcessEsRecheck::getProcessInstanceId, processInstanceId);
lambdaQueryWrapper.eq(ProcessEsRecheck::getDelFlag, YesOrNoEnum.NO.getValue());
ProcessEsRecheck data = getOne(lambdaQueryWrapper);
recheckData.setData(data);
return recheckData;
}
@Override
public void approval(ESRecheckDataVO recheckData, boolean pass) {
String userId = UserUtils.getUserId();
CommonVO commonVO = recheckData.getCommon();
String taskId = commonVO.getTaskId();
if (StrUtil.isBlank(taskId) || !actFlowCommonService.taskExists(taskId)) {
throw new JeroBootException(ResultCommon.TASK_NOT_EXISTS);
}
ProcessEsRecheck data = recheckData.getData();
Map<String, Object> flowUser = recheckData.getFlowUser();
String processInstanceId = actFlowCommonService.getProcessInstanceIdByTaskId(taskId);
if (pass) {
saveOrUpdate(recheckData.getData());
if (flowUser != null) {
// 人员数据
Map<String, Object> variables = recheckData.getFlowUser();
// 设置联络人节点人员
actFlowCommonService.putIfNotNull(variables, "standardizationUser", data.getStandardizationUser());
// 设置流程变量
Map<String, Object> actVariables = this.setVariables(variables);
// 根据流程实例Id获取流程定义ID
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
// 获取流程实例ID
String processDefinitionId = processInstance.getProcessDefinitionId();
// 手动设置所有流程变量
actFlowCommonService.setProcessVariables(processInstanceId, actVariables);
// 保存选人信息
processNodeLinkService.saveNodeUserLink(processDefinitionId, processInstanceId, this.getUserMap(variables));
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_RECHECK.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
if (data != null) {
updateById(data);
// 根据流程实例id更新流程总表
String prcName = commonVO.getPrcName();
String prcMes = commonVO.getPrcMes();
Date dueTime = commonVO.getDueTime();
Integer prcType = ProcessTypeEnum.ES_RECHECK.getValue();
actFlowCommonService.updateProcessAll(processInstanceId, userId, prcName, prcMes, prcType, dueTime);
}
}
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
String taskName = task.getName();
switch (taskName) {
case DRAFTER_EDIT:
taskService.setVariable(taskId, "mainDraftUser", userId);
break;
case DRAFTER_LEADER_APPROVAL:
taskService.setVariable(taskId, "mainDraftUserLeader", userId);
break;
case STANDARDIZATION_APPROVAL:
taskService.setVariable(taskId, "finalStandardEngineer", userId);
break;
}
// 设置流程变量
runtimeService.setVariable(processInstanceId, "pass", pass);
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfo(commonVO, taskId, pass);
// 审批节点
actFlowCommonService.completeTask(taskId, userId);
// 删除草稿
actFlowCommonService.removeDraft(commonVO);
}
}
@@ -1,145 +0,0 @@
package com.jero.modules.activiti.process.esRevision.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.esRevision.entity.vo.ESRevisionDataVO;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
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/revision")
public class ESRevisionController {
@Resource
private EsRevisionService revisionService;
@Resource
private IProcessHandleService processHandleService;
@Resource
private ActFlowCommonService actFlowCommonService;
/**
* 企标制修订流程
*
* @param revisionData
*/
@AutoLog(value = "企标制修订流程-发起流程")
@ApiOperation(value="企标制修订流程-发起流程", notes="企标制修订流程-发起流程")
@PostMapping("/start")
public Result<?> startProcess(@RequestBody ESRevisionDataVO revisionData) {
revisionService.startProcess(revisionData);
return Result.OK();
}
/**
* 保存到草稿
* @param processInfoVO
*/
@AutoLog(value = "企标制修订流程-保存")
@ApiOperation(value="企标制修订流程-保存", notes="企标制修订流程-保存")
@PostMapping("/save")
public Result<?> save(@Validated @RequestBody ProcessInfoVO<ESRevisionDataVO> processInfoVO) {
String draftId = revisionService.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_REVISION);
if (draft != null) {
return Result.OK(draft);
}
return Result.OK(revisionService.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_REVISION));
}
/**
* 同意
*
* @param revisionData
*/
@AutoLog(value = "企标制修订流程-同意")
@ApiOperation(value="企标制修订流程-同意", notes="企标制修订流程-同意")
@PostMapping("/agree")
public Result<?> agree(@RequestBody ESRevisionDataVO revisionData) {
revisionService.approval(revisionData, true);
return Result.OK();
}
/**
* 驳回
*
* @param revisionData
*/
@AutoLog(value = "企标制修订流程-驳回")
@ApiOperation(value="企标制修订流程-驳回", notes="企标制修订流程-驳回")
@PostMapping("/reject")
public Result<?> reject(@RequestBody ESRevisionDataVO revisionData) {
revisionService.approval(revisionData, false);
return Result.OK();
}
/**
* 转办
*
*/
@AutoLog(value = "企标制修订流程-转办")
@ApiOperation(value="企标制修订流程-转办", notes="企标制修订流程-转办")
@PostMapping(value = "/transfer")
public Result<?> transfer(@RequestBody TransferVO transferVO) {
revisionService.transfer(transferVO.getTaskId(), transferVO.getUserId());
return Result.OK();
}
/**
* 获取签署信息
*
*/
@AutoLog(value = "企标制修订流程-获取签署信息")
@ApiOperation(value="企标制修订流程-获取签署信息", notes="企标制修订流程-获取签署信息")
@GetMapping(value = "/getSignInfo")
public Result<?> getSignInfo(@RequestParam String processInstanceId) {
return Result.OK(revisionService.getSignInfo(processInstanceId));
}
}
@@ -1,114 +0,0 @@
package com.jero.modules.activiti.process.esRevision.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_revision_advice
*/
@TableName(value ="process_es_revision_advice")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EsRevisionAdvice 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 processInstanceId;
/**
* 执行id
*/
@ApiModelProperty(value = "执行id")
private String executionId;
/**
* 条款号
*/
@ApiModelProperty(value = "条款号")
private String clauseNum;
/**
* 条款名称
*/
@ApiModelProperty(value = "条款名称")
private String clauseName;
/**
* 修改意见内容(包括修改理由和依据)
*/
@ApiModelProperty(value = "修改意见内容(包括修改理由和依据)")
private String editAdvice;
/**
* 意见提出人
*/
@Dict(dictTable = "sys_user", dicText = "CONCAT(realname, '(', username, ')')", dicCode = "id")
@ApiModelProperty(value = "意见提出人")
private String createUserId;
/**
* 1采纳 2部分采纳 3不采纳
*/
@ApiModelProperty(value = "1采纳 2部分采纳 3不采纳")
@Dict(dicCode = "consultation_opinion")
private String handleAdvice;
/**
* 理由
*/
@ApiModelProperty(value = "理由")
private String reason;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -1,38 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity;
import lombok.Getter;
/**
* @author: Mzaxd
* @Date: 2024/1/28 17:36
*/
@Getter
public enum HandleAdviceEnum {
/**
* 1:采纳
*/
AGREE("同意", "1"),
/**
* 2:部分采纳
*/
PART_DISAGREE("部分采纳", "2"),
/**
* 3:不采纳
*/
DISAGREE("不采纳", "3"),
;
private final String name;
private final String value;
HandleAdviceEnum(String name, String value) {
this.name = name;
this.value = value;
}
}
@@ -1,24 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity;
import lombok.Getter;
/**
* @author: Mzaxd
* @Date: 2023/12/22 15:04
*/
@Getter
public enum OperateTypeEnum {
CANNOT_OPERATE("不能操作显示", "1"),
UPLOAD_AND_CHANGE_DRAFT_USER("可以上传并且将起草人改为‘我’", "2"),
UPLOAD("可以上传起草人字段维持不变", "3");
private final String name;
private final String value;
OperateTypeEnum(String name, String value) {
this.name = name;
this.value = value;
}
}
@@ -1,363 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity;
import com.alibaba.fastjson.JSON;
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 com.jero.modules.activiti.process.esRevision.entity.vo.InspectContentVO;
import com.jero.modules.activiti.process.esRevision.entity.vo.OtherDraftUserVO;
import com.jero.modules.activiti.process.esRevision.entity.vo.ReviewMeetingDetailVO;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
*
* @TableName process_es_revision
*/
@TableName(value ="process_es_revision")
@Data
public class ProcessEsRevision 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;
/**
* 0表示未删除,1表示删除
*/
@ApiModelProperty(value = "0表示未删除,1表示删除")
private Integer delFlag;
/**
* 企标计划Id
*/
@ApiModelProperty(value = "企标计划Id")
private String espId;
/**
* 流程实例Id
*/
@ApiModelProperty(value = "流程实例Id")
private String processInstanceId;
/**
* 业务json数据
*/
@ApiModelProperty(value = "业务JSON数据")
private String businessJson;
/**
* 其他起草人上传文件JSON
*/
@ApiModelProperty(value = "其他起草人上传文件JSON")
private String otherDrafterUploadFileJson;
/**
* 稽查内容JSON
*/
@ApiModelProperty(value = "稽查内容JSON")
private String inspectContentJson;
/**
* 评审会评分细节JSON
*/
@ApiModelProperty(value = "评审会评分细节JSON")
private String reviewMeetingDetailJson;
/**
* 执行id
*/
@ApiModelProperty(value = "执行id")
private String executionId;
/**
* 是否需要稽查 0不需要 1需要
*/
@Dict(dicCode = "yn")
@ApiModelProperty(value = "是否需要稽查 0不需要 1需要")
private String inspectFlag;
/**
* 是否可以进行评审会
*/
@TableField(exist = false)
@ApiModelProperty(value = "是否可以进行评审会")
private String reviewMeetingFlag;
/**
* 评审人
*/
@ApiModelProperty(value = "评审人")
private String reviewUser;
/**
* 评分人
*/
@TableField(exist = false)
@ApiModelProperty(value = "评分人")
private String raters;
/**
* 评审日期
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ApiModelProperty(value = "评审日期")
private Date reviewDate;
/**
* 评审地点
*/
@TableField(exist = false)
@ApiModelProperty(value = "评审地点")
private String reviewPlace;
/**
* 是否开启征求意见 0不征求 1征求
*/
@TableField(exist = false)
@ApiModelProperty(value = "是否开启征求意见 0不征求 1征求")
private String adviceFlag;
/**
* 部门联络人
*/
@TableField(exist = false)
@ApiModelProperty(value = "部门联络人")
private String contactUser;
/**
* 部门联络人主管级领导
*/
@TableField(exist = false)
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "部门联络人主管级领导")
private String contactUserLeader;
/**
* 会议纪要
*/
@ApiModelProperty(value = "会议纪要")
private String meetingSummary;
/**
* 会议纪要(主起草人上传会议纪要节点)
*/
@ApiModelProperty(value = "会议纪要(主起草人上传会议纪要节点)")
private String meetingSummarySecond;
/**
* 参会人员
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "参会人员")
private String meetingUsers;
/**
* 参会人员(主起草人上传会议纪要节点)
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "参会人员(主起草人上传会议纪要节点)")
private String meetingUsersSecond;
/**
* 校对人
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "校对人")
private String proofreader;
/**
* 审批人(主管级领导)
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "审批人(主管级领导)")
private String approvalUser;
/**
* 审批人(标准化)
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "审批人(标准化)")
private String approvalUserStandard;
/**
* 相关部门领导
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "相关部门领导")
private String relatedLeader;
/**
* 授权部门
*/
@ApiModelProperty(value = "授权部门")
private String authDept;
/**
* 发布日期
*/
@ApiModelProperty(value = "发布日期")
private String releaseDate;
/**
* 实施日期
*/
@ApiModelProperty(value = "实施日期")
private String implementDate;
/**
* 征求意见截止日期
*/
@TableField(exist = false)
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ApiModelProperty(value = "征求意见截止日期")
private Date adviceDeadline;
/**
* 工作组
*/
@ApiModelProperty(value = "工作组")
private String workGroup;
/**
* 主起草人
*/
@ApiModelProperty(value = "主起草人")
private String mainDraftUser;
@ApiModelProperty(value = "其他起草人上传节点是否完成标识 0未完成 1已完成")
private String otherDrafterUploadFinishFlag;
/**
* 总工程师
*/
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "总工程师")
private String chiefEngineer;
@TableField(exist = false)
@ApiModelProperty(value = "评审会总分")
private String totalScore;
@TableField(exist = false)
@ApiModelProperty(value = "其他起草人")
private List<OtherDraftUserVO> otherDraftUserVOS;
@TableField(exist = false)
@ApiModelProperty(value = "稽查内容")
private List<InspectContentVO> inspectContents;
@TableField(exist = false)
@ApiModelProperty(value = "评审结果")
private List<ReviewMeetingDetailVO> reviewMeetingDetails;
@TableField(exist = false)
@ApiModelProperty(value = "意见列表")
private List<EsRevisionAdvice> advices;
/**
* 编制说明
*/
@ApiModelProperty(value = "编制说明")
private String compIllustration;
/**
* 在线编辑文件id
*/
@ApiModelProperty(value = "在线编辑文件id")
private String onEditFile;
/**
* 意见汇总
*/
@ApiModelProperty(value = "意见汇总")
private String commentsSummary;
/**
* 自动发起标识
*/
@TableField(exist = false)
@ApiModelProperty(value = "自动发起标识")
private boolean autoStartFlag;
public void setOtherDrafterUploadFileJson(String otherDrafterUploadFileJson) {
this.otherDrafterUploadFileJson = otherDrafterUploadFileJson;
}
public void setInspectContentJson(String inspectContentJson) {
this.inspectContentJson = inspectContentJson;
}
public void setReviewMeetingDetailJson(String reviewMeetingDetailJson) {
this.reviewMeetingDetailJson = reviewMeetingDetailJson;
}
public void setOtherDrafterUploadFileJson(List<OtherDraftUserVO> otherDraftUserVOS) {
this.otherDrafterUploadFileJson = JSON.toJSONString(otherDraftUserVOS);
}
public void setInspectContentJson(List<InspectContentVO> inspectContents) {
this.inspectContentJson = JSON.toJSONString(inspectContents);
}
public void setReviewMeetingDetailJson(List<ReviewMeetingDetailVO> reviewMeetingDetails) {
this.reviewMeetingDetailJson = JSON.toJSONString(reviewMeetingDetails);
}
public List<OtherDraftUserVO> parseOtherDraftUserVOS() {
return JSON.parseArray(this.otherDrafterUploadFileJson, OtherDraftUserVO.class);
}
public List<InspectContentVO> parseInspectContents() {
return JSON.parseArray(this.inspectContentJson, InspectContentVO.class);
}
public List<ReviewMeetingDetailVO> parseReviewMeetingDetails() {
return JSON.parseArray(this.reviewMeetingDetailJson, ReviewMeetingDetailVO.class);
}
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
@@ -1,46 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity;
/**
* @author: Mzaxd
* @Date: 2023/12/19 15:14
*/
public class RevisionTaskNodeIdConstant {
/** 主起草人分发 */
public static final String MAIN_DRAFT_USER_DISTRIBUTE = "Activity_0v98tow";
/** 其他起草人上传企标 */
public static final String OTHER_DRAFT_USER_UPLOAD = "Activity_1d2la4l";
/** 主起草人汇总 */
public static final String MAIN_DRAFT_USER_COLLECT_FIRST = "Activity_1dz3u0m";
/** 标准化审批 */
public static final String STANDARDIZATION_CHECK = "Activity_0m576ex";
/** 评分人评分 */
public static final String RATER_RATE = "Activity_1qhpnpa";
/** 标准化确认是否开启征求意见 */
public static final String CONFIRM_ADVISE = "Activity_1siuksf";
/** 部门联络人下发 */
public static final String CONTACT_USER_DISTRIBUTE = "Activity_1ns6olf";
/** 征求意见对象填写意见 */
public static final String ADVICE = "Activity_04m430n";
/** 部门联络人汇总数据 */
public static final String CONTACT_USER_COLLECT = "Activity_1riqzkp";
/** 部所联络人主管级领导审批 */
public static final String CONTACT_USER_LEADER_APPROVAL = "Activity_1ralk8e";
/** 主起草人汇总 */
public static final String MAIN_DRAFT_USER_COLLECT_SECOND = "Activity_1hb9aun";
/** 主起草人上传会议纪要 */
public static final String MAIN_DRAFT_USER_UPLOAD = "Activity_11uuyg0";
/** 其它起草人校对 */
public static final String OTHER_DRAFT_USER_CHECK = "Activity_1seways";
/** 主管级领导审批 */
public static final String LEADER_APPROVAL = "Activity_1l028rz";
/** 标准化审批 */
public static final String STANDARDIZATION_APPROVAL = "Activity_0uxua0b";
/** 相关部门领导会签 */
public static final String RELATED_LEADER_APPROVAL = "Activity_05pybsc";
/** 总工程师审批 */
public static final String CHIEF_ENGINEER_APPROVAL = "Activity_1yr56ac";
/** 主起草人发布 */
public static final String MAIN_DRAFT_USER_RELEASE = "Activity_0n0h60s";
}
@@ -1,54 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* @author: Mzaxd
* @Date: 2024/1/31 9:58
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SignInfo {
/**
* 人员信息
*/
@ApiModelProperty(value = "人员信息")
private String userId;
/**
* 人员信息
*/
@ApiModelProperty(value = "人员姓名")
private String userName;
/**
* 签署日期
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@ApiModelProperty(value = "签署日期")
private Date signTime;
/**
* 手写签字图片id
*/
@ApiModelProperty(value = "手写签字图片id")
private String avatarFileId;
/**
* 手写签字图片url
*/
@ApiModelProperty(value = "手写签字图片url")
private String avatarFileUrl;
}
@@ -1,26 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.jero.modules.activiti.process.common.entity.CommonVO;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import lombok.Data;
import java.util.Map;
/**
* @author: Mzaxd
* @Date: 2023/12/19 14:50
*/
@Data
public class ESRevisionDataVO {
@JsonProperty("common")
CommonVO common;
@JsonProperty("data")
ProcessEsRevision data;
@JsonProperty("flowUser")
Map<String, Object> flowUser;
}
@@ -1,33 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity.vo;
import com.alibaba.fastjson.annotation.JSONField;
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/12/20 17:46
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class InspectContentVO {
/** 条款 */
@JSONField(name = "clause")
@ApiModelProperty(value = "条款")
private String clause;
/** 标准内容或要求 */
@JSONField(name = "requirement")
@ApiModelProperty(value = "标准内容或要求")
private String requirement;
@JSONField(name = "rectificationDepartment")
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "整改部门")
private String rectificationDepartment;
}
@@ -1,53 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity.vo;
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;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author: Mzaxd
* @Date: 2023/12/20 10:16
*/
@Data
public class OtherDraftUserVO {
@Dict(dictTable = "sys_depart", dicCode = "id", dicText = "depart_name")
@ApiModelProperty(value = "起草人责任单位")
private String dept;
@Dict(dictTable = "sys_user", dicCode = "id", dicText = "CONCAT(realname, '(', username, ')')")
@ApiModelProperty(value = "起草人")
private String user;
@ApiModelProperty(value = "起草范围")
private String scope;
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@ApiModelProperty(value = "截止日期")
private Date deadline;
@Dict(dicCode = "id", dicText = "file_name", dictTable = "oss_file")
@ApiModelProperty(value = "文件ID")
private String fileId;
@ApiModelProperty(value = "1:不能操作显示/2:可以上传并且将起草人改为‘我’/3:可以上传起草人字段维持不变")
private String operateType;
@ApiModelProperty(value = "绑定的taskId")
private String taskId;
@ApiModelProperty(value = "未完成为0 已完成为1")
private String finishFlag;
public String getISODeadlineTime() {
SimpleDateFormat isoFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
return isoFormat.format(this.deadline);
}
}
@@ -1,30 +0,0 @@
package com.jero.modules.activiti.process.esRevision.entity.vo;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @author: Mzaxd
* @Date: 2023/12/20 16:13
*/
@Data
public class ReviewMeetingDetailVO {
/**评分项目*/
@ApiModelProperty(value = "评分项目")
private String evaluateItem;
/**评分分值*/
@ApiModelProperty(value = "评分分值")
private String evaluateScore;
/**评分人id*/
@ApiModelProperty(value = "评分人id")
private String adjudicatorId;
/**扣分理由*/
@ApiModelProperty(value = "扣分理由")
private String deductionScoreReason;
}
@@ -1,114 +0,0 @@
package com.jero.modules.activiti.process.esRevision.job;
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.process.esRevision.entity.EsRevisionAdvice;
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.ProcessApprovalRecordService;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.Execution;
import org.jetbrains.annotations.NotNull;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author: Mzaxd
* @Date: 2023/12/28 18:40
*/
@Slf4j
public class AdviceDeadlineJob implements Job {
@Resource
private EsRevisionService revisionService;
@Resource
private ProcessApprovalRecordService approvalRecordService;
@Resource
private RuntimeService runtimeService;
@Resource
private TaskService taskService;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
log.info("开始执行征求意见截止日期每日定时任务");
LambdaQueryWrapper<ProcessEsRevision> revisionLambdaQueryWrapper = new LambdaQueryWrapper<>();
revisionLambdaQueryWrapper.eq(ProcessEsRevision::getDelFlag, YesOrNoEnum.NO.getValue());
revisionLambdaQueryWrapper.isNotNull(ProcessEsRevision::getProcessInstanceId);
List<ProcessEsRevision> revisionList = revisionService.list(revisionLambdaQueryWrapper);
if (revisionList == null || revisionList.isEmpty()) {
return;
}
Map<String, ProcessEsRevision> revisionMap = revisionList.stream()
.collect(Collectors.toMap(ProcessEsRevision::getProcessInstanceId, revision -> revision));
// 找到所有征求意见的未完成的待办
LambdaQueryWrapper<ProcessApprovalRecord> arWrapper = new LambdaQueryWrapper<>();
arWrapper.eq(ProcessApprovalRecord::getFinishFlag, FinishFlagEnum.INCOMPLETE.getValue());
arWrapper.in(ProcessApprovalRecord::getProcessInstanceId, revisionMap.keySet());
arWrapper.eq(ProcessApprovalRecord::getTaskName, "征求意见对象填写意见");
arWrapper.isNotNull(ProcessApprovalRecord::getTaskId);
List<ProcessApprovalRecord> arList = approvalRecordService.list(arWrapper);
Date curDate = new Date();
for (ProcessApprovalRecord record : arList) {
String taskId = record.getTaskId();
// 根据record获取每一个任务的deadline
// 获取Task
taskService.createTaskQuery().taskId(record.getTaskId()).singleResult();
// 根据Task获取其父级executionId
String executionId = taskService.createTaskQuery()
.taskId(record.getTaskId()).singleResult().getExecutionId();
// 获取Execution
Execution execution = runtimeService.createExecutionQuery().executionId(executionId).singleResult();
String parentExecutionId = execution.getParentId();
// 根据executionId获取流程变量
Date adviceDeadline = (Date) taskService.getVariable(taskId, parentExecutionId + "-adviceDeadline");
if (adviceDeadline == null) {
continue;
}
adviceDeadline = getDeadlineDate(adviceDeadline);
// 如果当前日期大于该条数据的截止日期 则自动完成任务
if (curDate.after(adviceDeadline)) {
ESRevisionDataVO handleData = revisionService.getHandleData(taskId);
handleData.getCommon().setTaskId(taskId);
ProcessEsRevision data = handleData.getData();
EsRevisionAdvice esRevisionAdvice = new EsRevisionAdvice();
esRevisionAdvice.setClauseName("");
esRevisionAdvice.setClauseNum("");
esRevisionAdvice.setEditAdvice("");
data.setAdvices(new ArrayList<>(Collections.singletonList(esRevisionAdvice)));
revisionService.approval(handleData, true);
}
}
log.info("征求意见截止日期每日定时任务执行结束");
}
@NotNull
private static Date getDeadlineDate(Date deadline) {
// 设置deadline为今天的最后一秒
// 创建一个 Calendar 对象
Calendar calendar = Calendar.getInstance();
// 获取当前日期和时间
calendar.setTime(deadline);
// 设置时间部分为当天的最后一秒
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 999);
// 将修改后的日期和时间设置回原始的 Date 对象
deadline = calendar.getTime();
return deadline;
}
}
@@ -1,164 +0,0 @@
package com.jero.modules.activiti.process.esRevision.job;
import cn.hutool.core.util.StrUtil;
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.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.esRevision.entity.ProcessEsRevision;
import com.jero.modules.activiti.process.esRevision.entity.RevisionTaskNodeIdConstant;
import com.jero.modules.activiti.process.esRevision.entity.vo.ESRevisionDataVO;
import com.jero.modules.activiti.process.esRevision.entity.vo.OtherDraftUserVO;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
import com.jero.modules.activiti.service.ProcessApprovalRecordService;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.apache.tomcat.jni.Proc;
import org.jetbrains.annotations.NotNull;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import static org.apache.tools.ant.taskdefs.SetPermissions.NonPosixMode.pass;
/**
* @author: Mzaxd
* @Date: 2023/12/28 18:40
*/
@Slf4j
public class OtherDraftUserUploadDeadlineJob implements Job {
@Resource
private EsRevisionService revisionService;
@Resource
private ProcessApprovalRecordService approvalRecordService;
@Resource
private ActFlowCommonService actFlowCommonService;
@Resource
private TaskService taskService;
@Resource
private RuntimeService runtimeService;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
LambdaQueryWrapper<ProcessEsRevision> revisionLambdaQueryWrapper = new LambdaQueryWrapper<>();
revisionLambdaQueryWrapper.eq(ProcessEsRevision::getOtherDrafterUploadFinishFlag, YesOrNoEnum.NO.getValue());
List<ProcessEsRevision> revisionList = revisionService.list(revisionLambdaQueryWrapper);
LambdaQueryWrapper<ProcessApprovalRecord> arWrapper = new LambdaQueryWrapper<>();
arWrapper.eq(ProcessApprovalRecord::getFinishFlag, FinishFlagEnum.INCOMPLETE.getValue());
for (ProcessEsRevision revision : revisionList) {
String prcId = revision.getProcessInstanceId();
if (StrUtil.isBlank(prcId)) {
continue;
}
List<OtherDraftUserVO> otherDraftUserVOS = revision.parseOtherDraftUserVOS();
if (otherDraftUserVOS == null || otherDraftUserVOS.isEmpty()) {
continue;
}
arWrapper.eq(ProcessApprovalRecord::getProcessInstanceId, prcId);
List<ProcessApprovalRecord> arList = approvalRecordService.list(arWrapper);
arWrapper.clear();
// 将task和记录进行绑定
this.bundleTaskAndApprovalRecord(otherDraftUserVOS, arList);
Date curDate = new Date();
for (OtherDraftUserVO otherDraftUser : otherDraftUserVOS) {
if (StrUtil.isNotBlank(otherDraftUser.getFileId())) {
continue;
}
if (StrUtil.isBlank(otherDraftUser.getTaskId())) {
log.error("未找到对应待办");
continue;
}
// 获取TaskId
Date deadline = getDeadlineDate(otherDraftUser);
// 如果当前日期大于该条数据的截止日期 则自动完成任务
if (curDate.after(deadline)) {
// 审批节点
// 更新审批表为完成,填充数据
actFlowCommonService.updateApprovalInfoWithoutNodeId(otherDraftUser.getTaskId());
// 判断能否根据TaskId找到有效的Task
if (taskService.createTaskQuery().taskId(otherDraftUser.getTaskId()).singleResult() == null) {
log.error("未找到对应Task");
continue;
}
taskService.complete(otherDraftUser.getTaskId());
otherDraftUser.setFinishFlag(YesOrNoEnum.YES.getValue());
}
}
revision.setOtherDrafterUploadFileJson(otherDraftUserVOS);
revisionService.updateById(revision);
}
}
private void bundleTaskAndApprovalRecord(List<OtherDraftUserVO> otherDraftUserVOS, List<ProcessApprovalRecord> arList) {
Map<String, List<ProcessApprovalRecord>> arMap = arList.stream().filter(p -> StrUtil.isNotBlank(p.getOriginUserId()))
.collect(Collectors.groupingBy(ProcessApprovalRecord::getOriginUserId));
List<String> alreadyTaskId = new ArrayList<>();
otherDraftUserVOS.forEach(o -> alreadyTaskId.add(o.getTaskId()));
for (OtherDraftUserVO otherDraftUser : otherDraftUserVOS) {
if (StrUtil.isNotBlank(otherDraftUser.getTaskId())) {
continue;
}
if (YesOrNoEnum.YES.getValue().equals(otherDraftUser.getFinishFlag())) {
continue;
}
String originUserId = otherDraftUser.getUser();
List<ProcessApprovalRecord> ar = arMap.get(originUserId);
if (ar == null || ar.isEmpty()) {
log.error("未找到对应待办");
continue;
}
for (ProcessApprovalRecord processApprovalRecord : ar) {
if (alreadyTaskId.contains(processApprovalRecord.getTaskId())) {
continue;
}
String taskId = processApprovalRecord.getTaskId();
String taskName = processApprovalRecord.getTaskName();
if (StrUtil.isBlank(taskId)) {
log.error("任务Id为空");
continue;
}
if (!taskName.equals("其他起草人上传企标")) {
continue;
}
otherDraftUser.setTaskId(taskId);
alreadyTaskId.add(taskId);
break;
}
}
}
@NotNull
private static Date getDeadlineDate(OtherDraftUserVO otherDraftUser) {
Date deadline = otherDraftUser.getDeadline();
// 设置deadline为今天的最后一秒
// 创建一个 Calendar 对象
Calendar calendar = Calendar.getInstance();
// 获取当前日期和时间
calendar.setTime(deadline);
// 设置时间部分为当天的最后一秒
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 999);
// 将修改后的日期和时间设置回原始的 Date 对象
deadline = calendar.getTime();
return deadline;
}
}
@@ -1,29 +0,0 @@
package com.jero.modules.activiti.process.esRevision.listener;
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;
/**
* @author: Mzaxd
* @Date: 2023/10/10 14:14
*/
@Slf4j
@Component("adviceCreateListener")
public class AdviceCreateListener implements TaskListener {
@Resource
private TaskService taskService;
@Override
public void notify(DelegateTask delegateTask) {
String parentExecutionId = (String) taskService.getVariable(delegateTask.getId(), "contactExecutionId");
delegateTask.setVariable(delegateTask.getExecutionId() + "-ContactExecutionId", parentExecutionId);
}
}
@@ -1,142 +0,0 @@
package com.jero.modules.activiti.process.esRevision.listener;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.jero.common.constant.enums.YesOrNoEnum;
import com.jero.modules.activiti.process.common.enums.StandardStateEnum;
import com.jero.modules.activiti.process.esInitChange.entity.enums.ESPProjectStatus;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import com.jero.modules.activiti.process.esRevision.entity.vo.ReviewMeetingDetailVO;
import com.jero.modules.activiti.process.esRevision.service.EsRevisionService;
import com.jero.modules.laws.common.constant.FieldCommon;
import com.jero.modules.laws.common.service.ILawsCommonService;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardPlan;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardReviewMeetingRecord;
import com.jero.modules.laws.enterprise.entity.EnterpriseStandardRmrEvaluateDetail;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardPlanService;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardReviewMeetingRecordService;
import com.jero.modules.laws.enterprise.service.EnterpriseStandardRmrEvaluateDetailService;
import com.jero.modules.laws.enterprise.util.BeanCopyUtils;
import com.jero.modules.laws.enterprise.util.EnterpriseStandardUtil;
import com.jero.modules.onlyoffice.service.IBusProcessModelHisService;
import com.jero.modules.tag.enums.TableNameEnum;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
/**
* @author: Mzaxd
* @Date: 2023/12/19 11:59
*/
@Component
public class ProcessESRevisionEndListener implements ExecutionListener {
@Resource
private EnterpriseStandardPlanService espService;
@Resource
private EsRevisionService esRevisionService;
@Resource
private EnterpriseStandardReviewMeetingRecordService rmrService;
@Resource
private EnterpriseStandardRmrEvaluateDetailService rmrDetailService;
@Resource
private ILawsCommonService lawsCommonService;
@Resource
private IBusProcessModelHisService busProcessModelHisService;
@Override
public void notify(DelegateExecution delegateExecution) {
// 获取流程实例Id
String processInstanceId = delegateExecution.getProcessInstanceId();
// 根据流程Id获取业务数据
LambdaQueryWrapper<ProcessEsRevision> revisionWrapper = new LambdaQueryWrapper<>();
revisionWrapper.eq(ProcessEsRevision::getProcessInstanceId, processInstanceId);
// 获取企标相关数据
ProcessEsRevision data = esRevisionService.getOne(revisionWrapper);
Map<String, Object> variables = JSON.parseObject(data.getBusinessJson(), Map.class);
String inspectContentJson = data.getInspectContentJson();
List<LinkedHashMap<String, Object>> inspectContentList;
if (StrUtil.isNotBlank(inspectContentJson)) {
inspectContentList =
JSON.parseObject(inspectContentJson, new TypeReference<List<LinkedHashMap<String, Object>>>() {});
variables.put(FieldCommon.CHECK_LIST, inspectContentList);
}
// 将标准号进行拆分后填充字段
String standardNumber = (String) variables.get(FieldCommon.STANDARD_NUMBER);
if (StringUtils.isNotBlank(standardNumber)) {
Map<String, String> map = EnterpriseStandardUtil.splitStandardNumber(standardNumber);
variables.putAll(map);
// 如果没有主起草人,则需要填充主起草人
}
// 主起草人
String mainDraftUser = (String) variables.get(FieldCommon.MAIN_DRAFTING_USER);
if (StringUtils.isBlank(mainDraftUser)) {
variables.put(FieldCommon.MAIN_DRAFTING_USER, data.getMainDraftUser());
}
// 标准状态
variables.put(FieldCommon.STANDARD_STATE, StandardStateEnum.RELEASE.getStateValue());
String tryFlag = (String) variables.get(FieldCommon.TRY_FLAG);
if (tryFlag != null) {
if (tryFlag.equals(YesOrNoEnum.YES.getValue())) {
variables.put(FieldCommon.STANDARD_STATE, StandardStateEnum.TRIAL_OPERATION.getStateValue());
}
}
variables.put(FieldCommon.COMP_ILLUSTRATION, data.getCompIllustration());
variables.put(FieldCommon.RELEASE_DATE, data.getReleaseDate());
variables.put(FieldCommon.IMPLEMENTATION_DATE, data.getImplementDate());
variables.put(FieldCommon.MAIN_DRAFTING_UNIT_RESPONSIBLE_PERSON, data.getApprovalUser());
variables.put(FieldCommon.MODULE, TableNameEnum.ENTERPRISE_STANDARDS.getValue());
variables.put(FieldCommon.AUTH_DEPT, data.getAuthDept());
String standardId = IdWorker.getIdStr();
variables.put(FieldCommon.ID, standardId);
// minio上传在线编辑文件
String onEditFile = data.getOnEditFile();
if (StringUtils.isNotBlank(onEditFile)) {
String fileId = busProcessModelHisService.saveProcessFileToOss(onEditFile);
variables.put(FieldCommon.FILE_PUBLISH_OF_ORIGINAL, fileId);
}
// 发布企标
lawsCommonService.commonAdd(variables);
String espId = data.getEspId();
EnterpriseStandardPlan esp = espService.getById(espId);
// 保存评审会记录
EnterpriseStandardReviewMeetingRecord esRmr = new EnterpriseStandardReviewMeetingRecord();
esRmr.setStandardId(standardId);
esRmr.setPlanId(esp.getId());
esRmr.setReviewDate(data.getReviewDate());
esRmr.setReviewUser(data.getReviewUser());
rmrService.save(esRmr);
// 保存评审会评审结果
List<ReviewMeetingDetailVO> reviewMeetingDetailVOS = data.parseReviewMeetingDetails();
List<EnterpriseStandardRmrEvaluateDetail> rmrEvaluateDetails =
BeanCopyUtils.copyBeanList(reviewMeetingDetailVOS, EnterpriseStandardRmrEvaluateDetail.class);
rmrEvaluateDetails.forEach(r -> r.setReviewMeetingId(esRmr.getId()));
rmrDetailService.saveBatch(rmrEvaluateDetails);
// 企标计划改为已完成或者逾期完成
Date curDate = new Date();
if (curDate.after(esp.getDraftPlannedCompleteDate()) ||
curDate.after(esp.getSolicitationDraftPlanCompleteDate()) ||
curDate.after(esp.getPlanApprovalDate())) {
esp.setProjectStatus(ESPProjectStatus.OVERDUE_COMPLETED.getValue());
} else {
esp.setProjectStatus(ESPProjectStatus.COMPLETED.getValue());
}
espService.updateById(esp);
// 软删除制修订计划
esRevisionService.removeById(data.getId());
}
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esRevision.mapper;
import com.jero.modules.activiti.process.esRevision.entity.EsRevisionAdvice;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_revision_advice】的数据库操作Mapper
* @createDate 2023-12-20 17:17:56
* @Entity com.jero.modules.activiti.process.esRevision.entity.EsRevisionAdvice
*/
public interface EsRevisionAdviceMapper extends BaseMapper<EsRevisionAdvice> {
}
@@ -1,18 +0,0 @@
package com.jero.modules.activiti.process.esRevision.mapper;
import com.jero.modules.activiti.process.esRevision.entity.ProcessEsRevision;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author ThinkBook
* @description 针对表【process_es_revision】的数据库操作Mapper
* @createDate 2023-12-19 11:58:59
* @Entity com.jero.modules.activiti.process.esRevision.entity.EsRevision
*/
public interface EsRevisionMapper extends BaseMapper<ProcessEsRevision> {
}

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