org.activiti.engine.task.TaskInfoQuery Maven / Gradle / Ivy
The newest version!
/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.task;
import org.activiti.engine.ActivitiIllegalArgumentException;
import org.activiti.engine.api.internal.Internal;
import org.activiti.engine.history.HistoricTaskInstanceQuery;
import org.activiti.engine.query.Query;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* Interface containing shared methods between the {@link TaskQuery} and the {@link HistoricTaskInstanceQuery}.
*
*/
@Internal
public interface TaskInfoQuery, V extends TaskInfo> extends Query {
/**
* Only select tasks with the given task id (in practice, there will be maximum one of this kind)
*/
T taskId(String taskId);
/** Only select tasks with the given name */
T taskName(String name);
/**
* Only select tasks with a name that is in the given list
*
* @throws ActivitiIllegalArgumentException
* When passed name list is empty or null or contains null String.
*/
T taskNameIn(List nameList);
/**
* Only select tasks with a name that is in the given list
*
* This method, unlike the {@link #taskNameIn(List)} method will not take in account the upper/lower case: both the input parameters as the column value are lowercased when the query is executed.
*
* @throws ActivitiIllegalArgumentException
* When passed name list is empty or null or contains null String.
*/
T taskNameInIgnoreCase(List nameList);
/**
* Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%activiti%)
*/
T taskNameLike(String nameLike);
/**
* Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%activiti%)
*
* This method, unlike the {@link #taskNameLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is executed.
*/
T taskNameLikeIgnoreCase(String nameLike);
/** Only select tasks with the given description. */
T taskDescription(String description);
/**
* Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%activiti%)
*/
T taskDescriptionLike(String descriptionLike);
/**
* Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%activiti%)
*
* This method, unlike the {@link #taskDescriptionLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is
* executed.
*/
T taskDescriptionLikeIgnoreCase(String descriptionLike);
/** Only select tasks with the given priority. */
T taskPriority(Integer priority);
/** Only select tasks with the given priority or higher. */
T taskMinPriority(Integer minPriority);
/** Only select tasks with the given priority or lower. */
T taskMaxPriority(Integer maxPriority);
/** Only select tasks which are assigned to the given user. */
T taskAssignee(String assignee);
/**
* Only select tasks which were last assigned to an assignee like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*/
T taskAssigneeLike(String assigneeLike);
/**
* Only select tasks which were last assigned to an assignee like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*
* This method, unlike the {@link #taskAssigneeLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is
* executed.
*/
T taskAssigneeLikeIgnoreCase(String assigneeLikeIgnoreCase);
/**
*Only select tasks with an assignee that is in the given list
*
* @throws ActivitiIllegalArgumentException
* When passed name list is empty or null or contains null String.
*/
T taskAssigneeIds(List assigneeListIds);
/** Only select tasks for which the given user is the owner. */
T taskOwner(String owner);
/**
* Only select tasks which were last assigned to an owner like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*/
T taskOwnerLike(String ownerLike);
/**
* Only select tasks which were last assigned to an owner like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*
* This method, unlike the {@link #taskOwnerLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is
* executed.
*/
T taskOwnerLikeIgnoreCase(String ownerLikeIgnoreCase);
/** Only select tasks for which the given user is a candidate. If identity service is available then also through user's groups. */
T taskCandidateUser(String candidateUser);
/** Only select tasks for which the given user is a candidate. */
T taskCandidateUser(String candidateUser, List usersGroups);
/**
* Only select tasks for which there exist an {@link IdentityLink} with the given user, including tasks which have been assigned to the given user (assignee) or owned by the given user (owner).
*/
T taskInvolvedUser(String involvedUser);
/** Only select tasks for users involved in the given groups */
T taskInvolvedGroupsIn(List involvedGroups);
/** Only select tasks for which users in the given group are candidates. */
T taskCandidateGroup(String candidateGroup);
/**
* Only select tasks for which the 'candidateGroup' is one of the given groups.
*
* @throws ActivitiIllegalArgumentException
* When query is executed and {@link #taskCandidateGroup(String)} or {@link #taskCandidateUser(String)} has been executed on the query instance. When passed group list is empty or
* null.
*/
T taskCandidateGroupIn(List candidateGroups);
/**
* Only select tasks that have the given tenant id.
*/
T taskTenantId(String tenantId);
/**
* Only select tasks with a tenant id like the given one.
*/
T taskTenantIdLike(String tenantIdLike);
/**
* Only select tasks that do not have a tenant id.
*/
T taskWithoutTenantId();
/**
* Only select tasks for the given process instance id.
*/
T processInstanceId(String processInstanceId);
/**
* Only select tasks for the given process ids.
*/
T processInstanceIdIn(List processInstanceIds);
/** Only select tasks foe the given business key */
T processInstanceBusinessKey(String processInstanceBusinessKey);
/**
* Only select tasks with a business key like the given value The syntax is that of SQL: for example usage: processInstanceBusinessKeyLike("%activiti%").
*/
T processInstanceBusinessKeyLike(String processInstanceBusinessKeyLike);
/**
* Only select tasks with a business key like the given value The syntax is that of SQL: for example usage: processInstanceBusinessKeyLike("%activiti%").
*
* This method, unlike the {@link #processInstanceBusinessKeyLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the
* query is executed.
*/
T processInstanceBusinessKeyLikeIgnoreCase(String processInstanceBusinessKeyLikeIgnoreCase);
/**
* Only select tasks for the given execution.
*/
T executionId(String executionId);
/**
* Only select tasks that are created on the given date.
*/
T taskCreatedOn(Date createTime);
/**
* Only select tasks that are created before the given date.
*/
T taskCreatedBefore(Date before);
/**
* Only select tasks that are created after the given date.
*/
T taskCreatedAfter(Date after);
/**
* Only select tasks with the given category.
*/
T taskCategory(String category);
/**
* Only select tasks with the given taskDefinitionKey. The task definition key is the id of the userTask: <userTask id="xxx" .../>
**/
T taskDefinitionKey(String key);
/**
* Only select tasks with a taskDefinitionKey that match the given parameter. The syntax is that of SQL: for example usage: taskDefinitionKeyLike("%activiti%"). The task definition key is the id of
* the userTask: <userTask id="xxx" .../>
**/
T taskDefinitionKeyLike(String keyLike);
/**
* Only select tasks with the given due date.
*/
T taskDueDate(Date dueDate);
/**
* Only select tasks which have a due date before the given date.
*/
T taskDueBefore(Date dueDate);
/**
* Only select tasks which have a due date after the given date.
*/
T taskDueAfter(Date dueDate);
/*
* Only select subtasks of the given parent task
*/
T taskParentTaskId(String parentTaskId);
/**
* Only select tasks with no due date.
*/
T withoutTaskDueDate();
/**
* Only select tasks which are part of a process instance which has the given process definition key.
*/
T processDefinitionKey(String processDefinitionKey);
/**
* Only select tasks which are part of a process instance which has a process definition key like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*/
T processDefinitionKeyLike(String processDefinitionKeyLike);
/**
* Only select tasks which are part of a process instance which has a process definition key like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*
* This method, unlike the {@link #processDefinitionKeyLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query
* is executed.
*/
T processDefinitionKeyLikeIgnoreCase(String processDefinitionKeyLikeIgnoreCase);
/** Only select tasks that have a process definition for which the key is present in the given list **/
T processDefinitionKeyIn(List processDefinitionKeys);
/**
* Only select tasks which are part of a process instance which has the given process definition id.
*/
T processDefinitionId(String processDefinitionId);
/**
* Only select tasks which are part of a process instance which has the given process definition name.
*/
T processDefinitionName(String processDefinitionName);
/**
* Only select tasks which are part of a process instance which has a process definition name like the given value. The syntax that should be used is the same as in SQL, eg. %activiti%.
*/
T processDefinitionNameLike(String processDefinitionNameLike);
/**
* Only select tasks which are part of a process instance whose definition belongs to the category which is present in the given list.
*
* @throws ActivitiIllegalArgumentException
* When passed category list is empty or null or contains null String.
* @param processCategoryInList
*/
T processCategoryIn(List processCategoryInList);
/**
* Only select tasks which are part of a process instance whose definition does not belong to the category which is present in the given list.
*
* @throws ActivitiIllegalArgumentException
* When passed category list is empty or null or contains null String.
* @param processCategoryNotInList
*/
T processCategoryNotIn(List processCategoryNotInList);
/**
* Only select tasks which are part of a process instance which has the given deployment id.
*/
T deploymentId(String deploymentId);
/**
* Only select tasks which are part of a process instance which has the given deployment id.
*/
T deploymentIdIn(List deploymentIds);
/**
* Only select tasks which have a local task variable with the given name set to the given value.
*/
T taskVariableValueEquals(String variableName, Object variableValue);
/**
* Only select tasks which have at least one local task variable with the given value.
*/
T taskVariableValueEquals(Object variableValue);
/**
* Only select tasks which have a local string variable with the given value, case insensitive.
*
* This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use "collate UTF-8" on MySQL and for MSSQL, select one of the case-sensitive
* Collations available (MSDN Server Collation Reference).
*
*/
T taskVariableValueEqualsIgnoreCase(String name, String value);
/**
* 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 {@link Serializable} objects (which are not primitive
* type wrappers) are not supported.
*/
T taskVariableValueNotEquals(String variableName, Object variableValue);
/**
* Only select tasks which have a local string variable with is not the given value, case insensitive.
*
* This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use "collate UTF-8" on MySQL and for MSSQL, select one of the case-sensitive
* Collations available (MSDN Server Collation Reference).
*
*/
T taskVariableValueNotEqualsIgnoreCase(String name, String value);
/**
* Only select tasks which have a local variable value greater than the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers)
* are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T taskVariableValueGreaterThan(String name, Object value);
/**
* Only select tasks which have a local variable value greater than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type
* wrappers) are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T taskVariableValueGreaterThanOrEqual(String name, Object value);
/**
* Only select tasks which have a local variable value less than the passed value when the ended.Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers) are
* not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T taskVariableValueLessThan(String name, Object value);
/**
* Only select tasks which have a local variable value less than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type
* wrappers) are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T taskVariableValueLessThanOrEqual(String name, Object value);
/**
* Only select tasks which have a local variable value like the given value when they ended. This can be used on string variables only.
*
* @param name
* cannot be null.
* @param value
* cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).
*/
T taskVariableValueLike(String name, String value);
/** Only select tasks which have a local variable value like the given value (case insensitive)
* when they ended. This can be used on string variables only.
* @param name cannot be null.
* @param value cannot be null. The string can include the
* wildcard character '%' to express like-strategy: starts with
* (string%), ends with (%string) or contains (%string%). */
T taskVariableValueLikeIgnoreCase(String name, String value);
/**
* Only select tasks which are part of a process that has a variable with the given name set to the given value.
*/
T processVariableValueEquals(String variableName, Object variableValue);
/**
* Only select tasks which are part of a process that has at least one variable with the given value.
*/
T processVariableValueEquals(Object variableValue);
/**
* Only select tasks which are part of a process that has a local string variable which is not the given value, case insensitive.
*
* This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use "collate UTF-8" on MySQL and for MSSQL, select one of the case-sensitive
* Collations available (MSDN Server Collation Reference).
*
*/
T processVariableValueEqualsIgnoreCase(String name, String value);
/**
* Only select tasks which have a variable with the given name, but with a different value than the passed value. Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers)
* are not supported.
*/
T processVariableValueNotEquals(String variableName, Object variableValue);
/**
* Only select tasks which are part of a process that has a string variable with the given value, case insensitive.
*
* This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use "collate UTF-8" on MySQL and for MSSQL, select one of the case-sensitive
* Collations available (MSDN Server Collation Reference).
*
*/
T processVariableValueNotEqualsIgnoreCase(String name, String value);
/**
* Only select tasks which have a global variable value greater than the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers)
* are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T processVariableValueGreaterThan(String name, Object value);
/**
* Only select tasks which have a global variable value greater than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive
* type wrappers) are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T processVariableValueGreaterThanOrEqual(String name, Object value);
/**
* Only select tasks which have a global variable value less than the passed value when the ended.Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers) are
* not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T processVariableValueLessThan(String name, Object value);
/**
* Only select tasks which have a global variable value less than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type
* wrappers) are not supported.
*
* @param name
* cannot be null.
* @param value
* cannot be null.
*/
T processVariableValueLessThanOrEqual(String name, Object value);
/**
* Only select tasks which have a global variable value like the given value when they ended. This can be used on string variables only.
*
* @param name
* cannot be null.
* @param value
* cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).
*/
T processVariableValueLike(String name, String value);
/** Only select tasks which have a global variable value like the given value (case insensitive)
* when they ended. This can be used on string variables only.
* @param name cannot be null.
* @param value cannot be null. The string can include the
* wildcard character '%' to express like-strategy: starts with
* (string%), ends with (%string) or contains (%string%). */
T processVariableValueLikeIgnoreCase(String name, String value);
/**
* Include local task variables in the task query result
*/
T includeTaskLocalVariables();
/**
* Include global task variables in the task query result
*/
T includeProcessVariables();
/**
* Limit task variables
*/
T limitTaskVariables(Integer taskVariablesLimit);
/**
* Localize task name and description to specified locale.
*/
T locale(String locale);
/**
* Instruct localization to fallback to more general locales including the default locale of the JVM if the specified locale is not found.
*/
T withLocalizationFallback();
/**
* All query clauses called will be added to a single or-statement. This or-statement will be included with the other already existing clauses in the query, joined by an 'and'.
*
* Calling endOr() will add all clauses to the regular query again. Calling or() after endOr() has been called will result in an exception.
*/
T or();
T endOr();
// ORDERING
/**
* Order by task id (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskId();
/**
* Order by task name (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskName();
/**
* Order by description (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskDescription();
/**
* Order by priority (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskPriority();
/**
* Order by assignee (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskAssignee();
/**
* Order by the time on which the tasks were created (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskCreateTime();
/**
* Order by process instance id (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByProcessInstanceId();
/**
* Order by execution id (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByExecutionId();
/**
* Order by process definition id (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByProcessDefinitionId();
/**
* Order by task due date (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskDueDate();
/**
* Order by task owner (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskOwner();
/**
* Order by task definition key (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTaskDefinitionKey();
/**
* Order by tenant id (needs to be followed by {@link #asc()} or {@link #desc()}).
*/
T orderByTenantId();
/**
* Order by due date (needs to be followed by {@link #asc()} or {@link #desc()}). If any of the tasks have null for the due date, these will be first in the result.
*/
T orderByDueDateNullsFirst();
/**
* Order by due date (needs to be followed by {@link #asc()} or {@link #desc()}). If any of the tasks have null for the due date, these will be last in the result.
*/
T orderByDueDateNullsLast();
}