Activity7框架使用学习记录

用于记录在项目中使用工作流框架

PROC_DEF_ID: 流程定义的id bpmn文件中对流程图定义的id

TASK_DEF_KEY:任务定义的id bpmn文件中对每个任务定义的id

PROC_INST_ID:流程实例id 启动一个流程时对流程定义的id

PROC_DEF_ID（流程定义的ID）：在BPMN（Business Process Model and Notation）文件中，流程定义的ID是对整个流程图定义的唯一标识符。它通常用于区分不同的流程定义，以便系统可以识别和执行相应的流程。

TASK_DEF_KEY（任务定义的ID）：在BPMN文件中，每个任务都有一个唯一的任务定义ID。这个ID用于标识流程中的不同任务，例如用户任务、服务任务等。任务定义ID通常与特定任务的执行逻辑相关联。

PROC_INST_ID（流程实例ID）：当启动一个流程实例时，会为该实例分配一个唯一的流程实例ID。这个ID用于跟踪和管理特定流程实例的执行过程。通常，流程实例ID与流程定义ID相关联，但每个实例都有自己的唯一ID。

对于一些定制化的流程，可以通过自定义一个唯一的id作为流程id，来串联起多个流程

工作流框架提供的接口：

private RuntimeService runtimeService; 
	用于启动流程实例、查询正在执行的流程实例、发送信号等。它通常用于在流程执行期间与正在运行的流程实例进行交互
	
private TaskService taskService;
	用于管理用户任务。它提供了在流程执行期间管理任务的方法，例如创建、完成、分配、查询任务等。通过TaskService，你可以管理流程中的人工任务，以便用户可以参与流程并完成任务。

private HistoryService historyService;
	用于访问已完成的流程实例和任务的历史数据。它提供了查询已完成的流程实例、任务、变量等的方法。HistoryService对于跟踪流程执行的历史记录和生成报告非常有用。

private ProcessEngine processEngine;
负	责启动和管理整个流程引擎。通过ProcessEngine，你可以获取其他服务接口（如RuntimeService、TaskService、HistoryService等），并执行与流程引擎相关的各种操作。

private RepositoryService repositoryService;
	提供了对流程定义部署的管理方法。通过RepositoryService，你可以部署、查询、删除流程定义，以及管理流程资源（如流程图、表单等）。RepositoryService对于在运行时访问流程定义和资源非常有用。

import com.alibaba.fastjson2.JSONObject;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.impl.util.json.JSONArray;

import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

import java.util.List;


public interface FlowDBService {

    ProcessInstance start(String processDefinitionKey, String businessKey, JSONObject param);

    void complete(String taskId, JSONObject param);

    void complete(String taskId, JSONObject param,Boolean localScope);


    void addComment( String taskId, String comment);

    String getProcessDefinitionKeyByBusinessKey(String businessKey);

    List<Task> getNextNodes(String bizId);

    List<Task> getCurrentNodes(String bizId);

//    List listTaskHistory(ProcessHistoryQuery param);

    /**
     * 根据流程实例id 和 任务id（task_id） 获取节点的历史数据
     * @param processId
     * @return
     */
    List<HistoricVariableInstance> listNodeDataHistoryByTaskId(String processId, String taskId);

    /**
     * 根据实例id 和 任务定义key 获取节点的历史数据
     * @param processId
     * @param taskDefId
     * @return
     */
    List<List<HistoricVariableInstance>> listNodeDataHistoryByTaskDefId(String processId, String taskDefId);

    /**
     * 根据实例id 和 任务名 获取节点的历史数据
     * @param processId 实例id
     * @param taskName  ProcessTaskDefKeyEnum 枚举值
     * @return
     */
    List<List<HistoricVariableInstance>> listNodeDataHistoryBytaskName(String processId,String taskName);

//    /**
//     * 将结果转换为jsonArray
//     * @param lists
//     * @return
//     */
//    JSONArray transformHistoryData(List> lists);
//
//    /**
//     * 查询多个流程（重新提交审核）实例id 的 指定任务节点的 历史数据
//     * @param processIds
//     * @param taskName
//     * @return 以jsonArray返回
//     */
//    JSONArray listNodeAllDataHistory(String[] processIds,String taskName);


}

import org.activiti.engine.*;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricTaskInstanceQuery;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.history.HistoricVariableInstanceQuery;
import com.alibaba.fastjson2.JSONObject;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

@Component
public class FlowActivitiDBServiceImpl implements FlowDBService {

    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private HistoryService historyService;
    @Autowired
    private ProcessEngine processEngine;
    @Autowired
    private RepositoryService repositoryService;


    @Override
    public ProcessInstance start(String processDefinitionKey, String businessKey, JSONObject param) {
        return runtimeService.startProcessInstanceByKey(processDefinitionKey, businessKey, param);
    }

    @Override
    public void complete(String taskId, JSONObject param) {
        complete(taskId,param,true);
    }

    @Override
    public void complete(String taskId, JSONObject param, Boolean localScope) {
        taskService.complete(taskId,param,localScope);
    }

