package com.vci.web.dao.impl;
|
|
import com.vci.base.common.utility.ObjectUtility;
|
import com.vci.corba.common.VCIError;
|
import com.vci.corba.framework.data.UserEntityInfo;
|
import com.vci.corba.workflow.data.*;
|
import com.vci.corba.workflow.method.WorkflowService;
|
import com.vci.frameworkcore.compatibility.SmUserQueryServiceI;
|
import com.vci.frameworkcore.pagemodel.SmUserVO;
|
import com.vci.rmip.workflow.server.template.TasksAssigned;
|
import com.vci.starter.web.constant.QueryOptionConstant;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.DataGrid;
|
import com.vci.starter.web.pagemodel.PageHelper;
|
import com.vci.starter.web.pagemodel.SessionInfo;
|
import com.vci.starter.web.util.BeanUtil;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.util.VciDateUtil;
|
import com.vci.web.constant.WFVariablesKeyConstant;
|
import com.vci.web.dao.WebProcessDaoI;
|
import com.vci.web.model.ProcessInstance;
|
import com.vci.web.model.ProcessTask;
|
import com.vci.web.model.WFProcessClassifyDO;
|
import com.vci.web.model.WFProcessTemplateDO;
|
import com.vci.web.pageModel.*;
|
import com.vci.web.service.WebBoServiceI;
|
import com.vci.web.service.OsLifeCycleServiceI;
|
import com.vci.web.service.WebLoServiceI;
|
import com.vci.web.util.PlatformClientUtil;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Repository;
|
import org.springframework.util.CollectionUtils;
|
import plm.bs.bom.clientobject.ClientBusinessObject;
|
import plm.bs.bom.clientobject.ClientLinkObject;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_OID_NOT_EXIST;
|
|
/**
|
* 流程的数据层
|
* @author weidy
|
*/
|
@Repository
|
public class WebProcessDaoImpl implements WebProcessDaoI {
|
|
@Autowired
|
private WebBoServiceI boService;
|
|
@Autowired
|
private WebLoServiceI loService;
|
|
@Autowired
|
private OsLifeCycleServiceI lifeCycleService;
|
|
/**
|
* 用户查询服务
|
*/
|
@Autowired
|
private SmUserQueryServiceI userQueryService;
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 构造方法，初始化平台的流程服务
|
*/
|
|
/**
|
* 多语言的前缀
|
*/
|
private final String msgCodePrefix = "com.vci.web.flow.";
|
|
/**
|
* 平台的流程服务
|
*/
|
private WorkflowService workService = null;
|
|
/**
|
* 平台调用客户端
|
*/
|
@Autowired
|
private PlatformClientUtil platformClientUtil;
|
/***
|
* 流程分类主键和类型的映射
|
*/
|
private Map<String/*类型*/,String/*主键*/> categoryMap = new HashMap<String, String>();
|
|
private final String workitemBtmType = "workitem";
|
|
private final String workIntanceBtmType = "workflowinstance";
|
|
private final String processDataLink ="input";
|
|
private final String taskDataLink = "input";
|
|
|
/**
|
* 获取流程分类的映射
|
* @throws VciBaseException
|
*/
|
private void getCategory() throws VciBaseException {
|
// try {
|
// ProcessCategoryInfo[] pcia = getWorkService().getProcessCategories("root");
|
// if(pcia!=null&&pcia.length>0){
|
// for(ProcessCategoryInfo pci : pcia){
|
// categoryMap.put(pci.name.toLowerCase(), pci.id);
|
// }
|
// }
|
// } catch (VCIError e) {
|
// WebUtil.getVciBaseException(e);
|
// }//平台没有根据分类名称获取流程分类的接口
|
}
|
|
/**
|
* 获取某个分类下的所有流程模版
|
* @param type 分类信息
|
* @param filterTemplate 指定模板
|
* @param showAll 是否显示所有版本的
|
* @return
|
* @throws
|
*/
|
@Override
|
public List<ProcessTemplateVO> getTemplatesByType(String type, String filterTemplate,boolean showAll)
|
throws VciBaseException {
|
WebUtil.alertNotNull(type,"模板分类");
|
ProcessDefinitionInfo[] allFlowInType = null;
|
if(StringUtils.isBlank(filterTemplate)) {
|
type = type.toLowerCase();
|
if (categoryMap.isEmpty() || !categoryMap.containsKey(type)) {
|
getCategory();
|
}
|
String typeOid = "" ;
|
if (categoryMap.containsKey(type)) {
|
typeOid = categoryMap.get(type);
|
} else {
|
throw new VciBaseException(msgCodePrefix + "typeNotExist", new String[]{type});
|
}
|
// try {
|
// allFlowInType = getWorkService().getProcessDefinitions(typeOid);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
}else{
|
List<ProcessDefinitionInfo> infoList = new ArrayList<>();
|
VciBaseUtil.str2List(filterTemplate).stream().forEach(name->{
|
// try {
|
// String nameUnRev = name;
|
// String revision = "";
|
// if(name.contains("-")){
|
// nameUnRev = name.substring(0,name.lastIndexOf("-"));
|
// revision = name.substring(name.lastIndexOf("-")+1);
|
// }
|
// ProcessDefinitionInfo[] definition = getWorkService().getProcessDefinitionByProcessDefinitionName(nameUnRev, "");
|
// if(definition!=null){
|
// if(StringUtils.isBlank(revision)) {
|
// Collections.addAll(infoList, definition);
|
// }else{
|
// //过滤版本
|
// String finalRevision = revision;
|
// infoList.addAll(Arrays.stream(definition).filter(s -> finalRevision.equalsIgnoreCase(String.valueOf(s.version))).collect(Collectors.toList()));
|
// }
|
// }
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
});
|
allFlowInType = infoList.toArray(new ProcessDefinitionInfo[0]);
|
}
|
return swapProcessTemplate(allFlowInType, type, showAll);
|
}
|
|
@Override
|
public ProcessTemplateVO getTemplateByDeployId(String deployId) throws VciBaseException {
|
WebUtil.alertNotNull(deployId,"流程部署主键");
|
ProcessDefinitionInfo pdi = null;
|
// try {
|
// pdi = getWorkService().getProcessDefinitionByDeployId(deployId.trim());
|
// } catch (VCIError e) {
|
// throw new VciBaseException(msgCodePrefix + "deployIdNotExist", new String[]{deployId});
|
// }
|
List<ProcessTemplateVO> proTemplates = swapProcessTemplate(new ProcessDefinitionInfo[]{pdi},"",false);
|
if(proTemplates == null || proTemplates.size() == 0){
|
throw new VciBaseException(msgCodePrefix + "deployIdNotExist", new String[]{deployId});
|
}
|
return proTemplates.get(0);
|
}
|
|
private List<ProcessTemplateVO> swapProcessTemplate(ProcessDefinitionInfo[] allFlowInType, String type, boolean showAll){
|
List<ProcessTemplateVO> allTemplate = new ArrayList<ProcessTemplateVO>();
|
if(allFlowInType!=null&&allFlowInType.length>0){
|
for(ProcessDefinitionInfo pd : allFlowInType){
|
//status = 0 表示停用， status = 1表示启用
|
if("1".equalsIgnoreCase(pd.status) || showAll){
|
ProcessTemplateVO pt = new ProcessTemplateVO();
|
pt.setOid(pd.id);
|
pt.setCategroyOid(pd.categroyId);
|
pt.setDeploymentId(pd.jbpmDeploymentId);
|
pt.setKey(pd.key);
|
pt.setName(pd.name);
|
pt.setStatus(pd.status);
|
pt.setTaskType(type);
|
// pt.setVersion(pd.version);
|
allTemplate.add(pt);
|
}
|
}
|
}
|
return allTemplate;
|
}
|
|
/**
|
* 获取流程的所有节点
|
* @param processOid
|
*/
|
@Override
|
public List<ProcessNodeVO> getAllProcessNode(String processOid)
|
throws VciBaseException{
|
WebUtil.alertNotNull(processOid,"流程主键");
|
String deploymentId = getJbpmDeploymentId(processOid);
|
if(StringUtils.isBlank(deploymentId)){
|
throw new VciBaseException(msgCodePrefix + "processTemplateNotExist",new String[]{processOid});
|
}
|
String[] allTaskNames = getAllProcessNodeNameByDeploy(deploymentId);
|
List<ProcessNodeVO> allNode = new ArrayList<ProcessNodeVO>();
|
for(String taskName : allTaskNames){
|
ProcessNodeVO pn = getNodePresideUsersByDeploy(deploymentId, taskName);
|
allNode.add(pn);
|
}
|
return allNode;
|
}
|
@Override
|
public String getFirstNodeName(String deployId) throws VciBaseException {
|
WebUtil.alertNotNull(deployId,"部署主键");
|
// try {
|
// ProcessTaskInfo firstProcessTask = getWorkService().getFirstProcessTask(deployId);
|
// if(firstProcessTask!=null){
|
// return firstProcessTask.taskName;
|
// }
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
/**
|
* 获取流程的所有节点名称
|
* @param processOid
|
*/
|
@Override
|
public String[] getAllProcessNodeName(String processOid) throws VciBaseException{
|
if(StringUtils.isEmpty(processOid)){
|
WebUtil.alertNotNull(processOid);
|
}
|
String deploymentId = getJbpmDeploymentId(processOid);
|
if(StringUtils.isEmpty(deploymentId)){
|
throw new VciBaseException(msgCodePrefix + "processTemplateNotExist",new String[]{processOid});
|
}
|
return getAllProcessNodeNameByDeploy(deploymentId);
|
}
|
|
/**
|
* 获取流程中的所有节点名称
|
* @param deploymentId 流程引擎中的部署id
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public String[] getAllProcessNodeNameByDeploy(String deploymentId) throws VciBaseException{
|
String[] allTaskNames = null;
|
// try {
|
// allTaskNames = getWorkService().getAllTaskNames(deploymentId);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return allTaskNames;
|
}
|
|
/**
|
* 获取流程模板在流程引擎中的部署主键
|
* @param processOid
|
*/
|
@Override
|
public String getJbpmDeploymentId(String processOid) throws VciBaseException{
|
// WebUtil.alertNotNull(processOid,"流程模板主键");
|
// return getWorkService().getDeploymentID(processOid);
|
return null;
|
}
|
|
@Override
|
public String getJbpmDeploymentIdByExecutionId(String executionId) throws VciBaseException{
|
WebUtil.alertNotNull(executionId,"流程执行主键");
|
// try {
|
// return getWorkService().getDeploymentIdByExecutionId(executionId);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
@Override
|
public ProcessNodeVO getNodePresideUsersByDeploy(String deploymentId, String taskName) throws VciBaseException{
|
WebUtil.alertNotNull(taskName,"流程任务名称",deploymentId,"流程引擎中的部署主键");
|
ProcessNodeVO pn = new ProcessNodeVO();
|
// pn.setName(taskName);
|
// try {
|
// String[] nodePresideUsers = getWorkService().getCurCandidates(deploymentId, taskName, "", "");
|
// if(nodePresideUsers!=null&& nodePresideUsers.length>0){
|
// for(String preUsers : nodePresideUsers){
|
// //平台存储的方式是用户;角色;部门;自定义....
|
// if(StringUtils.isNotEmpty(preUsers)){
|
// String[] preUsersSplit = preUsers.split("\\;");
|
// if(preUsersSplit!=null && preUsersSplit.length>0){
|
// if(StringUtils.isNotEmpty(preUsersSplit[0])){
|
// pn.setUsers(preUsersSplit[0]);
|
// }
|
// if(preUsersSplit.length>1 && StringUtils.isNotEmpty(preUsersSplit[1])){
|
// pn.setRoles(preUsersSplit[1]);
|
// }
|
// if(preUsersSplit.length>2 && StringUtils.isNotEmpty(preUsersSplit[2])){
|
// pn.setDepts(preUsersSplit[2]);
|
// }
|
// if(preUsersSplit.length>3 && StringUtils.isNotEmpty(preUsersSplit[3])){
|
// pn.setCustomClass(preUsersSplit[3]);
|
// }
|
// }
|
// }
|
// }
|
// }
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return pn;
|
}
|
|
|
/**
|
* 获取流程模板中某个节点的处理人
|
* @param processOid
|
* @param taskName
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public ProcessNodeVO getNodePresideUsers(String processOid, String taskName) throws VciBaseException{
|
WebUtil.alertNotNull(taskName,"流程任务节点名称",processOid,"流程主键");
|
String deploymentId = getJbpmDeploymentId(processOid);
|
if(StringUtils.isEmpty(deploymentId)){
|
throw new VciBaseException(msgCodePrefix + "processTemplateNotExist",new String[]{processOid});
|
}
|
return getNodePresideUsersByDeploy(deploymentId,taskName);
|
}
|
|
@Override
|
public List<ProcessUserVO> getNodePresideUsersByTask(String executionid, String taskName)
|
throws VciBaseException{
|
WebUtil.alertNotNull(executionid,"流程执行任务",taskName,"任务名称");
|
// if("结束".equalsIgnoreCase(taskName)){
|
// return null;
|
// }
|
//不能使用workitem去查询，因为可能任务还没到
|
// String users = getWorkService().getNextTaskAssigner(executionid, taskName);
|
List<ProcessUserVO> allProUser = new ArrayList<ProcessUserVO>();
|
// if(StringUtils.isNotEmpty(users)){
|
// String userIds = users.replace("user:", "");//现在只支持设置用户
|
// List<SmUserVO> allUser = userQueryService.listUserByUserIds(WebUtil.str2List(userIds));
|
// if(allUser!=null && allUser.size()>0){
|
// for(SmUserVO user : allUser){
|
// ProcessUserVO pu = new ProcessUserVO();
|
// BeanUtils.copyProperties(user, pu);
|
// pu.setType("user");
|
// allProUser.add(pu);
|
// }
|
// }
|
// }
|
return allProUser;
|
}
|
|
/**
|
* 查询待办任务
|
*/
|
@Override
|
public DataGrid getUndoTask(
|
Map<String, String> conditionMap, PageHelper ph, String userId)
|
throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,1);
|
}
|
|
/**
|
* 使用流程实例获取所有的待办信息
|
* @param processInstanceId 流程的实例主键
|
* @return 待办的任务
|
*/
|
@Override
|
public DataGrid getUndoTaskByInstanceId(String processInstanceId, long mill){
|
Map<String,String> conditionMap = new HashMap<>();
|
conditionMap.put("executionid",processInstanceId+"*");
|
if(mill>0) {
|
conditionMap.put("ts", QueryOptionConstant.MORETHAN + VciDateUtil.date2Str(new Date(mill), VciDateUtil.DateTimeMillFormat));
|
}
|
return getProcessTask(conditionMap,new PageHelper(-1),null,8);
|
}
|
|
/**
|
* 查询流程任务
|
* @param conditionMap 查询条件
|
* @param ph 分页信息，没有排序
|
* @param userId 用户名
|
* @param doTaskType 用户类型，1-待办任务，2-已办任务
|
* @return
|
* @throws VciBaseException
|
*/
|
private DataGrid getProcessTask(Map<String, String> conditionMap, PageHelper ph, String userId,int doTaskType) throws VciBaseException,VciBaseException{
|
if(conditionMap == null) {
|
conditionMap = new HashMap<String, String>();
|
}
|
String btmType = "";
|
if(doTaskType== 1){//待办任务
|
WebUtil.alertNotNull(userId,"用户名");
|
conditionMap.put("businesstype", "5");//本项目没有实际的意义
|
conditionMap.put("principal", userId);
|
conditionMap.put("lcstatus", "Executing");
|
btmType = workitemBtmType;
|
//ph.addSort("createtime",ph.desc);
|
}else if(doTaskType == 2){//已办任务
|
WebUtil.alertNotNull(userId,"用户名");
|
conditionMap.put("taskoid", QueryOptionConstant.IN +" ( select ht.DBID_ FROM JBPM4_HIST_TASK ht left join PLFLOWAPPROVEOPINION op on ht.DBID_ = op.PLTASKID where DECODE(op.plassgin, null, ht.ASSIGNEE_, op.plassgin) = '" + userId + "') ");
|
conditionMap.put("lcstatus","Completed");
|
btmType = workitemBtmType;
|
}else if(doTaskType == 3){//完成的流程
|
if(StringUtils.isNotEmpty(userId)) {//为空表示查询所有的
|
conditionMap.put("creator", userId);
|
}
|
conditionMap.put("lcstatus", "Completed");
|
btmType = workIntanceBtmType;
|
}else if(doTaskType == 4){//被终止的流程
|
if(StringUtils.isNotEmpty(userId)) {
|
conditionMap.put("creator", userId);
|
}
|
conditionMap.put("lcstatus", "Obsoleted");
|
btmType = workIntanceBtmType;
|
}else if(doTaskType ==5){//被挂起的流程
|
if(StringUtils.isNotEmpty(userId)) {
|
conditionMap.put("creator", userId);
|
}
|
conditionMap.put("lcstatus", "Suspended");
|
btmType = workIntanceBtmType;
|
}else if(doTaskType == 6){//执行中的流程
|
if(StringUtils.isNotEmpty(userId)) {
|
conditionMap.put("creator", userId);
|
}
|
conditionMap.put("lcstatus", "Executing");
|
btmType = workIntanceBtmType;
|
}else if(doTaskType ==7){
|
WebUtil.alertNotNull(userId,"用户名");
|
conditionMap.put("creator", userId);
|
}else if(doTaskType ==8){
|
//流程获取所有待处理的任务
|
conditionMap.put("lcstatus", "Executing");
|
btmType = workitemBtmType;
|
}else{
|
throw new VciBaseException("msgCodePrefix",new String[]{doTaskType+""});
|
}
|
List<String> causeList = new ArrayList<String>();
|
causeList.add("*");
|
causeList.add("creator_name");
|
if(doTaskType!= 1){
|
ph.addSort("ts",ph.desc);
|
}
|
ph.addSort("createtime",ph.desc);
|
return boService.queryGridByBo(btmType, conditionMap, ph,causeList);
|
|
}
|
|
@Override
|
public DataGrid getDoneProcess(Map<String, String> conditionMap, PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,2);
|
}
|
|
@Override
|
public DataGrid getCompletedProcess(Map<String, String> conditionMap, PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,3);
|
}
|
|
@Override
|
public DataGrid getObsoledtedProcess(Map<String, String> conditionMap,
|
PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,4);
|
}
|
|
@Override
|
public DataGrid getSuspendedProcess(Map<String, String> conditionMap,
|
PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,5);
|
}
|
|
@Override
|
public DataGrid getExecutingProcess(Map<String, String> conditionMap,
|
PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,6);
|
}
|
|
@Override
|
public DataGrid getCreateProcess(Map<String, String> conditionMap,
|
PageHelper ph, String userId) throws VciBaseException {
|
return getProcessTask(conditionMap,ph,userId,7);
|
}
|
|
@Override
|
public List<ProcessTaskVO> getTaskByOid(String oid) throws VciBaseException{
|
WebUtil.alertNotNull(oid,"待办任务主键");
|
List<ProcessTask> tasks = boService.selectByOidCollection(VciBaseUtil.str2List(oid),ProcessTask.class);
|
return processTaskDO2VOs(tasks);
|
}
|
|
/**
|
* 还有任务的主键获取任务CBO对象
|
* @param oid 主键
|
* @return CBO对象
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public List<Map> getTaskCBOByOid(String oid) throws VciBaseException{
|
WebUtil.alertNotNull(oid,"待办任务主键");
|
return (boService.cbos2Map(boService.selectCBOByOidCollection(VciBaseUtil.str2List(oid),getWorkitemBtmType())));
|
}
|
|
/**
|
* 任务的对象转换为显示对象
|
* @param tasks 任务的对象
|
* @return 任务的显示对象
|
*/
|
private List<ProcessTaskVO> processTaskDO2VOs(Collection<ProcessTask> tasks){
|
List<ProcessTaskVO> taskVOList = new ArrayList<>();
|
Optional.ofNullable(tasks).orElseGet(()->new ArrayList<>()).stream().forEach(task->{
|
ProcessTaskVO taskVO = new ProcessTaskVO();
|
BeanUtil.convert(task,taskVO);
|
taskVOList.add(taskVO);
|
});
|
return taskVOList;
|
}
|
|
@Override
|
public ProcessInstanceVO getProcessByOid(String oid) throws VciBaseException{
|
WebUtil.alertNotNull(oid,"流程实例主键");
|
ProcessInstance process = boService.selectByOid(oid,ProcessInstance.class);
|
ProcessInstanceVO processInstanceVO = new ProcessInstanceVO();
|
if(process == null || StringUtils.isBlank(process.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
BeanUtil.convert(process,processInstanceVO);
|
return processInstanceVO;
|
}
|
|
@Override
|
public String getVariablesInProcess(String executionId,String key) throws VciBaseException{
|
WebUtil.alertNotNull(executionId,"流程执行主键",key,"参数Key");
|
UserEntityInfo ueo = new UserEntityInfo();
|
SessionInfo si = WebUtil.getCurrentUserSessionInfo();
|
ueo.ip = si.getIp();
|
ueo.modules = "流程";
|
ueo.userName = si.getUserId();
|
// while(StringUtils.countMatches(executionId,".")>1){
|
// //说明是子任务，用父任务获取一下变量
|
// executionId = executionId.substring(0,executionId.lastIndexOf("."));
|
// }
|
// try {
|
// return getWorkService().getProcessVariable(executionId, key, ueo);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
/**
|
* 获取流程中关联的数据
|
* @param taskOid 任务的主键
|
* @param processOid 流程的主键
|
* @param referColumns 引用的列
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public DataGrid getDataByTask(String taskOid,String processOid,String referColumns) throws VciBaseException {
|
if(StringUtils.isBlank(taskOid) && StringUtils.isBlank(processOid)){
|
throw new VciBaseException(msgCodePrefix + "taskOidOrProcessOidNotNull");
|
}
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
if(StringUtils.isNotBlank(taskOid)) {
|
conditionMap.put("f_oid", taskOid.trim());
|
conditionMap.put("f_btwname", workitemBtmType);
|
}else if(StringUtils.isNotBlank(processOid)){
|
//实际上传递的是executionid
|
conditionMap.put("f_oid", "\\IN(select oid from platformbtm_" + workIntanceBtmType + " where executionid = '" + processOid.trim() + "')");
|
conditionMap.put("f_btwname", workIntanceBtmType);
|
}
|
return getData(taskDataLink,conditionMap,referColumns);
|
}
|
|
/**
|
* 获取流程关联的业务数据的里阿杰类型
|
* @param taskOid 任务主键
|
* @param executionid 流程执行主键
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public List<ClientLinkObject> getDataCloInTask(String taskOid,String executionid) throws VciBaseException {
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
if(StringUtils.isNotBlank(taskOid)) {
|
conditionMap.put("f_oid", taskOid.trim());
|
conditionMap.put("f_btwname", getWorkitemBtmType());
|
}else if(StringUtils.isNotBlank(executionid)){
|
conditionMap.put("f_oid", "\\IN(select oid from platformbtm_" + getWorkIntanceBtmType() + " where executionid = '" + executionid.trim() + "')");
|
conditionMap.put("f_btwname", getWorkIntanceBtmType());
|
}
|
return loService.queryCLO(taskDataLink, conditionMap);
|
}
|
|
private DataGrid getData(String linkType,Map<String,String> conditionMap,String referColumns) throws VciBaseException{
|
List<ClientLinkObject> clos = loService.queryCLO(taskDataLink, conditionMap);
|
Map<String,List<String>> btmOidMap = new HashMap<String, List<String>>();
|
if(clos!=null&&clos.size()>0){
|
for(ClientLinkObject clo : clos){
|
List<String> oids = null;
|
String btm = clo.getToBTMName().toLowerCase();
|
if(btmOidMap.containsKey(btm)){
|
oids = btmOidMap.get(btm);
|
}else{
|
oids = new ArrayList<String>();
|
}
|
oids.add(clo.getToOid());
|
btmOidMap.put(btm, oids);
|
}
|
}
|
List<Map> data = new ArrayList<Map>();
|
if(!btmOidMap.isEmpty()){
|
Iterator<String> it = btmOidMap.keySet().iterator();
|
while(it.hasNext()){
|
String btm = it.next();
|
List<String> oids = btmOidMap.get(btm);
|
conditionMap.clear();
|
conditionMap.put("oid", QueryOptionConstant.IN + "(" + WebUtil.toInSql(oids.toArray(new String[0])) + ")");
|
List<String> caluesList = new ArrayList<String>();
|
if(StringUtils.isNotEmpty(referColumns)) {
|
caluesList = Arrays.asList(referColumns.split(","));
|
}else {
|
caluesList.add("*");
|
}
|
List<com.vci.client.bof.ClientBusinessObject> cbos = boService.queryCBO(btm, conditionMap,null,caluesList);
|
data.addAll(boService.cbos2Map(cbos));
|
}
|
}
|
DataGrid dg = new DataGrid();
|
dg.setData(data);
|
dg.setTotal(data.size());
|
dg.setLimit(-1);
|
dg.setPage(1);
|
return dg;
|
}
|
|
@Override
|
public DataGrid getDataByProcess(String executionId,String referColumns) throws VciBaseException{
|
WebUtil.alertNotNull(executionId,"流程执行ID");
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("f_oid","\\IN(select oid from platformbtm_" +getWorkIntanceBtmType() + " where executionid='" + executionId.trim() + "')");
|
conditionMap.put("f_btwname", getWorkIntanceBtmType());
|
return getData(processDataLink,conditionMap,referColumns);
|
}
|
|
@Override
|
public List<ProcessHistoryVO> getHistory(String executionId) throws VciBaseException{
|
WebUtil.alertNotNull(executionId,"流程执行主键");
|
List<ProcessHistoryVO> hisList = new ArrayList<ProcessHistoryVO>();
|
// FlowApproveHistoryInfo[] historyActivitys = null;
|
// try {
|
// historyActivitys = getWorkService().getHistoryActivityByProInsIdbyPLM(executionId);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
// //需要去除未处理的重复项
|
// for (int i = 0; i < historyActivitys.length; i++) {
|
// FlowApproveHistoryInfo historyActivity = historyActivitys[i];
|
// ProcessHistoryVO his = new ProcessHistoryVO();
|
// his.setTaskName(historyActivity.taskName);
|
// his.setOpinin(historyActivity.opinion);//这个是处理方式，就是同意还是不同意
|
// his.setCreateTime(historyActivity.createTime);
|
// his.setEndTime(historyActivity.endTime);
|
// his.setNode(historyActivity.note);
|
// his.setAssignee(historyActivity.assignee);
|
// his.setExecutionId(historyActivity.executionId);
|
// String userIdString = historyActivity.assignee;
|
// if(StringUtils.contains(userIdString,":")) {
|
// userIdString = userIdString.substring(userIdString.indexOf(":") + 1);
|
// }
|
// String userShowInfoString = "";
|
// SmUserVO user = userQueryService.getUserByUserId(userIdString);
|
// if(user != null){
|
// userShowInfoString = user.getName() + "(" + user.getId() + ")";
|
// }else{
|
// userShowInfoString = historyActivity.assignee;
|
// }
|
// his.setAssigneeName(userShowInfoString);
|
// if(StringUtils.isNotBlank(historyActivity.endTime)) {
|
// hisList.add(his);
|
// }
|
// //如果endTime为空表示是待办的，但是服务端的接口中有个问题是，会把会签或者子流程中已经处理的和未处理的混合在一起
|
// //直接从待办任务里去查询
|
// }
|
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("businesstype", "5");//本项目没有实际的意义
|
conditionMap.put("lcstatus", "Executing");
|
if(StringUtils.countMatches(executionId,".")>1){
|
String ex = executionId;
|
while(StringUtils.countMatches(ex,".")>1){
|
ex = ex.substring(0,ex.lastIndexOf("."));
|
}
|
conditionMap.put("executionid", ex + "*");
|
}else {
|
conditionMap.put("executionid", executionId + "*");
|
}
|
conditionMap.put(WebBoServiceI.QUERY_FILTER_SECRET,"false");
|
conditionMap.put(WebBoServiceI.QUERY_FILTER_DATARIGHT,"false");
|
PageHelper pageHelper = new PageHelper(-1);
|
pageHelper.setSort("endTime");
|
pageHelper.setOrder(pageHelper.asc);
|
List<com.vci.client.bof.ClientBusinessObject> undoTaskCbos= boService.queryCBO(workitemBtmType, conditionMap);
|
if(undoTaskCbos != null && undoTaskCbos.size() > 0) {
|
for(com.vci.client.bof.ClientBusinessObject cbo : undoTaskCbos) {
|
ProcessHistoryVO his = new ProcessHistoryVO();
|
String taskName = cbo.getName();
|
if(StringUtils.contains(taskName,"-")) {
|
taskName = taskName.substring(taskName.lastIndexOf("-") + 1);
|
}
|
his.setTaskName(taskName);
|
his.setCreateTime(String.valueOf(cbo.getCreateTime()));
|
String userIdString = cbo.getAttributeValue("principal");
|
if(StringUtils.contains(userIdString,":")) {
|
userIdString = userIdString.substring(userIdString.indexOf(":") + 1);
|
}
|
his.setAssignee(cbo.getAttributeValue("principal"));
|
String userShowInfoString = "";
|
SmUserVO user = userQueryService.getUserByUserId(userIdString);
|
if(user != null){
|
userShowInfoString = user.getName() + "(" + user.getId() + ")";
|
}else{
|
userShowInfoString = userIdString;
|
}
|
his.setAssigneeName(userShowInfoString);
|
his.setExecutionId(cbo.getAttributeValue("executionid"));
|
|
hisList.add(his);
|
}
|
}
|
return hisList;
|
}
|
|
@Override
|
public byte[] getProcessPicture(String executionId, String taskName)
|
throws VciBaseException{
|
WebUtil.alertNotNull(executionId,"流程执行主键",taskName,"流程任务名称");
|
// try {
|
// byte[] processChart = getWorkService().getExecutionImageByExecutionId(executionId, taskName);
|
// return processChart;
|
// } catch (Throwable e) {
|
// String msg = "有可能这个任务关联的流程已经结束或者被终止，不能再查看其流程图了";
|
// logger.error(msg,e);
|
// throw new VciBaseException(msg);
|
// }
|
return null;
|
}
|
|
@Override
|
public byte[] getProcessTemplatePicture(String executionId)
|
throws VciBaseException{
|
// WebUtil.alertNotNull(executionId,"流程实例主键");
|
// try {
|
// byte[] processChart = getWorkService().getFlowImageByDeployID(executionId);
|
// return processChart;
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
@Override
|
public String[] getAllOutComes(String taskOid) throws VciBaseException{
|
// try {
|
// return getWorkService().getAllOutComes(taskOid);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
@Override
|
public String getNextTaskName(String executionid, String taskName, String outCome) throws VciBaseException{
|
// WebUtil.alertNotNull(executionid,"流程执行主键",taskName,"任务名称");
|
// String deployId = getJbpmDeploymentIdByExecutionId(executionid);
|
// try {
|
// return getWorkService().getNextTaskNameByJbpmId(deployId, taskName, outCome);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
@Override
|
public WorkflowService getWorkService() throws VciBaseException{
|
if(workService == null){
|
try {
|
this.workService = platformClientUtil.getLogonFactoryService().getWorkflowService();
|
} catch (VCIError e) {
|
// logger.error(e.error_code,e);
|
throw WebUtil.getVciBaseException(e);
|
}
|
}
|
return workService;
|
}
|
|
@Override
|
public String getTaskDataLink() {
|
return taskDataLink;
|
}
|
|
@Override
|
public String getWorkitemBtmType() {
|
return workitemBtmType;
|
}
|
|
@Override
|
public String getWorkIntanceBtmType(){
|
return workIntanceBtmType;
|
}
|
|
/**
|
* 开启流程代理------平台只支持添加一个代理用户
|
*/
|
@Override
|
public void beginProxy(String userId, Date startDate, Date endDate,
|
boolean isNowEnable) throws VciBaseException {
|
WebUtil.alertNotNull(userId,"代理人的用户名",startDate,"开始时间");
|
TasksAssignedInfo taskAss = new TasksAssignedInfo();
|
taskAss.id = new ObjectUtility().getNewObjectID36();
|
SmUserVO user = userQueryService.getUserByUserId(userId);
|
if(user!=null){
|
taskAss.userName = user.getName();
|
}else{
|
taskAss.userName = "";
|
}
|
taskAss.TasksName = userId;
|
// taskAss.startTime = VciDateUtil.date2Str(startDate, VciDateUtil.DateFormat);
|
if(endDate == null){
|
endDate = VciDateUtil.getDateAddDay(startDate, 30);//默认最多代理一个月
|
}
|
// taskAss.endTime = VciDateUtil.date2Str(endDate, VciDateUtil.DateFormat);
|
// taskAss.isTrue = isNowEnable?1:0;
|
taskAss.fromUser =WebUtil.getCurrentUserSessionInfo().getUserId();
|
// try {
|
// getWorkService().saveOrUpdateTasksAssigned(taskAss, WebUtil.getUserEntityInfo("流程"));
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
}
|
|
|
|
@Override
|
public void endProxy()
|
throws VciBaseException {
|
//平台不支持停用启用代理信息..可以查询出来再重新添加。
|
// try {
|
// UserEntityInfo uei = WebUtil.getUserEntityInfo( "流程");
|
// getWorkService().deleteTasksAssignedByUserName(new String[]{uei.userName}, uei);
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
}
|
|
@Override
|
public TasksAssigned getProxy() throws VciBaseException{
|
TasksAssigned assign = null;
|
// try {
|
// TasksAssignedInfo taskAss = getWorkService().getTasksAssignedByUserName("", WebUtil.getUserEntityInfo( "流程"));
|
// if(taskAss!=null && StringUtils.isNotEmpty(taskAss.id)){
|
// assign = new TasksAssigned();
|
// assign.setId(taskAss.id);
|
// assign.setTasksName(taskAss.TasksName);
|
// assign.setStartTime(taskAss.startTime);
|
// assign.setEndTime(taskAss.endTime);
|
// assign.setFromUser(taskAss.fromUser);
|
// assign.setIsTrue(taskAss.isTrue);
|
// assign.setUserName(taskAss.userName);
|
// }
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return assign;
|
}
|
|
/**
|
* 结束流程
|
*
|
* @param executionId 流程执行主键
|
* @throws VciBaseException
|
*/
|
@Override
|
public void endProcess(String executionId) throws VciBaseException {
|
// try {
|
DataGrid dataGrid = getDataByProcess(executionId,null);
|
//先获取一下
|
UserEntityInfo userEntityInfo = WebUtil.getUserEntityInfo("流程");
|
String resetStatus = null;
|
// try{
|
// resetStatus = getWorkService().getProcessVariable(executionId, WFVariablesKeyConstant.RESET_STATUS, userEntityInfo);
|
// }catch (Throwable e){
|
// logger.error("获取流程的变量出错",e);
|
// }
|
// getWorkService().endProcessInstanceByplatform(executionId,userEntityInfo);
|
//平台没有自动将业务数据恢复到之前的状态
|
if(StringUtils.isNotBlank(resetStatus)){
|
resetLcStatusForBusinessData(dataGrid.getData(),resetStatus);
|
}
|
// } catch (VCIError vciError) {
|
// throw WebUtil.getVciBaseException(vciError);
|
// }
|
}
|
|
private void resetLcStatusForBusinessData(List<Map> bussinesDataList,String resetStatus) throws VciBaseException{
|
if(bussinesDataList!=null && bussinesDataList.size() > 0){
|
String btmType = "";
|
String lctId = "";
|
List<String> oidList = new ArrayList<String>();
|
//流程中的业务数据都是在同一个业务类型下的
|
for(Map data : bussinesDataList){
|
btmType = (String)data.get("btmname");
|
String oid = (String)data.get("oid");
|
lctId = (String)data.get("lctid");
|
oidList.add(oid);
|
}
|
//转换成500长度的
|
List<com.vci.client.bof.ClientBusinessObject> cboList = new ArrayList<com.vci.client.bof.ClientBusinessObject>();
|
if(oidList.size()>500){
|
List<List<String>> oidListForIn = WebUtil.switchListForOracleIn(oidList);
|
for(List<String> oidListForInRecord : oidListForIn){
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid",QueryOptionConstant.IN + "(" + WebUtil.toInSql(oidListForInRecord.toArray(new String[0])) + ")" );
|
List<com.vci.client.bof.ClientBusinessObject> tempCbos = boService.queryCBO(btmType,conditionMap);
|
cboList.addAll(tempCbos);
|
}
|
}else{
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid",QueryOptionConstant.IN + "(" + WebUtil.toInSql(oidList.toArray(new String[0])) + ")" );
|
List<com.vci.client.bof.ClientBusinessObject> tempCbos = boService.queryCBO(btmType,conditionMap);
|
cboList.addAll(tempCbos);
|
}
|
//找到这个业务类型的起始状态
|
lifeCycleService.transCboStatus(cboList,resetStatus);//执行重置
|
}
|
}
|
|
/**
|
* 根据业务类型查询正在执行的流程
|
*
|
* @param bussinessOid 业务类型数据
|
* @param btmName 业务类型名称
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public List<ProcessInstanceVO> listExecutingProcessByBussinessOid(String bussinessOid, String btmName) throws VciBaseException {
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid",QueryOptionConstant.IN + "(select f_oid from platformlt_" + getTaskDataLink() + " where f_btwname='" + getWorkIntanceBtmType() + "' " +
|
" and t_btwname='" + btmName + "' and t_oid = '" + bussinessOid + "' )");
|
conditionMap.put("lcstatus","Executing");
|
List<ProcessInstance> processInstances = boService.queryObject(ProcessInstance.class,conditionMap);
|
List<ProcessInstanceVO> instanceVOS = new ArrayList<>();
|
Optional.ofNullable(processInstances).orElseGet(()->new ArrayList<>()).stream().forEach(instance->{
|
ProcessInstanceVO instanceVO = new ProcessInstanceVO();
|
BeanUtil.convert(instance,instanceVO);
|
instanceVOS.add(instanceVO);
|
});
|
return instanceVOS;
|
}
|
|
/**
|
* 批量终止流程，
|
*
|
* @param executionIds 流程的执行主键
|
* @param note 终止原因
|
* @throws VciBaseException
|
*/
|
@Override
|
public void batchEndProcess(Collection<String> executionIds, String note) throws VciBaseException {
|
WebUtil.alertNotNull(executionIds,"流程执行主键信息");
|
for(String executionId : executionIds){
|
endProcess(executionId);
|
}
|
}
|
|
/**
|
* 获取流程xml的二进制内容
|
* @param jbpmDeploymentId
|
* @return 流程的二进制内容
|
* @throws VciBaseException
|
*/
|
@Override
|
public byte[] getProcessXmlContent(String jbpmDeploymentId) throws VciBaseException {
|
WebUtil.alertNotNull("流程执行主键信息",jbpmDeploymentId);
|
// try {
|
// return getWorkService().getProcessResource(jbpmDeploymentId,".xml");
|
// } catch (VCIError e) {
|
// throw WebUtil.getVciBaseException(e);
|
// }
|
return null;
|
}
|
|
/**
|
* 流程分类的数据对象转换为显示对象
|
* @param doCollection 数据对象的集合
|
* @return 显示对象
|
*/
|
@Override
|
public List<ProcessClassifyVO> processClassifyDO2VOs(Collection<WFProcessClassifyDO> doCollection){
|
List<ProcessClassifyVO> voList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(doCollection)){
|
doCollection.stream().forEach(classifyDO->{
|
ProcessClassifyVO classifyVO = processClassifyDO2VO(classifyDO);
|
voList.add(classifyVO);
|
});
|
}
|
return voList;
|
}
|
|
/**
|
* 流程分类的数据对象转换为显示对象
|
* @param classifyDO 数据对象
|
* @return 显示对象
|
*/
|
@Override
|
public ProcessClassifyVO processClassifyDO2VO(WFProcessClassifyDO classifyDO){
|
ProcessClassifyVO classifyVO = new ProcessClassifyVO();
|
if(classifyVO!=null){
|
BeanUtil.convert(classifyDO,classifyVO);
|
}
|
return classifyVO;
|
}
|
|
/**
|
* 流程模板的数据对象转换为显示对象
|
* @param doCollection 数据对象集合
|
* @return 显示对象
|
*/
|
@Override
|
public List<ProcessTemplateVO> processTemplateDO2VOs(Collection<WFProcessTemplateDO> doCollection){
|
List<ProcessTemplateVO> voList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(doCollection)){
|
doCollection.stream().forEach(templateDO->{
|
ProcessTemplateVO templateVO = processTemplateDO2VO(templateDO);
|
voList.add(templateVO);
|
});
|
}
|
return voList;
|
}
|
|
/**
|
* 流程模板的数据对象转换为显示对象
|
* @param templateDO 数据对象
|
* @return 显示对象
|
*/
|
@Override
|
public ProcessTemplateVO processTemplateDO2VO(WFProcessTemplateDO templateDO){
|
ProcessTemplateVO templateVO = new ProcessTemplateVO();
|
if(templateVO!=null){
|
BeanUtil.convert(templateDO,templateVO);
|
}
|
return templateVO;
|
}
|
|
/**
|
* 使用用户名查询待办任务的个数
|
*
|
* @param username 用户名
|
* @return 个数
|
*/
|
@Override
|
public int countUndoTaskByUsername(String username) {
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("businesstype", "5");//本项目没有实际的意义
|
conditionMap.put("principal", username);
|
conditionMap.put("lcstatus", "Executing");
|
return boService.queryCount(workitemBtmType,conditionMap);
|
}
|
|
|
}
|
