activiti-api/src/main/java/com/common/workflow/service/activiti/ActivitiService.java

package com.common.workflow.service.activiti;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.*;

import javax.annotation.Resource;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;

import com.common.workflow.service.activiti.supplierAnnualListener.AnnualApprovalRefuseTaskService;
import com.common.workflow.service.dto.ActiHistoricTaskDTO;
import com.common.workflow.service.dto.ActiMyTaskDTO;
import com.common.workflow.service.dto.ActiPageResultDTO;
import com.common.workflow.service.dto.ActiUserTaskDTO;
import com.common.workflow.web.rest.vm.ActiCompleteVM;
import com.common.workflow.web.rest.vm.AllProcessTaskVM;
import com.common.workflow.web.rest.vm.MultiActiCompleteVM;
import com.common.workflow.web.rest.vm.MultiOrgAuditVM;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.engine.*;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.event.impl.ActivitiEntityWithVariablesEventImpl;
import org.activiti.engine.history.*;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.activiti.image.ProcessDiagramGenerator;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ActivitiService {
    private static final Logger logger = LoggerFactory.getLogger(ActivitiService.class);
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private HistoryService historyService;
    @Autowired
    private ProcessEngine processEngine;
    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private ProcessEngineConfigurationImpl processEngineConfiguration;

    /**
     * 启动流程
     * @param businessKey 业务id
     */
    public String startProcesses(String processKey, String businessKey, String userNames, String result) {

        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("businessKey", businessKey);
        variables.put("recorder", userNames);
        variables.put("result", result);

        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processKey, variables);
        logger.info("流程启动成功，流程id:" + processInstance.getId() + " 业务ID: " + businessKey);
        return processInstance.getProcessInstanceId();
    }

    /**
     * 启动流程
     * @param businessKey 业务id
     */
    public String startProcesses(String processKey, String businessKey, String userNames, String result, String type, String supplierName) {

        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("businessKey", businessKey);
        variables.put("recorder", userNames);
        variables.put("result", result);
        variables.put("type", type);
        variables.put("supplierName", supplierName);

        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processKey, variables);
        logger.info("流程启动成功，流程id:" + processInstance.getId() + " 业务ID: " + businessKey);
        return processInstance.getProcessInstanceId();
    }

    /**
     *
     * <p>描述: 根据工作流Key, 用户id, 业务表Key 查询待办任务列表</p>
     */
    @Transactional
    public void completeTask(ActiCompleteVM actiVm) {
        String processKey = actiVm.getProcessKey();
        String businessKey = actiVm.getBusinessKey();
        String userNames = actiVm.getUserNames();
        String userId = actiVm.getUserId();
        String result = actiVm.getResult();
        String remarks = actiVm.getRemarks();
        String callbackUrl = actiVm.getCallbackUrl();

        Task myTask = taskService.createTaskQuery()
            .processDefinitionKey(processKey)
            .taskCandidateOrAssigned(userId)
            //.taskAssignee(userId)
            .processVariableValueEquals("businessKey", businessKey)
            .singleResult();

        /*List<Task> testTasks = taskService.createTaskQuery()
            .processDefinitionKey(processKey)
            .taskCandidateOrAssigned(userId)
            //.taskAssignee(userId)
            .processVariableValueEquals("businessKey", businessKey)
            .list();*/

        //获取流程实例
        logger.info("创建的myTask: " + myTask.toString());
        logger.info("工作流参数 processKey：" + processKey);
        logger.info("工作流参数 businessKey：" + businessKey);
        logger.info("工作流参数 userId：" + userId);
        logger.info("工作流参数 result：" + result);
        logger.info("工作流参数 callbackUrl：" + callbackUrl);
        taskService.claim(myTask.getId(), userId);

        Map<String,Object> vars = new HashMap<String,Object>();
        vars.put("users", userNames);
        vars.put("result", Integer.parseInt(result));
        vars.put("callbackUrl", callbackUrl);

        List<String> assigneeList = Arrays.asList(userNames.split(","));
        vars.put("assigneeList", assigneeList);

        //设置流程变量【基本类型】
        taskService.setVariableLocal(myTask.getId(), "businessKey", businessKey);
        taskService.setVariableLocal(myTask.getId(), "users", userNames);
        taskService.setVariableLocal(myTask.getId(), "result", Integer.parseInt(result));
        taskService.setVariableLocal(myTask.getId(), "remarks", remarks);

        taskService.complete(myTask.getId(), vars);
        //taskService.complete(myTask.getId(), vars, true);


    }

    /**
     *
     * <p>描述: 多实例，下一步</p>
     */
    public void multiCompleteTask(MultiActiCompleteVM actiVm) {
        String processKey = actiVm.getProcessKey();
        String businessKey = actiVm.getBusinessKey();
        String userNames = actiVm.getUserNames();
        List<MultiOrgAuditVM> multiOrgAudits = actiVm.getMultiOrgAudits();
        String userId = actiVm.getUserId();
        String result = actiVm.getResult();
        String remarks = actiVm.getRemarks();
        String callbackUrl = actiVm.getCallbackUrl();

        Task myTask = taskService.createTaskQuery()
            .processDefinitionKey(processKey)
            .taskCandidateOrAssigned(userId)
            //.taskAssignee(userId)
            .processVariableValueEquals("businessKey", businessKey)
            .singleResult();

        /*List<Task> testTasks = taskService.createTaskQuery()
            .processDefinitionKey(processKey)
            .taskCandidateOrAssigned(userId)
            //.taskAssignee(userId)
            .processVariableValueEquals("businessKey", businessKey)
            .list();*/

        //获取流程实例
        taskService.claim(myTask.getId(), userId);

        Map<String,Object> vars = new HashMap<String,Object>();
        vars.put("users", userNames);
        vars.put("result", Integer.parseInt(result));
        vars.put("callbackUrl", callbackUrl);

        List<String> orgInfos = new ArrayList<>();
        for(MultiOrgAuditVM orgInfo : multiOrgAudits) {
            String orgstr = orgInfo.getOrgId();
            orgstr += ":" + orgInfo.getOrgName();
            orgstr += ":" + orgInfo.getUserIds();
            orgInfos.add(orgstr);
        }

        vars.put("assigneeList", orgInfos);

        //设置流程变量【基本类型】
        taskService.setVariableLocal(myTask.getId(), "businessKey", businessKey);
        taskService.setVariableLocal(myTask.getId(), "users", userNames);
        taskService.setVariableLocal(myTask.getId(), "result", Integer.parseInt(result));
        taskService.setVariableLocal(myTask.getId(), "remarks", remarks);

        taskService.complete(myTask.getId(), vars);
        //taskService.complete(myTask.getId(), vars, true);


    }

    /**
     *
     * <p>描述:任务审批 	（通过/拒接） </p>
     * @author 范相如
     * @date 2018年2月25日
     * @param taskId 任务id
     * @param userId 用户id
     * @param result false OR true
     */
    /*public void completeTask(String taskId,String userId,String result, String comments) {
        //获取流程实例
        taskService.claim(taskId, userId);

        Map<String,Object> vars = new HashMap<String,Object>();
        vars.put("sign", "true");
        taskService.complete(taskId, vars);
    }*/

    /**
     *
     * <p>描述: 根据工作流Key 和 用户id查询待办任务列表</p>
     */
    public String findTasksByUserId(String processKey, String userId) {
        List<Task> resultTasks = taskService.createTaskQuery().processDefinitionKey(processKey).taskCandidateOrAssigned(userId).list();
        String businessKeys = "";
        int i = 0;
        for (Task myTask : resultTasks) {
            if(resultTasks.size()-1 == i) {
                businessKeys += taskService.getVariable(myTask.getId(), "businessKey").toString();
            } else {
                businessKeys += taskService.getVariable(myTask.getId(), "businessKey").toString()+ ",";
            }
            i++;
        }
        return businessKeys;
    }

    /**
     *
     * <p>描述: 根据工作流Key 和 用户id查询待办任务列表</p>
     */
    public List<ActiUserTaskDTO> findAllProcessTasks(AllProcessTaskVM allVm) {
        List<String> userList = Arrays.asList( allVm.getUserIds().split(",") );
        List<String> definitionKeys = Arrays.asList( allVm.getDefinitionKeys().split(",") );
        List<Task> resultTasks = taskService.createTaskQuery()
            .processDefinitionKeyIn(definitionKeys)
            .list();

        List<ActiUserTaskDTO> myTaskDTOS = new ArrayList<>();
        for (Task myTask : resultTasks) {
            ActiUserTaskDTO myTaskDTO = new ActiUserTaskDTO();
            myTaskDTO.setProcessDefinitionId(myTask.getProcessDefinitionId());
            myTaskDTO.setBusinessKey(taskService.getVariable(myTask.getId(), "businessKey").toString());
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());
            myTaskDTO.setTaskName(myTask.getName());
            myTaskDTO.setUserId( taskService.getVariable(myTask.getId(), "users").toString() );
            myTaskDTOS.add(myTaskDTO);
        }
        return myTaskDTOS;
    }

    /**
     *
     * <p>描述: 根据工作流Key 和 用户id查询待办任务列表</p>
     */
    public List<ActiMyTaskDTO> findTasksWithCreateTimeByUserId(String processKey, String userId) {
        List<Task> resultTasks = taskService.createTaskQuery().processDefinitionKey(processKey).taskCandidateOrAssigned(userId).list();
        List<ActiMyTaskDTO> myTaskDTOS = new ArrayList<>();

        for (Task myTask : resultTasks) {
            ActiMyTaskDTO myTaskDTO = new ActiMyTaskDTO();
            myTaskDTO.setBusinessKey(taskService.getVariable(myTask.getId(), "businessKey").toString());
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());
            myTaskDTOS.add(myTaskDTO);
        }
        return myTaskDTOS;
    }

    public String findAllUserTodoList() {
        List<Task> resultTasks  = taskService.createTaskQuery().includeTaskLocalVariables().list();
        List<String> todoTaskUserIdList = new ArrayList<>();

        for (Task myTask : resultTasks) {
            Map<String, Object> obj = myTask.getTaskLocalVariables();
            if (obj.size() > 0) {
                String userIds = obj.get("users").toString();
                List<String> userIdArr = Arrays.asList(userIds.split(","));
                todoTaskUserIdList.addAll(userIdArr);
            }
        }

        logger.info("所有待办任务审批人id：" + StringUtils.join(todoTaskUserIdList, ","));
        return StringUtils.join(todoTaskUserIdList, ",");
    }

    public ActiPageResultDTO findAllTypePagingTasksWithCreateTimeByUserId(String userId, int pageIndex, int pageSize, String wfName, String type, String supplierName) {
        TaskQuery taskQuery = taskService.createTaskQuery().taskCandidateOrAssigned(userId);
        //按工作流名称查询
        if (!wfName.isEmpty()) {
            taskQuery = taskQuery.processDefinitionKeyIn(Arrays.asList(wfName.split(",")));
        }
        //按分类查询
        if (!type.isEmpty()) {
            taskQuery = taskQuery.processVariableValueEquals("type", type);
        }
        //按供应商名称查询
        if (!supplierName.isEmpty()) {
            taskQuery = taskQuery.processVariableValueLikeIgnoreCase("supplierName", "%"+supplierName +"%");
        }
        //按节点名称查询。可按条件判断是否需要过滤掉集中评审
        //不获取集中评审的待办任务 select distinct NAME_ from ACT_RU_TASK;
        List<String> allTaskNameExceptConcentrate = Arrays.asList("准入申请", "年审申请", "增项申请", "变更申请", "日常评价", "二级单位分办", "二级单位初审", "二级单位复审", "二级单位审核",
            "业务处室接收", "业务处室专业审批", "专业审批", "专业处室分办", "交费", "企管法规处入库", "企管法规处审批", "企业法规处审批",
            "企业法规处审核", "企管法规处审核", "企管法规处编号、入库", "审批未通过", "审核未通过", "待开发票");
        taskQuery = taskQuery.taskNameIn(allTaskNameExceptConcentrate);
        long taskTotal = taskQuery.count();

        List<ActiMyTaskDTO> myTaskDTOS = new ArrayList<>();
        List<Task> resultTasks = taskQuery.orderByTaskCreateTime().desc().listPage((pageIndex-1)*pageSize, pageSize);

        for (Task myTask : resultTasks) {
            ActiMyTaskDTO myTaskDTO = new ActiMyTaskDTO();
            myTaskDTO.setProcessDefinitionId(myTask.getProcessDefinitionId());
            myTaskDTO.setBusinessKey(taskService.getVariable(myTask.getId(), "businessKey").toString());
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());
            myTaskDTO.setTaskName(myTask.getName());
            myTaskDTOS.add(myTaskDTO);
        }

        ActiPageResultDTO pageResultDTO = new ActiPageResultDTO();
        pageResultDTO.setTotal(taskTotal);
        pageResultDTO.setTaskDTOList(myTaskDTOS);
        return pageResultDTO;
    }

    public ActiPageResultDTO findAllTypePagingTasksWithCreateTimeByUserId(String userId, int pageIndex, int pageSize, String wfName, String taskName) {
        TaskQuery taskQuery = taskService.createTaskQuery().taskCandidateOrAssigned(userId);
        //按工作流名称查询
        if (!wfName.isEmpty()) {
            taskQuery = taskQuery.processDefinitionKeyIn(Arrays.asList(wfName.split(",")));
        }
        //按节点名称查询
        if (!taskName.isEmpty()) {
            taskQuery = taskQuery.taskNameIn(Arrays.asList(taskName.split(",")));
        }
        long taskTotal = taskQuery.count();

        List<ActiMyTaskDTO> myTaskDTOS = new ArrayList<>();
        List<Task> resultTasks = taskQuery.orderByTaskCreateTime().desc().listPage((pageIndex-1)*pageSize, pageSize);

        for (Task myTask : resultTasks) {
            ActiMyTaskDTO myTaskDTO = new ActiMyTaskDTO();
            myTaskDTO.setProcessDefinitionId(myTask.getProcessDefinitionId());
            myTaskDTO.setBusinessKey(taskService.getVariable(myTask.getId(), "businessKey").toString());
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());
            myTaskDTO.setTaskName(myTask.getName());
            myTaskDTOS.add(myTaskDTO);
        }

        ActiPageResultDTO pageResultDTO = new ActiPageResultDTO();
        pageResultDTO.setTotal(taskTotal);
        pageResultDTO.setTaskDTOList(myTaskDTOS);
        return pageResultDTO;
    }

    /**
     *
     * <p>描述: 根据工作流Key 和 用户id查询已办任务列表</p>
     */
    public String findTaskHistByUserId(String processKey, String userId) {
        List<HistoricTaskInstance>  hisTaskList = historyService.createHistoricTaskInstanceQuery()
            .processDefinitionKey(processKey)
            .taskAssignee(userId)
            .orderByTaskId()
            .desc()
            .list();
        List<String> businessKeyList = new ArrayList<>();
        String businessKeys = "";

        for (HistoricTaskInstance myTask : hisTaskList) {
            List<HistoricVariableInstance> varList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(myTask.getProcessInstanceId())
                .list();

            for(HistoricVariableInstance hisvar : varList) {
                if(hisvar.getVariableName().equals("businessKey") && !businessKeyList.contains(hisvar.getValue().toString())) {
                    businessKeyList.add(hisvar.getValue().toString());
                    break;
                }
            }
        }
        businessKeys = StringUtils.join(businessKeyList.toArray(), ",");
        return businessKeys;
    }

    /**
     *
     * <p>描述: 根据工作流Key 和 用户id查询已办任务列表</p>
     */
    public List<ActiMyTaskDTO> findTaskHistWithCreateTimeByUserId(String processKey, String userId) {
        List<HistoricTaskInstance>  hisTaskList = historyService.createHistoricTaskInstanceQuery()
            .processDefinitionKey(processKey)
            .taskAssignee(userId)
            .orderByTaskId()
            .desc()
            .list();

        List<ActiMyTaskDTO> myTaskDTOS = new ArrayList<>();

        for (HistoricTaskInstance myTask : hisTaskList) {
            ActiMyTaskDTO myTaskDTO = new ActiMyTaskDTO();
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());

            List<HistoricVariableInstance> varList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(myTask.getProcessInstanceId())
                .list();

            for(HistoricVariableInstance hisvar : varList) {
                if (hisvar.getVariableName().equals("businessKey")) {
                    myTaskDTO.setBusinessKey(hisvar.getValue().toString());
                    break;
                }
            }


            myTaskDTOS.add(myTaskDTO);
        }
        return myTaskDTOS;

    }

    public ActiPageResultDTO findAllTypePagingTaskHistWithCreateTimeByUserId(String userId, int pageIndex, int pageSize, String wfName, String type, String supplierName) {
        HistoricTaskInstanceQuery taskInstanceQuery = historyService.createHistoricTaskInstanceQuery().taskAssignee(userId);
        //按工作流名称查询
        if (!wfName.isEmpty()) {
            taskInstanceQuery = taskInstanceQuery.processDefinitionKeyIn(Arrays.asList(wfName.split(",")));
        }
        //按分类查询
        if (!type.isEmpty()) {
            taskInstanceQuery = taskInstanceQuery.processVariableValueEquals("type", type);
        }
        //按供应商名称查询
        if (!supplierName.isEmpty()) {
            taskInstanceQuery = taskInstanceQuery.processVariableValueLikeIgnoreCase("supplierName", "%"+supplierName +"%");
        }
        //查询总条数
        long taskTotal = taskInstanceQuery.count();
        //查询分页
        List<HistoricTaskInstance>  hisTaskList = taskInstanceQuery.orderByTaskCreateTime().desc()
            .listPage((pageIndex-1)*pageSize, pageSize);
        List<ActiMyTaskDTO> myTaskDTOS = new ArrayList<>();

        for (HistoricTaskInstance myTask : hisTaskList) {
            ActiMyTaskDTO myTaskDTO = new ActiMyTaskDTO();

            myTaskDTO.setProcessDefinitionId(myTask.getProcessDefinitionId());
            myTaskDTO.setTaskName(myTask.getName());
            myTaskDTO.setWorkflowId(myTask.getProcessInstanceId());
            myTaskDTO.setCreateTime(myTask.getCreateTime().getTime());

            List<HistoricVariableInstance> varList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(myTask.getProcessInstanceId())
                .list();

            for(HistoricVariableInstance hisvar : varList) {
                if (hisvar.getVariableName().equals("businessKey")) {
                    myTaskDTO.setBusinessKey(hisvar.getValue().toString());
                    break;
                }
            }
            myTaskDTOS.add(myTaskDTO);
        }

        ActiPageResultDTO pageResultDTO = new ActiPageResultDTO();
        pageResultDTO.setTotal(taskTotal);
        pageResultDTO.setTaskDTOList(myTaskDTOS);
        return pageResultDTO;
    }



    /**
     * 查询当前用户的待办任务
     * @param processDefinitionKey 流程定义key（流程定义的标识）
     * @return
     */
    /*public List<Task> findTasks(String processDefinitionKey, String assignee) {
        //创建查询对象
        TaskQuery taskQuery = taskService.createTaskQuery();
        //设置查询条件
        taskQuery.taskAssignee(assignee);
        //指定流程定义key，只查询某个流程的任务
        taskQuery.processDefinitionKey(processDefinitionKey);
        //获取查询列表
        List<Task> list = taskQuery.list();
        return list;
    }*/

    public List<ActiHistoricTaskDTO> getHistoricTasks(String processDefinitionKey, String businessKey, String processInstanceId) {

        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();

        List<HistoricVariableInstance> varList = historyService.createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();

        List<ActiHistoricTaskDTO> historicTaskDTOS = new ArrayList<>();

        if (list != null && list.size() > 0) {
            for(HistoricTaskInstance histTask : list) {

                ActiHistoricTaskDTO historicTask = new ActiHistoricTaskDTO();
                String orgName = "";
                for(HistoricVariableInstance hvi : varList){
                    if(hvi.getTaskId() != null && hvi.getTaskId().equals(histTask.getId())) {
                        if(hvi.getVariableName().equals("businessKey")) {
                            historicTask.setBusinessKey(hvi.getValue().toString());

                        } else if(hvi.getVariableName().equals("result")) {
                            historicTask.setResult(hvi.getValue().toString());

                        } else if(hvi.getVariableName().equals("remarks")) {
                            historicTask.setRemarks(hvi.getValue().toString());

                        } else if( hvi.getVariableName().equals("users")) {
                            historicTask.setUsers(hvi.getValue().toString());

                        } else if( hvi.getVariableName().equals("orgName")) {
                            orgName = hvi.getValue().toString();

                        } else if( hvi.getVariableName().equals("refuseName")) {
                            historicTask.setRefuseName(hvi.getValue().toString());

                        }
                    }

                }
                //当前未完成的步骤，取出当前操作人
                if ( histTask.getClaimTime() == null || histTask.getEndTime() == null ) {
                    List<HistoricVariableInstance> varListTmp = historyService.createHistoricVariableInstanceQuery()
                        .processInstanceId(processInstanceId)
                        .executionId(histTask.getExecutionId())
                        .list();

                    Collections.reverse(varListTmp);
                    for(HistoricVariableInstance hvi : varListTmp){
                        if(hvi.getVariableName().equals("businessKey")) {
                            historicTask.setBusinessKey(hvi.getValue().toString());

                        } else if(hvi.getVariableName().equals("result")) {
                            historicTask.setResult(hvi.getValue().toString());

                        } else if(hvi.getVariableName().equals("remarks")) {
                            historicTask.setRemarks(hvi.getValue().toString());

                        } else if( hvi.getVariableName().equals("users")) {
                            if (!StringUtils.isEmpty(hvi.getValue().toString()) && StringUtils.isEmpty(historicTask.getUsers())) {
                                historicTask.setUsers(hvi.getValue().toString());
                            }
                        } else if( hvi.getVariableName().equals("orgName")) {
                            orgName = hvi.getValue().toString();
                        } else if( hvi.getVariableName().equals("refuseName")) {
                            historicTask.setRefuseName(hvi.getValue().toString());

                        }

                    }
                }


                historicTask.setAssignee(histTask.getAssignee());
                historicTask.setTaskName(histTask.getName());
                if(orgName.length() > 0) {
                    historicTask.setTaskName(histTask.getName() + "-" + orgName);
                }
                if(histTask.getStartTime() != null) {
                    historicTask.setStartTime(histTask.getStartTime().getTime());
                }
                if(histTask.getEndTime() != null) {
                    historicTask.setEndTime(histTask.getEndTime().getTime());
                }
                historicTask.setProcessInstanceId(histTask.getProcessInstanceId());
                historicTaskDTOS.add(historicTask);

            }
        }

        return historicTaskDTOS;
    }


    /**
     * 更改业务流程状态#{ActivityDemoServiceImpl.updateBizStatus(execution,"tj")}
     * @param execution
     * @param status
     */
    /*public void updateBizStatus(DelegateExecution execution,String status) {
        String bizId = execution.getProcessBusinessKey();
        //根据业务id自行处理业务表
        logger.info("业务表["+bizId+"]状态更改成功，状态更改为："+status);
    }*/


    //流程节点权限用户列表${ActivityDemoServiceImpl.findUsers(execution,sign)}
    /*public List<String> findUsersForSL(DelegateExecution execution){
        return Arrays.asList("sly1","sly2");
    }*/

    //流程节点权限用户列表${ActivityDemoServiceImpl.findUsers(execution,sign)}
    /*public List<String> findUsersForSP(DelegateExecution execution){
        return Arrays.asList("spy1","uspy2");
    }*/

    /**
     *
     * <p>描述:  生成流程图
     * 首先启动流程，获取processInstanceId，替换即可生成</p>
     * @author 范相如
     * @date 2018年2月25日
     * @param processInstanceId
     * @throws Exception
     */
    /*public void queryProImg(String processInstanceId) throws Exception {
        //获取历史流程实例
        HistoricProcessInstance processInstance =  historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

        //根据流程定义获取输入流
        InputStream is = repositoryService.getProcessDiagram(processInstance.getProcessDefinitionId());
        BufferedImage bi = ImageIO.read(is);
        File file = new File("demo2.png");
        if(!file.exists()) file.createNewFile();
        FileOutputStream fos = new FileOutputStream(file);
        ImageIO.write(bi, "png", fos);
        fos.close();
        is.close();
        logger.info("图片生成成功");

        List<Task> tasks = taskService.createTaskQuery().taskCandidateUser("userId").list();
        for(Task t : tasks) {
            logger.info(t.getName());
        }
    }*/



    /**
     * 获取流程图像，已执行节点和流程线高亮显示
     */
    public void getActivitiProccessImage(String pProcessInstanceId, HttpServletResponse response)
    {
        //logger.info("[开始]-获取流程图图像");
        try {
            //  获取历史流程实例
            HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(pProcessInstanceId).singleResult();

            if (historicProcessInstance == null) {
                //throw new BusinessException("获取流程实例ID[" + pProcessInstanceId + "]对应的历史流程实例失败！");
            }
            else
            {
                // 获取流程定义
                ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                    .getDeployedProcessDefinition(historicProcessInstance.getProcessDefinitionId());

                // 获取流程历史中已执行节点，并按照节点在流程中执行先后顺序排序
                List<HistoricActivityInstance> historicActivityInstanceList = historyService.createHistoricActivityInstanceQuery()
                    .processInstanceId(pProcessInstanceId).orderByHistoricActivityInstanceId().asc().list();

                // 已执行的节点ID集合
                List<String> executedActivityIdList = new ArrayList<String>();
                int index = 1;
                //logger.info("获取已经执行的节点ID");
                for (HistoricActivityInstance activityInstance : historicActivityInstanceList) {
                    executedActivityIdList.add(activityInstance.getActivityId());

                    //logger.info("第[" + index + "]个已执行节点=" + activityInstance.getActivityId() + " : " +activityInstance.getActivityName());
                    index++;
                }

                BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());

                // 已执行的线集合
                List<String> flowIds = new ArrayList<String>();
                // 获取流程走过的线 (getHighLightedFlows是下面的方法)
                flowIds = getHighLightedFlows(bpmnModel,processDefinition, historicActivityInstanceList);



                // 获取流程图图像字符流
                ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
                ProcessDiagramGenerator pec = processEngine.getProcessEngineConfiguration().getProcessDiagramGenerator();
                //配置字体
                InputStream imageStream = pec.generateDiagram(bpmnModel, "png", executedActivityIdList, flowIds,"宋体","微软雅黑","黑体",null,2.0);

                response.setContentType("image/png");
                OutputStream os = response.getOutputStream();
                int bytesRead = 0;
                byte[] buffer = new byte[8192];
                while ((bytesRead = imageStream.read(buffer, 0, 8192)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                os.close();
                imageStream.close();
            }
            //logger.info("[完成]-获取流程图图像");
        } catch (Exception e) {
            logger.info(e.getMessage());
            //logger.error("【异常】-获取流程图失败！" + e.getMessage());
            //throw new BusinessException("获取流程图失败！" + e.getMessage());
        }
    }

    public List<String> getHighLightedFlows(BpmnModel bpmnModel,ProcessDefinitionEntity processDefinitionEntity,List<HistoricActivityInstance> historicActivityInstances)
    {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //24小时制
        List<String> highFlows = new ArrayList<String>();// 用以保存高亮的线flowId

        for (int i = 0; i < historicActivityInstances.size() - 1; i++)
        {
            // 对历史流程节点进行遍历
            // 得到节点定义的详细信息
            FlowNode activityImpl = (FlowNode)bpmnModel.getMainProcess().getFlowElement(historicActivityInstances.get(i).getActivityId());


            List<FlowNode> sameStartTimeNodes = new ArrayList<FlowNode>();// 用以保存后续开始时间相同的节点
            FlowNode sameActivityImpl1 = null;

            HistoricActivityInstance activityImpl_ = historicActivityInstances.get(i);// 第一个节点
            HistoricActivityInstance activityImp2_ ;

            for(int k = i + 1 ; k <= historicActivityInstances.size() - 1; k++)
            {
                activityImp2_ = historicActivityInstances.get(k);// 后续第1个节点

                if ( activityImpl_.getActivityType().equals("userTask") && activityImp2_.getActivityType().equals("userTask") &&
                    df.format(activityImpl_.getStartTime()).equals(df.format(activityImp2_.getStartTime()))   ) //都是usertask，且主节点与后续节点的开始时间相同，说明不是真实的后继节点
                {

                }
                else
                {
                    sameActivityImpl1 = (FlowNode)bpmnModel.getMainProcess().getFlowElement(historicActivityInstances.get(k).getActivityId());//找到紧跟在后面的一个节点
                    break;
                }

            }
            sameStartTimeNodes.add(sameActivityImpl1); // 将后面第一个节点放在时间相同节点的集合里
            for (int j = i + 1; j < historicActivityInstances.size() - 1; j++)
            {
                HistoricActivityInstance activityImpl1 = historicActivityInstances.get(j);// 后续第一个节点
                HistoricActivityInstance activityImpl2 = historicActivityInstances.get(j + 1);// 后续第二个节点

                if (df.format(activityImpl1.getStartTime()).equals(df.format(activityImpl2.getStartTime()))  )
                {// 如果第一个节点和第二个节点开始时间相同保存
                    FlowNode sameActivityImpl2 = (FlowNode)bpmnModel.getMainProcess().getFlowElement(activityImpl2.getActivityId());
                    sameStartTimeNodes.add(sameActivityImpl2);
                }
                else
                {// 有不相同跳出循环
                    break;
                }
            }
            List<SequenceFlow> pvmTransitions = activityImpl.getOutgoingFlows() ; // 取出节点的所有出去的线

            for (SequenceFlow pvmTransition : pvmTransitions)
            {// 对所有的线进行遍历
                FlowNode pvmActivityImpl = (FlowNode)bpmnModel.getMainProcess().getFlowElement( pvmTransition.getTargetRef());// 如果取出的线的目标节点存在时间相同的节点里，保存该线的id，进行高亮显示
                if (sameStartTimeNodes.contains(pvmActivityImpl)) {
                    highFlows.add(pvmTransition.getId());
                }
            }

        }
        return highFlows;

    }

    public void suspendProcessInstanceById(String processInstanceId) {
        runtimeService.suspendProcessInstanceById(processInstanceId);
    }

    public void deleteProcessInstance(String processInstanceId, String comments) {
        // 删除正在运行中的流程根据流程实例ID
        try {
            runtimeService.deleteProcessInstance(processInstanceId, comments);
        } catch (Exception e) {
            logger.info("删除工作流，未找到进行中工作流ID：" + processInstanceId + ", 异常信息：" + e);
        }
        // 删除历史流程实例根据流程实例ID
        try {
            historyService.deleteHistoricProcessInstance(processInstanceId);
        } catch (Exception e) {
            logger.info("删除历史或已完成工作流，ID：" + processInstanceId + ", 异常信息：" + e);
        }
    }

    @Transactional
    public void returnAssignNode(String processKey, String businessKey, String proInstanceId, String curUserId, String createUserId, String callBackUrl) {

        Task task = taskService.createTaskQuery()
            .processDefinitionKey(processKey)
            .processVariableValueEquals("businessKey", businessKey)
            .singleResult();
        if(null==task || proInstanceId.equals("") || curUserId.equals("") || createUserId.equals("")) {
            return;
        }

        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
            .processInstanceId(proInstanceId)
            .list();

        String myTaskId = null;
        HistoricTaskInstance myTask = null;
        if (list != null && list.size() > 0) {
            for(HistoricTaskInstance hti : list) {
                if(curUserId.equals(hti.getAssignee())) {
                    myTaskId = hti.getId();
                    myTask = hti;
                    break;
                }
            }
        }

        if(null==myTaskId) {
            return;
        }
        String processDefinitionId = myTask.getProcessDefinitionId();
        // ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);

        //变量
		// Map<String, VariableInstance> variables = runtimeService.getVariableInstances(currentTask.getExecutionId());
        String myActivityId = null;
        List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
            .executionId(myTask.getExecutionId()).finished().list();
        for(HistoricActivityInstance hai : haiList) {
            if(myTaskId.equals(hai.getTaskId())) {
                myActivityId = hai.getActivityId();
                break;
            }
        }
        FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(myActivityId);


        Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
        String activityId = execution.getActivityId();
        logger.warn("------->> 撤回的activityId:" + activityId);
        FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);

        //记录原活动方向
        List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
        oriSequenceFlows.addAll(flowNode.getOutgoingFlows());

        //清理活动方向
        flowNode.getOutgoingFlows().clear();
        //建立新方向
        List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
        SequenceFlow newSequenceFlow = new SequenceFlow();
        newSequenceFlow.setId("newSequenceFlowId");
        newSequenceFlow.setSourceFlowElement(flowNode);
        newSequenceFlow.setTargetFlowElement(myFlowNode);
        newSequenceFlowList.add(newSequenceFlow);
        flowNode.setOutgoingFlows(newSequenceFlowList);

        Authentication.setAuthenticatedUserId(curUserId);
        // TODO 审批意见字段未设置成功
        taskService.addComment(task.getId(), task.getProcessInstanceId(), "上级单位撤回");
        taskService.setAssignee(task.getId(), createUserId);
        taskService.setVariable(task.getId(),"remarks", "上级单位撤回");
        taskService.setVariableLocal(task.getId(), "remarks", "上级单位撤回");

        Map<String,Object> currentVariables = new HashMap<String,Object>();
        currentVariables.put("applier", curUserId);
        currentVariables.put("businessKey", businessKey);
        currentVariables.put("users", curUserId);
        currentVariables.put("remarks", "上级单位撤回");
        currentVariables.put("callbackUrl", callBackUrl);

        //完成任务
        taskService.complete(task.getId(),currentVariables);
        //恢复原方向
        flowNode.setOutgoingFlows(oriSequenceFlows);
        logger.info("回滚完成：businessKey  " + businessKey);
    }
}