    @Override
    public void addComment(String taskId, String comment) {
//        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
    }

    @Override
    public String getProcessDefinitionKeyByBusinessKey(String businessKey) {
        return null;
    }

    @Override
    public List<Task> getNextNodes(String bizId) {
        return null;
    }

    @Override
    public List<Task> getCurrentNodes(String bizId) {
        List<Task> list = processEngine.getTaskService().createTaskQuery().processInstanceBusinessKey(bizId).list();
        return list;
    }

//    public List listTaskHistory(ProcessHistoryQuery param) {
//        HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery();
//        Boolean conditionAnyOne = false;
//        if(CollectionUtil.isNotEmpty(param.getBizTypes())){
//            historicTaskInstanceQuery.processDefinitionKeyIn(param.getBizTypes());
//            conditionAnyOne = true;
//        }
//        if(CollectionUtil.isNotEmpty(param.getBizActions())){
//            historicTaskInstanceQuery.taskNameIn(param.getBizActions());
//            conditionAnyOne = true;
//        }
//        if(StringUtils.isNotBlank(param.getProcessOrderId())){
//            historicTaskInstanceQuery.processInstanceBusinessKey(param.getProcessOrderId());
//            conditionAnyOne = true;
//        }
//        if(CollectionUtil.isNotEmpty(param.getQuery())){
//            for (String key : param.getQuery().keySet()) {
//                historicTaskInstanceQuery.processVariableValueEquals(key,param.getQuery().get(key));
//            }
//            conditionAnyOne = true;
//        }
//        if(!conditionAnyOne)
//            return new ArrayList<>();
//        List list = historicTaskInstanceQuery
//                .includeProcessVariables()
//                .includeTaskLocalVariables()
//                .finished()
//                .orderByTaskCreateTime().desc().list();
//        return transformHistoryTaskData(list);
//    }

    @Override
    public List<HistoricVariableInstance> listNodeDataHistoryByTaskId(String processId, String taskId) {
        HistoricVariableInstanceQuery historicVariableInstanceQuery = historyService.createHistoricVariableInstanceQuery();
        List<HistoricVariableInstance> list = historicVariableInstanceQuery.processInstanceId(processId).taskId(taskId).list();
        return list;
    }

    @Override
    public List<List<HistoricVariableInstance>> listNodeDataHistoryByTaskDefId(String processId, String taskDefId) {
        HistoricTaskInstanceQuery historicTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processId)
                .taskDefinitionKey(taskDefId);
        List<List<HistoricVariableInstance>> data = new ArrayList<>();
        List<HistoricTaskInstance> list = historicTaskInstanceQuery.list();
        list.forEach(task->{
            List<HistoricVariableInstance> historicVariableInstances = listNodeDataHistoryByTaskId(processId, task.getId());
            data.add(historicVariableInstances);
        });
        return data;
    }

    @Override
    public List<List<HistoricVariableInstance>> listNodeDataHistoryBytaskName(String processId, String taskName) {
//        ProcessTaskDefKeyEnum processTaskDefKeyEnum = ProcessTaskDefKeyEnum.map.get(taskName);
//        String taskDefId = processTaskDefKeyEnum.getTaskDefKey();
//        return listNodeDataHistoryByTaskDefId(processId, taskDefId);
        return null;
    }

//    @Override
//    public JSONArray transformHistoryData(List> lists) {
//        JSONArray jsonArray = new JSONArray();
//        for(List list : lists){
//            JSONObject jsonObject = new JSONObject();
//            for(HistoricVariableInstance instance:list){
//                jsonObject.put(instance.getVariableName(),instance.getValue());
//            }
//            jsonArray.add(jsonObject);
//        }
//        return jsonArray;
//    }
//
//    @Override
//    public JSONArray listNodeAllDataHistory(String[] processIds, String taskName) {
//        JSONArray jsonArray = new JSONArray();
//        for(String processId : processIds){
//            List> data = listNodeDataHistoryBytaskName(processId, taskName);
//            jsonArray.add(transformHistoryData(data));
//        }
//        return jsonArray;
//    }
//
//    private List transformHistoryTaskData(List historicTaskInstances) {
//        if(CollectionUtil.isEmpty(historicTaskInstances))
//            return new ArrayList<>();
//        return historicTaskInstances.stream().map(t->{
//            ProcessNodeDTO dto = new ProcessNodeDTO();
//            dto.setParamMap(t.getTaskLocalVariables());
//            dto.setNewestParamMap(t.getProcessVariables());
//            dto.setProcessInstanceId(t.getProcessInstanceId());
//            dto.setTemplate(StringUtils.split(t.getProcessDefinitionId(),":")[0]);
//            dto.setAction(t.getTaskDefinitionKey());
//            dto.setBizId(t.getBusinessKey());
//            dto.setStartTime(t.getStartTime());
//            dto.setEndTime(t.getEndTime());
//            dto.setDescription(t.getDescription());
//            return dto;
//        }).toList();
//    }


}