最近在项目中需要将数据调用webService接口推向ERP系统，erp负责服务的，我这边使用客户端调用，首先我这里调用的接口是需要用户名和密码的，注意哈，不需要用户名和密码的直接去找Apache的CXF生成客户端，我这肯定不适合，重要的事情说三遍
废话不多说直接开始，提前准备好jdk，想必大家都有吧，好像这玩意有版本的限制，相比大家jdk的版本都不会很老旧把，我这里是1.8的为例
如下图所示，进入到bin目录
C:\Program Files\Java\jdk1.8.0_92\bin
其实生成就是一句命令，命令，还说命令，但是这句命令里有两个地方是比较关键的，一个是存放生成代码的文件全路径，一个是authfile文件存放的路径，authfile.txt文件存放的其实就是用户名和密码以及你要调用的接口拼在一起的个东西，下面有讲到的
准备好生成webService接口的命令：这里需要注意的有两个点，一个是生成代码的路径，一个是authfile文件的路径，一定是存在的和可以访问的，不然后面肯定回出错
wsimport -d （生成代码的存放路径，我存在D:\webservice\src下）D:\webservice\src -keep -verbose -Xauthfile （关键点，存放用户名密码的验证文件路径，我这里是D:\test\authfile.txt）D:\test\authfile.txt （这里是服务方给你调用的接口路径，隐私原因删减部分，不影响学习）http://x.x.x.x:7004/OfficeSB/ToDoList/PortalYjy/ProxyService/OfficePortalYjyTodoListCreateSvcSyncProxy?wsdl
本博主的路径，仅供参考
G:\Sys\src\main\java\com\shanqi\modules\product\webService\yjyMhTask
http://x.x.x.x:7004/OfficeSB/ToDoList/PortalYjy/ProxyService/OfficePortalYjyTodoListCreateSvcSyncProxy?wsdl
其次准备好authfile.txt 文件，authfile文件里其实就是用户名和密码加上要访问的接口路径，因为我调用的接口需要用户名和密码校验权限，如果不需要用户名和密码的话其实可以使用cxf方式直接生成就好了，不用这么大费周章
文件里面写如下内容
用户名密码替换成自己的就可以了，其中123.456.789:7004/QualitySB/Report/Environmental/ProxyService?wsdl，就是服务方提供调用的地址，复制下来换成你自己的就可以了，主要保存的地址，把它的地址放到生成客户端的路径上去
http://用户名:密码@123.456.789:7004/QualitySB/Report/Environmental/ProxyService?wsdl
保存文件起名authfile2.txt即可
如下图
文件内容
万事具备，好了就可以开始生成操作了
1.找到你的jdk，并进入到bin目录，在路径上输入cmd打开 命令窗口
如下图
2.复制咱们准备好的命令和文件,将命令粘贴进命令窗口，点击回车，你猜怎么着，生成好了，，java的味道
3.打开咱们生成代码的路径，进去后发现已经生成好了，将所有的java文件全部复制到项目中，此处几个是java文件基本上基础的东西，分为request表示请求参数的结构实体类，response是请求后返回的结构实体类RequestCollection这个请求的实体类结构，而request实体类其实只有个RequestCollection类的属性和get、set方法而已，自动生成的我也就没细细研究了，基本上这几个文件不用去改动，出发服务端接口需要新增或者返回结构改了那就必须要改request或者response实体类结构了
例如 创建门户待办任务
request实体类里写的内容，因为我的请求结构问题吧 
稍微讲一下request实体类吧，首先请求和返回的参数都是xml格式的，因为request实体类声明了属性是RequestCollection类，所有基础的东西都是在RequestCollection类里的，下面讲一下大概就是@XmlElement注解里面的name就是xml里的字段名，加在字段上进行映射绑定，通过@XmlType，将下面实体类的字段声明一下，进行绑定，大概就是这样的，这些代码都是生成的，知道个大概就可以了，不然就得自己去拼xml那也很麻烦
下面我把请求参数的实体类贴出来，大家看看就行了，大概就是这样，用的时候直接set对应属性，然后调用请求方法就是xml格式的了很方便
package com.sxqc.osb.office.todolist.schema;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>anonymous complex type�� Java �ࡣ
*
* <p>����ģʽƬ��ָ�������ڴ����е�Ԥ�����ݡ�
*
* <pre>
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element name="List">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element name="AppName" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="CreateTime" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="DocCreator" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ExtendContent" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Key" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Level" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Link" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ModelId" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ModelName" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Others" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Parameter1" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Parameter2" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Subject" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Targets" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Type" type="{http://www.w3.org/2001/XMLSchema}string"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"list"
})
@XmlRootElement(name = "CreateTodoReq")
public class CreateTodoReq {
@XmlElement(name = "List", required = true)
protected CreateTodoReq.List list;
/**
* ��ȡlist���Ե�ֵ��
*
* @return
* possible object is
* {@link CreateTodoReq.List }
*
*/
public CreateTodoReq.List getList() {
return list;
}
/**
* ����list���Ե�ֵ��
*
* @param value
* allowed object is
* {@link CreateTodoReq.List }
*
*/
public void setList(CreateTodoReq.List value) {
this.list = value;
}
/**
* <p>anonymous complex type�� Java �ࡣ
*
* <p>����ģʽƬ��ָ�������ڴ����е�Ԥ�����ݡ�
*
* <pre>
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element name="AppName" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="CreateTime" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="DocCreator" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ExtendContent" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Key" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Level" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Link" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ModelId" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="ModelName" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Others" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Parameter1" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Parameter2" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
* <element name="Subject" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Targets" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="Type" type="{http://www.w3.org/2001/XMLSchema}string"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"appName",
"createTime",
"docCreator",
"extendContent",
"key",
"level",
"link",
"modelId",
"modelName",
"others",
"parameter1",
"parameter2",
"subject",
"targets",
"type"
})
public static class List {
@XmlElement(name = "AppName", required = true)
protected String appName;
@XmlElement(name = "CreateTime", required = true)
protected String createTime;
@XmlElement(name = "DocCreator", required = true)
protected String docCreator;
@XmlElement(name = "ExtendContent", required = true)
protected String extendContent;
@XmlElement(name = "Key")
protected String key;
@XmlElement(name = "Level", required = true)
protected String level;
@XmlElement(name = "Link", required = true)
protected String link;
@XmlElement(name = "ModelId", required = true)
protected String modelId;
@XmlElement(name = "ModelName", required = true)
protected String modelName;
@XmlElement(name = "Others", required = true)
protected String others;
@XmlElement(name = "Parameter1")
protected String parameter1;
@XmlElement(name = "Parameter2")
protected String parameter2;
@XmlElement(name = "Subject", required = true)
protected String subject;
@XmlElement(name = "Targets", required = true)
protected String targets;
@XmlElement(name = "Type", required = true)
protected String type;
/**
* ��ȡappName���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getAppName() {
return appName;
}
/**
* ����appName���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAppName(String value) {
this.appName = value;
}
/**
* ��ȡcreateTime���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getCreateTime() {
return createTime;
}
/**
* ����createTime���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setCreateTime(String value) {
this.createTime = value;
}
/**
* ��ȡdocCreator���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getDocCreator() {
return docCreator;
}
/**
* ����docCreator���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDocCreator(String value) {
this.docCreator = value;
}
/**
* ��ȡextendContent���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getExtendContent() {
return extendContent;
}
/**
* ����extendContent���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setExtendContent(String value) {
this.extendContent = value;
}
/**
* ��ȡkey���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getKey() {
return key;
}
/**
* ����key���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setKey(String value) {
this.key = value;
}
/**
* ��ȡlevel���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getLevel() {
return level;
}
/**
* ����level���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setLevel(String value) {
this.level = value;
}
/**
* ��ȡlink���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getLink() {
return link;
}
/**
* ����link���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setLink(String value) {
this.link = value;
}
/**
* ��ȡmodelId���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelId() {
return modelId;
}
/**
* ����modelId���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelId(String value) {
this.modelId = value;
}
/**
* ��ȡmodelName���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelName() {
return modelName;
}
/**
* ����modelName���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelName(String value) {
this.modelName = value;
}
/**
* ��ȡothers���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getOthers() {
return others;
}
/**
* ����others���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setOthers(String value) {
this.others = value;
}
/**
* ��ȡparameter1���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getParameter1() {
return parameter1;
}
/**
* ����parameter1���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setParameter1(String value) {
this.parameter1 = value;
}
/**
* ��ȡparameter2���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getParameter2() {
return parameter2;
}
/**
* ����parameter2���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setParameter2(String value) {
this.parameter2 = value;
}
/**
* ��ȡsubject���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getSubject() {
return subject;
}
/**
* ����subject���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setSubject(String value) {
this.subject = value;
}
/**
* ��ȡtargets���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getTargets() {
return targets;
}
/**
* ����targets���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setTargets(String value) {
this.targets = value;
}
/**
* ��ȡtype���Ե�ֵ��
*
* @return
* possible object is
* {@link String }
*
*/
public String getType() {
return type;
}
/**
* ����type���Ե�ֵ��
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setType(String value) {
this.type = value;
}
}
}
具体调用的几个关键类，这两个类是负责调用接口的核心类，其他几个其实就是为这个接口类提供服务的
如下图
废话不多说，直接上最终展示代码（jeeSite集成门户待办）
/**
* Copyright © 2012-2016 <a href="https://github.com/thinkgem/jeesite">JeeSite</a> All rights reserved.
*/
package com.shanqi.modules.act.web;
import com.alibaba.fastjson.JSONArray;
import com.google.common.collect.Lists;
import com.shanqi.common.config.Global;
import com.shanqi.common.dto.JqueryResult;
import com.shanqi.common.persistence.Page;
import com.shanqi.common.utils.IdGen;
import com.shanqi.common.utils.SpringContextUtil;
import com.shanqi.common.web.BaseController;
import com.shanqi.modules.act.ProAssignee;
import com.shanqi.modules.act.baseEnum.BusinessProcessEnum;
import com.shanqi.modules.act.dao.ActDao;
import com.shanqi.modules.act.dao.ActExTaskOpininonDao;
import com.shanqi.modules.act.entity.Act;
import com.shanqi.modules.act.entity.ActExTaskOpininon;
import com.shanqi.modules.act.entity.ActExtendTask;
import com.shanqi.modules.act.entity.ActModelBaseInfo;
import com.shanqi.modules.act.service.ActExTaskOpininonService;
import com.shanqi.modules.act.service.ActExtendTaskService;
import com.shanqi.modules.act.service.ActModelService;
import com.shanqi.modules.act.service.ActTaskService;
import com.shanqi.modules.act.utils.ActUtils;
import com.shanqi.modules.act.utils.AsynchronousEmailUtils;
import com.shanqi.modules.act.utils.ProcessHandleHelper;
import com.shanqi.modules.product.annualproject.product.dao.ProjectProductDevelopNewDao;
import com.shanqi.modules.product.annualproject.product.entity.ActHiTaskinstNew;
import com.shanqi.modules.product.annualproject.product.entity.ProjectProductDevelopNew;
import com.shanqi.modules.product.annualproject.product.entity.ProjectProductSuspendRecord;
import com.shanqi.modules.product.annualproject.product.service.ActHiTaskinstNewService;
import com.shanqi.modules.product.annualproject.product.service.ProjectProductDevelopNewService;
import com.shanqi.modules.product.annualproject.product.service.ProjectProductSuspendRecordService;
import com.shanqi.modules.product.annualproject.technology.entity.ProjectTechnologyCountersign;
import com.shanqi.modules.product.annualproject.technology.entity.ProjectTechnologyDevelop;
import com.shanqi.modules.product.annualproject.technology.service.ProjectTechnologyCountersignService;
import com.shanqi.modules.product.annualproject.technology.service.ProjectTechnologyDevelopService;
import com.shanqi.modules.product.annualproject.utils.ProjectSysMhUtils;
import com.shanqi.modules.product.development.projectstageplan.entity.ProjectStagePlanEntity;
import com.shanqi.modules.product.development.projectstageplan.service.ProjectStagePlanService;
import com.shanqi.modules.product.development.receiptnotice.entity.ReceiptNoticeEntity;
import com.shanqi.modules.product.development.receiptnotice.service.ReceiptNoticeService;
import com.shanqi.modules.product.flow.entity.FlowNodeEntity;
import com.shanqi.modules.product.flow.entity.FlowVarEntity;
import com.shanqi.modules.product.flow.service.FlowNodeService;
import com.shanqi.modules.product.mhtask.entity.ProjectPortalAgentStatus;
import com.shanqi.modules.product.mhtask.service.ProjectPortalAgentStatusService;
import com.shanqi.modules.product.projectmanage.entity.ProChangeEntity;
import com.shanqi.modules.product.projectmanage.entity.ProjectEntity;
import com.shanqi.modules.product.projectmanage.service.ProChangeService;
import com.shanqi.modules.product.projectmanage.service.ProjectService;
import com.shanqi.modules.product.requirement.entity.DemandEntity;
import com.shanqi.modules.product.requirement.entity.EvaEstablishEntity;
import com.shanqi.modules.product.requirement.entity.InstituteEntity;
import com.shanqi.modules.product.requirement.entity.ProductDevelopmentEntity;
import com.shanqi.modules.product.requirement.service.DemandService;
import com.shanqi.modules.product.requirement.service.DevelopmentService;
import com.shanqi.modules.product.requirement.service.EvaEstablishService;
import com.shanqi.modules.product.requirement.service.InstituteService;
import com.shanqi.modules.sys.entity.Dict;
import com.shanqi.modules.sys.entity.User;
import com.shanqi.modules.sys.service.SystemService;
import com.shanqi.modules.sys.utils.DictUtils;
import com.shanqi.modules.sys.utils.UserUtils;
import org.activiti.engine.HistoryService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.pvm.PvmActivity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
import org.activiti.engine.impl.task.TaskDefinition;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.*;
/**
* 流程个人任务相关Controller
*
* @author ThinkGem
* @version 2013-11-03
*/
@Controller
@RequestMapping(value = "${adminPath}/act/task")
public class ActTaskController extends BaseController {
@Autowired
private ActTaskService actTaskService;
@Autowired
private RepositoryService repositoryService;
@Autowired
private RuntimeService runtimeService;
@Autowired
private SystemService systemService;
@Autowired
private ActExtendTaskService extendTaskService;
@Autowired
private ActModelService actModelService;
@Autowired
private HistoryService historyService;
@Autowired
private FlowNodeService flowNodeService;
@Autowired
protected TaskService taskService;
private Thread thread;
@Autowired
private ActExTaskOpininonDao actExTaskOpininonDao;
@Autowired
private ActDao actDao;
@Autowired
private DemandService demandService;
@Autowired
private DevelopmentService developmentService;
@Autowired
private EvaEstablishService evaEstablishService;
@Autowired
private InstituteService instituteService;
@Autowired
private ProjectProductDevelopNewService projectProductDevelopNewService;
@Autowired
private ProjectStagePlanService projectStagePlanService;
@Autowired
private ProjectService projectService;
@Autowired
private ProChangeService proChangeService;
@Autowired
private ReceiptNoticeService receiptNoticeService;
@Autowired
private ProjectTechnologyDevelopService projectTechnologyDevelopService;
@Autowired
private ProjectTechnologyCountersignService technologyCountersignService;
@Autowired
private ProjectProductDevelopNewDao projectProductDevelopNewDao;
@Autowired
private ProjectProductSuspendRecordService projectProductSuspendRecordService;
@Autowired
private ActExTaskOpininonService taskOpininonService;
@Autowired
private ActHiTaskinstNewService hiTaskinstNewService;
@Autowired
private ProjectPortalAgentStatusService portalAgentStatusService;
/**
* 进入待办页面(需求管理布部分的专属待办模块)
*
* @param act
* @param response
* @param model
* @return
* @throws Exception
*/
@RequestMapping(value = "toTaskListOfDemand")
public String toTaskListOfDemand(Act act, HttpServletResponse response, Model model) throws Exception {
//设置查询流程：客户需求反馈表（flow_requirement）、开发建议书（flow_project）、需求立项申请（flow_establish）的任务
List <String> listProKey = new ArrayList <>();
listProKey.add(BusinessProcessEnum.Flow_Demand.getProcessDefkey());
listProKey.add(BusinessProcessEnum.Flow_Project.getProcessDefkey());
listProKey.add(BusinessProcessEnum.Flow_Establish.getProcessDefkey());
//查询任务
List <Act> list = actTaskService.todoListOfDemand(act, listProKey);
if (list != null && list.size() > 0) {
// todo 对不同的流程任务进行对象构造
}
model.addAttribute("list", list);
return "modules/act/actTaskTodoListOfDemand";
}
/**
* 进入待办页面
*
* @param act
* @param response
* @param model
* @return
* @throws Exception
*/
@RequestMapping(value = "toTaskList")
public String toTaskList(Act act, HttpServletResponse response, Model model) throws Exception {
List <Act> list = actTaskService.todoList(act);
try {
//根据流程KEK区分流程
if (list != null && list.size() > 0) {
for (Act actInfo : list) {
//根据流程实例ID查询业务表信息
String procId = actInfo.getTask().getProcessInstanceId();
//区分客户需求反馈表 BusinessProcessEnum.Flow_Demand.getProcessDefkey()
if (BusinessProcessEnum.Flow_Demand.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
DemandEntity demandEntity = demandService.getInfoByProcId(procId);
if (demandEntity != null) {
actInfo.setProjectName(demandEntity.getDemandName());
actInfo.setDemandNo(demandEntity.getDemandNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(demandEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Project.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//建议书
ProductDevelopmentEntity productDevelopmentEntity = developmentService.getInfoByProcId(procId);
if (productDevelopmentEntity != null) {
actInfo.setProjectName(productDevelopmentEntity.getDevelopmentName());
actInfo.setDemandNo(productDevelopmentEntity.getDevelopmentNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(productDevelopmentEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Establish.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//需求立项申请
EvaEstablishEntity evaEstablishEntity = evaEstablishService.getInfoByProcId(procId);
if (evaEstablishEntity != null) {
actInfo.setProjectName(evaEstablishEntity.getProjectName());
actInfo.setDemandNo(evaEstablishEntity.getEstablishNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(evaEstablishEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Institute.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//生产技术准备通知
InstituteEntity instituteEntity = instituteService.getInfoByProcId(procId);
if (instituteEntity != null) {
actInfo.setProjectName(instituteEntity.getProjectName());
actInfo.setDemandNo("-");
actInfo.setProjectNo(instituteEntity.getProjectNum());
}
} else if (BusinessProcessEnum.Flow_Dev_Plan.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//项目接收流程
ProjectStagePlanEntity projectStagePlanEntity = projectStagePlanService.getInfoByProcId(procId);
if (projectStagePlanEntity != null) {
ProjectEntity projectEntity = projectService.get(projectStagePlanEntity.getProjectId());
if (projectEntity != null) {
actInfo.setProjectName(projectEntity.getProjectName());
actInfo.setDemandNo(projectEntity.getEstablishNo());
actInfo.setProjectNo(projectEntity.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Element_Dev.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//零部件投产流程
ReceiptNoticeEntity receiptNoticeEntity = receiptNoticeService.getInfoByProcInstId(procId);
if (receiptNoticeEntity != null) {
ProjectEntity projectEntity = projectService.get(receiptNoticeEntity.getProjectId());
if (projectEntity != null) {
actInfo.setProjectName(projectEntity.getProjectName());
actInfo.setDemandNo(projectEntity.getEstablishNo());
actInfo.setProjectNo(projectEntity.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Project_New_One.getProcessDefkey().equals(actInfo.getProcDef().getKey()) || BusinessProcessEnum.Flow_Project_New_Two.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//产品开发建议书-必要性分析/可行性分析
ProjectProductDevelopNew projectProductDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(procId);
if (projectProductDevelopNew != null) {
actInfo.setProjectName(projectProductDevelopNew.getDevelopmentName());
actInfo.setDemandNo(projectProductDevelopNew.getDevelopmentNo());
actInfo.setProjectNo(projectProductDevelopNew.getProjectNum());
}
} else if (BusinessProcessEnum.Flow_Non_Market.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//技术开发项目
ProjectTechnologyDevelop projectTechnologyDevelop = projectTechnologyDevelopService.getInfoByProcInstId(procId);
if (projectTechnologyDevelop != null) {
actInfo.setProjectName(projectTechnologyDevelop.getDevelopmentName());
actInfo.setDemandNo(projectTechnologyDevelop.getDevelopmentNo());
actInfo.setProjectNo(projectTechnologyDevelop.getProjectNum());
}
}else if (BusinessProcessEnum.Flow_Project_Suspend.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//节点暂停项目
ProjectProductSuspendRecord suspendRecord = projectProductSuspendRecordService.getInfoByProcInstId(procId);
if (suspendRecord != null && StringUtils.isNotBlank(suspendRecord.getInstanceParentId())) {
ProjectProductDevelopNew productDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(suspendRecord.getInstanceParentId());
actInfo.setDemandNo(suspendRecord.getDevelopmentNo());
actInfo.setProjectNo(productDevelopNew.getProjectNum());
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
model.addAttribute("list", list);
return "modules/act/actTaskTodoList";
}
/**
* 进入待办页面
*
* @param
* @param response
* @param model
* @return
* @throws Exception
*/
@RequiresPermissions("act:task:all")
@RequestMapping(value = "toTaskAllList")
public String toTaskAllList(Act act, HttpServletRequest request, HttpServletResponse response, Model model) throws Exception {
Page page = new Page(request, response);
page = actTaskService.todoAllList(page, act);
model.addAttribute("page", page);
return "modules/act/actTaskTodoAllList";
}
/**
* 获取已办任务
* page
* procDefKey流程定义标识
*
* @return
*/
@RequestMapping(value = "historic")
public String historicList(Act act, HttpServletRequest request, HttpServletResponse response, Model model) throws Exception {
Page <Act> page = new Page <Act>(request, response);
page = actTaskService.historicList(page, act);
try {
//根据流程KEK区分流程
if (page.getList() != null && page.getList().size() > 0) {
for (Act actInfo : page.getList()) {
//根据流程实例ID查询业务表信息
String procId = actInfo.getHistTask().getProcessInstanceId();
//区分客户需求反馈表 BusinessProcessEnum.Flow_Demand.getProcessDefkey()
if (BusinessProcessEnum.Flow_Demand.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
DemandEntity demandEntity = demandService.getInfoByProcId(procId);
if (demandEntity != null) {
actInfo.setProjectName(demandEntity.getDemandName());
actInfo.setDemandNo(demandEntity.getDemandNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(demandEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Project.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//建议书
ProductDevelopmentEntity productDevelopmentEntity = developmentService.getInfoByProcId(procId);
if (productDevelopmentEntity != null) {
actInfo.setProjectName(productDevelopmentEntity.getDevelopmentName());
actInfo.setDemandNo(productDevelopmentEntity.getDevelopmentNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(productDevelopmentEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Establish.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//需求立项申请
EvaEstablishEntity evaEstablishEntity = evaEstablishService.getInfoByProcId(procId);
if (evaEstablishEntity != null) {
actInfo.setProjectName(evaEstablishEntity.getProjectName());
actInfo.setDemandNo(evaEstablishEntity.getEstablishNo());
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setMainBusinessId(evaEstablishEntity.getId());
ProjectEntity projectInfo = projectService.getProjectByMainBusinessId(projectEntity);
if (projectInfo != null) {
actInfo.setProjectNo(projectInfo.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Institute.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//生产技术准备通知
InstituteEntity instituteEntity = instituteService.getInfoByProcId(procId);
if (instituteEntity != null) {
actInfo.setProjectName(instituteEntity.getProjectName());
actInfo.setDemandNo("-");
actInfo.setProjectNo(instituteEntity.getProjectNum());
}
} else if (BusinessProcessEnum.Flow_Dev_Plan.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//项目接收流程
ProjectStagePlanEntity projectStagePlanEntity = projectStagePlanService.getInfoByProcId(procId);
if (projectStagePlanEntity != null) {
ProjectEntity projectEntity = projectService.get(projectStagePlanEntity.getProjectId());
if (projectEntity != null) {
actInfo.setProjectName(projectEntity.getProjectName());
actInfo.setDemandNo(projectEntity.getEstablishNo());
actInfo.setProjectNo(projectEntity.getProjectNo());
}
}
} else if (BusinessProcessEnum.Flow_Project_New_One.getProcessDefkey().equals(actInfo.getProcDef().getKey()) || BusinessProcessEnum.Flow_Project_New_Two.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//产品开发建议书-必要性分析/可行性分析
ProjectProductDevelopNew projectProductDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(procId);
if (projectProductDevelopNew != null) {
actInfo.setProjectName(projectProductDevelopNew.getDevelopmentName());
actInfo.setDemandNo(projectProductDevelopNew.getDevelopmentNo());
actInfo.setProjectNo(projectProductDevelopNew.getProjectNum());
}
} else if (BusinessProcessEnum.Flow_Non_Market.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//技术开发项目
ProjectTechnologyDevelop projectTechnologyDevelop = projectTechnologyDevelopService.getInfoByProcInstId(procId);
if (projectTechnologyDevelop != null) {
actInfo.setProjectName(projectTechnologyDevelop.getDevelopmentName());
actInfo.setDemandNo(projectTechnologyDevelop.getDevelopmentNo());
actInfo.setProjectNo(projectTechnologyDevelop.getProjectNum());
}
}else if (BusinessProcessEnum.Flow_Project_Suspend.getProcessDefkey().equals(actInfo.getProcDef().getKey())) {
//节点暂停项目
ProjectProductSuspendRecord suspendRecord = projectProductSuspendRecordService.getInfoByProcInstId(procId);
ProjectProductDevelopNew productDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(suspendRecord.getInstanceParentId());
if (suspendRecord != null && productDevelopNew !=null) {
actInfo.setDemandNo(suspendRecord.getDevelopmentNo());
actInfo.setProjectNo(productDevelopNew.getProjectNum());
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
model.addAttribute("page", page);
return "modules/act/actTaskHistoricList";
}
/**
* 获取流转历史列表
*
* @param act 流程实例
* @param startAct 开始活动节点名称
* @param endAct 结束活动节点名称
*/
@RequestMapping(value = "histoicFlow")
public String histoicFlow(Act act, String startAct, String endAct, Model model) {
if (StringUtils.isNotBlank(act.getProcInstId())) {
List <ActExTaskOpininon> histoicFlowList = actTaskService.histoicFlowList(act.getProcInstId(), "");
for(ActExTaskOpininon opininon: histoicFlowList){
if(FlowVarEntity.PROCESS_VAR_DEV_SUSPEND_START.equals(opininon.getTaskKey())){
//获取暂停原因
ProjectProductSuspendRecord suspendRecord = projectProductSuspendRecordService.getInfoByProcInstId(act.getProcInstId());
opininon.setOpinion(suspendRecord.getOpinion());
}
}
model.addAttribute("histoicFlowList", histoicFlowList);
}
return "modules/act/actTaskHistoricFlow";
}
/**
* 获取流转历史列表
*
* @param procInstId 流程实例
* @param taskId 任务ID
*/
@RequestMapping(value = "histoicFlowSelect")
public String histoicFlowSelect(String procInstId, String taskId, Model model) {
if (StringUtils.isNotBlank(procInstId)) {
List <Map> backListNode = actTaskService.listBackNodes(procInstId, taskId);
model.addAttribute("backListNode", backListNode);
}
return "modules/act/actTaskHistoricFlow";
}
/**
* 获取流程列表
*
* @param category 流程分类
*/
@RequestMapping(value = "process")
public String processList(String category, HttpServletRequest request, HttpServletResponse response, Model model) {
Page <Object[]> page = new Page <Object[]>(request, response);
page = actTaskService.processList(page, category);
model.addAttribute("page", page);
model.addAttribute("category", category);
return "modules/act/actTaskProcessList";
}
/**
* 获取流程表单
*
* @param act
* @return
*/
@RequestMapping(value = "form")
public String form(Act act, Model model) {
// 获取流程XML上的表单KEY
String formKey = actTaskService.getFormKey(act.getProcDefId(), act.getTaskDefKey());
//获取当前环境
String active = Global.getConfig("system.profiles.active");
//表单key
String taskDefKey = act.getTaskDefKey();
// 获取流程实例对象
if (act.getProcInstId() != null) {
ProcessInstance p = actTaskService.getProcIns(act.getProcInstId());
act.setProcIns(p);
ActExtendTask extendTask = extendTaskService.getByTaskIdAndDeplymentId(act.getTaskDefKey(), p.getDeploymentId());
model.addAttribute("act", act);
model.addAttribute("extendTask", extendTask);
//可以退回节点
List <Map> backListNode = actTaskService.listBackNodes(act.getProcInstId(), act.getTaskId());
model.addAttribute("backListNode", backListNode);
if (extendTask != null) {
/***
* 临时权限配置
*/
if (StringUtils.isNotBlank(extendTask.getPermission())) {
String[] permssions = extendTask.getPermission().split(";");
for (String permssion : permssions) {
ActUtils.updatePermission(permssion);
}
}
/***
* 判断流程变量
*/
if (StringUtils.isNotBlank(extendTask.getConditionParam())) {
}
/***
* 判断是否有下一节点任务
*/
if (StringUtils.isNotBlank(extendTask.getChoiceUserByRole())) {
List <User> choiceList = systemService.findUserByRoleEnname(extendTask.getChoiceUserByRole());
model.addAttribute("choiceList", choiceList);
}
}
List <Map> actListBack = actTaskService.listBackActivityIdBy(act.getProcIns(), act.getTaskId());
//返回节点为null时初始化
if (actListBack == null) {
actListBack = Lists.newArrayList();
}
//***特殊情况处理***///
/**
* 部分节点意见隐藏
*/
if (FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEM.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_RESEARCH_DEM.equals(taskDefKey)) {
model.addAttribute("taskOpinionHideFlag", Global.NO);
}
//判断是否是技术管理部部长\副部长审批节点
if (FlowVarEntity.PROCESS_VAR_INSTITUTE_SKILL_MANAGE_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_INSTITUTE_APPEND_SKILL_MANAGE_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_LEADER_KEY_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_LEADER_KEY_ZS.equals(taskDefKey)) {
model.addAttribute("isConfirm", "true");
} else {
model.addAttribute("isConfirm", "false");
}
//版本区分
Integer addBackNodeVer = Integer.valueOf(DictUtils.getDictValue("add_back_node", "flow_institute_version", "0"));
boolean a = (p.getProcessDefinitionVersion() > addBackNodeVer);
//2022.07.08版本
Integer changeDevMinisterTrialNodeVer = Integer.valueOf(DictUtils.getDictValue("change_dev_minister_trial_node", "flow_project_version", "0"));
//是新版本
boolean newVersion2 = (p.getProcessDefinitionVersion() > changeDevMinisterTrialNodeVer);
/**
* 处理部分特殊节点仅可退回指定节点
*/
Map mapBack = new HashMap();
Map mapBack2 = new HashMap();
if (FlowVarEntity.PROCESS_VAR_MINISTER_ONE_DEM.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEM_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEM_CS.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEM);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEM_CH);
actListBack.clear();
actListBack.add(mapBack);
// mapBack2.put("id",FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM);
// mapBack2.put("name",FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM_CH);
// actListBack.add(mapBack2);
} else if (FlowVarEntity.PROCESS_VAR_APPOINT_DEM.equals(taskDefKey)) {
//综合评审节点，可退回节点为研究院节点
String ifFlag = (String) actTaskService.getVar(act.getTaskId(), FlowVarEntity.PROCESS_VAR_IF_ANA);
if (Global.YES.equals(ifFlag)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_RESEARCH_DEM);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_RESEARCH_DEM_CH);
actListBack.clear();
actListBack.add(mapBack);
} else {
actListBack.clear();
}
} else if (FlowVarEntity.PROCESS_VAR_MINISTER_DEM.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_SKILLS_DEM.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_OVER_DEM_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_OVER_DEM_CS.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_APPOINT_DEM);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_APPOINT_DEM_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_MINISTER_DEV.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_SKILLS_DEV.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_OVER_DEV_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_OVER_DEV_CS.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_APPOINT_DEV);
if (newVersion2) {
mapBack.put("name", FlowVarEntity.PROCESS_VAR_REVIEW_DEV_CH);
} else {
mapBack.put("name", FlowVarEntity.PROCESS_VAR_APPOINT_DEV_CH);
}
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_MINISTER_ONE_DEV.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_SKILL_DEV.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_CS.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV_CH);
actListBack.clear();
actListBack.add(mapBack);
// mapBack2.put("id",FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV);
// mapBack2.put("name",FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV_CH);
// actListBack.add(mapBack2);
} else if (FlowVarEntity.PROCESS_VAR_PROOFREADING_CHIEF_PLAN.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_PROOFREADING_PLAN.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_TECHNOLOGY_PLAN.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_WORD_ORDER_PLAN);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_WORD_ORDER_PLAN_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_INSTITUTE_SECTION_KEY.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_INSTITUTE_SKILL_MANAGE_KEY.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_INSTITUTE_DEV_MANAGE_KEY.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_INSTITUTE_PRO_MANAGER_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_INSTITUTE_PRO_MANAGER_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_ZS.equals(taskDefKey)) {
//科长只能驳回至提报人
mapBack.put("id", FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_INSTITUTE_SECTION_APPOINT_KEY.equals(taskDefKey) && a) {
//科长只能驳回至提报人
mapBack.put("id", FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_INSTITUTE_PRO_MANAGER_KEY.equals(taskDefKey) && a) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_INSTITUTE_SECTION_APPOINT_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_INSTITUTE_SECTION_APPOINT_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_LEADER_KEY_CS.equals(taskDefKey)) {
//计划调整中计划下发科长审核及部长审核只可驳回至项目负责人调整计划节点--测试
mapBack.put("id", FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_CS);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_LEADER_KEY_ZS.equals(taskDefKey)) {
//计划调整中计划下发科长审核及部长审核只可驳回至项目负责人调整计划节点--正式
mapBack.put("id", FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_ZS);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_SKILLS_MANAGER_DEV_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_SKILLS_MANAGER_DEV_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_ZS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_CS.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_ZS.equals(taskDefKey)) {
//指派立项负责人或者立项负责人驳回至铁三角组长
actListBack = Lists.newArrayList();
if (Global.SYSTEM_DEV.equals(active)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS);
} else if (Global.SYSTEM_PROD.equals(active)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_ZS);
}
mapBack.put("name", FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_ZS.equals(taskDefKey)) {
//主管副总批准立项隐藏驳回
actListBack = Lists.newArrayList();
} else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_ZS.equals(taskDefKey)) {
//研发审核 驳回至研发负责人意见
actListBack = Lists.newArrayList();
if (Global.SYSTEM_DEV.equals(active)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS);
} else if (Global.SYSTEM_PROD.equals(active)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS);
}
mapBack.put("name", FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(taskDefKey)) {
//综合判断 驳回至提报节点 立项负责人选择
actListBack = Lists.newArrayList();
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT_CH);
actListBack.clear();
actListBack.add(mapBack);
mapBack2.put("id", FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_TWO);
mapBack2.put("name", FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_TWO_CH);
actListBack.add(mapBack2);
} else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(taskDefKey)) {
//立项负责人选择1 驳回至综合判断
actListBack = Lists.newArrayList();
} else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_DIRECTOR_APPLICATION_RELEASE.equals(taskDefKey)) {
//综合判断 立项负责人选择1
actListBack = Lists.newArrayList();
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_DEV_THREE_SUBMIT_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (
FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_DEVELOPMENT_MINISTER.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_UNDERSECRETARY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_MINISTER.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_SZQ_TECHNOLOGY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_GROUP_TECHNOLOGY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_FINAL_JUDGMENT.equals(taskDefKey)
) {
//审核发布 可驳回至PMO主任申请发布
actListBack = Lists.newArrayList();
mapBack.put("id", FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_DIRECTOR_APPLICATION_RELEASE);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_DIRECTOR_APPLICATION_RELEASE_CH);
actListBack.clear();
actListBack.add(mapBack);
}
//零部件投产流程驳回只可驳回至上级
if (BusinessProcessEnum.Flow_Element_Dev.getProcessDefkey().equals(p.getProcessDefinitionKey())) {
//开发管理部部长退回至科长
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_MANAGE_KEY.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SECTION_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SECTION_CH);
actListBack.clear();
actListBack.add(mapBack);
} else if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SKILL_MANAGE_KEY.equals(taskDefKey)) {
//一把手退回至开发管理部部长
mapBack.put("id", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_MANAGE_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_MANAGE_CH);
actListBack.clear();
actListBack.add(mapBack);
}
}
//立项负责人驳回
if (FlowVarEntity.PROCESS_VAR_DEPUTY_PERSON.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_FZ_PERSON_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_NECESSITY_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_FIRST_NECESSITY_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_ID.equals(taskDefKey)) {
// mapBack.put("id",FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY);
// mapBack.put("name",FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_CH);
actListBack.clear();
// actListBack.add(mapBack);
}
//技术项目开发建议书流程驳回只可驳回至上级
if (BusinessProcessEnum.Flow_Non_Market.getProcessDefkey().equals(p.getProcessDefinitionKey())) {
//项目必要性评审退回至开发建议书提报
ProjectTechnologyDevelop projectTechnologyDevelop = projectTechnologyDevelopService.getInfoByProcInstId(act.getProcInstId());
if ((!"3".equals(projectTechnologyDevelop.getDevelopmentType()) ||
!"4".equals(projectTechnologyDevelop.getDevelopmentType()))
&& Float.valueOf(projectTechnologyDevelop.getProjectEstimatedCost()) >= 30) {
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_ID.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_TWO);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_ONE_NAME);
actListBack.clear();
actListBack.add(mapBack);
}
}
//主管副总
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_DEPUTY_MANAGER_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SZQ_FZ_PERSON.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_KEY);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_NAME);
actListBack.clear();
actListBack.add(mapBack);
}
//技术开发项目-决策与目标发布-退回至PMO主任申请发布
if (FlowVarEntity.PROCESS_VAR_RELEASE_MINISTER.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_RELEASE_UNDERSECRETARY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_RELEASE_MINISTER_TWO.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_RELEASE_SZQ_TECHNOLOGY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_RELEASE_GROUP_TECHNOLOGY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_PMO_DIRECTOR.equals(taskDefKey)) {
mapBack.put("id", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_ID);
mapBack.put("name", FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_NAME);
actListBack.clear();
actListBack.add(mapBack);
}
//立项负责人选择2
// if(FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PROJECT_INITIATION_TWO_CS.equals(taskDefKey)){
// mapBack.put("id",FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_ID_CS);
// mapBack.put("name",FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_NAME_CS);
// actListBack.clear();
// actListBack.add(mapBack);
// }
}
/**
* 流程提交按钮个性化处理
*/
String btnSubmitText = "同意";
if (FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_EVA.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_EDIT_NOTICE_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_WORD_ORDER_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEM.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ANALYSIS_TWO_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_GOLD_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ANALYSIS_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_RESEARCH_DEM.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_MINISTER_APPOINT__DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_TASK_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_EVA_TASK.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SUB_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_FINANCIAL_DEM_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_FINANCIAL_DEV_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_FINANCIAL_DEM_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_FINANCIAL_DEV_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FOUR.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_TWO.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(taskDefKey)
) {
btnSubmitText = "提交";
} else if (FlowVarEntity.PROCESS_VAR_SECTION_CHIEF_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_APPOINT_DEM.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SUBMIT_REVIEW.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PROJECT_PERSON.equals(taskDefKey)
) {
btnSubmitText = "指派";
} else if (FlowVarEntity.PROCESS_VAR_DEALER_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DESIGN_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DUCT_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT_PERSON_CONFIRM.equals(taskDefKey)) {
btnSubmitText = "确认";
} else if (FlowVarEntity.PROCESS_VAR_INSTITUTE_PRO_MANAGER_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SEND_NOTICE_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SEND_ORDER_PLAN.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_ZS.equals(taskDefKey)) {
btnSubmitText = "下发";
} else if (FlowVarEntity.PROCESS_VAR_APPOINT_DEM.equals(taskDefKey)) {
//如果是综合评审 研究院节点不选择（客户需求反馈表），则按钮名字改变
String ifFlag = (String) actTaskService.getVar(act.getTaskId(), FlowVarEntity.PROCESS_VAR_IF_ANA);
if (!Global.YES.equals(ifFlag)) {
btnSubmitText = "提交";
}
} else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_DIRECTOR_APPLICATION_RELEASE.equals(taskDefKey)) {
//产品开发建议书-决策与目标发布-PMO主任申请发布
btnSubmitText = "发布";
}
//产品开发建议书-必要性分析-主管副总批准立项 节点按钮个性化设置
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_APPROVAL_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_SZQ_APPROVAL_ZS.equals(taskDefKey)) {
//产品开发建议书-必要性分析-主管副总批准立项 节点展示同意立项
btnSubmitText = "同意立项";
model.addAttribute("backText", "驳回到立项负责人");
model.addAttribute("submitText", "提交PTC决策");
model.addAttribute("stopText", "不同意立项，终止项目");
}
//产品开发建议书-决策与目标发布-技术副总判断 节点按钮个性化设置
if (
FlowVarEntity.PROCESS_VAR_DEV_TWO_DEPUTY_TECHNOLOGY.equals(taskDefKey)
) {
//产品开发建议书-必要性分析-主管副总批准立项 节点展示同意立项
btnSubmitText = "同意";
model.addAttribute("backText", "驳回");
model.addAttribute("submitText", "提请PTC决策");
model.addAttribute("stopText", "终止");
}
//产品开发建议书-必要性分析-铁三角负责人及铁三角组长评审须由杨忱批准是否同意暂停
//技术可行性分析 经济可行性分析 工艺可行性分析 认证分析
//立项负责人 立项负责人选择1 综合判断
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SKILL_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_ECONOMIC_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROCESS_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_CERTIFICATION_ANALYSIS_TWO.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FOUR.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FIVE.equals(taskDefKey)
) {
//先查询该流程中是否还有为审批完成的暂停流程如果有则隐藏暂停按钮否则显示该按钮
/* ProjectProductSuspendRecord suspendRecord = new ProjectProductSuspendRecord();
suspendRecord.setTaskParentId(act.getTaskId());
suspendRecord.setInstanceParentId(act.getProcInstId());
suspendRecord.setPrimeMover(UserUtils.getUser().getLoginName());
List <String> list = projectProductSuspendRecordService.selectProcesstateList(suspendRecord);
if(null != list && list.size() > 0){
if (!list.contains("10")){
model.addAttribute("suspendText", "暂停");
}
}else {
model.addAttribute("suspendText", "暂停");
}*/
}
if (FlowVarEntity.PROCESS_VAR_DEV_SUSPEND_START.equals(taskDefKey)) {
model.addAttribute("suspendNode", "提交");
model.addAttribute("stopText", "终止");
btnSubmitText = "";
}
//产品开发建议书-节点审批人驳回
if (FlowVarEntity.PROCESS_VAR_DEV_SUSPEND_APPROVE.equals(taskDefKey)) {
actListBack.clear();
model.addAttribute("backText", "驳回");
}
//技术开发项目
if (FlowVarEntity.PROCESS_VAR_DEPUTY_PERSON.equals(taskDefKey)
) {
//技术开发项目-决策与目标发布-技术副总判断 节点展示同意立项
btnSubmitText = "同意立项";
model.addAttribute("backText", "驳回");
model.addAttribute("submitText", "提请PTC决策");
model.addAttribute("stopText", "终止");
}
//提报部门一把手审核
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SUBMIT_REVIEW_ONE.equals(taskDefKey)) {
model.addAttribute("backText", "驳回");
}
//技术部负责人
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PERSON_CHARGE.equals(taskDefKey)) {
btnSubmitText = "同意立项";
}
//ptc决策审核之后 立项负责人
if (FlowVarEntity.PROCESS_VAR_SELECT_THREE_PERSON.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_DEPUTY_MANAGER_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SZQ_FZ_PERSON.equals(taskDefKey)) {
model.addAttribute("stopText", "终止");
}
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_NECESSITY_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_FIRST_NECESSITY_KEY.equals(taskDefKey)
) {
btnSubmitText = "同意";
model.addAttribute("backText", "驳回");
model.addAttribute("stopText", "终止");
}
// if(FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PMO_ID_CS.equals(taskDefKey)){
// model.addAttribute("backText","驳回至技术部立项负责人");
// }
model.addAttribute("btnSubmitText", btnSubmitText);
//项目负责人-暂存按钮 区分是否开启子表单编辑框
if (FlowVarEntity.PROCESS_VAR_INSTITUTE_PRO_MANAGER_KEY.equals(taskDefKey)) {
model.addAttribute("tempSaveBtn", "1");
}
//财务部审批-暂存按钮 区分保存子表单中财务意见
if (FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_ZS.equals(taskDefKey)) {
model.addAttribute("tempSaveBtn", "2");
}
//认证分析-暂存按钮 其他暂存按钮，无特殊操作
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_CS.equals(taskDefKey) || FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_ZS.equals(taskDefKey)) {
model.addAttribute("tempSaveBtn", "3");
}
/**
* 判断开发立项流程可并行驳回节点
*/
if (FlowVarEntity.PROCESS_VAR_APPOINT_DEV.equals(taskDefKey)) {
List <Map> newListBack = new ArrayList <>();
//是否退回上一步
Integer backCount = 0;
for (Map map : actListBack) {
if (!FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(map.get("id")) && !FlowVarEntity.PROCESS_VAR_APPOINT_ONE_DEV.equals(map.get("id"))) {
newListBack.add(map);
}
if (FlowVarEntity.PROCESS_VAR_GOLD_DEV.equals(map.get("id")) || FlowVarEntity.PROCESS_VAR_ANALYSIS_DEV.equals(map.get("id"))) {
backCount++;
}
}
actListBack.clear();
actListBack = newListBack;
if (backCount == 2) {
Map back = new HashMap();
back.put("id", FlowVarEntity.PROCESS_BACK_DEV_BACK001);
back.put("name", FlowVarEntity.PROCESS_BACK_DEV_BACK001_CH);
actListBack.add(back);
}
}
model.addAttribute("actListBack", actListBack);
String suspendFlag = "false";
//添加中断按钮
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SUB_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_SUBMISSION_EVA.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_SUB_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_MANAGER_KEY_ZS.equals(taskDefKey)) {
suspendFlag = "true";
}
model.addAttribute("suspendFlag", suspendFlag);
String stopFlag = "false";
//添加终止按钮
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FIVE.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_ASSIGN_ZS.equals(taskDefKey)
) {
stopFlag = "true";
}
model.addAttribute("stopFlag", stopFlag);
}
//在主流程中显示暂停流程审批记录
String flowName = act.getProcDefId().split(":")[0];
// if(FlowVarEntity.MH_SEND_PROC_KEY_ONE_LIST.contains(flowName)) {
ProjectProductSuspendRecord suspendRecord = new ProjectProductSuspendRecord();
suspendRecord.setInstanceParentId(act.getProcInstId());
List <ProjectProductSuspendRecord> suspendList = projectProductSuspendRecordService.findList(suspendRecord);
if (null != suspendList && suspendList.size() > 0) {
for (ProjectProductSuspendRecord suspend : suspendList) {
Task task = actTaskService.getTask(suspend.getTaskParentId());
if(null!=task){
suspend.setTaskName(task.getName());
}else {
List <ActExTaskOpininon> histoicFlowList = actTaskService.histoicFlowList(suspend.getInstanceParentId(), "");
if (null != histoicFlowList && histoicFlowList.size() > 0) {
for (ActExTaskOpininon opininon : histoicFlowList) {
if (suspend.getTaskParentId().equals(opininon.getTaskId())) {
suspend.setTaskName(opininon.getTaskName());
continue;
}
}
}
}
}
model.addAttribute("suspendList", suspendList);
}
// }
return "modules/act/workspace";
}
/***
* 批量审核任务提交
* @return
*/
@RequestMapping(value = "batchSubmitTask", method = RequestMethod.POST)
@ResponseBody
public JqueryResult batchSubmitTask(String opinion, String businessInfo, Model model) throws UnsupportedEncodingException {
StringBuffer sb = null;
String info = StringEscapeUtils.unescapeHtml(businessInfo);
List <Map> businessInfoList = JSONArray.parseArray(info, Map.class);
if (null != businessInfoList && businessInfoList.size() > 0) {
for (Map map : businessInfoList) {
//获取需求编号
String developmentNo = String.valueOf(map.get("developmentNo"));
//获取流程实例id
String procInstId = String.valueOf(map.get("processInstanceId"));
//获取任务id
String taskId = String.valueOf(map.get("taskId"));
if (StringUtils.isNotBlank(developmentNo) && StringUtils.isNotBlank(procInstId) && StringUtils.isNotBlank(taskId)) {
//提交任务
JqueryResult jqueryResult = this.submitTask(taskId, null, null, procInstId, opinion, null, model);
if (FAIL_CODE == jqueryResult.getCode()) {
//失败信息拼接sb中
if (sb == null) {
sb = new StringBuffer("批量审批部分成功!失败的需求编号为:" + developmentNo);
} else {
sb.append("、" + developmentNo);
}
}
}
}
}
if (sb == null) {
return new JqueryResult.Builder(SUCCESS_CODE).build();
} else {
return new JqueryResult.Builder(FAIL_CODE).message(sb.toString() + " ,请进行单任务审批!").build();
}
}
/***
* 提交任务
* @param taskId 任务ID
* @param currentTaskDefKey 当前任务key
* @param nextTaskDefId 下一节点的任务标识
* @param procInstId 流程实例ID
* @param opinion 意见表
* @param userIds 用户集合ID
* @param model
* @return
*/
@RequestMapping(value = "submitTask", method = RequestMethod.POST)
@ResponseBody
public JqueryResult submitTask(String taskId, String currentTaskDefKey, String nextTaskDefId, String procInstId, String opinion, String userIds,
Model model) {
try {
ProcessInstance p = actTaskService.getProcIns(procInstId);
Task task = actTaskService.getTask(taskId);
if (task == null) {
return new JqueryResult.Builder(FAIL_CODE).message("任务已经完成").build();
}
//todo 判断产品建议书项目暂停节点是否审批完成
String taskDefKey = currentTaskDefKey;
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SKILL_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_ECONOMIC_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROCESS_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_CERTIFICATION_ANALYSIS_TWO.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FOUR.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FIVE.equals(taskDefKey)
) {
ProjectProductSuspendRecord productSuspendRecord = new ProjectProductSuspendRecord();
productSuspendRecord.setInstanceParentId(task.getProcessInstanceId());
productSuspendRecord.setTaskParentId(task.getId());
List <ProjectProductSuspendRecord> list = projectProductSuspendRecordService.findList(productSuspendRecord);
if (null != list && list.size() > 0) {
List <String> strList = actDao.selectActNameAndActType(list.get(0).getProcessInstanceId());
if (!strList.contains("endEvent")) {
return new JqueryResult.Builder(FAIL_CODE).message("节点暂停任务未处理完，不能提交流程！").build();
}
}
}
model.addAttribute("procInstId", p.getId());
model.addAttribute("taskId", task.getId());
model.addAttribute("currentTaskDefKey", task.getName());
Map map = new HashMap();
if (StringUtils.isNotBlank(userIds)) {
List <String> userLoinNamesList = Lists.newArrayList();
for (String id : userIds.split(",")) {
if (StringUtils.isNotBlank(id)) {
userLoinNamesList.add(id);
}
}
ProAssignee proAssignee = new ProAssignee(procInstId, userLoinNamesList);
ProcessHandleHelper.setProAssignee(proAssignee);
}
ActExtendTask currentTask = extendTaskService.getByTaskIdAndDeplymentId(currentTaskDefKey, p.getDeploymentId());
//开始处理任务
//如果是立项中的同步节点退回再次提交，则特殊处理
if (FlowVarEntity.PROCESS_VAR_GOLD_DEV.equals(currentTaskDefKey) || FlowVarEntity.PROCESS_VAR_ANALYSIS_DEV.equals(currentTaskDefKey)) {
//获取指定流程全局变量
String devBack = (String) actTaskService.getVar(taskId, FlowVarEntity.PROCESS_BACK_DEV_BACK);
if (StringUtils.isNotBlank(devBack) && Global.YES.equals(devBack)) {
//处理退回后再次提交的同步节点
actTaskService.addAgreeOpinion(procInstId, task, opinion);
//将退回标志还原为0
map.put(FlowVarEntity.PROCESS_BACK_DEV_BACK, Global.NO);
actTaskService.jumpTask(procInstId, FlowVarEntity.PROCESS_VAR_APPOINT_DEV, map);
} else {
actTaskService.complete(taskId, procInstId, opinion, map);
}
//更新门户代办
ProjectPortalAgentStatus projectPortalAgentStatus = portalAgentStatusService.selectEntityByTaskId(taskId, procInstId);
if (null!=projectPortalAgentStatus){
ProjectSysMhUtils.mhTaskUpdate(taskId, task.getAssignee(),null);
}
//创建新的门户代办
List <Task> list = taskService.createTaskQuery().processInstanceId(procInstId).orderByTaskId().desc().list();
if (null !=list && list.size() >0){
for (Task t: list){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),"1");
}
}
}
} else {
//完成门户任务并更新标题及访问地址
if (Global.TRUE.equals(Global.getConfig("sys.mh.task"))){
ProjectPortalAgentStatus projectPortalAgentStatus = portalAgentStatusService.selectEntityByTaskId(taskId, procInstId);
if (null!=projectPortalAgentStatus){
ProjectSysMhUtils.mhTaskUpdate(taskId, task.getAssignee(),null);
}
}
actTaskService.complete(taskId, procInstId, opinion, map);
List <Task> taskList = taskService.createTaskQuery().processInstanceId(procInstId).orderByTaskId().desc().list();
System.out.println(taskList);
//重新提交
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_TWO.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_SUBMISSION_EVA.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(task.getTaskDefinitionKey())
){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_CERTIFICATION_ANALYSIS_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_SUBMISSION_EVA.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(task.getTaskDefinitionKey())
//生产技术准备通知重新提报
||FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY.equals(task.getTaskDefinitionKey())){
// HistoricTaskInstance historicTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
List<Task> list =taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).orderByTaskId().desc().list();
System.out.println(list);
if (null !=list && list.size() == 3){
for (Task t1: list){
ProjectSysMhUtils.mhTaskCreate(procInstId,t1.getId(), UserUtils.getUser().getLoginName(),"1");
}
}else {
ProjectSysMhUtils.mhTaskCreate(procInstId,list.get(0).getId(), UserUtils.getUser().getLoginName(),"1");
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_TWO.equals(task.getTaskDefinitionKey())){
//产品开发建议书-可行性分析及发布-立项负责人选择
List<Task> list =taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).orderByTaskId().desc().list();
if (null !=list && list.size() >0){
for (Task t1: list){
ProjectSysMhUtils.mhTaskCreate(procInstId,t1.getId(), UserUtils.getUser().getLoginName(),"1");
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_DEPARTMENT_EXPERT_COUNTERSIGN.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(task.getTaskDefinitionKey())){
//会签和立项负责人选择 技术开发项目重新提交
if (null!=taskList && taskList.size()>0){
for (Task t1: taskList){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t1.getId(), t1.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t1.getId(), UserUtils.getUser().getLoginName(),"1");
}
}
}
}else {
ProjectSysMhUtils.mhTaskCreate(procInstId,task.getId(), UserUtils.getUser().getLoginName(),"1");
}
}else {
//HistoricTaskInstance historicTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
List<Task> list =taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).orderByTaskId().desc().list();
if (null!=list && list.size()>0){
if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_FIRST_NECESSITY_KEY.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_TWO.equals(task.getTaskDefinitionKey())
||"task20220714142451".equals(task.getTaskDefinitionKey())){
//立项负责人选择1 选择会签时候 技术开发项目第一次项目必要性评审或者立项负责人选择1 选择会签
for (Task t: list){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
if (list.size() == 3){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_ZS.equals(task.getTaskDefinitionKey())
){//铁三角销售负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-销售负责人意见
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_ZS.equals(task.getTaskDefinitionKey())){
//铁三角研发负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-研发负责人意见
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_ZS.equals(task.getTaskDefinitionKey())){
//铁三角技术负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-技术负责人意见
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_DEPARTMENT_EXPERT_COUNTERSIGN.equals(task.getTaskDefinitionKey())){
for (Task t: list){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else {
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_ASSIGN_ZS.equals(task.getTaskDefinitionKey())
){//铁三角销售负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-销售负责人意见
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_ASSIGN_ZS.equals(task.getTaskDefinitionKey())){
//铁三角研发负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-研发负责人意见
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_ASSIGN_ZS.equals(task.getTaskDefinitionKey())){
//铁三角技术负责人指派
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-技术负责人意见
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}
if(FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(task.getTaskDefinitionKey())
){//铁三角-研发负责人意见
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-研发审核
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_ECONOMIC_FEASIBILITY_ANALYSIS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_PROCESS_FEASIBILITY_ANALYSIS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_CERTIFICATION_ANALYSIS_TWO.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_SKILL_ANALYSIS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_TARGET_PROFIT_NOTICE_ISSUED.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_TWO_DEPARTMENT_EXPERT_COUNTERSIGN.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_FIRST_SKILL_PERSON.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SECOND_SKILL_PERSON.equals(task.getTaskDefinitionKey())){
//会签
//产品开发建议书-可行性分析阶段-经济可行性分析、工艺可行性分析、认证分析
ProjectPortalAgentStatus portalAgentStatus = new ProjectPortalAgentStatus();
portalAgentStatus.setTaskId(list.get(0).getId());
portalAgentStatus.setProcinstId(list.get(0).getProcessInstanceId());
List <ProjectPortalAgentStatus> list1 = portalAgentStatusService.findList(portalAgentStatus);
if (null==list1 || list1.size()==0){
ProjectSysMhUtils.mhTaskCreate(procInstId,list.get(0).getId(), UserUtils.getUser().getLoginName(),null);
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(task.getTaskDefinitionKey())){
for (Task t: list){
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_CS.equals(t.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_AUDIT_ZS.equals(t.getTaskDefinitionKey())){
//铁三角-研发审核
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}else {
//铁三角组长
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(t.getId(), t.getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,t.getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else if(
!FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(task.getTaskDefinitionKey())
&&!FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(task.getTaskDefinitionKey())
&&!FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(task.getTaskDefinitionKey())
&&!FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(task.getTaskDefinitionKey())
&&!FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_CS.equals(currentTaskDefKey)
&&!FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_ZS.equals(currentTaskDefKey)
/* &&!FlowVarEntity.PROCESS_VAR_CHANGE_SECTION_KEY.equals(currentTaskDefKey)
&&!FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_CS.equals(currentTaskDefKey)
&&!FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_ZS.equals(currentTaskDefKey)*/
){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(list.get(0).getId(), list.get(0).getProcessInstanceId());
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,list.get(0).getId(), UserUtils.getUser().getLoginName(),null);
}
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(task.getTaskDefinitionKey())){
//todo 构造开启可行性分析流程的门户待办任务
ProjectProductDevelopNew productDevelopNew = projectProductDevelopNewDao.getInfoByProcInstId(procInstId);
if ("5".equals(productDevelopNew.getProjectLevel()) || "6".equals(productDevelopNew.getProjectLevel())){
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(taskId, procInstId);
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,taskId, UserUtils.getUser().getLoginName(),"4");
}else {
portalAgentStatus.setTransactors(UserUtils.getUser().getLoginName());
portalAgentStatus.setOperationType("2");
portalAgentStatusService.updateEntityByTaskIdAndProcInstId(portalAgentStatus);
ProjectSysMhUtils.mhTaskCreate(procInstId,taskId, UserUtils.getUser().getLoginName(),"4");
}
}
}else if (FlowVarEntity.PROCESS_VAR_DEV_TWO_PMO_FINAL_JUDGMENT.equals(task.getTaskDefinitionKey())){
//TODO 构造开启项目接收的门户待办任务
ProjectProductDevelopNew productDevelopNew = projectProductDevelopNewDao.getInfoByProcInstId(procInstId);
if ("20".equals(productDevelopNew.getProcesState())){
ProjectEntity projectEntity = projectService.getByProNo(productDevelopNew.getProjectNum());
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(taskId, procInstId);
if (null==portalAgentStatus){
ProjectSysMhUtils.mhTaskCreate(procInstId,taskId, UserUtils.getUser().getLoginName(),"5");
}else {
portalAgentStatus.setTransactors(UserUtils.getUser().getLoginName());
portalAgentStatus.setOperationType("2");
portalAgentStatusService.updateEntityByTaskIdAndProcInstId(portalAgentStatus);
ProjectSysMhUtils.mhTaskCreate(procInstId,taskId, UserUtils.getUser().getLoginName(),"5");
}
}
}
}
}
//如果为产品开发建议书-审核发布-立项主管部长 或者 产品开发建议书-审核发布-陕重汽技术副总
if (FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_MINISTER.equals(task.getTaskDefinitionKey()) || FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_SZQ_TECHNOLOGY.equals(task.getTaskDefinitionKey())) {
Task task1 = actTaskService.getCurrentTask(task.getProcessInstanceId());
boolean b = (FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_GROUP_TECHNOLOGY.equals(task1.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_RELEASE_SZQ_TECHNOLOGY.equals(task1.getTaskDefinitionKey())) && (p.getProcessDefinitionVersion() < 4);
if (b) {
try {
//去除节点名称中的技术二字
actDao.updateActHiActinstNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", ""));
actDao.updateActHiTaskinstNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", ""));
actDao.updateActRuTaskNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", ""));
} catch (Exception e) {
logger.error("去除节点名称中的技术二字失败！");
}
}
//TODO 20230221将技术副总文字改为陕重汽副总
if (FlowVarEntity.PROCESS_VAR_DEV_TWO_DEPUTY_TECHNOLOGY.equals(task1.getTaskDefinitionKey()) && (p.getProcessDefinitionVersion() < 7)) {
//将节点名称由技术副总判断改为陕重汽副总判断
actDao.updateActHiActinstNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", "陕重汽"));
actDao.updateActHiTaskinstNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", "陕重汽"));
actDao.updateActRuTaskNodeName(task1.getProcessInstanceId(), task1.getTaskDefinitionKey(), task1.getName().replace("技术", "陕重汽"));
}
}
//版本区分(客户需求反馈)
Integer addRequirementBackNodeVer = Integer.valueOf(DictUtils.getDictValue("add_skillUnderSecretary_node", "flow_requirement_version", "0"));
boolean oldRequirementVersion = (p.getProcessDefinitionVersion() <= addRequirementBackNodeVer);
if (oldRequirementVersion) {
//旧版本 客户需求反馈流程 如果是需求管理部部长初次审核 默认技术一把手初次审核通过
if (FlowVarEntity.PROCESS_VAR_MINISTER_ONE_DEM.equals(currentTaskDefKey)) {
this.defaultPass(procInstId, opinion, map, FlowVarEntity.PROCESS_NODE_FLAG_N20);
}
} else {
//新版本 客户需求反馈流程 如果是技术管理部部长初次审核 默认技术一把手初次审核通过
if (FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEM_ZS.equals(currentTaskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEM_CS.equals(currentTaskDefKey)) {
this.defaultPass(procInstId, opinion, map, FlowVarEntity.PROCESS_NODE_FLAG_N20);
}
}
//版本区分(开发建议书)
Integer addDevelopmentBackNodeVer = Integer.valueOf(DictUtils.getDictValue("add_skillUnderSecretary_node", "flow_project_version", "0"));
boolean oldDevelopmentVersion = (p.getProcessDefinitionVersion() <= addDevelopmentBackNodeVer);
if (oldDevelopmentVersion) {
//旧版本 开发建议书流程 如果是需求管理部部长初次审核 默认技术一把手初次审核通过
if (FlowVarEntity.PROCESS_VAR_MINISTER_ONE_DEV.equals(currentTaskDefKey)) {
this.defaultPass(procInstId, opinion, map, FlowVarEntity.PROCESS_NODE_FLAG_N20);
}
} else {
//新版本 开发建议书流程 如果是技术管理部部长初次审核 默认技术一把手初次审核通过
if (FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_ZS.equals(currentTaskDefKey) || FlowVarEntity.PROCESS_VAR_UNDERSECRETARY_TWO_DEV_CS.equals(currentTaskDefKey)) {
this.defaultPass(procInstId, opinion, map, FlowVarEntity.PROCESS_NODE_FLAG_N20);
}
}
if (FlowVarEntity.PROCESS_VAR_CHANGE_SECTION_KEY.equals(currentTaskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_CS.equals(currentTaskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_ZS.equals(currentTaskDefKey)) {
//查询项目变更信息
ProChangeEntity proChangeEntity = proChangeService.getEntityByProcInstId(procInstId);
//处理变更 TODO
if (null != proChangeEntity && StringUtils.isNotBlank(proChangeEntity.getProjectId())) {
//根据项目id查询项目信息
ProjectEntity projectEntity = projectService.get(proChangeEntity.getProjectId());
if (null != projectEntity && StringUtils.isNotBlank(projectEntity.getProjectLev())) {
//获取需要跳过的项目级别
String projectLev = DictUtils.getDictLabel("1", "auto_bypass_project_lev", "");
if (StringUtils.isNotBlank(projectLev)) {
List <String> projectLevList = Lists.newArrayList(projectLev.split(","));
if (projectLevList.size() > 0 && projectLevList.contains(projectEntity.getProjectLev())) {
this.defaultPass(procInstId, opinion, map, FlowVarEntity.PROCESS_NODE_FLAG_N80);
proChangeService.updateTaskStatus(proChangeEntity);
}
}
}
}
//计划下发时 任务下发部长审核节点处理业务-下发计划 其他类型处理任务
if (ProChangeEntity.PROCHANGE_TYPE_PLAN.equals(proChangeEntity.getChangeType())) {
if (FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_CS.equals(currentTaskDefKey)
|| FlowVarEntity.PROCESS_VAR_CHANGE_PLAN_SECTION_KEY_ZS.equals(currentTaskDefKey)) {
proChangeService.planIssueLeader(proChangeEntity);
}
}
}
//TODO 创建节点暂停审批记录（主流程）
if (FlowVarEntity.PROCESS_VAR_DEV_SUSPEND_APPROVE.equals(currentTaskDefKey)) {
saveActExTaskOpininon(taskId, procInstId, opinion);
//修改产品开发建议书数据状态为暂停状态
ProjectProductDevelopNew productDevelopNew = new ProjectProductDevelopNew();
ProjectProductSuspendRecord infoByProcInstId = projectProductSuspendRecordService.getInfoByProcInstId(procInstId);
if(null != infoByProcInstId && StringUtils.isNotBlank(infoByProcInstId.getProcessInstanceId())){
ProjectProductDevelopNew developNew = projectProductDevelopNewService.getInfoByProcInstId(infoByProcInstId.getInstanceParentId());
productDevelopNew.setStatus(ProjectProductDevelopNew.REQUIREMENT_STATUS_SUSPEND);
productDevelopNew.setUpdateDate(new Date());
productDevelopNew.setId(developNew.getId());
projectProductDevelopNewService.updateStatusById(productDevelopNew);
}
}
//恢复技术开发建议书状态
String status = null;
ProjectProductDevelopNew developNew = projectProductDevelopNewService.getInfoByProcInstId(procInstId);
//必要性分析节段
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_CS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_ZS.equals(taskDefKey)){
status = ProjectProductDevelopNew.REQUIREMENT_STATUS_APPROVAL;
if(null != developNew && StringUtils.isNotBlank(developNew.getProcessInstanceId())){
ProjectProductDevelopNew productDevelopNew = new ProjectProductDevelopNew();
productDevelopNew.setStatus(status);
productDevelopNew.setUpdateDate(new Date());
productDevelopNew.setId(developNew.getId());
projectProductDevelopNewService.updateStatusById(productDevelopNew);
}
//可行性分析节段
}else if ( FlowVarEntity.PROCESS_VAR_DEV_TWO_SKILL_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_ECONOMIC_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROCESS_FEASIBILITY_ANALYSIS.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_CERTIFICATION_ANALYSIS_TWO.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FOUR.equals(taskDefKey)
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FIVE.equals(taskDefKey)
) {
//修改产品开发建议书数据状态
status = ProjectProductDevelopNew.REQUIREMENT_STATUS_ONE_FAIL;
if(null != developNew && StringUtils.isNotBlank(developNew.getProcessInstanceId())){
ProjectProductDevelopNew productDevelopNew = new ProjectProductDevelopNew();
productDevelopNew.setStatus(status);
productDevelopNew.setUpdateDate(new Date());
productDevelopNew.setId(developNew.getId());
projectProductDevelopNewService.updateStatusById(productDevelopNew);
}
}
//流程发送邮件开关
if (Global.TRUE.equals(Global.getConfig("processTaskSendEmail"))) {
//发送邮件
AsynchronousEmailUtils.sendProcessEmail(procInstId, Act.ACT_FLAG_AGREE);
}
return new JqueryResult.Builder(SUCCESS_CODE).message("任务处理成功").build();
} catch (Exception e) {
logger.error(e.toString());
return new JqueryResult.Builder(FAIL_CODE).message("任务处理失败" + e.toString()).build();
}
}
/**
* 构造审批记录
* @param taskId
* @param procInstId
* @param opinion
*/
public void saveActExTaskOpininon(String taskId, String procInstId, String opinion) {
// 节点暂停审批人同意后 给主流程 新增一条 审批记录
// 新增的节点记录开始时间为主流的原来的开始时间结束时间为节点暂停的审批时间
// 此时主流程的 同意时的开始时间为节点审批后的结束时间
//获取主任务或者子任务的时间
ProjectProductSuspendRecord productSuspendRecord = projectProductSuspendRecordService.getInfoByProcInstId(procInstId);
HistoricTaskInstance mainTaskFinishInfo = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
HistoricTaskInstance mainTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(productSuspendRecord.getTaskParentId()).singleResult();
if(StringUtils.isNotBlank(productSuspendRecord.getInstanceParentId())){
ActHiTaskinstNew taskinst = new ActHiTaskinstNew();
taskinst.setProcDefId(mainTaskInstance.getProcessDefinitionId());
taskinst.setTaskDefKey(mainTaskInstance.getTaskDefinitionKey());
taskinst.setProcInstId(productSuspendRecord.getInstanceParentId());
taskinst.setExecutionId(mainTaskInstance.getExecutionId());
taskinst.setName(mainTaskInstance.getName()+"暂停");
taskinst.setAssignee(UserUtils.getUser().getLoginName());
// taskinst.setStartTime(mainTaskInstance.getCreateTime());
taskinst.setStartTime(mainTaskFinishInfo.getEndTime());
taskinst.setEndTime(mainTaskFinishInfo.getEndTime());
/*不计算项目暂停周期*/
// long second = mainTaskFinishInfo.getEndTime().getTime() - mainTaskInstance.getCreateTime().getTime();
// taskinst.setDuration(second);
taskinst.setDeleteReason("completed");
taskinst.setPriority("50");
//taskinst.setFormKey(mainTaskInstance.getFormKey());
hiTaskinstNewService.save(taskinst);
//修改主流程中(流程发起时间startTime)
// actDao.updateStartTime(productSuspendRecord.getInstanceParentId(),mainTaskInstance.getFormKey(),mainTaskFinishInfo.getEndTime());
//创建审批记录
ActExTaskOpininon taskOpininon = new ActExTaskOpininon();
taskOpininon.setInstId(productSuspendRecord.getInstanceParentId());
//productSuspendRecord.getTaskParentId()
taskOpininon.setTaskId(taskinst.getId());
taskOpininon.setTaskKey(mainTaskInstance.getTaskDefinitionKey());
taskOpininon.setTaskName(mainTaskInstance.getName()+"暂停");
taskOpininon.setApprover(UserUtils.getUser().getLoginName());
User user = UserUtils.getByLoginName(productSuspendRecord.getPrimeMover());
taskOpininon.setApproverName("由"+user.getName()+"发起" +"\r\n"+ UserUtils.getUser().getName()+"审批通过");
//暂停原因
taskOpininon.setOpinion(productSuspendRecord.getOpinion());
//暂停节点完成时间
taskOpininon.setApproveTime(mainTaskFinishInfo.getEndTime());
taskOpininon.setStatus("suspend_end");
taskOpininonService.saveOpininon(taskOpininon);
}
}
/**
* 默认通过
*
* @param procInstId
* @param opinion
* @param map
*/
private void defaultPass(String procInstId, String opinion, Map map, String nodeName) {
List <Task> taskList = taskService.createTaskQuery().processInstanceId(procInstId).list();
if (taskList != null && taskList.size() == 1) {
User user = flowNodeService.findExaminerUserByNodeFlag(nodeName);
opinion = "系统自动默认审批通过";
actTaskService.complete(taskList.get(0).getId(), procInstId, opinion, user, map);
taskList = taskService.createTaskQuery().processInstanceId(procInstId).list();
ProjectPortalAgentStatus portalAgentStatus = portalAgentStatusService.selectEntityByTaskId(taskList.get(0).getId(), taskList.get(0).getProcessInstanceId());
if (null==portalAgentStatus){
try {
ProjectSysMhUtils.mhTaskCreate(procInstId,taskList.get(0).getId(), UserUtils.getUser().getLoginName(),null);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/***
* 提交任务（弃用）
* @param taskId 任务ID
* @param nextTaskDefId 下一节点的任务标识
* @param procInstId 流程实例ID
* @param opinion 意见表
* @param userIds 用户集合ID
* @param approverType 审批人类型：1，提报人审批阶段 2，直接指定节点
* @param approverNextNodeFlag 下一审批节点标识
* @param model
* @return
*/
@RequestMapping(value = "submitTaskTwo", method = RequestMethod.POST)
@ResponseBody
public JqueryResult submitTaskTwo(String taskId, String currentTaskDefKey, String nextTaskDefId, String procInstId, String opinion, String userIds,
Model model, String approverType, String approverNextNodeFlag) {
try {
ProcessInstance p = actTaskService.getProcIns(procInstId);
Task task = actTaskService.getTask(taskId);
if (task == null) {
return new JqueryResult.Builder(FAIL_CODE).message("任务已经完成").build();
}
model.addAttribute("procInstId", p.getId());
model.addAttribute("taskId", task.getId());
model.addAttribute("currentTaskDefKey", task.getName());
Map map = new HashMap();
List <String> userLoinNamesList = Lists.newArrayList();
//userIds未在前台指定下，系统自动设置下一节点审批人
if (StringUtils.isBlank(userIds)) {
//区分类型
if (StringUtils.isNotBlank(approverType)) {
if (FlowVarEntity.APPROVER_TYPE_APPOINT.equals(approverType)) {
//指定指定节点
if (StringUtils.isNotBlank(approverNextNodeFlag)) {
Map <String, String> examinerInfo = flowNodeService.findExaminerByNodeFlag(approverNextNodeFlag);
if (examinerInfo == null) {
return new JqueryResult.Builder(FAIL_CODE).message("下一节点审批人缺失，请联系管理员").build();
} else {
//直接指定下一节点审批人
if (FlowNodeEntity.NODE_TYPE_APPOINT.equals(examinerInfo.get("type"))) {
userIds = examinerInfo.get("userLoginName");
} else if (FlowNodeEntity.NODE_TYPE_DISTRIBUTE.equals(examinerInfo.get("type"))) {
//根据选择的人及节点标识处理审批人
//客户需求反馈-任务派发
if (FlowVarEntity.PROCESS_NODE_FLAG_N30.equals(approverNextNodeFlag)) {
String dealer = flowNodeService.findDemandDealer(procInstId);
if (StringUtils.isNotBlank(dealer)) {
userIds = dealer;
} else {
//若未查询到，则设置默认的任务处理人
userIds = examinerInfo.get("userLoginName");
}
}
}
}
} else {
return new JqueryResult.Builder(FAIL_CODE).message("未指定下一节点审批人标识，请联系管理员").build();
}
}
}
}
if (StringUtils.isNotBlank(userIds)) {
for (String id : userIds.split(",")) {
if (StringUtils.isNotBlank(id)) {
userLoinNamesList.add(id);
}
}
ProAssignee proAssignee = new ProAssignee(procInstId, userLoinNamesList);
ProcessHandleHelper.setProAssignee(proAssignee);
}
ActExtendTask currentTask = extendTaskService.getByTaskIdAndDeplymentId(currentTaskDefKey, p.getDeploymentId());
actTaskService.complete(taskId, procInstId, opinion, map);
return new JqueryResult.Builder(SUCCESS_CODE).message("任务处理成功").build();
} catch (Exception e) {
logger.error(e.toString());
return new JqueryResult.Builder(FAIL_CODE).message("任务处理失败" + e.toString()).build();
}
}
/***
* 流程退回接口
* @param taskId
* @param backActivitId
* @param opinion
* @param procInstId
* @param userIds
* @param model
* @return
*/
@RequestMapping(value = "disAgreeTask", method = RequestMethod.POST)
@ResponseBody
public JqueryResult disAgreeTask(String taskId, String backActivitId, String opinion, String procInstId, String userIds,
Model model, String backNodeId, String backNodeOpinion, String agreeFlag) {
try {
//如果backNodeId存在值，说明为实际的驳回点节（因客户需求，部分节点并非驳回列表的节点）
Task task = actTaskService.getTask(taskId);
if (StringUtils.isNotBlank(backNodeId)) {
backActivitId = backNodeId;
if (backActivitId.contains("end")) {
//设置业务表中流程状态为已终止
ProcessInstance pr = runtimeService.createProcessInstanceQuery().processInstanceId(procInstId).singleResult();
Act act = new Act();
if(null!=pr){
act.setBusinessTable(pr.getBusinessKey().split(":")[0]);
act.setBusinessId(pr.getBusinessKey().split(":")[1]);
act.setStatus("40");
act.setProcInstId(procInstId);
actTaskService.updateProcessStatusByBusinessId(act);
}else {
task = actTaskService.getCurrentTask(procInstId);
act.setBusinessTable(task.getProcessDefinitionId().split(":")[0]);
act.setStatus("40");
act.setProcInstId(procInstId);
actTaskService.updateProcessStatusByProcInstId(act);
}
ProjectSysMhUtils.mhTaskUpdate(taskId,task.getAssignee(),backNodeId);
}else {
//todo 当铁三角组长提交时下一节点为立项负责人时
if((FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_ZS.equals(task.getTaskDefinitionKey()))
&& (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(backNodeId))){
backNodeId = "";
ProjectSysMhUtils.mhTaskUpdate(taskId,task.getAssignee(),backNodeId);
}else {
//PROCESS_VAR_DEV_TWO_PMO_DIRECTOR_APPLICATION_RELEASE
ProjectSysMhUtils.mhTaskUpdate(taskId,task.getAssignee(),backNodeId);
}
}
if (StringUtils.isNotBlank(backNodeOpinion)) {
opinion = backNodeOpinion;
}
}else {
//退回或者终止
task = actTaskService.getTask(taskId);
if(FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_INSTITUTE_FINANCIAL_KEY_ZS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.releaseApprovedBackNodeList.contains(task.getTaskDefinitionKey())
||FlowVarEntity.skillBackNodeList.contains(task.getTaskDefinitionKey())
||FlowVarEntity.technologyBackNodeList.contains(task.getTaskDefinitionKey())
||FlowVarEntity.developmentSuggestionsList.contains(task.getTaskDefinitionKey())
||FlowVarEntity.projectChangeList.contains(task.getTaskDefinitionKey())
||FlowVarEntity.productionOfComponentsList.contains(task.getTaskDefinitionKey())){
backNodeId = FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT;
ProjectSysMhUtils.mhTaskUpdate(taskId,task.getAssignee(),backNodeId);
}else {
ProjectSysMhUtils.mhTaskUpdate(taskId,task.getAssignee(),backNodeId);
}
}
//todo 技术项目开发驳回更新第一次会签版本号
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(backActivitId)) {
ProjectTechnologyCountersign technologyCountersign = new ProjectTechnologyCountersign();
technologyCountersign.setProcessInstanceId(procInstId);
technologyCountersign.setCountersignerNum("1");
technologyCountersignService.updateDelFlag(technologyCountersign);
}
//todo 技术项目开发驳回更新第二次会签版本号
if (FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_SELECT_PERSON_TWO.equals(backActivitId)) {
ProjectTechnologyCountersign technologyCountersign = new ProjectTechnologyCountersign();
technologyCountersign.setProcessInstanceId(procInstId);
technologyCountersign.setCountersignerNum("2");
technologyCountersignService.updateDelFlag(technologyCountersign);
ProjectTechnologyDevelop technologyDevelop = new ProjectTechnologyDevelop();
technologyDevelop.setBackStatus("1");//退回状态
technologyDevelop.setProcessinstanceid(procInstId);
projectTechnologyDevelopService.updateBackStatus(technologyDevelop);
}
//todo 产品开发建议书-节点暂停返回
//门户驳回值初次提报节点
if ((FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_CS.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_DEV_ONE_SUBMIT_ZS.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_DEV_TWO_SUBMIT.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_DEV_SUSPEND_START.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_APPLY_KEY.equals(backNodeId)
||FlowVarEntity.PROCESS_VAR_INSTITUTE_SUB_KEY.equals(backNodeId))
&& !backActivitId.contains("end")){
ProjectSysMhUtils.mhTaskUpdate(taskId,UserUtils.getUser().getLoginName(),backNodeId);
}
actTaskService.taskBack(procInstId, taskId, backActivitId, opinion, UserUtils.getUser());
task = actTaskService.getCurrentTask(procInstId);
if(null!=task){
logger.info("taskId1:>>>>>>>>"+taskId+"taskId2:======"+task!=null ? task.getId() : "");
}
if (!backActivitId.contains("end")){
ProjectSysMhUtils.mhTaskCreate(procInstId,task.getId(),UserUtils.getUser().getLoginName(),null);
}
//流程发送邮件开关
if (Global.TRUE.equals(Global.getConfig("processTaskSendEmail"))) {
//发送邮件
AsynchronousEmailUtils.sendProcessEmail(procInstId, Act.ACT_FLAG_DISAGREE);
}
if (StringUtils.isNotBlank(backNodeId)) {
//如果不为初评通过 则构造技术管理部一把手默认审批通过信息
if (FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM.equals(backNodeId) || FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(backNodeId)) {
//修改驳回类型为同意驳回agree_return
actExTaskOpininonDao.updateStatus(procInstId, taskId, "agree_return");
//构造记录
ActExTaskOpininon actExTaskOpininon = new ActExTaskOpininon();
actExTaskOpininon.setId(IdGen.uuid());
actExTaskOpininon.setInstId(procInstId);
actExTaskOpininon.setTaskId(IdGen.uuid());
if (FlowVarEntity.PROCESS_VAR_SUBMISSION_DEM.equals(backNodeId)) {
actExTaskOpininon.setTaskKey(FlowVarEntity.PROCESS_VAR_SKILLS_ONE_DEM);
} else if (FlowVarEntity.PROCESS_VAR_SUBMISSION_DEV.equals(backNodeId)) {
actExTaskOpininon.setTaskKey(FlowVarEntity.PROCESS_VAR_SKILLS_ONE_DEV);
}
actExTaskOpininon.setTaskName("技术管理部一把手初次审核");
String loginName = flowNodeService.findExaminerLoginNameByNodeFlag(FlowVarEntity.PROCESS_NODE_FLAG_N20);
actExTaskOpininon.setApprover(loginName);
actExTaskOpininon.setApproverName(UserUtils.getByLoginName(loginName).getName());
actExTaskOpininon.setApproveTime(new Date());
actExTaskOpininon.setOpinion("系统自动默认审批通过");
actExTaskOpininon.setStatus("agree");
actExTaskOpininon.setCreateBy(UserUtils.getUser());
actExTaskOpininon.setCreateTime(new Date());
actExTaskOpininonDao.insert(actExTaskOpininon);
}
//如果驳回backNodeId不是驳回操作时
if (FlowVarEntity.PROCESS_VAR_DEPUTY_PERSON.equals(backNodeId)
|| FlowVarEntity.PROCESS_VAR_ELEMENT_DEV_PROJECT_PERSON.equals(backNodeId)) {
actExTaskOpininonDao.updateStatus(procInstId, taskId, "agree");
}
//若存在同意标识 更新状态
if (StringUtils.isNotBlank(agreeFlag)) {
actExTaskOpininonDao.updateStatus(procInstId, taskId, agreeFlag);
}
}
return new JqueryResult.Builder(SUCCESS_CODE).message("任务处理成功").build();
} catch (Exception e) {
logger.error(e.toString());
return new JqueryResult.Builder(FAIL_CODE).message("任务处理失败" + e.toString()).build();
}
}
/**
* 启动流程
*
* @param act
* @param table
* @param id
* @param model
* @return
* @throws Exception
*/
@RequestMapping(value = "start")
@ResponseBody
public String start(Act act, String table, String id, Model model) throws Exception {
actTaskService.startProcess(act.getProcDefKey(), act.getBusinessId(), act.getBusinessTable(), act.getTitle());
return "true";//adminPath + "/act/task";
}
/**
* 签收任务
*
* @param act
* @return
*/
@RequestMapping(value = "claim")
@ResponseBody
public String claim(Act act) {
String userId = UserUtils.getUser().getLoginName();//ObjectUtils.toString(UserUtils.getUser().getId());
actTaskService.claim(act.getTaskId(), userId);
return "true";//adminPath + "/act/task";
}
/**
* 完成任务
*
* @param act
* @return
*/
@RequestMapping(value = "complete")
@ResponseBody
public String complete(Act act) {
actTaskService.complete(act.getTaskId(), act.getProcInstId(), act.getComment(), act.getVars().getVariableMap());
return "true";//adminPath + "/act/task";
}
@RequestMapping("detail")
public String detail(Act act, Model model) {
ProcessInstance p = actTaskService.getProcIns(act.getProcInstId());
act.setProcIns(p);
model.addAttribute("act", act);
return "modules/act/workspace_detail";
}
/**
* 读取带跟踪的图片
*/
@RequestMapping(value = "trace/photo/{procDefId}/{execId}/{procinstId}")
public void tracePhoto(@PathVariable("procDefId") String procDefId, @PathVariable("execId") String execId, @PathVariable("procinstId") String procinstId, HttpServletResponse response) throws Exception {
InputStream imageStream = actTaskService.tracePhoto(procDefId, execId, procinstId);
// 输出资源内容到相应对象
byte[] b = new byte[1024];
int len;
while ((len = imageStream.read(b, 0, 1024)) != -1) {
response.getOutputStream().write(b, 0, len);
}
}
/**
* 查看流程图
*
* @param procDefId
* @param execId
* @param response
* @throws Exception
*/
@RequestMapping(value = "trace/photo")
public void getDiagramView(String procDefId, String execId, String procinstId, HttpServletResponse response) throws Exception {
InputStream imageStream = actTaskService.tracePhoto(procDefId, execId, procinstId);
// 输出资源内容到相应对象
byte[] b = new byte[1024];
int len;
while ((len = imageStream.read(b, 0, 1024)) != -1) {
response.getOutputStream().write(b, 0, len);
}
}
/**
* 输出跟踪流程信息
*
* @param proInsId
* @return
* @throws Exception
*/
@ResponseBody
@RequestMapping(value = "trace/info/{proInsId}")
public List <Map <String, Object>> traceInfo(@PathVariable("proInsId") String proInsId) throws Exception {
List <Map <String, Object>> activityInfos = actTaskService.traceProcess(proInsId);
return activityInfos;
}
/**
* 显示流程图
*/
@RequestMapping(value = "processPic")
public void processPic(String procDefId, HttpServletResponse response) throws Exception {
ProcessDefinition procDef = repositoryService.createProcessDefinitionQuery().processDefinitionId(procDefId).singleResult();
String diagramResourceName = procDef.getDiagramResourceName();
InputStream imageStream = repositoryService.getResourceAsStream(procDef.getDeploymentId(), diagramResourceName);
byte[] b = new byte[1024];
int len = -1;
while ((len = imageStream.read(b, 0, 1024)) != -1) {
response.getOutputStream().write(b, 0, len);
}
}
/**
* 获取跟踪信息
*/
@RequestMapping(value = "processMap")
public String processMap(String procDefId, String proInstId, Model model)
throws Exception {
List <ActivityImpl> actImpls = new ArrayList <ActivityImpl>();
ProcessDefinition processDefinition = repositoryService
.createProcessDefinitionQuery().processDefinitionId(procDefId)
.singleResult();
ProcessDefinitionImpl pdImpl = (ProcessDefinitionImpl) processDefinition;
String processDefinitionId = pdImpl.getId();// 流程标识
ProcessDefinitionEntity def = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(processDefinitionId);
List <ActivityImpl> activitiList = def.getActivities();// 获得当前任务的所有节点
List <String> activeActivityIds = runtimeService.getActiveActivityIds(proInstId);
for (String activeId : activeActivityIds) {
for (ActivityImpl activityImpl : activitiList) {
String id = activityImpl.getId();
if (activityImpl.isScope()) {
if (activityImpl.getActivities().size() > 1) {
List <ActivityImpl> subAcList = activityImpl
.getActivities();
for (ActivityImpl subActImpl : subAcList) {
String subid = subActImpl.getId();
System.out.println("subImpl:" + subid);
if (activeId.equals(subid)) {// 获得执行到那个节点
actImpls.add(subActImpl);
break;
}
}
}
}
if (activeId.equals(id)) {// 获得执行到那个节点
actImpls.add(activityImpl);
System.out.println(id);
}
}
}
model.addAttribute("procDefId", procDefId);
model.addAttribute("proInstId", proInstId);
model.addAttribute("actImpls", actImpls);
return "modules/act/actTaskMap";
}
/**
* 删除任务
*
* @param taskId 流程实例ID
* @param reason 删除原因
*/
@RequiresPermissions("act:process:edit")
@RequestMapping(value = "deleteTask")
public String deleteTask(String taskId, String reason, RedirectAttributes redirectAttributes) {
if (StringUtils.isBlank(reason)) {
addMessage(redirectAttributes, "请填写删除原因");
} else {
actTaskService.deleteTask(taskId, reason);
addMessage(redirectAttributes, "删除任务成功，任务ID=" + taskId);
}
return "redirect:" + adminPath + "/act/task";
}
/**
* 任务签收并办理
*
* @param act
* @return
*/
@RequestMapping(value = "claimForm")
public String claimForm(Act act) {
System.out.println("任务办理人编号：" + act.getAssignee());
String userId = UserUtils.getUser().getLoginName();//ObjectUtils.toString(UserUtils.getUser().getId());
actTaskService.claim(act.getTaskId(), userId);
// 获取流程XML上的表单KEY
String formKey = actTaskService.getFormKey(act.getProcDefId(), act.getTaskDefKey());
// 获取流程实例对象
if (act.getProcInstId() != null) {
ProcessInstance p = actTaskService.getProcIns(act.getProcInstId());
if (p == null) {
HistoricProcessInstance h = actTaskService.getHistoricProcIns(act.getProcInstId());
if (h != null) {
String[] business_key_ = h.getBusinessKey().split(":");
if (business_key_.length >= 1) {
act.setBusinessId(h.getBusinessKey().split(":")[1]);
}
}
} else {
act.setProcIns(p);
}
}
return "redirect:" + ActUtils.getFormUrl(formKey, act);
}
/***
* 跳转到转办选人页面
* @param taskId
* @param taskName
* @param title
* @param model
* @return
*/
@RequestMapping(value = "toClaimPage")
public String toClaimPage(String taskId,String taskName,String title,Model model){
model.addAttribute("taskId",taskId);
model.addAttribute("taskName",taskName);
model.addAttribute("title",title);
//当前登陆人 非admin
User user = UserUtils.getUser();
if(!user.isAdmin()){
model.addAttribute("loginId",user.getId());
}
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
if(FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(task.getTaskDefinitionKey())
||FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(task.getTaskDefinitionKey())){
model.addAttribute("status","1");
}
//产品开发建议书-必要性分析-铁三角负责人及铁三角组长评审须由杨忱批准是否同意暂停
//技术可行性分析 经济可行性分析 工艺可行性分析 认证分析
//负责人 综合评审
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_INSTITUTE_PERSON_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SALES_PERSON_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_SKILL_PERSON_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_MANAGEMENT_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SKILL_ANALYSIS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_ECONOMIC_FEASIBILITY_ANALYSIS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROCESS_FEASIBILITY_ANALYSIS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_CERTIFICATION_ANALYSIS_TWO.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_DEMAND_OR_PROJECT_PERSON_ZS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_SYNTHETIC_JUDGMENT.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_THREE.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FOUR.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_TWO_PROJECT_PERSON_SELECT_FIVE.equals(task.getTaskDefinitionKey())
) {
//先查询该流程中是否还有为审批完成的暂停流程如果有则隐藏暂停按钮否则显示该按钮
ProjectProductSuspendRecord suspendRecord = new ProjectProductSuspendRecord();
suspendRecord.setTaskParentId(task.getId());
suspendRecord.setInstanceParentId(task.getProcessInstanceId());
suspendRecord.setPrimeMover(UserUtils.getUser().getLoginName());
List <String> strList = projectProductSuspendRecordService.selectProcesstateList(suspendRecord);
if(null != strList && strList.size() > 0){
if (strList.contains("10")){
// ProjectProductDevelopNew projectProductDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(task.getProcessInstanceId());
model.addAttribute("state","1");
}
}
}
//产品开发项目（非仅认证项目）的项目接收流程只能给本科室人员转办，不得给其他科室人员转办
// if (FlowVarEntity.PROCESS_VAR_SECTION_CHIEF_PLAN.equals(task.getTaskDefinitionKey())
// || FlowVarEntity.PROCESS_VAR_DEPARTMENT_MINISTER.equals(task.getTaskDefinitionKey())) {
//立项分配任务流程表
ProjectStagePlanEntity projectStagePlanEntityOld = projectStagePlanService.getInfoByProcId(task.getProcessInstanceId());
if(null != projectStagePlanEntityOld){
//根据项目id获取实际业务表id
ProjectEntity projectEntity = projectService.get(projectStagePlanEntityOld.getProjectId());
//查找产品开发建议书 需求类型1是否为非仅认证项目 需求类型1 1：产品开发需求 2：仅认证公告需求
ProjectProductDevelopNew developNew = projectProductDevelopNewService.get(projectEntity.getMainBusinessId());
//查询相关只需要转办给本科室或者本部门的taskKey集合
List <Dict> dictList = DictUtils.getDictList("flow_task_transfer");
List<String> strlist = Lists.newArrayList();
for (Dict dict: dictList){
strlist.add(dict.getValue());
}
if(null != developNew){
if (!ProjectProductDevelopNew.CERTIFICATION_ANALYSIS_TYPE.equals(developNew.getDemandTypeOne())) {
if (strlist.contains(task.getTaskDefinitionKey())){
model.addAttribute("officeId", UserUtils.getUser().getOffice().getId());
}
/* // 科长指派负责人
if (FlowVarEntity.PROCESS_VAR_SECTION_CHIEF_PLAN.equals(task.getTaskDefinitionKey())) {
model.addAttribute("officeId", UserUtils.getUser().getOffice().getId());
} else {
//部门部长分配任务
model.addAttribute("officeId", UserUtils.getUser().getOffice().getId());
}*/
}
}
}
// }
return "modules/act/actTaskClaimSelectPerson";
}
/***
* 转办任务
* @param taskId
* @param userId
* @param model
* @param redirectAttributes
* @return
*/
@RequiresPermissions("act:task:transfer")
@RequestMapping(value = "transferAssignee")
public String transferAssignee(String taskId, String userId, Model model, RedirectAttributes redirectAttributes) {
Map vars = new HashMap();
ProjectProductDevelopNew projectProductDevelopNew = null;
User user = systemService.getUser(userId);
try {
//actTaskService.saveMyTaskChange(user.getLoginName(),taskId);
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
//更新门户主任务为转办
String type = "2";//转办
ProjectSysMhUtils.mhTaskUpdate(task.getId(),user.getLoginName(),type);
//构建转办记录
TaskEntity subTask = createTask(task, task.getAssignee());
if (null != subTask) {
String comment = "转办给：" + user.getName();
//子任务的创建时间为主任务历史表中的创建时间
HistoricTaskInstance mainTaskFinishInfo = historyService.createHistoricTaskInstanceQuery().taskId(task.getId()).singleResult();
//更新子任务历史数据
actDao.updateActHiTaskinst(subTask.getId(), task.getProcessDefinitionId(), task.getProcessInstanceId(), task.getExecutionId(), mainTaskFinishInfo.getCreateTime());
System.out.println("创建时间" + mainTaskFinishInfo.getCreateTime() + "====" + "当前时间" + mainTaskFinishInfo.getTime());
taskService.addComment(subTask.getId(), subTask.getProcessInstanceId(), comment);
//获取任务开始时间时间戳
long createTime = mainTaskFinishInfo.getCreateTime().getTime();
//当前时间
Date date = new Date();
//耗时
long consumingTime = date.getTime() - createTime;
//提交子任务
taskService.complete(subTask.getId());
//更新已办任务完成时间
actDao.updateActHiTaskinstEndTime(subTask.getId(), date, consumingTime);
//修改主任务的持有人及办理人
// taskService.setOwner(taskId,task.getAssignee());
// taskService.setAssignee(taskId, user.getLoginName());
actTaskService.saveMyTaskChange(user.getLoginName(), taskId);
//获取子任务完成时间
HistoricTaskInstance subTaskFinishInfo = historyService.createHistoricTaskInstanceQuery().taskId(subTask.getId()).singleResult();
//更新主任务历史数据 - 开始时间为子任务的完成时间
actDao.updateActHiTaskinst(task.getId(), task.getProcessDefinitionId(), task.getProcessInstanceId(), task.getExecutionId(), subTaskFinishInfo.getEndTime());
//更新我的列表中转办任务的创建时间
actDao.updateActRuTaskCreateTime(task.getId(), subTaskFinishInfo.getEndTime());
ActExTaskOpininon actExTaskOpininon = new ActExTaskOpininon();
actExTaskOpininon.setInstId(task.getProcessInstanceId());
actExTaskOpininon.setTaskId(subTask.getId());
actExTaskOpininon.setTaskKey(task.getTaskDefinitionKey());
actExTaskOpininon.setTaskName(task.getName());
actExTaskOpininon.setApprover(task.getAssignee());
User u = systemService.getUserByLoginName(task.getAssignee());
actExTaskOpininon.setApproverName(u.getName());
actExTaskOpininon.setApproveTime(subTaskFinishInfo.getEndTime());
actExTaskOpininon.setOpinion(comment);
actExTaskOpininon.setStatus("transfer");
actExTaskOpininon.preInsert();
actExTaskOpininonDao.insert(actExTaskOpininon);
}
//更换转办人
if (FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_CS.equals(task.getTaskDefinitionKey())
|| FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON_ZS.equals(task.getTaskDefinitionKey())) {
projectProductDevelopNew = projectProductDevelopNewService.getInfoByProcInstId(task.getProcessInstanceId());
ProjectProductDevelopNew productDevelopNew = new ProjectProductDevelopNew();
productDevelopNew.setProjectPersonId(userId);
productDevelopNew.setProjectPersonName(user.getName());
productDevelopNew.setId(projectProductDevelopNew.getId());
projectProductDevelopNewDao.updateProjectPerson(productDevelopNew);
//修改流程中的立项负责人
vars.put(FlowVarEntity.PROCESS_VAR_DEV_ONE_PROJECT_PERSON, user.getLoginName());
RuntimeService runtimeService = (RuntimeService) SpringContextUtil.getBean("runtimeService");
runtimeService.setVariables(task.getProcessInstanceId(), vars);
//流程发送邮件开关
if (Global.TRUE.equals(Global.getConfig("processTaskSendEmail"))) {
//发送邮件
AsynchronousEmailUtils.sendProcessEmail(task.getProcessInstanceId(), Act.ACT_FLAG_AGREE);
}
}
//流程key
String procKey = subTask.getProcessDefinitionId().split(":")[0];
//查询当前流程是否需要推送至门户
if (FlowVarEntity.MH_SEND_PROC_KEY_LIST.indexOf(procKey)!=-1){
//创建门户转办代办任务
ProjectSysMhUtils.mhTaskCreate(subTask.getProcessInstanceId(),subTask.getId(),user.getLoginName(),type);
}
addMessage(redirectAttributes, "转办任务成功" + taskId);
} catch (Exception e) {
logger.error(e.toString());
addMessage(redirectAttributes, "转办任务失败");
}
if (UserUtils.getUser().isAdmin()) {
return "redirect:" + adminPath + "/act/task/toTaskAllList";
} else {
return "redirect:" + adminPath + "/act/task/toTaskList";
}
}
/***
* 业务表的基础数据
* @param proInstId
* @param businessId
* @return
*/
@RequestMapping(value = "detailBuiness")
public String toBusinessDetail(String proInstId, String businessId, Model model,String f) {
ProcessInstance pr =
runtimeService.createProcessInstanceQuery().processInstanceId(proInstId).singleResult();
if (pr != null) {
String id = pr.getBusinessKey().split(":")[1];
ActModelBaseInfo info = actModelService.getActModelBaseInfoByKey(pr.getProcessDefinitionKey());
return "redirect:" + adminPath + "/" + info.getDetailUrl() + "?id=" + id +"&f="+f;
} else {
HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(proInstId).singleResult();
if (historicProcessInstance != null) {
String id = historicProcessInstance.getBusinessKey().split(":")[1];
ActModelBaseInfo info = actModelService.getActModelBaseInfoByKey(historicProcessInstance.getProcessDefinitionKey());
return "redirect:" + adminPath + "/" + info.getDetailUrl() + "?id=" + id+"&f="+f;
}
}
model.addAttribute("errorMsg", "未找到对应的业务详情表单");
return "error/businessError";
}
/***
* 流程中断
* @param procInstId
* @param taskId
* @param opinion
* @param currentTaskDefKey
* @return
*/
@RequestMapping(value = "suspendTask", method = RequestMethod.POST)
@ResponseBody
public JqueryResult suspendTask(String procInstId, String taskId, String opinion, String currentTaskDefKey) {
if (StringUtils.isNotBlank(procInstId)) {
return actTaskService.suspendTask(procInstId, taskId,currentTaskDefKey);
} else {
return new JqueryResult.Builder(FAIL_CODE).message("任务处理失败").build();
}
}
/**
* 创建子任务
*
* @param parentTask 父级任务对象
* @param assignee 子任务办理人
* @return
*/
public TaskEntity createTask(Task parentTask, String assignee) {
TaskEntity taskEntity = null;
if (null != parentTask) {
//生成子任务
taskEntity = (TaskEntity) taskService.newTask();
taskEntity.setCategory(parentTask.getCategory());
taskEntity.setDescription(parentTask.getDescription());
taskEntity.setTenantId(parentTask.getTenantId());
taskEntity.setAssignee(assignee);
taskEntity.setName(parentTask.getName());
taskEntity.setParentTaskId(parentTask.getId());
taskEntity.setProcessInstanceId(parentTask.getProcessInstanceId());
taskEntity.setProcessDefinitionId(parentTask.getProcessDefinitionId());
taskEntity.setTaskDefinitionKey(parentTask.getTaskDefinitionKey());
taskEntity.setPriority(parentTask.getPriority());
taskEntity.setCreateTime(parentTask.getCreateTime());
taskService.saveTask(taskEntity);
}
return taskEntity;
}
}
Authenticator 类是权限用户名和密码在调用的过程中也是要组装的，上面注释也写了，这里直接贴出实体类
package com.pps.project.webservice.utils;
import com.pps.project.webservice.erp.config.ErpTaskConfig;
import java.net.Authenticator;
import java.net.PasswordAuthentication;
/**
* @Description: esb权限
* @Author chq
* @Date 2021/9/26
**/
public class EsbAuthenticator extends Authenticator {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(ErpTaskConfig.esbUserInfo, ErpTaskConfig.esbPassWordInfo.toCharArray());
}
}
上面类里面用到了ErpTaskConfig ，配置用户名和密码的，我这里用的是yml文件配置的
package com.pps.project.webservice.erp.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @Description: erp接口调用配置
*/
@Component
@ConfigurationProperties(prefix = "erp")
public class ErpTaskConfig {
public static String esbUserInfo;
public static String esbPassWordInfo;
public static String pushUrlInfo;
/**
* esb账号
*/
private String esbUser;
/**
* esb密码
*/
private String esbPassWord;
/**
* 调用esb接口路径
*/
private String pushUrl;
public String getEsbUser() {
return esbUser;
}
public void setEsbUser(String esbUser) {
this.esbUser = esbUser;
esbUserInfo = esbUser;
}
public String getEsbPassWord() {
return esbPassWord;
}
public void setEsbPassWord(String esbPassWord) {
this.esbPassWord = esbPassWord;
esbPassWordInfo = esbPassWord;
}
public String getPushUrl() {
return pushUrl;
}
public void setPushUrl(String pushUrl) {
this.pushUrl = pushUrl;
pushUrlInfo = pushUrl;
}
}
若依项目配置文件
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
