Java HistoryService类代码示例

import org.activiti.engine.HistoryService; //导入依赖的package包/类
/**
 * 已结流程.
 */
public Page findCompletedProcessInstances(String userId, String tenantId,
        Page page) {
    HistoryService historyService = processEngine.getHistoryService();

    long count = historyService.createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId).startedBy(userId).finished()
            .count();
    List<HistoricProcessInstance> historicProcessInstances = historyService
            .createHistoricProcessInstanceQuery().startedBy(userId)
            .processInstanceTenantId(tenantId).finished()
            .listPage((int) page.getStart(), page.getPageSize());

    page.setResult(historicProcessInstances);
    page.setTotalCount(count);

    return page;
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
/**
 * 参与流程.
 */
public Page findInvolvedProcessInstances(String userId, String tenantId,
        Page page) {
    HistoryService historyService = processEngine.getHistoryService();

    // TODO: finished(), unfinished()
    long count = historyService.createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId).involvedUser(userId).count();
    List<HistoricProcessInstance> historicProcessInstances = historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId).involvedUser(userId)
            .listPage((int) page.getStart(), page.getPageSize());

    page.setResult(historicProcessInstances);
    page.setTotalCount(count);

    return page;
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
protected void deleteAllocatedRoutes(HistoryService historyService, String processInstanceId) throws SLException {
    HistoricVariableInstance allocatedPortsInstance = getHistoricVarInstanceValue(historyService, processInstanceId,
        Constants.VAR_ALLOCATED_PORTS);
    if (allocatedPortsInstance == null) {
        return;
    }
    CloudFoundryOperations client = getCloudFoundryClient(historyService, processInstanceId);
    String defaultDomain = client.getDefaultDomain() != null ? client.getDefaultDomain().getName() : null;
    if (defaultDomain == null) {
        LOGGER.warn(Messages.COULD_NOT_COMPUTE_DEFAULT_DOMAIN);
        return;
    }
    Integer[] allocatedPorts = JsonUtil.getFromBinaryJson((byte[]) allocatedPortsInstance.getValue(), Integer[].class);
    for (Integer port : allocatedPorts) {
        try {
            client.deleteRoute(port.toString(), defaultDomain);
        } catch (CloudFoundryException e) {
            LOGGER.warn(format(Messages.COULD_NOT_DELETE_ROUTE_FOR_PORT, port));
        }
    }
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
protected void deleteDeploymentFiles(HistoryService historyService, String processInstanceId) throws FileStorageException {
    HistoricVariableInstance keepFiles = getHistoricVarInstanceValue(historyService, processInstanceId, Constants.PARAM_KEEP_FILES);
    if (shouldKeepFiles(keepFiles)) {
        return;
    }
    HistoricVariableInstance extensionDescriptorFileIds = getHistoricVarInstanceValue(historyService, processInstanceId,
        Constants.PARAM_EXT_DESCRIPTOR_FILE_ID);
    HistoricVariableInstance appArchiveFileIds = getHistoricVarInstanceValue(historyService, processInstanceId,
        Constants.PARAM_APP_ARCHIVE_ID);

    String spaceId = (String) getHistoricVarInstanceValue(historyService, processInstanceId,
        com.sap.cloud.lm.sl.persistence.message.Constants.VARIABLE_NAME_SPACE_ID).getValue();

    FileSweeper fileSweeper = new FileSweeper(spaceId, getBeanProvider().getFileService());
    fileSweeper.sweep(extensionDescriptorFileIds);
    fileSweeper.sweep(appArchiveFileIds);
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
@Override
public EngineServices getEngineServices() {
    if (this.engineServicesMock != null) {
        return this.engineServicesMock;
    }

    this.engineServicesMock = mock(EngineServices.class);
    when(engineServicesMock.getFormService()).thenReturn(mock(FormService.class));
    when(engineServicesMock.getHistoryService()).thenReturn(mock(HistoryService.class));
    when(engineServicesMock.getIdentityService()).thenReturn(mock(IdentityService.class));
    when(engineServicesMock.getManagementService()).thenReturn(mock(ManagementService.class));
    when(engineServicesMock.getRepositoryService()).thenReturn(mock(RepositoryService.class));
    when(engineServicesMock.getRuntimeService()).thenReturn(mock(RuntimeService.class));
    when(engineServicesMock.getTaskService()).thenReturn(mock(TaskService.class));

    return engineServicesMock;
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
@Override
protected HistoricVariableInstance getHistoricVarInstanceValue(HistoryService historyService, String processInstanceId,
    String parameter) {
    switch (parameter) {
        case com.sap.cloud.lm.sl.persistence.message.Constants.VARIABLE_NAME_SPACE_ID:
            return createInstanceMock(SPACE_ID);
        case Constants.PARAM_EXT_DESCRIPTOR_FILE_ID:
            return createInstanceMock(extensionDescriptorIds);
        case Constants.PARAM_APP_ARCHIVE_ID:
            return createInstanceMock(archiveIds);
        case Constants.PARAM_KEEP_FILES:
            return createInstanceMock(shouldKeepFiles);
        default:
            return null;
    }
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
public String getStatus(){
    
    HistoryService historyService = processEngine.getHistoryService();
    
    //Get all variables of process generated during execution (data objects and inputs/outputs)
    List<HistoricVariableInstance> outVariables = historyService.createHistoricVariableInstanceQuery().processInstanceId(processInstance.getId()).list();
        
    //For each variable of process
    for (HistoricVariableInstance historicVariableInstance : outVariables)
        if(historicVariableInstance.getVariableName().equals("status")){
            if(historicVariableInstance.getValue() != null)
                return (String) historicVariableInstance.getValue();
        }
    
    return "failure";
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx =
            new AnnotationConfigApplicationContext();
    ctx.register(SpringAnnotationConfiguration.class);
    ctx.refresh();

    assertNotNull(ctx.getBean(ProcessEngine.class));
    assertNotNull(ctx.getBean(RuntimeService.class));
    TaskService bean = ctx.getBean(TaskService.class);
    assertNotNull(bean);
    assertNotNull(ctx.getBean(HistoryService.class));
    assertNotNull(ctx.getBean(RepositoryService.class));
    assertNotNull(ctx.getBean(ManagementService.class));
    assertNotNull(ctx.getBean(FormService.class));
    Task task = bean.newTask();
    task.setName("哈哈");
    bean.saveTask(task);
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
@Override
public void notify(DelegateExecution delegateExecution) throws Exception {

    // Process instance details have to be fetched from history service as some information such as process start time is not available from
    // runtime service or delegate execution.
    HistoryService historyService = delegateExecution.getEngineServices().getHistoryService();
    List<HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery().
            processInstanceId(delegateExecution.getProcessInstanceId()).list();
    if (historicProcessInstances.size() == 1) {
        HistoricProcessInstance instance = historicProcessInstances.get(0);
        BPMNAnalyticsHolder.getInstance().getBpmnDataPublisher().publishProcessEvent(instance);

        //publishing analytics data of service tasks in the process
        if(BPMNAnalyticsHolder.getInstance().getAsyncDataPublishingEnabled()){
        BPMNAnalyticsHolder.getInstance().getBpmnDataPublisher().publishServiceTaskEvent(historyService.
                createHistoricActivityInstanceQuery().processInstanceId(delegateExecution.getProcessInstanceId()));
        }
    }
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
/**
 * Get paginated history instances
 *
 * @param start
 * @param size
 * @return list of BPMNInstances
 */
public BPMNInstance[] getPaginatedHistoryInstances(int start, int size){
    BPMNInstance bpmnInstance;
    Integer tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
    List<BPMNInstance> bpmnInstances = new ArrayList<>();
    HistoryService historyService = BPMNServerHolder.getInstance().getEngine().getHistoryService();
    HistoricProcessInstanceQuery query =
            historyService.createHistoricProcessInstanceQuery().processInstanceTenantId(tenantId.toString())
                    .finished().includeProcessVariables();
    historyInstanceCount = (int) query.count();
    List<HistoricProcessInstance> historicProcessInstances = query.listPage(start, size);
    for(HistoricProcessInstance instance: historicProcessInstances){
        bpmnInstance = new BPMNInstance();
        bpmnInstance.setInstanceId(instance.getId());
        bpmnInstance.setProcessId(instance.getProcessDefinitionId());
        bpmnInstance.setStartTime(instance.getStartTime());
        bpmnInstance.setEndTime(instance.getEndTime());
        bpmnInstance.setVariables(formatVariables(instance.getProcessVariables()));
        bpmnInstances.add(bpmnInstance);
    }
    return bpmnInstances.toArray(new BPMNInstance[bpmnInstances.size()]);
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
/**
 * Delete process instance by passing instance ID
 *
 * @param instanceId
 * @throws BPSFault
 */
public void deleteProcessInstance(String instanceId) throws BPSFault {
    Integer tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
    RuntimeService runtimeService = BPMNServerHolder.getInstance().getEngine().getRuntimeService();
    List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery()
            .processInstanceTenantId(tenantId.toString()).processInstanceId(instanceId).list();
    if (processInstances.isEmpty()) {
        HistoryService historyService = BPMNServerHolder.getInstance().getEngine().getHistoryService();
        List<HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery()
                .processInstanceTenantId(tenantId.toString()).processInstanceId(instanceId).list();
        if (historicProcessInstances.isEmpty()) {
            String msg = "No process instances with the ID: " + instanceId;
            log.error(msg);
            throw new BPSFault(msg);
        }
        historyService.deleteHistoricProcessInstance(instanceId);
        return;
    }
    runtimeService.deleteProcessInstance(instanceId, "Deleted by user: " + tenantId);
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
@GET
@Path("/{taskId}/identitylinks")
@Produces({MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public Response getTaskIdentityLinks(@PathParam("taskId") String taskId) {
    HistoryService historyService = BPMNOSGIService.getHistoryService();
    List<HistoricIdentityLink> identityLinks = historyService.getHistoricIdentityLinksForTask(taskId);

    List<HistoricIdentityLinkResponse> historicIdentityLinkResponseList = new ArrayList<>();
    if (identityLinks != null) {

        historicIdentityLinkResponseList =  new RestResponseFactory().createHistoricIdentityLinkResponseList
                (identityLinks, uriInfo.getBaseUri
                ().toString());
    }

    HistoricIdentityLinkResponseCollection historicIdentityLinkResponseCollection = new
            HistoricIdentityLinkResponseCollection();
    historicIdentityLinkResponseCollection.setHistoricIdentityLinkResponses(historicIdentityLinkResponseList);

    return Response.ok().entity(historicIdentityLinkResponseCollection).build();
}
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
private void cleanProcessDefinitionHistory(HistoryService hs, String... definitions) {

        for (String definitionId : definitions) {
            List<HistoricProcessInstance> hpiList = hs.createHistoricProcessInstanceQuery()
                .processDefinitionId(definitionId)
                .orderByProcessDefinitionId().asc().list();
            if (hpiList == null || hpiList.size() == 0) {
                out().printf("No History found for process definition %s %n", definitionId);
                break;
            }
            for (HistoricProcessInstance hpi : hpiList) {
                String processId = hpi.getId();
                hs.deleteHistoricProcessInstance(hpi.getId());
                out().printf("History removed for process instance %s with definition %s%n", processId,
                    definitionId);
            }
        }
    }
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
private void printHistoricProcessInstances(PrintWriter out, HistoryService his, boolean printActive) {

        List<HistoricProcessInstance> hpiList = his.createHistoricProcessInstanceQuery()
            .orderByProcessDefinitionId().asc().list();

        out.println();
        out.println("History of Activiti Process Instances");
        out.println("-------------------------------------");
        if (hpiList.isEmpty()) {
            out.println("No History on Activiti Processes.");
            return;
        }

        TextTable txtTable = new TextTable(4);

        txtTable.addHeaders("Definition ID", "Instance ID", "Start Time", "End Time");
        for (HistoricProcessInstance hpi : hpiList) {
            Date endTime = hpi.getEndTime();
            if (endTime == null && !printActive) {
                continue;  // don't print active instance history if printActive is false - default.
            }
            txtTable.addRow(hpi.getProcessDefinitionId(), hpi.getId(),
                formatDate(hpi.getStartTime()), formatDate(hpi.getEndTime()));
        }
        txtTable.print(out);
    }
 

import org.activiti.engine.HistoryService; //导入依赖的package包/类
public HistoryService getHistoryService() {
    if (processEngine == null) {
        return null;
    }

    return processEngine.getHistoryService();
}