Java HistoricProcessInstanceQuery.variableValueEquals方法代码示例

import org.activiti.engine.history.HistoricProcessInstanceQuery; //导入方法依赖的package包/类
@Override
public List<HistoricProcessInstance> getFinishedProcessInstance(
		String processDefinitionId, String taskKey, String startedOrgId,
		Date startTime, Date endTime) {
	List<HistoricProcessInstance> hpiList = new ArrayList<HistoricProcessInstance>();
	HistoricProcessInstanceQuery hipQuery = historyService
			.createHistoricProcessInstanceQuery().finished();
	if (!StringUtils.isEmpty(processDefinitionId)) {
		hipQuery.processDefinitionId(processDefinitionId);
	}
	if (startTime != null) {
		hipQuery.startedAfter(startTime);
	}
	if (endTime != null) {
		hipQuery.startedBefore(endTime);
	}
	if(!StringUtils.isEmpty(startedOrgId)){
		hipQuery.variableValueEquals("startCompanyId", startedOrgId);
	}
	hpiList = hipQuery.includeProcessVariables().list();
	/*for (HistoricProcessInstance hpi : hpiList) {
		BaseBpDataEx bpDataEx = (BaseBpDataEx) historyService
				.createHistoricVariableInstanceQuery()
				.processInstanceId(hpi.getId())
				.variableName(Constant.BPM_BP_DATA_EX_KEY).singleResult()
				.getValue();
		bpDataEx.getPiId();
	}*/
	return hpiList;
}
 

import org.activiti.engine.history.HistoricProcessInstanceQuery; //导入方法依赖的package包/类
protected void addVariables(HistoricProcessInstanceQuery processInstanceQuery, List<QueryVariable> variables) {
    for (QueryVariable variable : variables) {
        if (variable.getVariableOperation() == null) {
            throw new ActivitiIllegalArgumentException("Variable operation is missing for variable: " + variable.getName());
        }
        if (variable.getValue() == null) {
            throw new ActivitiIllegalArgumentException("Variable value is missing for variable: " + variable.getName());
        }

        boolean nameLess = variable.getName() == null;

        RestResponseFactory restResponseFactory = new RestResponseFactory();

        Object actualValue = restResponseFactory.getVariableValue(variable);

        // A value-only query is only possible using equals-operator
        if (nameLess && variable.getVariableOperation() != QueryVariable.QueryVariableOperation.EQUALS) {
            throw new ActivitiIllegalArgumentException("Value-only query (without a variable-name) is only supported when using 'equals' operation.");
        }

        switch (variable.getVariableOperation()) {

            case EQUALS:
                if (nameLess) {
                    processInstanceQuery.variableValueEquals(actualValue);
                } else {
                    processInstanceQuery.variableValueEquals(variable.getName(), actualValue);
                }
                break;

            case EQUALS_IGNORE_CASE:
                if (actualValue instanceof String) {
                    processInstanceQuery.variableValueEqualsIgnoreCase(variable.getName(), (String) actualValue);
                } else {
                    throw new ActivitiIllegalArgumentException("Only string variable values are supported when ignoring casing, but was: "
                            + actualValue.getClass().getName());
                }
                break;

            case NOT_EQUALS:
                processInstanceQuery.variableValueNotEquals(variable.getName(), actualValue);
                break;

            case LIKE:
                if (actualValue instanceof String) {
                    processInstanceQuery.variableValueLike(variable.getName(), (String) actualValue);
                } else {
                    throw new ActivitiIllegalArgumentException("Only string variable values are supported for like, but was: "
                            + actualValue.getClass().getName());
                }
                break;

            case GREATER_THAN:
                processInstanceQuery.variableValueGreaterThan(variable.getName(), actualValue);
                break;

            case GREATER_THAN_OR_EQUALS:
                processInstanceQuery.variableValueGreaterThanOrEqual(variable.getName(), actualValue);
                break;

            case LESS_THAN:
                processInstanceQuery.variableValueLessThan(variable.getName(), actualValue);
                break;

            case LESS_THAN_OR_EQUALS:
                processInstanceQuery.variableValueLessThanOrEqual(variable.getName(), actualValue);
                break;

            default:
                throw new ActivitiIllegalArgumentException("Unsupported variable query operation: " + variable.getVariableOperation());
        }
    }
}
 

import org.activiti.engine.history.HistoricProcessInstanceQuery; //导入方法依赖的package包/类
@Override
	public List<HistoricProcessInstance> queryProcess(
			String processDefinitionId, String taskDefinitionKey,
			String startedOrgId, Date startTime, Date endTime) {
		HistoricProcessInstanceQuery query = historyService
				.createHistoricProcessInstanceQuery().unfinished();
		if (processDefinitionId != null && !"".equals(processDefinitionId)) {
			query.processDefinitionId(processDefinitionId);
		}
		if (startTime != null && !"".equals(startTime)) {
			query.startedAfter(startTime);
		}
		if (endTime != null && !"".equals(endTime)) {
			query.startedAfter(endTime);
		}
		if (!StringUtils.isEmpty(startedOrgId)) {
			query.variableValueEquals("startCompanyId", startedOrgId);
		}
		List<HistoricProcessInstance> hPiList = query.list();
		if (hPiList == null || hPiList.size() < 1)
			return null;
		List<HistoricProcessInstance> temphPis = new ArrayList<HistoricProcessInstance>();
		for (HistoricProcessInstance pi : hPiList) {
			// 获取流程的当前节点
			// 执行实例
			ExecutionEntity execution = (ExecutionEntity) runtimeService
					.createProcessInstanceQuery().processInstanceId(pi.getId())
					.singleResult();
			String activityId = execution.getActivityId();
			// 判断流程是否包含选定的节点定义key
			if (taskDefinitionKey != null
					&& StringUtils.isNotEmpty(taskDefinitionKey)
					&& !taskDefinitionKey.equals(activityId)) {
				// 将不满足条件的流程从集合中移除
				temphPis.add(pi);
			}
			if (!StringUtils.isEmpty(startedOrgId)
					&& !StringUtils.isEmpty(pi.getStartUserId())) {
				String userId = pi.getStartUserId();
				IBaseEntity user = authService.resolveUserByUserExp(userId);
//				if (user != null && !startedOrgId.equals(user.getOrgId())) {
//					temphPis.add(pi);
//				}
			}
		}
		// 将不满足条件的流程从集合中移除
		hPiList.removeAll(temphPis);
		if (hPiList.size() > 0) {
			return hPiList;
		} else {
			return null;
		}
	}