/**
|
* 版权所有，侵权必究！
|
*/
|
|
package com.zt.modules.workflow.service;
|
|
import cn.hutool.core.convert.Convert;
|
import com.zt.common.entity.BaseEntity;
|
import com.zt.common.entity.BusiEntity;
|
import com.zt.common.entity.FlowInfo;
|
import com.zt.common.service.BaseService;
|
import com.zt.common.utils.UUIDUtil;
|
import com.zt.core.context.UserContext;
|
import com.zt.core.sys.model.SysUser;
|
import com.zt.modules.workflow.dao.WfRunTaskDao;
|
import com.zt.modules.workflow.dto.BizInfoDto;
|
import com.zt.modules.workflow.dto.QueryWfInfoDto;
|
import com.zt.modules.workflow.dto.TaskParamDto;
|
import com.zt.modules.workflow.model.WfRunInstance;
|
import com.zt.modules.workflow.model.WfRunTask;
|
import com.zt.modules.workflowconfig.dao.WfDefDao;
|
import com.zt.modules.workflowconfig.dao.WfDefStepDao;
|
import com.zt.modules.workflowconfig.model.WfDef;
|
import com.zt.modules.workflowconfig.model.WfDefStep;
|
import com.zt.modules.workflowconfig.service.WorkflowConfigService;
|
import org.apache.commons.lang.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 工作流服务
|
*
|
* @author 朱曙光
|
* @since 1.0.0
|
*/
|
@Service
|
public class WorkflowService extends BaseService<WfRunTaskDao, WfRunTask> {
|
@Autowired
|
private WfDefStepDao wfDefStepDao;
|
|
@Autowired
|
private WfDefDao wfDefDao;
|
|
@Autowired
|
private WorkflowConfigService workflowConfigService;
|
|
@Autowired
|
private WfRunInstanceService wfRunInstanceService;
|
|
@Value("${zt.oss.local-server}")
|
private String localServer;
|
|
public QueryWfInfoDto queryWfStepInfo(String wfCode, String wfStepId) {
|
QueryWfInfoDto dto = new QueryWfInfoDto();
|
|
dto.setIsMyStep(0);
|
dto.setIsFirstStep(0);
|
dto.setIsFinallyStep(0);
|
|
WfDefStep firstStep = this.queryWfDefFirstStep(wfCode);
|
WfDefStep finallyStep = this.queryWfDefFinallyStep(wfCode);
|
WfDefStep currentStep;
|
if (wfStepId == null) {
|
currentStep = firstStep;
|
} else {
|
currentStep = wfDefStepDao.selectById(Convert.toLong(wfStepId));
|
}
|
if (currentStep == null)
|
currentStep = firstStep;
|
|
dto.setWfStepId(currentStep.getId());
|
dto.setIsCounterSign(currentStep.getIsCounterSign());
|
dto.setCanRefuse(currentStep.getCanRefuse());
|
dto.setStepName(currentStep.getName());
|
dto.setApproverIds(currentStep.getApproverIds());
|
|
if (firstStep.getId() == currentStep.getId()) {
|
dto.setIsFirstStep(1);
|
}
|
if (finallyStep.getId() == currentStep.getId()) {
|
dto.setIsFinallyStep(1);
|
}
|
if (("," + currentStep.getApproverIds() + ",").contains("," + UserContext.getUserId().toString() + ",")) {
|
dto.setIsMyStep(1);
|
}
|
return dto;
|
}
|
|
public WfDefStep queryWfDefStep(String wfIdCode, String stepIdMarker) {
|
List<WfDefStep> list = wfDefStepDao.queryWfDefStep(wfIdCode, stepIdMarker);
|
if (list.isEmpty()) {
|
return null;
|
} else {
|
WfDefStep step = list.get(0);
|
// step.setCurrentUserId(UserContext.getUserId().toString());
|
return step;
|
}
|
}
|
|
public WfDefStep queryWfDefFirstStep(String wfIdCode) {
|
List<WfDefStep> list = wfDefStepDao.queryWfDefFirstStep(wfIdCode);
|
if (list.isEmpty()) {
|
return null;
|
} else {
|
WfDefStep step = list.get(0);
|
// step.setCurrentUserId(UserContext.getUserId().toString());
|
return step;
|
}
|
}
|
|
public WfDefStep queryWfDefFinallyStep(String wfIdCode) {
|
List<WfDefStep> list = wfDefStepDao.queryWfDefFinallyStep(wfIdCode);
|
if (list.isEmpty()) {
|
return null;
|
} else {
|
WfDefStep step = list.get(0);
|
// step.setCurrentUserId(UserContext.getUserId().toString());
|
return step;
|
}
|
}
|
|
public WfDefStep queryWfDefNextStep(WfDefStep currentStep) {
|
if (currentStep == null) {
|
throw new RuntimeException("Null WfDefStep object.");
|
}
|
|
List<WfDefStep> list = wfDefStepDao.queryWfDefNextStep(currentStep);
|
if (list.isEmpty()) {
|
} else {
|
return list.get(0);
|
}
|
return null;
|
}
|
|
public WfDefStep queryWfDefPreStep(WfDefStep currentStep) {
|
if (currentStep == null) {
|
throw new RuntimeException("Null WfDefStep object.");
|
}
|
List<WfDefStep> list = wfDefStepDao.queryWfDefPreStep(currentStep);
|
if (list.isEmpty()) {
|
} else {
|
return list.get(0);
|
}
|
return null;
|
}
|
|
public WfDefStep queryCurrentTaskStep(String wfIdCode, Long bizId) {
|
List<WfDefStep> list = baseDao.queryCurrentTaskStep(wfIdCode, bizId);
|
if (list.size() > 0)
|
return list.get(0);
|
else
|
return null;
|
}
|
|
public WfDefStep queryCurrentTaskStep100(String wfIdCode, Long bizId) {
|
List<WfDefStep> list = baseDao.queryCurrentTaskStep100(wfIdCode, bizId);
|
if (list.size() > 0)
|
return list.get(0);
|
else
|
return null;
|
}
|
|
public Boolean isFlowFinish(String wfIdCode, Long bizId) {
|
Boolean result = true;
|
String[] wfIdCodeArr = wfIdCode.split(",");
|
for (String code : wfIdCodeArr) {
|
List<WfRunTask> list = baseDao.getFlowFinish(wfIdCode, bizId);
|
if (list.size() == 0) {
|
result = false;
|
break;
|
}
|
}
|
return result;
|
}
|
|
// 按task分組設置上一步狀體，並獲取設置狀態后縂的步驟狀態
|
public Boolean setMyStepStatus(Long prevStepId, Long currentStepId, Integer status, Long bizId, Integer option) {
|
Boolean result = false;
|
WfDefStep prevStep = workflowConfigService.get(prevStepId);
|
if (prevStep != null) {
|
String taskGroup = prevStep.getTaskGroup();
|
status = status == 0 ? 20 : 10; // (0:20 pass, 1:10 refuse)
|
|
// 设置状态 本人status 别人status+1 taskGroup
|
baseDao.setTaskStatus(bizId, prevStepId, status, UserContext.getUserId(),
|
UserContext.getUser().getRealName(), taskGroup, option);
|
if (prevStep.getStepType() != 0 && currentStepId == 0L)
|
return false;
|
|
if (option == 1) {
|
// 1 refuse 2 pass 已办任务不显示 施工清单已办
|
// 设置状态 是否是驳回的（撤回？）
|
// 如果是駁回的，則後面的步驟都設置 status2 =1， 查詢狀態或待辦任務的時候要剔出
|
baseDao.setTaskRefuse(bizId, currentStepId, 1);
|
}
|
|
if (status == 10) {
|
// 驳回肯定执行（如果是按专业、部门分组的话，都驳回）
|
result = true;
|
} else {
|
// 前进的话检查，是否所有的都完成了（taskGroup）
|
result = this.getFlowStepFinish(prevStep.getWfDefId().toString(), bizId, prevStep.getStepMarker());
|
}
|
}
|
return result;
|
}
|
|
public void setTaskPartFinish(Long bizId, Long currentStepId, Integer status) {
|
baseDao.setTaskPartFinish(bizId, currentStepId, status);
|
}
|
|
public void setTaskPartFinish2(Long bizId, Long receiveId, Integer status) {
|
baseDao.setTaskPartFinish2(bizId, receiveId, status);
|
}
|
|
public void setTaskPartFinish3(Long bizId, Long receiveDeptId, Integer status) {
|
baseDao.setTaskPartFinish3(bizId, receiveDeptId, status);
|
}
|
|
public void setFlowTask(Long prevStepId, Long currentStepId, Integer status, Long bizId, String deptIds,
|
Integer direct) {
|
Boolean result = true;
|
if (prevStepId > 0) {
|
// 设置上一步骤的分組状态，並獲取上一步骤縂的狀態
|
result = setMyStepStatus(prevStepId, currentStepId, status, bizId, direct);
|
}
|
if (result) {
|
/*
|
* int num = baseDao.isExistsStep(null, currentStepId, bizId); if (num == 0) {
|
* setNextFlowTask(prevStepId, currentStepId, status, bizId, deptIds); }
|
*/
|
setNextFlowTask(prevStepId, currentStepId, status, bizId, deptIds);
|
}
|
}
|
|
public int isExistsStep(String currentStepMarker, Long currentStepId, Long bizId) {
|
int num = baseDao.isExistsStep(currentStepMarker, currentStepId, bizId);
|
System.out.println("num:" + num);
|
return num;
|
}
|
|
public void setNextFlowTask(Long prevStepId, Long currentStepId, Integer status, Long bizId, String deptIds) {
|
int num = baseDao.isExistsRunningStep(null, currentStepId, bizId);
|
if (num > 0) {
|
// 已經存在該步驟了，不用繼續
|
return;
|
}
|
WfDefStep currentStep = workflowConfigService.get(currentStepId);
|
WfDefStep finallyStep = this.queryWfDefFinallyStep(currentStep.getWfDefId().toString());
|
|
WfDef wfDef = wfDefDao.queryWfDef(currentStep.getWfDefId(), null).get(0);
|
|
Long instanceId = UUIDUtil.generateId();
|
WfRunInstance wfRunInstanceOld = wfRunInstanceService.getFlowInstance(wfDef.getCode(), bizId);
|
Boolean isNewInstance = true;
|
if (wfRunInstanceOld != null) {
|
isNewInstance = false;
|
instanceId = wfRunInstanceOld.getId();
|
}
|
|
String sqlStr = wfDef.getBizSql();
|
sqlStr = sqlStr.replace("${bizId}", bizId.toString());
|
List<BizInfoDto> bizInfoList = baseDao.getSqlResult(sqlStr);
|
BizInfoDto bizInfoDto = bizInfoList.size() > 0 ? bizInfoList.get(0) : null;
|
|
Long preTaskId = 0L;
|
WfRunTask task = getFlowStepStatus(wfDef.getCode(), bizId, currentStep.getStepMarker());
|
if (task != null)
|
preTaskId = task.getId();
|
|
// sqlStr = "update project set subject='aaa' where id=${bizId}";
|
// sqlStr = sqlStr.replace("${bizId}",bizId.toString());
|
// baseDao.exeSql(sqlStr);
|
|
Map<Long, String> existsUsers = new HashMap<Long, String>();
|
|
TaskParamDto taskParamDto = new TaskParamDto();
|
taskParamDto.setInstanceId(instanceId);
|
taskParamDto.setPreTaskId(preTaskId);
|
taskParamDto.setPrevStepId(prevStepId);
|
taskParamDto.setBizId(bizId);
|
taskParamDto.setStatus(status);
|
taskParamDto.setStatus2(0);
|
taskParamDto.setGroupId(UUIDUtil.generateId());
|
taskParamDto.setGroupId2(null);
|
taskParamDto.setEventDate(new Date());
|
taskParamDto.setWfDef(wfDef);
|
taskParamDto.setCurrentStep(currentStep);
|
taskParamDto.setBizInfoDto(bizInfoDto);
|
|
if (finallyStep.getStepNo() > currentStep.getStepNo()) {
|
|
Integer isSelfDept = currentStep.getIsSelfDept();
|
if (isSelfDept > 0 && bizInfoDto!=null) {
|
deptIds = bizInfoDto.getDeptIds();
|
}
|
if (isSelfDept == 0)
|
deptIds = null;
|
|
String bizGroupId = bizInfoList.get(0).getBizId();
|
if ("br".equals(currentStep.getTaskGroup())) {
|
List<SysUser> listUser = baseDao.getAssignUser(wfDef.getCode(), currentStep.getStepMarker(), bizId);
|
for (SysUser user : listUser) {
|
if (existsUsers.containsKey(user.getId())) {
|
continue;
|
}
|
existsUsers.put(user.getId(), "");
|
taskParamDto.setUser(user);
|
taskParamDto.setGroupId2(user.getId());
|
insertFlowTaskData(taskParamDto);
|
}
|
}
|
else if (StringUtils.isNotBlank(currentStep.getTaskGroup()) && "pall,zrr,csr,shr,pzr".contains(currentStep.getTaskGroup())) {
|
String userList = null;
|
if ("zrr".equals(currentStep.getTaskGroup())) {
|
userList = bizInfoDto.getZrr();
|
}
|
if ("csr".equals(currentStep.getTaskGroup())) {
|
userList = bizInfoDto.getCsr();
|
}
|
if ("shr".equals(currentStep.getTaskGroup())) {
|
userList = bizInfoDto.getShr();
|
}
|
if ("pzr".equals(currentStep.getTaskGroup())) {
|
userList = bizInfoDto.getPzr();
|
}
|
if ("pall".equals(currentStep.getTaskGroup())) {
|
userList = bizInfoDto.getPall();
|
}
|
if (userList != null) {
|
String[] userArr = userList.split(",");
|
Long groupId2 = UUIDUtil.generateId();
|
for (String userStr : userArr) {
|
Long userId = Convert.toLong(userStr);
|
SysUser user = baseDao.getUserById(userId);
|
existsUsers.put(userId, "");
|
taskParamDto.setUser(user);
|
taskParamDto.setGroupId2(groupId2);
|
insertFlowTaskData(taskParamDto);
|
}
|
}
|
} else if ("sqr".equals(currentStep.getTaskGroup())) {
|
SysUser user = baseDao.getUserById(bizInfoList.get(0).getApplyUserId());
|
existsUsers.put(user.getId(), "");
|
taskParamDto.setUser(user);
|
taskParamDto.setGroupId2(user.getId());
|
insertFlowTaskData(taskParamDto);
|
} else {
|
String roleIds = currentStep.getApproverRoleIds();
|
if (StringUtils.isBlank(roleIds)) {
|
throw new RuntimeException("没有设置下一步流程角色！");
|
}
|
String[] roleIdArr = roleIds.split(",");
|
for (String roleId : roleIdArr) {
|
if (StringUtils.isBlank(roleId))
|
continue;
|
List<SysUser> listUser = baseDao.getTaskUser(roleId, deptIds);
|
for (SysUser user : listUser) {
|
if (existsUsers.containsKey(user.getId())) {
|
continue;
|
}
|
existsUsers.put(user.getId(), "");
|
taskParamDto.setUser(user);
|
taskParamDto.setGroupId2(Convert.toLong(roleId));
|
insertFlowTaskData(taskParamDto);
|
}
|
}
|
}
|
if (existsUsers.size() == 0) {
|
throw new RuntimeException("没有符合(" + wfDef.getName() + ")流程的下一步(" + currentStep.getName() + ")执行人！");
|
}
|
|
WfDefStep prevStep = workflowConfigService.get(prevStepId);
|
if (prevStep!=null) {
|
String updateSql = prevStep.getUpdateSql();
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(updateSql)) {
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${nickName}", UserContext.getUser().getRealName());
|
updateSql = updateSql.replace("${userId}", UserContext.getUser().getId().toString());
|
baseDao.exeSql(updateSql);
|
}
|
}
|
} else {
|
taskParamDto.setUser(null);
|
taskParamDto.setGroupId2(null);
|
status = 100;
|
taskParamDto.setFinishTime(new Date());
|
taskParamDto.setStatus(status);
|
insertFlowTaskData(taskParamDto);
|
|
String updateSql = currentStep.getUpdateSql();
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(updateSql)) {
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${nickName}", UserContext.getUser().getRealName());
|
updateSql = updateSql.replace("${userId}", UserContext.getUser().getId().toString());
|
baseDao.exeSql(updateSql);
|
}
|
|
WfDefStep prevStep = workflowConfigService.get(prevStepId);
|
if (prevStep!=null) {
|
updateSql = prevStep.getUpdateSql();
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(updateSql)) {
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${bizId}", bizId.toString());
|
updateSql = updateSql.replace("${nickName}", UserContext.getUser().getRealName());
|
updateSql = updateSql.replace("${userId}", UserContext.getUser().getId().toString());
|
baseDao.exeSql(updateSql);
|
}
|
}
|
|
if (!StringUtils.isBlank(currentStep.getNextFlows())) {
|
boolean canNext = true;
|
if (!StringUtils.isBlank(currentStep.getPreFlows())) {
|
if (!this.isFlowFinish(currentStep.getPreFlows(), bizId)) {
|
canNext = false;
|
}
|
}
|
if (canNext) {
|
String[] nextFlowArr = currentStep.getNextFlows().split(",");
|
for (String nextFlowCode : nextFlowArr) {
|
this.startFlow(nextFlowCode, bizId);
|
}
|
}
|
}
|
}
|
if (currentStep.getStepType() == 0) {
|
WfRunInstance wfRunInstance = new WfRunInstance();
|
|
wfRunInstance.setFlowId(wfDef.getId());
|
wfRunInstance.setFlowCode(wfDef.getCode());
|
|
wfRunInstance.setBizId(bizId);
|
wfRunInstance.setRunStatus(1);
|
|
wfRunInstance.setHasOut(0);
|
wfRunInstance.setStepSite(currentStep.getStepSite());
|
wfRunInstance.setStepId(currentStep.getStepId());
|
wfRunInstance.setStepMarker(currentStep.getStepMarker());
|
wfRunInstance.setStepName(currentStep.getName());
|
wfRunInstance.setStatus(status);
|
wfRunInstance.setPrevId(preTaskId);
|
wfRunInstance.setPrevStepId(prevStepId);
|
|
wfRunInstance.setSenderId(UserContext.getUser().getId());
|
wfRunInstance.setSenderName(UserContext.getUser().getRealName());
|
wfRunInstance.setSenderTime(taskParamDto.getEventDate());
|
|
String param = bizInfoDto == null ? "" : bizInfoDto.getParam();
|
param = "".equals(param) ? "" : " (" + param + ")";
|
wfRunInstance.setRemark(wfDef.getRemark() + param);
|
|
wfRunInstance.setTitle(wfDef.getName());
|
if (bizInfoList.size() > 0) {
|
wfRunInstance.setBizGroupId(taskParamDto.getBizInfoDto().getBizGroupId());
|
wfRunInstance.setApplyUserId(taskParamDto.getBizInfoDto().getApplyUserId());
|
wfRunInstance.setApplyUser(taskParamDto.getBizInfoDto().getApplyUser());
|
wfRunInstance.setApplyTime(taskParamDto.getBizInfoDto().getApplyTime());
|
wfRunInstance.setTopic(taskParamDto.getBizInfoDto().getTopic());
|
}
|
|
if (isNewInstance) {
|
// wfRunInstance = new WfRunInstance();
|
wfRunInstance.setId(instanceId);
|
wfRunInstanceService.insert(wfRunInstance);
|
} else {
|
wfRunInstance.setId(wfRunInstanceOld.getId());
|
wfRunInstanceService.update(wfRunInstance);
|
}
|
}
|
|
WfDefStep prevStep = workflowConfigService.get(prevStepId);
|
if (prevStep != null && currentStep.getStepType() == 0) {
|
if (prevStep.getCopyTo() != null) {
|
String[] copyStepArr = prevStep.getCopyTo().split(",");
|
for (String stepMarker : copyStepArr) {
|
WfDefStep wfDefStep = this.queryWfDefStep(null, stepMarker);
|
if (wfDefStep != null)
|
setNextFlowTask(prevStep.getId(), wfDefStep.getId(), 0, bizId, null);
|
}
|
}
|
}
|
}
|
|
public void insertFlowTaskData(TaskParamDto taskParamDto) {
|
WfRunTask wfRunTask = new WfRunTask();
|
wfRunTask.setInstanceId(taskParamDto.getInstanceId());
|
wfRunTask.setPrevId(taskParamDto.getPreTaskId());
|
wfRunTask.setPrevStepId(taskParamDto.getPrevStepId());
|
wfRunTask.setFlowCode(taskParamDto.getWfDef().getCode());
|
wfRunTask.setFlowId(taskParamDto.getCurrentStep().getWfDefId());
|
wfRunTask.setStepId(taskParamDto.getCurrentStep().getId());
|
wfRunTask.setStepName(taskParamDto.getCurrentStep().getName());
|
wfRunTask.setStepMarker(taskParamDto.getCurrentStep().getStepMarker());
|
|
wfRunTask.setHasOut(0);
|
wfRunTask.setStepSite(taskParamDto.getCurrentStep().getStepSite());
|
|
wfRunTask.setBizId(taskParamDto.getBizId());
|
wfRunTask.setGroupId(taskParamDto.getGroupId());
|
wfRunTask.setGroupId2(taskParamDto.getGroupId2());
|
|
wfRunTask.setSenderId(UserContext.getUser().getId());
|
wfRunTask.setSenderName(UserContext.getUser().getRealName());
|
wfRunTask.setSenderTime(taskParamDto.getEventDate());
|
|
if (taskParamDto.getUser() != null) {
|
wfRunTask.setReceiveId(taskParamDto.getUser().getId());
|
wfRunTask.setReceiveName(taskParamDto.getUser().getRealName());
|
}
|
|
wfRunTask.setReceiveTime(taskParamDto.getEventDate());
|
wfRunTask.setOpenTime(null);
|
wfRunTask.setFinishTime(null);
|
wfRunTask.setFinishTime2(null);
|
|
wfRunTask.setStatus(taskParamDto.getStatus());
|
String param = "";
|
if (taskParamDto.getBizInfoDto() != null) {
|
param = taskParamDto.getBizInfoDto().getParam();
|
wfRunTask.setBizGroupId(taskParamDto.getBizInfoDto().getBizGroupId());
|
wfRunTask.setApplyUserId(taskParamDto.getBizInfoDto().getApplyUserId());
|
wfRunTask.setApplyUser(taskParamDto.getBizInfoDto().getApplyUser());
|
wfRunTask.setApplyTime(taskParamDto.getBizInfoDto().getApplyTime());
|
wfRunTask.setTopic(taskParamDto.getBizInfoDto().getTopic());
|
}
|
if (StringUtils.isBlank(taskParamDto.getCurrentStep().getStepTitle())) {
|
wfRunTask.setTitle(taskParamDto.getWfDef().getName());
|
} else {
|
wfRunTask.setTitle(taskParamDto.getCurrentStep().getStepTitle());
|
}
|
param = "".equals(param) ? "" : " (" + param + ")";
|
wfRunTask.setRemark(taskParamDto.getWfDef().getRemark() + param);
|
|
baseDao.insert(wfRunTask);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean writeFlowTask(WfRunTask wfRunTask) {
|
Date eventDate = new Date();
|
Long groupId = UUIDUtil.generateId();
|
// wfRunTask.setPrevId(0L);
|
/// wfRunTask.setPrevStepId(0L);
|
// wfRunTask.setFlowId(currentStep.getWfDefId());
|
// wfRunTask.setFlowCode(wfDef.get(0).getCode());
|
// wfRunTask.setStepId(currentStep.getId());
|
// wfRunTask.setStepName(currentStep.getName());
|
// wfRunTask.setStepMarker(currentStep.getStepMarker());
|
// wfRunTask.setBizId(bizId);
|
// wfRunTask.setTitle(currentStep.getStepTitle());
|
wfRunTask.setSenderId(UserContext.getUser().getId());
|
wfRunTask.setSenderName(UserContext.getUser().getRealName());
|
wfRunTask.setSenderTime(eventDate);
|
|
wfRunTask.setGroupId(groupId);
|
wfRunTask.setGroupId2(groupId);
|
// wfRunTask.setReceiveId(UserContext.getUser().getId());
|
// wfRunTask.setReceiveName(UserContext.getUser().getRealName());
|
wfRunTask.setReceiveTime(eventDate);
|
wfRunTask.setOpenTime(null);
|
wfRunTask.setFinishTime(null);
|
wfRunTask.setFinishTime2(null);
|
|
// wfRunTask.setStatus(100);
|
wfRunTask.setApplyUserId(UserContext.getUser().getId());
|
wfRunTask.setApplyUser(UserContext.getUser().getRealName());
|
wfRunTask.setApplyTime(eventDate);
|
|
baseDao.insert(wfRunTask);
|
return true;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean startFlow(String wfCode, Long bizId) {
|
if (hasExistFlow(wfCode, bizId)) {
|
return false;
|
}
|
WfDefStep firstStep = this.queryWfDefFirstStep(wfCode);
|
if (firstStep == null) {
|
throw new RuntimeException("没有定义流程" + wfCode);
|
}
|
|
// this.createFlowInstance(wfCode,bizId);
|
this.setFlowTask(0L, firstStep.getId(), 0, bizId, null, 0);
|
return true;
|
}
|
|
public void createFlowInstance(String wfCode, Long bizId) {
|
WfDef wfDef = wfDefDao.queryWfDef(null, wfCode).get(0);
|
WfRunInstance wfRunInstance = new WfRunInstance();
|
wfRunInstance.setFlowId(wfDef.getId());
|
wfRunInstance.setFlowCode(wfDef.getCode());
|
wfRunInstance.setBizId(bizId);
|
wfRunInstanceService.insert(wfRunInstance);
|
}
|
|
public void deleteFlowTask(String wfIdCodes, Long bizId) {
|
baseDao.deleteFlowTask(wfIdCodes, bizId);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void approvePass(String wfIdCode, Long bizId, String stepIdMark) {
|
WfDefStep taskDbStep = this.queryCurrentTaskStep(wfIdCode, bizId);
|
if (taskDbStep == null) {
|
throw new RuntimeException("没有当前任务");
|
}
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该步骤");
|
}
|
|
WfDefStep endStep = this.queryWfDefFinallyStep(wfIdCode);
|
if (currentStep.getStepNo() == endStep.getStepNo()) {
|
throw new RuntimeException("已经完成了，不能继续提交");
|
}
|
|
if (taskDbStep.getStepNo() != currentStep.getStepNo()) {
|
throw new RuntimeException("其他用户已经提交");
|
} else {
|
Long nextStepId = 0L;
|
if (currentStep.getStepType() == 0) {
|
WfDefStep nextStep = this.queryWfDefNextStep(currentStep);
|
nextStepId = nextStep.getId();
|
}
|
this.setFlowTask(currentStep.getId(), nextStepId, 0, bizId, null, 2);
|
}
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void approvePass2(String wfIdCode, Long bizId, String stepIdMark, String nextStepIdMark) {
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该当前步骤");
|
}
|
|
Long nextStepId = 0L;
|
if (currentStep.getStepType() == 0) {
|
WfDefStep nextStep = this.queryWfDefStep(wfIdCode, nextStepIdMark);
|
nextStepId = nextStep.getId();
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有指定下一步步骤");
|
}
|
}
|
|
WfDefStep endStep = this.queryWfDefFinallyStep(wfIdCode);
|
if (currentStep.getStepNo() == endStep.getStepNo()) {
|
throw new RuntimeException("已经完成了，不能继续提交");
|
}
|
this.setFlowTask(currentStep.getId(), nextStepId, 0, bizId, null, 2);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void approveDirectPass(String wfIdCode, Long bizId, String stepIdMark, String nextStepIdMark) {
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该当前步骤");
|
}
|
|
Long nextStepId = 0L;
|
if (currentStep.getStepType() == 0) {
|
WfDefStep nextStep = this.queryWfDefStep(wfIdCode, nextStepIdMark);
|
nextStepId = nextStep.getId();
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有指定下一步步骤");
|
}
|
}
|
|
WfDefStep endStep = this.queryWfDefFinallyStep(wfIdCode);
|
if (currentStep.getStepNo() == endStep.getStepNo()) {
|
throw new RuntimeException("已经完成了，不能继续提交");
|
}
|
this.setNextFlowTask(currentStep.getId(), nextStepId, 0, bizId, null);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
// 驳回到上一步
|
public void approveRefuse(String wfIdCode, Long bizId, String stepIdMark) {
|
WfDefStep taskDbStep = this.queryCurrentTaskStep(wfIdCode, bizId);
|
if (taskDbStep == null) {
|
throw new RuntimeException("没有当前任务");
|
}
|
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该步骤");
|
}
|
|
WfDefStep firstStep = this.queryWfDefFirstStep(wfIdCode);
|
if (currentStep.getStepNo() == firstStep.getStepNo()) {
|
throw new RuntimeException("已经第一步了，不能驳回");
|
}
|
|
if (taskDbStep.getStepNo() != currentStep.getStepNo()) {
|
throw new RuntimeException("其他用户已经提交");
|
} else {
|
WfDefStep preStep = this.queryWfDefPreStep(currentStep);
|
this.setFlowTask(currentStep.getId(), preStep.getId(), 1, bizId, null, 1);
|
}
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
// 驳回到指定步骤
|
public void approveRefuse2(String wfIdCode, Long bizId, String stepIdMark, String prevStepIdMark) {
|
WfDefStep taskDbStep = this.queryCurrentTaskStep100(wfIdCode, bizId);
|
if (taskDbStep == null) {
|
throw new RuntimeException("没有当前任务");
|
}
|
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该当前步骤");
|
}
|
|
WfDefStep firstStep = this.queryWfDefFirstStep(wfIdCode);
|
if (currentStep.getStepNo() == firstStep.getStepNo()) {
|
throw new RuntimeException("已经第一步了，不能驳回");
|
}
|
|
WfDefStep preStep = this.queryWfDefStep(wfIdCode, prevStepIdMark);
|
if (preStep == null) {
|
throw new RuntimeException("该流程没有指定前一步步骤");
|
}
|
this.setFlowTask(currentStep.getId(), preStep.getId(), 1, bizId, null, 1);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
// 重新从某一步开始
|
public void reStartFlow(String wfIdCode, Long bizId, String stepIdMark, String prevStepIdMark) {
|
WfDefStep taskDbStep = this.queryCurrentTaskStep100(wfIdCode, bizId);
|
if (taskDbStep == null) {
|
throw new RuntimeException("没有当前任务");
|
}
|
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (currentStep == null) {
|
throw new RuntimeException("该流程没有该当前步骤");
|
}
|
|
WfDefStep firstStep = this.queryWfDefFirstStep(wfIdCode);
|
if (currentStep.getStepNo() == firstStep.getStepNo()) {
|
throw new RuntimeException("已经第一步了，不能驳回");
|
}
|
|
WfDefStep preStep = this.queryWfDefStep(wfIdCode, prevStepIdMark);
|
if (preStep == null) {
|
throw new RuntimeException("该流程没有指定前一步步骤");
|
}
|
baseDao.setReStartStatus(wfIdCode, bizId);
|
this.setFlowTask(currentStep.getId(), preStep.getId(), 0, bizId, null, 1);
|
}
|
|
public Map<String, WfRunTask> getSingleFlowStatus(String wfIdCodes, Long bizId) {
|
int lastStepStatus = 100;
|
Map<String, WfRunTask> result = new HashMap<>();
|
if ("yearPlanFlow".equals(wfIdCodes)) {
|
WfRunTask item_zl = new WfRunTask();
|
WfRunTask item_cz = new WfRunTask();
|
int count = baseDao.getRoleCount(UserContext.getUser().getId(), "zlbm");
|
if (count > 1) {
|
item_zl.setStatus(1);
|
item_cz.setStatus(0);
|
} else {
|
item_zl.setStatus(20);
|
item_cz.setStatus(1);
|
}
|
result.put("yearPlanFlow_zl", item_zl);
|
result.put("yearPlanFlow_cz", item_cz);
|
} else if ("yearPlanFlow2".equals(wfIdCodes)) {
|
WfRunTask item_zl = new WfRunTask();
|
WfRunTask item_cz = new WfRunTask();
|
int status = baseDao.getPlanStatus(bizId);
|
if (status == 10) {
|
item_zl.setStatus(20);
|
item_cz.setStatus(20);
|
} else if (status == 5) {
|
item_zl.setStatus(20);
|
item_cz.setStatus(1);
|
} else {
|
item_zl.setStatus(1);
|
item_cz.setStatus(0);
|
}
|
|
result.put("yearPlanFlow_zl", item_zl);
|
result.put("yearPlanFlow_cz", item_cz);
|
} else {
|
List<WfRunTask> list = baseDao.getSingleFlowStatus(wfIdCodes, bizId);
|
for (WfRunTask item : list) {
|
lastStepStatus = checkStaus(lastStepStatus, item.getStatus(), item);
|
item.setStatus(lastStepStatus);
|
result.put(item.getStepMarker(), item);
|
}
|
}
|
return result;
|
}
|
|
public int checkStaus(int lastStepStatus, int currentStepStatus, WfRunTask item) {
|
if (currentStepStatus > lastStepStatus && !"jzjys_sc".equals(item.getStepMarker())) {
|
return 0;
|
} else {
|
return currentStepStatus;
|
}
|
}
|
|
public Map<String, WfRunTask> getFlowStatus(String wfIdCodes, Long bizId) {
|
int lastStepStatus = 0;
|
String lastflowCode = "";
|
Map<String, WfRunTask> result = new HashMap<>();
|
List<WfRunTask> list = baseDao.getFlowStatus(wfIdCodes, bizId);
|
for (WfRunTask item : list) {
|
if (!lastflowCode.equals(item.getFlowCode())) {
|
lastflowCode = item.getFlowCode();
|
lastStepStatus = item.getStatus();
|
result.put(item.getStepMarker(), item);
|
} else {
|
lastStepStatus = checkStaus(lastStepStatus, item.getStatus(), item);
|
item.setStatus(lastStepStatus);
|
result.put(item.getStepMarker(), item);
|
}
|
}
|
|
List<WfRunTask> list2 = baseDao.getFlowStatus2(wfIdCodes, bizId);
|
for (WfRunTask item : list2) {
|
if (!lastflowCode.equals(item.getFlowCode())) {
|
lastflowCode = item.getFlowCode();
|
lastStepStatus = item.getStatus();
|
result.put(item.getStepMarker(), item);
|
} else {
|
lastStepStatus = checkStaus(lastStepStatus, item.getStatus(), item);
|
item.setStatus(lastStepStatus);
|
result.put(item.getStepMarker(), item);
|
}
|
}
|
return result;
|
}
|
|
public Map<String, WfRunTask> getFlowStatus2(String wfIdCodes, Long bizId) {
|
Map<String, WfRunTask> result = new HashMap<>();
|
List<WfRunTask> list = baseDao.getFlowStatus3(wfIdCodes, bizId);
|
for (WfRunTask item : list) {
|
result.put(item.getFlowCode(), item);
|
}
|
return result;
|
}
|
|
// 弃用
|
public Map<String, Integer> getPlanFlowStatus(Long bizId) {
|
Map<String, Integer> result = new HashMap<>();
|
/*
|
* List<WfRunTask> list = baseDao.getPLanFlowStatus(bizId); for (WfRunTask item
|
* : list) { result.put(item.getFlowCode(), item.getStatus()); }
|
*/
|
return result;
|
}
|
|
// 准备弃用
|
public Map<String, WfRunTask> getPlanFlowStatus2(Long bizId) {
|
Map<String, WfRunTask> result = new HashMap<>();
|
/*
|
* List<WfRunTask> list = baseDao.getPLanFlowStatus(bizId); for (WfRunTask item
|
* : list) { if ("planFlow".equals(item.getFlowCode()))
|
* result.put("gcjd_plan_tybx", item); else if
|
* ("sgmxFlow".equals(item.getFlowCode())) result.put("gcjd_sgmx_bb", item);
|
* else if ("sgqdFlow".equals(item.getFlowCode())) result.put("gcjd_sgqd_cz",
|
* item); else if ("gckyFlow".equals(item.getFlowCode()))
|
* result.put("gcjd_gcky_bb", item); else if
|
* ("gywjFlow".equals(item.getFlowCode())) result.put("gcjd_gywj_sc", item);
|
* else if ("jzjFlow".equals(item.getFlowCode())) result.put("gcjd_jzj_bb",
|
* item); else if ("wltFlow".equals(item.getFlowCode()))
|
* result.put("gcjd_wlt_pz", item); else if
|
* ("wxsbFlow".equals(item.getFlowCode())) result.put("gcjd_wxsb_wxsb", item);
|
* else if ("jsfaFlow".equals(item.getFlowCode())) result.put("gcjd_jsfa_sc",
|
* item); else if ("yxscFlow".equals(item.getFlowCode()))
|
* result.put("gcjd_yxsc_bb", item); }
|
*/
|
return result;
|
}
|
|
public Map<String, WfRunTask> getPhaseFlowStatus(String wfIdCode, Long bizId) {
|
Map<String, WfRunTask> result = new HashMap<>();
|
List<WfRunTask> list = baseDao.getPhaseFlowStatus(wfIdCode, bizId);
|
for (WfRunTask item : list) {
|
result.put(item.getFlowCode(), item);
|
}
|
return result;
|
}
|
|
public Boolean getFlowStepFinish(String wfIdCode, Long bizId, String stepIdMark) {
|
Integer finishNum = baseDao.getFlowStepFinish(wfIdCode, bizId, stepIdMark);
|
if (finishNum > 0)
|
return false;
|
else
|
return true;
|
}
|
|
public Boolean getFlowStepFinish2(String wfIdCode, Long bizId, String stepIdMark) {
|
Integer finishNum = baseDao.getFlowStepFinish2(wfIdCode, bizId, stepIdMark);
|
if (finishNum > 0)
|
return true;
|
else
|
return false;
|
}
|
|
public Boolean isMyStepFinish(String wfIdCode, Long bizId, String stepIdMark) {
|
Integer finishNum = baseDao.isMyStepFinish(wfIdCode, bizId, stepIdMark, UserContext.getUser().getId());
|
if (finishNum > 0) {
|
// 我的完成了
|
return true;
|
} else {
|
// 我的未完成了
|
return false;
|
}
|
}
|
|
/*
|
* myStatus 0: 不是我的步骤 1: 是我的步骤，当前正需要我执行 2：其他情况 5：步骤执行过了
|
*/
|
public WfRunTask getFlowStepStatus(String wfIdCode, Long bizId, String stepIdMark) {
|
WfRunTask result = null;
|
WfDefStep requestStep = this.queryWfDefStep(wfIdCode, stepIdMark);
|
if (requestStep != null) {
|
List<WfRunTask> list = baseDao.getFlowStepStatus(wfIdCode, bizId);
|
if (list.size() > 0) {
|
result = list.get(0);
|
result.setMyStatus(0);
|
WfDefStep currentStep = this.queryWfDefStep(wfIdCode, list.get(0).getStepMarker());
|
Integer myStep = baseDao.isMyStep(wfIdCode, bizId, requestStep.getStepMarker(),
|
UserContext.getUser().getId());
|
if (myStep > 0)
|
result.setMyStatus(1);
|
else if (currentStep.getStepNo() > requestStep.getStepNo()) {
|
result.setMyStatus(5); // 执行过了
|
} else if (currentStep.getStepNo() == requestStep.getStepNo()) {
|
result.setMyStatus(2);
|
}
|
}
|
}
|
return result;
|
}
|
|
public WfRunTask getFlowStepStatus2(String wfIdCode, Long bizId, String stepIdMark) {
|
List<WfRunTask> list = baseDao.getFlowStepStatus(wfIdCode, bizId);
|
WfRunTask result = null;
|
if (list.size() > 0) {
|
result = list.get(0);
|
result.setMyStatus(0);
|
if (result.getStatus() == 0 || result.getStatus() == 1) {
|
Integer myStep = baseDao.isMyStep(wfIdCode, bizId, result.getStepMarker(),
|
UserContext.getUser().getId());
|
if (myStep > 0)
|
result.setMyStatus(1);
|
else
|
result.setMyStatus(2);
|
}
|
}
|
return result;
|
}
|
|
public List<Map<String, Object>> getStepCount(String wfIdCode, Long bizId) {
|
List<WfRunTask> list = baseDao.getStepCount(wfIdCode, bizId);
|
List<Map<String, Object>> result = new ArrayList<>();
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", "数量");
|
for (WfRunTask item : list) {
|
map.put(item.getStepMarker(), item.getStatus());
|
}
|
result.add(map);
|
return result;
|
}
|
|
public Boolean hasExistFlow(String wfIdCode, Long bizId) {
|
Integer num = baseDao.getBizTaskCount(wfIdCode, bizId);
|
return num > 0 ? true : false;
|
}
|
|
public String recallFlow(String wfIdCode, Long bizId, String stepMarker, Long taskId, Long taskPrevId) {
|
WfRunTask task = getFlowStepStatus(wfIdCode, bizId, stepMarker);
|
if (task != null) {
|
if (task.getStatus() == 0 || task.getStatus() == 1) {
|
if (localServer.equals(task.getStepSite()) || localServer.equals("yjs") || task.getHasOut() == 0) {
|
baseDao.setTaskRecall(taskId, wfIdCode);
|
WfRunTask task2 = baseDao.selectById(taskId);
|
if (task2 != null) {
|
Long stepId = task2.getStepId();
|
WfDefStep wfDefStep = workflowConfigService.get(stepId);
|
this.refuseExecSql(wfDefStep, bizId);
|
}
|
return "OK";
|
} else {
|
return "已经导出到其他服务器执行，不能撤回了";
|
}
|
}
|
}
|
return "任务已经执行完毕，不能撤回了";
|
}
|
|
public void refuseExecSql(WfDefStep wfDefStep, Long bizId) {
|
if (wfDefStep != null) {
|
String sqlStr = wfDefStep.getRecallSql();
|
if (StringUtils.isNotEmpty(sqlStr)) {
|
sqlStr = sqlStr.replace("${bizId}", bizId.toString());
|
baseDao.exeSql(sqlStr);
|
}
|
}
|
}
|
|
public Map<String, Map<String, String>> getAllSteps() {
|
Map<String, String> bean = new HashMap<>();
|
bean.put("status", "");
|
bean.put("receiveName", "");
|
Map<String, Map<String, String>> result = new HashMap<>();
|
List<String> list = wfDefStepDao.getAllSteps();
|
for (String item : list) {
|
result.put(item, bean);
|
}
|
return result;
|
}
|
|
public List<WfRunTask> getConnectInformation(String oldShipTeam) {
|
return baseDao.getConnectInformation(oldShipTeam);
|
}
|
|
public void updateConnect(String oldShipTeam) {
|
baseDao.updateConnect(oldShipTeam);
|
}
|
|
public List<WfRunTask> getFlowTrack(String flowCode, Long bizId) {
|
List<WfRunTask> flowTrack = baseDao.getFlowTrack(flowCode, bizId);
|
return flowTrack;
|
}
|
|
public String getFlowStepName(String wfIdCodes, Long bizId) {
|
return baseDao.getFlowStepName(wfIdCodes, bizId);
|
}
|
|
public void deleteFlowStep(String wfIdCode, String stepIdMark, Long bizId){
|
baseDao.deleteFlowStep(wfIdCode,stepIdMark,bizId);
|
}
|
|
public void getRunFlow(List<? extends BusiEntity> dataList, String flowCode) {
|
List<Long> ids = dataList.stream().map(f -> f.getId()).collect(Collectors.toList());
|
Map<String, Object> params = new HashMap<String, Object>();
|
params.put("bizIds", ids);
|
params.put("flowCode", flowCode);
|
List<FlowInfo> list = baseDao.getRunFlow(params);
|
for (BaseEntity item : dataList) {
|
List<FlowInfo> list2 = list.stream().filter(item2->item2.getBizId().equals(item.getId())).collect(Collectors.toList());
|
if (list2.size()>0) {
|
item.setFlowInfo(list2.get(0));
|
}else{
|
item.setFlowInfo(new FlowInfo());
|
}
|
}
|
}
|
}
|
