import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
private List<WorkflowTask> queryHistoricTasks(WorkflowTaskQuery query)
{
    HistoricTaskInstanceQuery historicQuery = createHistoricTaskQuery(query);

   List<HistoricTaskInstance> results;
   int limit = query.getLimit();
   if (limit > 0)
   {
       results = historicQuery.listPage(0, limit);
   }
   else
   {
       results = historicQuery.list();
   }
   return getValidHistoricTasks(results);
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
private void addProcessPropertiesToQuery(Map<QName, Object> processCustomProps, 
            HistoricTaskInstanceQuery taskQuery) 
{
    for(Entry<QName, Object> customProperty : processCustomProps.entrySet()) 
    {
        String name =factory.mapQNameToName(customProperty.getKey());
        
        // Exclude the special "VAR_TENANT_DOMAIN" variable, this cannot be queried by users
        if(name != ActivitiConstants.VAR_TENANT_DOMAIN)
        {
            // Perform minimal property conversions
            Object converted = propertyConverter.convertPropertyToValue(customProperty.getValue());
            taskQuery.processVariableValueEquals(name, converted);
        }
    }
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery processCategoryIn(List<String> processCategoryInList) {
    if (processCategoryInList == null) {
        throw new ActivitiIllegalArgumentException("Process category list is null");
    }
    if (processCategoryInList.isEmpty()) {
        throw new ActivitiIllegalArgumentException("Process category list is empty");
    }
    for (String processCategory : processCategoryInList) {
        if (processCategory == null) {
            throw new ActivitiIllegalArgumentException("None of the given process categories can be null");
        }
    }

    if (inOrStatement) {
        currentOrQueryObject.processCategoryInList = processCategoryInList;
    } else {
        this.processCategoryInList = processCategoryInList;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery processCategoryNotIn(List<String> processCategoryNotInList) {
    if (processCategoryNotInList == null) {
        throw new ActivitiIllegalArgumentException("Process category list is null");
    }
    if (processCategoryNotInList.isEmpty()) {
        throw new ActivitiIllegalArgumentException("Process category list is empty");
    }
    for (String processCategory : processCategoryNotInList) {
        if (processCategory == null) {
            throw new ActivitiIllegalArgumentException("None of the given process categories can be null");
        }
    }

    if (inOrStatement) {
        currentOrQueryObject.processCategoryNotInList = processCategoryNotInList;
    } else {
        this.processCategoryNotInList = processCategoryNotInList;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskNameIn(List<String> taskNameList) {
    if (taskNameList == null) {
        throw new ActivitiIllegalArgumentException("Task name list is null");
    }
    if (taskNameList.isEmpty()) {
        throw new ActivitiIllegalArgumentException("Task name list is empty");
    }

    if (taskName != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskNameIn and taskName");
    }
    if (taskNameLike != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskNameIn and taskNameLike");
    }
    if (taskNameLikeIgnoreCase != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskNameIn and taskNameLikeIgnoreCase");
    }

    if (inOrStatement) {
        currentOrQueryObject.taskNameList = taskNameList;
    } else {
        this.taskNameList = taskNameList;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskCandidateGroup(String candidateGroup) {
    if (candidateGroup == null) {
        throw new ActivitiIllegalArgumentException("Candidate group is null");
    }

    if (candidateGroups != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both candidateGroup and candidateGroupIn");
    }

    if (inOrStatement) {
        this.currentOrQueryObject.candidateGroup = candidateGroup;
    } else {
        this.candidateGroup = candidateGroup;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskCandidateGroupIn(List<String> candidateGroups) {
    if (candidateGroups == null) {
        throw new ActivitiIllegalArgumentException("Candidate group list is null");
    }

    if (candidateGroups.isEmpty()) {
        throw new ActivitiIllegalArgumentException("Candidate group list is empty");
    }

    if (candidateGroup != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both candidateGroupIn and candidateGroup");
    }

    if (inOrStatement) {
        this.currentOrQueryObject.candidateGroups = candidateGroups;
    } else {
        this.candidateGroups = candidateGroups;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
/**
 * @param localId String
 * @return HistoricTaskInstance
 */
public HistoricTaskInstance getHistoricTaskInstance(String localId)
{
    HistoricTaskInstanceQuery taskQuery =  historyService.createHistoricTaskInstanceQuery()
        .taskId(localId);
    if(!deployWorkflowsInTenant) {
    	taskQuery.processVariableValueEquals(ActivitiConstants.VAR_TENANT_DOMAIN, TenantUtil.getCurrentDomain());
    }
    return taskQuery.singleResult();
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
private void addTaskPropertiesToQuery(Map<QName, Object> taskCustomProps, 
            HistoricTaskInstanceQuery taskQuery) 
{
    for(Entry<QName, Object> customProperty : taskCustomProps.entrySet()) 
    {
        String name =factory.mapQNameToName(customProperty.getKey());
        
        // Perform minimal property conversions
        Object converted = propertyConverter.convertPropertyToValue(customProperty.getValue());
        taskQuery.taskVariableValueEquals(name, converted);
    }
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
/**
	 * 获取已办任务
	 * @param page
	 * @param procDefKey 流程定义标识
	 * @return
	 */
	public Page<Act> historicList(Page<Act> page, Act act){
		String userId = UserUtils.getUser().getLoginName();//ObjectUtils.toString(UserUtils.getUser().getId());

		HistoricTaskInstanceQuery histTaskQuery = historyService.createHistoricTaskInstanceQuery().taskAssignee(userId).finished()
				.includeProcessVariables().orderByHistoricTaskInstanceEndTime().desc();
		
		// 设置查询条件
		if (StringUtils.isNotBlank(act.getProcDefKey())){
			histTaskQuery.processDefinitionKey(act.getProcDefKey());
		}
		if (act.getBeginDate() != null){
			histTaskQuery.taskCompletedAfter(act.getBeginDate());
		}
		if (act.getEndDate() != null){
			histTaskQuery.taskCompletedBefore(act.getEndDate());
		}
		
		// 查询总数
		page.setCount(histTaskQuery.count());
		
		// 查询列表
		List<HistoricTaskInstance> histList = histTaskQuery.listPage(page.getFirstResult(), page.getMaxResults());
		for (HistoricTaskInstance histTask : histList) {
			Act e = new Act();
			e.setHistTask(histTask);
			e.setVars(histTask.getProcessVariables());
//			e.setTaskVars(histTask.getTaskLocalVariables());
//			System.out.println(histTask.getId()+"  =  "+histTask.getProcessVariables() + "  ========== " + histTask.getTaskLocalVariables());
			e.setProcDef(ProcessDefCache.get(histTask.getProcessDefinitionId()));
//			e.setProcIns(runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult());
//			e.setProcExecUrl(ActUtils.getProcExeUrl(task.getProcessDefinitionId()));
			e.setStatus("finish");
			page.getList().add(e);
		}
		return page;
	}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery processDefinitionKeyIn(List<String> processDefinitionKeys) {
    if (inOrStatement) {
        this.currentOrQueryObject.processDefinitionKeys = processDefinitionKeys;
    } else {
        this.processDefinitionKeys = processDefinitionKeys;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery deploymentIdIn(List<String> deploymentIds) {
    if (inOrStatement) {
        currentOrQueryObject.deploymentIds = deploymentIds;
    } else {
        this.deploymentIds = deploymentIds;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskParentTaskId(String parentTaskId) {
    if (inOrStatement) {
        this.currentOrQueryObject.taskParentTaskId = parentTaskId;
    } else {
        this.taskParentTaskId = parentTaskId;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskAssigneeIds(List<String> assigneeIds) {
    if (assigneeIds == null) {
        throw new ActivitiIllegalArgumentException("Task assignee list is null");
    }
    if (assigneeIds.isEmpty()) {
        throw new ActivitiIllegalArgumentException("Task assignee list is empty");
    }
    for (String assignee : assigneeIds) {
        if (assignee == null) {
            throw new ActivitiIllegalArgumentException("None of the given task assignees can be null");
        }
    }

    if (taskAssignee != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskAssigneeIds and taskAssignee");
    }
    if (taskAssigneeLike != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskAssigneeIds and taskAssigneeLike");
    }
    if (taskAssigneeLikeIgnoreCase != null) {
        throw new ActivitiIllegalArgumentException("Invalid query usage: cannot set both taskAssigneeIds and taskAssigneeLikeIgnoreCase");
    }

    if (inOrStatement) {
        currentOrQueryObject.taskAssigneeIds = assigneeIds;
    } else {
        this.taskAssigneeIds = assigneeIds;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery finished() {
    if (inOrStatement) {
        this.currentOrQueryObject.finished = true;
    } else {
        this.finished = true;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery unfinished() {
    if (inOrStatement) {
        this.currentOrQueryObject.unfinished = true;
    } else {
        this.unfinished = true;
    }
    return this;
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskVariableValueEquals(String variableName, Object variableValue) {
    if (inOrStatement) {
        currentOrQueryObject.variableValueEquals(variableName, variableValue);
        return this;
    } else {
        return variableValueEquals(variableName, variableValue);
    }
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskVariableValueEqualsIgnoreCase(String name, String value) {
    if (inOrStatement) {
        currentOrQueryObject.variableValueEqualsIgnoreCase(name, value);
        return this;
    } else {
        return variableValueEqualsIgnoreCase(name, value);
    }
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskVariableValueNotEqualsIgnoreCase(String name, String value) {
    if (inOrStatement) {
        currentOrQueryObject.variableValueNotEqualsIgnoreCase(name, value);
        return this;
    } else {
        return variableValueNotEqualsIgnoreCase(name, value);
    }
}
 

import org.activiti.engine.history.HistoricTaskInstanceQuery; //导入依赖的package包/类
@Override
public HistoricTaskInstanceQuery taskVariableValueNotEquals(String variableName, Object variableValue) {
    if (inOrStatement) {
        currentOrQueryObject.variableValueNotEquals(variableName, variableValue);
        return this;
    } else {
        return variableValueNotEquals(variableName, variableValue);
    }
}