TaskQuery (camunda BPM - engine 7.10.0-alpha4 API)

All Superinterfaces:

Query<TaskQuery,Task>

All Known Implementing Classes:

TaskQueryImpl
```
public interface TaskQuery
extends Query<TaskQuery,Task>
```
Allows programmatic querying of Tasks;

Author:

Joram Barrez, Falko Menge

Method Summary

Methods
Modifier and Type	Method and Description
`TaskQuery`	`active()` Only select tasks which are active (ie.
`TaskQuery`	`activityInstanceIdIn(String... activityInstanceIds)` Only select task which have one of the activity instance ids.
`TaskQuery`	`caseDefinitionId(String caseDefinitionId)` Only select tasks which are part of a case instance which has the given case definition id.
`TaskQuery`	`caseDefinitionKey(String caseDefinitionKey)` Only select tasks which are part of a case instance which has the given case definition key.
`TaskQuery`	`caseDefinitionName(String caseDefinitionName)` Only select tasks which are part of a case instance which has the given case definition name.
`TaskQuery`	`caseDefinitionNameLike(String caseDefinitionNameLike)` Only select tasks which are part of a case instance which case definition name is like the given parameter.
`TaskQuery`	`caseExecutionId(String caseExecutionId)` Only select tasks for the given case execution.
`TaskQuery`	`caseInstanceBusinessKey(String caseInstanceBusinessKey)` Only select tasks for the given case instance business key
`TaskQuery`	`caseInstanceBusinessKeyLike(String caseInstanceBusinessKeyLike)` Only select tasks matching the given case instance business key.
`TaskQuery`	`caseInstanceId(String caseInstanceId)` Only select tasks for the given case instance id.
`TaskQuery`	`caseInstanceVariableValueEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name set to the given value.
`TaskQuery`	`caseInstanceVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name and a variable value greater than the passed value.
`TaskQuery`	`caseInstanceVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value greater than or equal to the passed value.
`TaskQuery`	`caseInstanceVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value less than the passed value.
`TaskQuery`	`caseInstanceVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value less than or equal to the passed value.
`TaskQuery`	`caseInstanceVariableValueLike(String variableName, String variableValue)` Only select tasks which are part of a case instance that have a variable value like the given value.
`TaskQuery`	`caseInstanceVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name, but with a different value than the passed value.
`TaskQuery`	`dueAfter(Date dueDate)` Only select tasks which have a due date after the given date.
`TaskQuery`	`dueAfterExpression(String dueDateExpression)` Only select tasks which have a due date after the described date by the given expression.
`TaskQuery`	`dueBefore(Date dueDate)` Only select tasks which have a due date before the given date.
`TaskQuery`	`dueBeforeExpression(String dueDateExpression)` Only select tasks which have a due date before the described date by the given expression.
`TaskQuery`	`dueDate(Date dueDate)` Only select tasks with the given due date.
`TaskQuery`	`dueDateExpression(String dueDateExpression)` Only select tasks with the described due date by the given expression.
`TaskQuery`	`endOr()` endOr() terminates an OR query on which an arbitrary amount of filter criteria were applied.
`TaskQuery`	`excludeSubtasks()` Only select tasks that have no parent (i.e.
`TaskQuery`	`executionId(String executionId)` Only select tasks for the given execution.
`TaskQuery`	`followUpAfter(Date followUpDate)` Only select tasks which have a follow-up date after the given date.
`TaskQuery`	`followUpAfterExpression(String followUpDateExpression)` Only select tasks which have a follow-up date after the described date by the given expression.
`TaskQuery`	`followUpBefore(Date followUpDate)` Only select tasks which have a follow-up date before the given date.
`TaskQuery`	`followUpBeforeExpression(String followUpDateExpression)` Only select tasks which have a follow-up date before the described date by the given expression.
`TaskQuery`	`followUpBeforeOrNotExistent(Date followUpDate)` Only select tasks which have no follow-up date or a follow-up date before the given date.
`TaskQuery`	`followUpBeforeOrNotExistentExpression(String followUpDateExpression)` Only select tasks which have no follow-up date or a follow-up date before the described date by the given expression.
`TaskQuery`	`followUpDate(Date followUpDate)` Only select tasks with the given follow-up date.
`TaskQuery`	`followUpDateExpression(String followUpDateExpression)` Only select tasks with the described follow-up date by the given expression.
`TaskQuery`	`includeAssignedTasks()` Select both assigned and not assigned tasks for candidate user or group queries.
`TaskQuery`	`initializeFormKeys()` If called, the form keys of the fetched tasks are initialized and `Task.getFormKey()` will return a value (in case the task has a form key).
`TaskQuery`	`or()` After calling or(), a chain of several filter criteria could follow.
`TaskQuery`	`orderByCaseExecutionId()` Order by case execution id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByCaseExecutionVariable(String variableName, org.camunda.bpm.engine.variable.type.ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByCaseInstanceId()` Order by case instance id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByCaseInstanceVariable(String variableName, org.camunda.bpm.engine.variable.type.ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByDueDate()` Order by due date (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByExecutionId()` Order by execution id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByExecutionVariable(String variableName, org.camunda.bpm.engine.variable.type.ValueType valueType)` Order by an execution variable value of a certain type.
`TaskQuery`	`orderByFollowUpDate()` Order by follow-up date (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByProcessInstanceId()` Order by process instance id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByProcessVariable(String variableName, org.camunda.bpm.engine.variable.type.ValueType valueType)` Order by a process instance variable value of a certain type.
`TaskQuery`	`orderByTaskAssignee()` Order by assignee (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskCreateTime()` Order by the time on which the tasks were created (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskDescription()` Order by description (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskId()` Order by task id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskName()` Order by task name (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskNameCaseInsensitive()` Order by task name case insensitive (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskPriority()` Order by priority (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskVariable(String variableName, org.camunda.bpm.engine.variable.type.ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByTenantId()` Order by tenant id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`processDefinitionId(String processDefinitionId)` Only select tasks which are part of a process instance which has the given process definition id.
`TaskQuery`	`processDefinitionKey(String processDefinitionKey)` Only select tasks which are part of a process instance which has the given process definition key.
`TaskQuery`	`processDefinitionKeyIn(String... processDefinitionKeys)` Only select tasks which are part of a process instance which has one of the given process definition keys.
`TaskQuery`	`processDefinitionName(String processDefinitionName)` Only select tasks which are part of a process instance which has the given process definition name.
`TaskQuery`	`processDefinitionNameLike(String processDefinitionName)` Only select tasks which are part of a process instance which process definition name is like the given parameter.
`TaskQuery`	`processInstanceBusinessKey(String processInstanceBusinessKey)` Only select tasks for the given process instance business key
`TaskQuery`	`processInstanceBusinessKeyExpression(String processInstanceBusinessKeyExpression)` Only select tasks for the given process instance business key described by the given expression
`TaskQuery`	`processInstanceBusinessKeyIn(String... processInstanceBusinessKeys)` Only select tasks for any of the given the given process instance business keys.
`TaskQuery`	`processInstanceBusinessKeyLike(String processInstanceBusinessKey)` Only select tasks matching the given process instance business key.
`TaskQuery`	`processInstanceBusinessKeyLikeExpression(String processInstanceBusinessKeyExpression)` Only select tasks matching the given process instance business key described by the given expression.
`TaskQuery`	`processInstanceId(String processInstanceId)` Only select tasks for the given process instance id.
`TaskQuery`	`processVariableValueEquals(String variableName, Object variableValue)` Only select tasks which have are part of a process that have a variable with the given name set to the given value.
`TaskQuery`	`processVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than the given one.
`TaskQuery`	`processVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`processVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value less than the given one.
`TaskQuery`	`processVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`processVariableValueLike(String variableName, String variableValue)` Only select tasks which are part of a process that have a variable with the given name and matching the given value.
`TaskQuery`	`processVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which have a variable with the given name, but with a different value than the passed value.
`TaskQuery`	`suspended()` Only select tasks which are suspended, because its process instance was suspended.
`TaskQuery`	`taskAssigned()` Only select tasks which have an assignee.
`TaskQuery`	`taskAssignee(String assignee)` Only select tasks which are assigned to the given user.
`TaskQuery`	`taskAssigneeExpression(String assigneeExpression)` Only select tasks which are assigned to the user described by the given expression.
`TaskQuery`	`taskAssigneeLike(String assignee)` Only select tasks which are matching the given user.
`TaskQuery`	`taskAssigneeLikeExpression(String assigneeLikeExpression)` Only select tasks which are assigned to the user described by the given expression.
`TaskQuery`	`taskCandidateGroup(String candidateGroup)` Only select tasks for which users in the given group are candidates.
`TaskQuery`	`taskCandidateGroupExpression(String candidateGroupExpression)` Only select tasks for which users in the described group by the given expression are candidates.
`TaskQuery`	`taskCandidateGroupIn(List<String> candidateGroups)` Only select tasks for which the 'candidateGroup' is one of the given groups.
`TaskQuery`	`taskCandidateGroupInExpression(String candidateGroupsExpression)` Only select tasks for which the 'candidateGroup' is one of the described groups of the given expression.
`TaskQuery`	`taskCandidateUser(String candidateUser)` Only select tasks for which the given user or one of his groups is a candidate.
`TaskQuery`	`taskCandidateUserExpression(String candidateUserExpression)` Only select tasks for which the described user by the given expression is a candidate.
`TaskQuery`	`taskCreatedAfter(Date after)` Only select tasks that are created after the given date.
`TaskQuery`	`taskCreatedAfterExpression(String afterExpression)` Only select tasks that are created after the described date by the given expression.
`TaskQuery`	`taskCreatedBefore(Date before)` Only select tasks that are created before the given date.
`TaskQuery`	`taskCreatedBeforeExpression(String beforeExpression)` Only select tasks that are created before the described date by the given expression.
`TaskQuery`	`taskCreatedOn(Date createTime)` Only select tasks that are created on the given date.
`TaskQuery`	`taskCreatedOnExpression(String createTimeExpression)` Only select tasks that are created on the described date by the given expression.
`TaskQuery`	`taskDefinitionKey(String key)` Only select tasks with the given taskDefinitionKey.
`TaskQuery`	`taskDefinitionKeyIn(String... taskDefinitionKeys)` Only select tasks which have one of the taskDefinitionKeys.
`TaskQuery`	`taskDefinitionKeyLike(String keyLike)` Only select tasks with a taskDefinitionKey that match the given parameter.
`TaskQuery`	`taskDelegationState(DelegationState delegationState)` Only select tasks with the given `DelegationState`.
`TaskQuery`	`taskDescription(String description)` Only select tasks with the given description.
`TaskQuery`	`taskDescriptionLike(String descriptionLike)` Only select tasks with a description matching the parameter .
`TaskQuery`	`taskId(String taskId)` Only select tasks with the given task id (in practice, there will be maximum one of this kind)
`TaskQuery`	`taskInvolvedUser(String involvedUser)` Only select tasks for which there exist an `IdentityLink` with the given user
`TaskQuery`	`taskInvolvedUserExpression(String involvedUserExpression)` Only select tasks for which there exist an `IdentityLink` with the described user by the given expression
`TaskQuery`	`taskMaxPriority(Integer maxPriority)` Only select tasks with the given priority or lower.
`TaskQuery`	`taskMinPriority(Integer minPriority)` Only select tasks with the given priority or higher.
`TaskQuery`	`taskName(String name)` Only select tasks with the given name
`TaskQuery`	`taskNameLike(String nameLike)` Only select tasks with a name matching the parameter.
`TaskQuery`	`taskNameNotEqual(String name)` Only select tasks with a name not matching the given name
`TaskQuery`	`taskNameNotLike(String nameNotLike)` Only select tasks with a name not matching the parameter.
`TaskQuery`	`taskOwner(String owner)` Only select tasks for which the given user is the owner.
`TaskQuery`	`taskOwnerExpression(String ownerExpression)` Only select tasks for which the described user by the given expression is the owner.
`TaskQuery`	`taskParentTaskId(String parentTaskId)` Select the tasks which are sub tasks of the given parent task.
`TaskQuery`	`taskPriority(Integer priority)` Only select tasks with the given priority.
`TaskQuery`	`taskUnassigned()` Only select tasks which don't have an assignee.
`TaskQuery`	`taskUnnassigned()` Deprecated.
`TaskQuery`	`taskVariableValueEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name set to the given value.
`TaskQuery`	`taskVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value greater than the given one.
`TaskQuery`	`taskVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`taskVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value less than the given one.
`TaskQuery`	`taskVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value less than or equal to the given one.
`TaskQuery`	`taskVariableValueLike(String variableName, String variableValue)` Only select tasks which have a local task variable with the given name matching the given value.
`TaskQuery`	`taskVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name, but with a different value than the passed value.
`TaskQuery`	`tenantIdIn(String... tenantIds)` Only select tasks with one of the given tenant ids.
`TaskQuery`	`withCandidateGroups()` Only select tasks which have a candidate group
`TaskQuery`	`withCandidateUsers()` Only select tasks which have a candidate user
`TaskQuery`	`withoutCandidateGroups()` Only select tasks which have no candidate group
`TaskQuery`	`withoutCandidateUsers()` Only select tasks which have no candidate user
`TaskQuery`	`withoutTenantId()` Only select tasks which have no tenant id.

Methods inherited from interface org.camunda.bpm.engine.query.Query
asc, count, desc, list, listPage, singleResult

- Method Detail
  - taskId
```
TaskQuery taskId(String taskId)
```
    Only select tasks with the given task id (in practice, there will be maximum one of this kind)
  - taskName
```
TaskQuery taskName(String name)
```
    Only select tasks with the given name
  - taskNameNotEqual
```
TaskQuery taskNameNotEqual(String name)
```
    Only select tasks with a name not matching the given name
  - taskNameLike
```
TaskQuery taskNameLike(String nameLike)
```
    Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%camunda%)
  - taskNameNotLike
```
TaskQuery taskNameNotLike(String nameNotLike)
```
    Only select tasks with a name not matching the parameter. The syntax is that of SQL: for example usage: nameNotLike(%camunda%)
  - taskDescription
```
TaskQuery taskDescription(String description)
```
    Only select tasks with the given description.
  - taskDescriptionLike
```
TaskQuery taskDescriptionLike(String descriptionLike)
```
    Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%camunda%)
  - taskPriority
```
TaskQuery taskPriority(Integer priority)
```
    Only select tasks with the given priority.
  - taskMinPriority
```
TaskQuery taskMinPriority(Integer minPriority)
```
    Only select tasks with the given priority or higher.
  - taskMaxPriority
```
TaskQuery taskMaxPriority(Integer maxPriority)
```
    Only select tasks with the given priority or lower.
  - taskAssignee
```
TaskQuery taskAssignee(String assignee)
```
    Only select tasks which are assigned to the given user.
  - taskAssigneeExpression
```
TaskQuery taskAssigneeExpression(String assigneeExpression)
```
    Only select tasks which are assigned to the user described by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskAssigneeLike
```
TaskQuery taskAssigneeLike(String assignee)
```
    Only select tasks which are matching the given user. The syntax is that of SQL: for example usage: nameLike(%camunda%)
  - taskAssigneeLikeExpression
```
TaskQuery taskAssigneeLikeExpression(String assigneeLikeExpression)
```
    Only select tasks which are assigned to the user described by the given expression. The syntax is that of SQL: for example usage: taskAssigneeLikeExpression("${'%test%'}")
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskOwner
```
TaskQuery taskOwner(String owner)
```
    Only select tasks for which the given user is the owner.
  - taskOwnerExpression
```
TaskQuery taskOwnerExpression(String ownerExpression)
```
    Only select tasks for which the described user by the given expression is the owner.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskUnassigned
```
TaskQuery taskUnassigned()
```
    Only select tasks which don't have an assignee.
  - taskUnnassigned
```
@Deprecated
TaskQuery taskUnnassigned()
```
    Deprecated.
    
    See Also:
    #taskUnassigned}
  - taskAssigned
```
TaskQuery taskAssigned()
```
    Only select tasks which have an assignee.
  - taskDelegationState
```
TaskQuery taskDelegationState(DelegationState delegationState)
```
    Only select tasks with the given DelegationState.
  - taskCandidateUser
```
TaskQuery taskCandidateUser(String candidateUser)
```
    Only select tasks for which the given user or one of his groups is a candidate.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateGroup(String) or taskCandidateGroupIn(List) has been executed on the "and query" instance. No exception is thrown when query is executed and taskCandidateGroup(String) or taskCandidateGroupIn(List) has been executed on the "or query" instance.
    When passed user is null.
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskCandidateUserExpression
```
TaskQuery taskCandidateUserExpression(String candidateUserExpression)
```
    Only select tasks for which the described user by the given expression is a candidate.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateGroup(String) or taskCandidateGroupIn(List) has been executed on the query instance.
    When passed user is null.
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskInvolvedUser
```
TaskQuery taskInvolvedUser(String involvedUser)
```
    Only select tasks for which there exist an IdentityLink with the given user
  - taskInvolvedUserExpression
```
TaskQuery taskInvolvedUserExpression(String involvedUserExpression)
```
    Only select tasks for which there exist an IdentityLink with the described user by the given expression
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - withCandidateGroups
```
TaskQuery withCandidateGroups()
```
    Only select tasks which have a candidate group
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - withoutCandidateGroups
```
TaskQuery withoutCandidateGroups()
```
    Only select tasks which have no candidate group
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - withCandidateUsers
```
TaskQuery withCandidateUsers()
```
    Only select tasks which have a candidate user
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - withoutCandidateUsers
```
TaskQuery withoutCandidateUsers()
```
    Only select tasks which have no candidate user
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - taskCandidateGroup
```
TaskQuery taskCandidateGroup(String candidateGroup)
```
    Only select tasks for which users in the given group are candidates.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateUser(String) or taskCandidateGroupIn(List) has been executed on the "and query" instance.
    No exception is thrown when query is executed and taskCandidateUser(String) or taskCandidateGroupIn(List) has been executed on the "or query" instance.
    When passed group is null.
  - taskCandidateGroupExpression
```
TaskQuery taskCandidateGroupExpression(String candidateGroupExpression)
```
    Only select tasks for which users in the described group by the given expression are candidates.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateUser(String) or taskCandidateGroupIn(List) has been executed on the query instance.
    When passed group is null.
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - taskCandidateGroupIn
```
TaskQuery taskCandidateGroupIn(List<String> candidateGroups)
```
    Only select tasks for which the 'candidateGroup' is one of the given groups.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateGroup(String) or taskCandidateUser(String) has been executed on the "and query" instance.
    No exception is thrown when query is executed and taskCandidateGroup(String) or taskCandidateUser(String) has been executed on the "or query" instance.
    When passed group list is empty or null.
  - taskCandidateGroupInExpression
```
TaskQuery taskCandidateGroupInExpression(String candidateGroupsExpression)
```
    Only select tasks for which the 'candidateGroup' is one of the described groups of the given expression.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify includeAssignedTasks() in your query.
    Throws:
    ProcessEngineException -
    When query is executed and taskCandidateGroup(String) or taskCandidateUser(String) has been executed on the query instance.
    When passed group list is empty or null.
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - includeAssignedTasks
```
TaskQuery includeAssignedTasks()
```
    Select both assigned and not assigned tasks for candidate user or group queries.
    By default taskCandidateUser(String), taskCandidateGroup(String) and taskCandidateGroupIn(List) queries only select not assigned tasks.
    
    Throws:
    
    ProcessEngineException - When no candidate user or group(s) are specified beforehand
  - processInstanceId
```
TaskQuery processInstanceId(String processInstanceId)
```
    Only select tasks for the given process instance id.
  - processInstanceBusinessKey
```
TaskQuery processInstanceBusinessKey(String processInstanceBusinessKey)
```
    Only select tasks for the given process instance business key
  - processInstanceBusinessKeyExpression
```
TaskQuery processInstanceBusinessKeyExpression(String processInstanceBusinessKeyExpression)
```
    Only select tasks for the given process instance business key described by the given expression
  - processInstanceBusinessKeyIn
```
TaskQuery processInstanceBusinessKeyIn(String... processInstanceBusinessKeys)
```
    Only select tasks for any of the given the given process instance business keys.
  - processInstanceBusinessKeyLike
```
TaskQuery processInstanceBusinessKeyLike(String processInstanceBusinessKey)
```
    Only select tasks matching the given process instance business key. The syntax is that of SQL: for example usage: nameLike(%camunda%)
  - processInstanceBusinessKeyLikeExpression
```
TaskQuery processInstanceBusinessKeyLikeExpression(String processInstanceBusinessKeyExpression)
```
    Only select tasks matching the given process instance business key described by the given expression. The syntax is that of SQL: for example usage: processInstanceBusinessKeyLikeExpression("${ '%camunda%' }")
  - executionId
```
TaskQuery executionId(String executionId)
```
    Only select tasks for the given execution.
  - activityInstanceIdIn
```
TaskQuery activityInstanceIdIn(String... activityInstanceIds)
```
    Only select task which have one of the activity instance ids.
  - taskCreatedOn
```
TaskQuery taskCreatedOn(Date createTime)
```
    Only select tasks that are created on the given date.
  - taskCreatedOnExpression
```
TaskQuery taskCreatedOnExpression(String createTimeExpression)
```
    Only select tasks that are created on the described date by the given expression.
  - taskCreatedBefore
```
TaskQuery taskCreatedBefore(Date before)
```
    Only select tasks that are created before the given date.
  - taskCreatedBeforeExpression
```
TaskQuery taskCreatedBeforeExpression(String beforeExpression)
```
    Only select tasks that are created before the described date by the given expression.
  - taskCreatedAfter
```
TaskQuery taskCreatedAfter(Date after)
```
    Only select tasks that are created after the given date.
  - taskCreatedAfterExpression
```
TaskQuery taskCreatedAfterExpression(String afterExpression)
```
    Only select tasks that are created after the described date by the given expression.
  - excludeSubtasks
```
TaskQuery excludeSubtasks()
```
    Only select tasks that have no parent (i.e. do not select subtasks).
  - taskDefinitionKey
```
TaskQuery taskDefinitionKey(String key)
```
    Only select tasks with the given taskDefinitionKey. The task definition key is the id of the userTask: <userTask id="xxx" .../>
  - taskDefinitionKeyLike
```
TaskQuery taskDefinitionKeyLike(String keyLike)
```
    Only select tasks with a taskDefinitionKey that match the given parameter. The syntax is that of SQL: for example usage: taskDefinitionKeyLike("%camunda%"). The task definition key is the id of the userTask: <userTask id="xxx" .../>
  - taskDefinitionKeyIn
```
TaskQuery taskDefinitionKeyIn(String... taskDefinitionKeys)
```
    Only select tasks which have one of the taskDefinitionKeys.
  - taskParentTaskId
```
TaskQuery taskParentTaskId(String parentTaskId)
```
    Select the tasks which are sub tasks of the given parent task.
  - caseInstanceId
```
TaskQuery caseInstanceId(String caseInstanceId)
```
    Only select tasks for the given case instance id.
  - caseInstanceBusinessKey
```
TaskQuery caseInstanceBusinessKey(String caseInstanceBusinessKey)
```
    Only select tasks for the given case instance business key
  - caseInstanceBusinessKeyLike
```
TaskQuery caseInstanceBusinessKeyLike(String caseInstanceBusinessKeyLike)
```
    Only select tasks matching the given case instance business key. The syntax is that of SQL: for example usage: nameLike(%aBusinessKey%)
  - caseExecutionId
```
TaskQuery caseExecutionId(String caseExecutionId)
```
    Only select tasks for the given case execution.
  - caseDefinitionKey
```
TaskQuery caseDefinitionKey(String caseDefinitionKey)
```
    Only select tasks which are part of a case instance which has the given case definition key.
  - caseDefinitionId
```
TaskQuery caseDefinitionId(String caseDefinitionId)
```
    Only select tasks which are part of a case instance which has the given case definition id.
  - caseDefinitionName
```
TaskQuery caseDefinitionName(String caseDefinitionName)
```
    Only select tasks which are part of a case instance which has the given case definition name.
  - caseDefinitionNameLike
```
TaskQuery caseDefinitionNameLike(String caseDefinitionNameLike)
```
    Only select tasks which are part of a case instance which case definition name is like the given parameter. The syntax is that of SQL: for example usage: nameLike(%processDefinitionName%)
  - taskVariableValueEquals
```
TaskQuery taskVariableValueEquals(String variableName,
                                Object variableValue)
```
    Only select tasks which have a local task variable with the given name set to the given value.
  - taskVariableValueNotEquals
```
TaskQuery taskVariableValueNotEquals(String variableName,
                                   Object variableValue)
```
    Only select tasks which have a local task variable with the given name, but with a different value than the passed value. Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
  - taskVariableValueLike
```
TaskQuery taskVariableValueLike(String variableName,
                              String variableValue)
```
    Only select tasks which have a local task variable with the given name matching the given value. The syntax is that of SQL: for example usage: valueLike(%value%)
  - taskVariableValueGreaterThan
```
TaskQuery taskVariableValueGreaterThan(String variableName,
                                     Object variableValue)
```
    Only select tasks which have a local task variable with the given name and a value greater than the given one.
  - taskVariableValueGreaterThanOrEquals
```
TaskQuery taskVariableValueGreaterThanOrEquals(String variableName,
                                             Object variableValue)
```
    Only select tasks which have a local task variable with the given name and a value greater than or equal to the given one.
  - taskVariableValueLessThan
```
TaskQuery taskVariableValueLessThan(String variableName,
                                  Object variableValue)
```
    Only select tasks which have a local task variable with the given name and a value less than the given one.
  - taskVariableValueLessThanOrEquals
```
TaskQuery taskVariableValueLessThanOrEquals(String variableName,
                                          Object variableValue)
```
    Only select tasks which have a local task variable with the given name and a value less than or equal to the given one.
  - processVariableValueEquals
```
TaskQuery processVariableValueEquals(String variableName,
                                   Object variableValue)
```
    Only select tasks which have are part of a process that have a variable with the given name set to the given value.
  - processVariableValueNotEquals
```
TaskQuery processVariableValueNotEquals(String variableName,
                                      Object variableValue)
```
    Only select tasks which have a variable with the given name, but with a different value than the passed value. Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
  - processVariableValueLike
```
TaskQuery processVariableValueLike(String variableName,
                                 String variableValue)
```
    Only select tasks which are part of a process that have a variable with the given name and matching the given value. The syntax is that of SQL: for example usage: valueLike(%value%)
  - processVariableValueGreaterThan
```
TaskQuery processVariableValueGreaterThan(String variableName,
                                        Object variableValue)
```
    Only select tasks which are part of a process that have a variable with the given name and a value greater than the given one.
  - processVariableValueGreaterThanOrEquals
```
TaskQuery processVariableValueGreaterThanOrEquals(String variableName,
                                                Object variableValue)
```
    Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
  - processVariableValueLessThan
```
TaskQuery processVariableValueLessThan(String variableName,
                                     Object variableValue)
```
    Only select tasks which are part of a process that have a variable with the given name and a value less than the given one.
  - processVariableValueLessThanOrEquals
```
TaskQuery processVariableValueLessThanOrEquals(String variableName,
                                             Object variableValue)
```
    Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
  - caseInstanceVariableValueEquals
```
TaskQuery caseInstanceVariableValueEquals(String variableName,
                                        Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable with the given name set to the given value. The type of variable is determined based on the value, using types configured in ProcessEngineConfiguration#getVariableSerializers(). Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - name of the variable, cannot be null.
  - caseInstanceVariableValueNotEquals
```
TaskQuery caseInstanceVariableValueNotEquals(String variableName,
                                           Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable with the given name, but with a different value than the passed value. The type of variable is determined based on the value, using types configured in ProcessEngineConfiguration#getVariableSerializers(). Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - name of the variable, cannot be null.
  - caseInstanceVariableValueLike
```
TaskQuery caseInstanceVariableValueLike(String variableName,
                                      String variableValue)
```
    Only select tasks which are part of a case instance that have a variable value like the given value. This be used on string variables only.
    
    Parameters:
    name - variable name, cannot be null.
    value - variable value. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).
  - caseInstanceVariableValueGreaterThan
```
TaskQuery caseInstanceVariableValueGreaterThan(String variableName,
                                             Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable with the given name and a variable value greater than the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - variable name, cannot be null.
  - caseInstanceVariableValueGreaterThanOrEquals
```
TaskQuery caseInstanceVariableValueGreaterThanOrEquals(String variableName,
                                                     Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable value greater than or equal to the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - variable name, cannot be null.
  - caseInstanceVariableValueLessThan
```
TaskQuery caseInstanceVariableValueLessThan(String variableName,
                                          Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable value less than the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - variable name, cannot be null.
  - caseInstanceVariableValueLessThanOrEquals
```
TaskQuery caseInstanceVariableValueLessThanOrEquals(String variableName,
                                                  Object variableValue)
```
    Only select tasks which are part of a case instance that have a variable value less than or equal to the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Parameters:
    name - variable name, cannot be null.
  - processDefinitionKey
```
TaskQuery processDefinitionKey(String processDefinitionKey)
```
    Only select tasks which are part of a process instance which has the given process definition key.
  - processDefinitionKeyIn
```
TaskQuery processDefinitionKeyIn(String... processDefinitionKeys)
```
    Only select tasks which are part of a process instance which has one of the given process definition keys.
  - processDefinitionId
```
TaskQuery processDefinitionId(String processDefinitionId)
```
    Only select tasks which are part of a process instance which has the given process definition id.
  - processDefinitionName
```
TaskQuery processDefinitionName(String processDefinitionName)
```
    Only select tasks which are part of a process instance which has the given process definition name.
  - processDefinitionNameLike
```
TaskQuery processDefinitionNameLike(String processDefinitionName)
```
    Only select tasks which are part of a process instance which process definition name is like the given parameter. The syntax is that of SQL: for example usage: nameLike(%processDefinitionName%)
  - dueDate
```
TaskQuery dueDate(Date dueDate)
```
    Only select tasks with the given due date.
  - dueDateExpression
```
TaskQuery dueDateExpression(String dueDateExpression)
```
    Only select tasks with the described due date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - dueBefore
```
TaskQuery dueBefore(Date dueDate)
```
    Only select tasks which have a due date before the given date.
  - dueBeforeExpression
```
TaskQuery dueBeforeExpression(String dueDateExpression)
```
    Only select tasks which have a due date before the described date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - dueAfter
```
TaskQuery dueAfter(Date dueDate)
```
    Only select tasks which have a due date after the given date.
  - dueAfterExpression
```
TaskQuery dueAfterExpression(String dueDateExpression)
```
    Only select tasks which have a due date after the described date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - followUpDate
```
TaskQuery followUpDate(Date followUpDate)
```
    Only select tasks with the given follow-up date.
  - followUpDateExpression
```
TaskQuery followUpDateExpression(String followUpDateExpression)
```
    Only select tasks with the described follow-up date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - followUpBefore
```
TaskQuery followUpBefore(Date followUpDate)
```
    Only select tasks which have a follow-up date before the given date.
  - followUpBeforeExpression
```
TaskQuery followUpBeforeExpression(String followUpDateExpression)
```
    Only select tasks which have a follow-up date before the described date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - followUpBeforeOrNotExistent
```
TaskQuery followUpBeforeOrNotExistent(Date followUpDate)
```
    Only select tasks which have no follow-up date or a follow-up date before the given date. Serves the typical use case "give me all tasks without follow-up or follow-up date which is already due"
  - followUpBeforeOrNotExistentExpression
```
TaskQuery followUpBeforeOrNotExistentExpression(String followUpDateExpression)
```
    Only select tasks which have no follow-up date or a follow-up date before the described date by the given expression. Serves the typical use case "give me all tasks without follow-up or follow-up date which is already due"
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - followUpAfter
```
TaskQuery followUpAfter(Date followUpDate)
```
    Only select tasks which have a follow-up date after the given date.
  - followUpAfterExpression
```
TaskQuery followUpAfterExpression(String followUpDateExpression)
```
    Only select tasks which have a follow-up date after the described date by the given expression.
    Throws:
    BadUserRequestException -
    When the query is executed and expressions are disabled for adhoc queries (in case the query is executed via Query.list(), Query.listPage(int, int), Query.singleResult(), or Query.count()) or stored queries (in case the query is stored along with a filter). Expression evaluation can be activated by setting the process engine configuration properties enableExpressionsInAdhocQueries (default false) and enableExpressionsInStoredQueries (default true) to true.
  - suspended
```
TaskQuery suspended()
```
    Only select tasks which are suspended, because its process instance was suspended.
  - active
```
TaskQuery active()
```
    Only select tasks which are active (ie. not suspended)
  - initializeFormKeys
```
TaskQuery initializeFormKeys()
```
    If called, the form keys of the fetched tasks are initialized and Task.getFormKey() will return a value (in case the task has a form key).
    
    Returns:
    the query itself
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query". Method must be executed on the base query.
  - tenantIdIn
```
TaskQuery tenantIdIn(String... tenantIds)
```
    Only select tasks with one of the given tenant ids.
  - withoutTenantId
```
TaskQuery withoutTenantId()
```
    Only select tasks which have no tenant id.
  - orderByTaskId
```
TaskQuery orderByTaskId()
```
    Order by task id (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskName
```
TaskQuery orderByTaskName()
```
    Order by task name (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskNameCaseInsensitive
```
TaskQuery orderByTaskNameCaseInsensitive()
```
    Order by task name case insensitive (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskDescription
```
TaskQuery orderByTaskDescription()
```
    Order by description (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskPriority
```
TaskQuery orderByTaskPriority()
```
    Order by priority (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskAssignee
```
TaskQuery orderByTaskAssignee()
```
    Order by assignee (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskCreateTime
```
TaskQuery orderByTaskCreateTime()
```
    Order by the time on which the tasks were created (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByProcessInstanceId
```
TaskQuery orderByProcessInstanceId()
```
    Order by process instance id (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByCaseInstanceId
```
TaskQuery orderByCaseInstanceId()
```
    Order by case instance id (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByExecutionId
```
TaskQuery orderByExecutionId()
```
    Order by execution id (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByCaseExecutionId
```
TaskQuery orderByCaseExecutionId()
```
    Order by case execution id (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByDueDate
```
TaskQuery orderByDueDate()
```
    Order by due date (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByFollowUpDate
```
TaskQuery orderByFollowUpDate()
```
    Order by follow-up date (needs to be followed by Query.asc() or Query.desc()).
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByProcessVariable
```
TaskQuery orderByProcessVariable(String variableName,
                               org.camunda.bpm.engine.variable.type.ValueType valueType)
```
    Order by a process instance variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByExecutionVariable
```
TaskQuery orderByExecutionVariable(String variableName,
                                 org.camunda.bpm.engine.variable.type.ValueType valueType)
```
    Order by an execution variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTaskVariable
```
TaskQuery orderByTaskVariable(String variableName,
                            org.camunda.bpm.engine.variable.type.ValueType valueType)
```
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByCaseExecutionVariable
```
TaskQuery orderByCaseExecutionVariable(String variableName,
                                     org.camunda.bpm.engine.variable.type.ValueType valueType)
```
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByCaseInstanceVariable
```
TaskQuery orderByCaseInstanceVariable(String variableName,
                                    org.camunda.bpm.engine.variable.type.ValueType valueType)
```
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - orderByTenantId
```
TaskQuery orderByTenantId()
```
    Order by tenant id (needs to be followed by Query.asc() or Query.desc()). Note that the ordering of tasks without tenant id is database-specific.
    
    Throws:
    
    ProcessEngineException - When method has been executed within "or query".
  - or
```
TaskQuery or()
```
    After calling or(), a chain of several filter criteria could follow. Each filter criterion that follows or() will be linked together with an OR expression until the OR query is terminated. To terminate the OR query right after the last filter criterion was applied, endOr() must be invoked.
    
    Returns:
    an object of the type TaskQuery on which an arbitrary amount of filter criteria could be applied. The several filter criteria will be linked together by an OR expression.
    
    Throws:
    
    ProcessEngineException - when or() has been invoked directly after or() or after or() and trailing filter criteria. To prevent throwing this exception, endOr() must be invoked after a chain of filter criteria to mark the end of the OR query.
  - endOr
```
TaskQuery endOr()
```
    endOr() terminates an OR query on which an arbitrary amount of filter criteria were applied. To terminate the OR query which has been started by invoking or(), endOr() must be invoked. Filter criteria which are applied after calling endOr() are linked together by an AND expression.
    
    Returns:
    an object of the type TaskQuery on which an arbitrary amount of filter criteria could be applied. The filter criteria will be linked together by an AND expression.
    
    Throws:
    
    ProcessEngineException - when endOr() has been invoked before or() was invoked. To prevent throwing this exception, or() must be invoked first.

Interface TaskQuery

Method Summary

Methods inherited from interface org.camunda.bpm.engine.query.Query

Method Detail

taskId

taskName

taskNameNotEqual

taskNameLike

taskNameNotLike

taskDescription

taskDescriptionLike

taskPriority

taskMinPriority

taskMaxPriority

taskAssignee

taskAssigneeExpression

taskAssigneeLike

taskAssigneeLikeExpression

taskOwner

taskOwnerExpression

taskUnassigned

taskUnnassigned

taskAssigned

taskDelegationState

taskCandidateUser

taskCandidateUserExpression

taskInvolvedUser

taskInvolvedUserExpression

withCandidateGroups

withoutCandidateGroups

withCandidateUsers

withoutCandidateUsers

taskCandidateGroup

taskCandidateGroupExpression

taskCandidateGroupIn

taskCandidateGroupInExpression

includeAssignedTasks

processInstanceId

processInstanceBusinessKey

processInstanceBusinessKeyExpression

processInstanceBusinessKeyIn

processInstanceBusinessKeyLike

processInstanceBusinessKeyLikeExpression

executionId

activityInstanceIdIn

taskCreatedOn

taskCreatedOnExpression

taskCreatedBefore

taskCreatedBeforeExpression

taskCreatedAfter

taskCreatedAfterExpression

excludeSubtasks

taskDefinitionKey

taskDefinitionKeyLike

taskDefinitionKeyIn

taskParentTaskId

caseInstanceId

caseInstanceBusinessKey

caseInstanceBusinessKeyLike

caseExecutionId

caseDefinitionKey

caseDefinitionId

caseDefinitionName

caseDefinitionNameLike

taskVariableValueEquals

taskVariableValueNotEquals

taskVariableValueLike

taskVariableValueGreaterThan

taskVariableValueGreaterThanOrEquals

taskVariableValueLessThan

taskVariableValueLessThanOrEquals

processVariableValueEquals

processVariableValueNotEquals

processVariableValueLike

processVariableValueGreaterThan

processVariableValueGreaterThanOrEquals

processVariableValueLessThan

processVariableValueLessThanOrEquals

caseInstanceVariableValueEquals

caseInstanceVariableValueNotEquals