public virtual void testQueryOverrideExpression()
{
string queryString = "query";
string expressionString = "expression";
string testStringExpression = "${'" + expressionString + "'}";
DateTime queryDate = (new DateTime(now())).minusYears(1).toDate();
string testDateExpression = "${now()}";
TaskQueryImpl taskQuery = (TaskQueryImpl)taskQuery().taskAssigneeExpression(testStringExpression).taskAssignee(queryString).taskAssigneeLikeExpression(testStringExpression).taskAssigneeLike(queryString).taskOwnerExpression(expressionString).taskOwner(queryString).taskInvolvedUserExpression(expressionString).taskInvolvedUser(queryString).taskCreatedBeforeExpression(testDateExpression).taskCreatedBefore(queryDate).taskCreatedOnExpression(testDateExpression).taskCreatedOn(queryDate).taskCreatedAfterExpression(testDateExpression).taskCreatedAfter(queryDate).dueBeforeExpression(testDateExpression).dueBefore(queryDate).dueDateExpression(testDateExpression).dueDate(queryDate).dueAfterExpression(testDateExpression).dueAfter(queryDate).followUpBeforeExpression(testDateExpression).followUpBefore(queryDate).followUpDateExpression(testDateExpression).followUpDate(queryDate).followUpAfterExpression(testDateExpression).followUpAfter(queryDate);
// execute query so expression will be evaluated
taskQuery.count();
assertEquals(queryString, taskQuery.Assignee);
assertEquals(queryString, taskQuery.AssigneeLike);
assertEquals(queryString, taskQuery.Owner);
assertEquals(queryString, taskQuery.InvolvedUser);
assertTrue(taskQuery.CreateTimeBefore.Equals(queryDate));
assertTrue(taskQuery.CreateTime.Equals(queryDate));
assertTrue(taskQuery.CreateTimeAfter.Equals(queryDate));
assertTrue(taskQuery.DueBefore.Equals(queryDate));
assertTrue(taskQuery.DueDate.Equals(queryDate));
assertTrue(taskQuery.DueAfter.Equals(queryDate));
assertTrue(taskQuery.FollowUpBefore.Equals(queryDate));
assertTrue(taskQuery.FollowUpDate.Equals(queryDate));
assertTrue(taskQuery.FollowUpAfter.Equals(queryDate));
// candidates has to be tested separately cause they have to be set exclusively
taskQuery = (TaskQueryImpl)taskQuery().taskCandidateGroupExpression(testStringExpression).taskCandidateGroup(queryString);
// execute query so expression will be evaluated
taskQuery.count();
assertEquals(queryString, taskQuery.CandidateGroup);
taskQuery = (TaskQueryImpl)taskQuery().taskCandidateUserExpression(testStringExpression).taskCandidateUser(queryString);
// execute query so expression will be evaluated
taskQuery.count();
assertEquals(queryString, taskQuery.CandidateUser);
CurrentUser = user;
IList <string> queryList = Arrays.asList("query");
string testGroupsExpression = "${currentUserGroups()}";
taskQuery = (TaskQueryImpl)taskQuery().taskCandidateGroupInExpression(testGroupsExpression).taskCandidateGroupIn(queryList);
// execute query so expression will be evaluated
taskQuery.count();
assertEquals(1, taskQuery.CandidateGroups.Count);
}
public virtual void testCreateFilterWithTenantIdCriteria()
{
TaskQuery query = taskService.createTaskQuery().tenantIdIn(TENANT_IDS);
filterId = createFilter(query);
Filter savedFilter = filterService.getFilter(filterId);
TaskQueryImpl savedQuery = savedFilter.Query;
assertThat(savedQuery.TenantIds, @is(TENANT_IDS));
}
protected internal virtual void addVariables(TaskQueryImpl query, JsonArray variables, bool isTaskVariable, bool isProcessVariable)
{
foreach (JsonElement variable in variables)
{
JsonObject variableObj = JsonUtil.getObject(variable);
string name = JsonUtil.getString(variableObj, NAME);
object rawValue = JsonUtil.getRawObject(variableObj, "value");
QueryOperator @operator = Enum.Parse(typeof(QueryOperator), JsonUtil.getString(variableObj, "operator"));
query.addVariable(name, rawValue, @operator, isTaskVariable, isProcessVariable);
}
}
public virtual void testCreateFilterWithNoTenantIdCriteria()
{
TaskQuery query = taskService.createTaskQuery().withoutTenantId();
filterId = createFilter(query);
Filter savedFilter = filterService.getFilter(filterId);
TaskQueryImpl savedQuery = savedFilter.Query;
assertThat(savedQuery.TenantIdSet, @is(true));
assertThat(savedQuery.TenantIds, @is(nullValue()));
}
public virtual void testExtendFilter()
{
TaskQuery extendingQuery = taskService.createTaskQuery().taskName("newName").taskOwner("newOwner");
Filter newFilter = filter.extend(extendingQuery);
assertNull(newFilter.Id);
TaskQueryImpl filterQuery = newFilter.Query;
assertEquals("newName", filterQuery.Name);
assertEquals("newOwner", filterQuery.Owner);
}
// task query //////////////////////////////////////////////
public virtual void configureTaskQuery(TaskQueryImpl query)
{
configureQuery(query);
if (query.AuthCheck.AuthorizationCheckEnabled)
{
// necessary authorization check when the task is part of
// a running process instance
CompositePermissionCheck permissionCheck = (new PermissionCheckBuilder()).disjunctive().atomicCheck(TASK, "RES.ID_", READ).atomicCheck(PROCESS_DEFINITION, "PROCDEF.KEY_", READ_TASK).build();
addPermissionCheck(query.AuthCheck, permissionCheck);
}
}
/// <summary>
///
/// </summary>
public virtual IPage <TaskModel> GetAllTasks(TaskQuery taskQuery)
{
TaskQueryImpl query = taskService.CreateTaskQuery() as TaskQueryImpl;
FastCopy.Copy <TaskQuery, TaskQueryImpl>(taskQuery, query);
sortApplier.ApplySort(query, taskQuery.Pageable);
return(pageRetriever.LoadPage(taskService as ServiceImpl, query, taskQuery.Pageable, taskConverter, (q, firstResult, pageSize) =>
{
return new GetProcessInstanceTasksCmd(q, firstResult, pageSize);
}));
}
/// <summary>
/// 读取分页记录
/// </summary>
/// <param name="taskService">任务仓储服务</param>
/// <param name="pageableRepositoryService">分页仓储服务</param>
/// <param name="qo">查询对象</param>
/// <returns></returns>
public IPage <TaskModel> LoadPage(ITaskService taskService,
PageableTaskRepositoryService pageableRepositoryService,
TaskQuery qo)
{
TaskQueryImpl query = taskService.CreateTaskQuery() as TaskQueryImpl;
FastCopy.Copy <TaskQuery, TaskQueryImpl>(qo, query);
pageableRepositoryService.SortApplier.ApplySort(query, qo.Pageable);
IPage <TaskModel> defs = pageableRepositoryService.PageRetriever.LoadPage(query, qo.Pageable, pageableRepositoryService.TaskConverter);
return(defs);
}
public virtual IList <ITask> FindTasksAndVariablesByQueryCriteria(ITaskQuery taskQuery)
{
const string query = "selectTaskWithVariablesByQueryCriteria";
TaskQueryImpl taskQueyImpl = taskQuery as TaskQueryImpl;
// paging doesn't work for combining task instances and variables due to
// an outer join, so doing it in-memory
if (taskQueyImpl.FirstResult < 0 || taskQueyImpl.MaxResults <= 0)
{
return(new List <ITask>());
}
int firstResult = taskQueyImpl.FirstResult;
int maxResults = taskQueyImpl.MaxResults;
// setting max results, limit to 20000 results for performance reasons
if (taskQueyImpl.TaskVariablesLimit != null)
{
taskQueyImpl.MaxResults = taskQueyImpl.TaskVariablesLimit.GetValueOrDefault();
}
else
{
taskQueyImpl.MaxResults = ProcessEngineConfiguration.TaskQueryLimit;
}
taskQueyImpl.FirstResult = 0;
IList <ITask> instanceList = DbSqlSession.SelectListWithRawParameterWithoutFilter <TaskEntityImpl, ITask>(query, taskQueyImpl, taskQueyImpl.FirstResult, taskQueyImpl.MaxResults);
if (instanceList != null && instanceList.Count > 0)
{
if (firstResult > 0)
{
if (firstResult <= instanceList.Count)
{
int toIndex = firstResult + Math.Min(maxResults, instanceList.Count - firstResult);
return(instanceList.Skip(firstResult).Take(toIndex).ToList());
}
else
{
return(new List <ITask>());
}
}
else
{
int toIndex = Math.Min(maxResults, instanceList.Count);
return(instanceList.Skip(0).Take(toIndex).ToList());
}
}
return(new List <ITask>());
}
protected internal virtual void addTenantIdFields(JsonObject jsonObject, TaskQueryImpl query)
{
if (query.TenantIdSet)
{
if (query.TenantIds != null)
{
JsonUtil.addArrayField(jsonObject, TENANT_IDS, query.TenantIds);
}
else
{
JsonUtil.addField(jsonObject, WITHOUT_TENANT_ID, true);
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnTasksByExtendingQuery_OrInExtendedQuery()
public virtual void shouldReturnTasksByExtendingQuery_OrInExtendedQuery()
{
// given
TaskQuery extendedQuery = taskService.createTaskQuery().or().taskName("aTaskName").endOr().or().taskNameLike("anotherTaskName").endOr();
TaskQuery extendingQuery = taskService.createTaskQuery().taskCandidateGroup("aCandidateGroup");
// when
TaskQueryImpl result = (TaskQueryImpl)((TaskQueryImpl)extendedQuery).extend(extendingQuery);
// then
assertEquals("aTaskName", result.Queries[1].Name);
assertEquals("anotherTaskName", result.Queries[2].NameLike);
assertEquals("aCandidateGroup", result.CandidateGroup);
}
public Void execute(CommandContext commandContext)
{
AuthorizationManager authorizationManager = outerInstance.spyOnSession(commandContext, typeof(AuthorizationManager));
TaskQueryImpl taskQuery = (TaskQueryImpl)spy(outerInstance.processEngine.TaskService.createTaskQuery());
AuthorizationCheck authCheck = spy(new AuthorizationCheck());
when(taskQuery.AuthCheck).thenReturn(authCheck);
taskQuery.list();
verify(authorizationManager, atLeastOnce()).filterAuthenticatedGroupIds(eq(testGroupIds));
verify(authCheck, atLeastOnce()).AuthGroupIds = (IList <string>)argThat(containsInAnyOrder(testGroupIds.ToArray()));
return(null);
}
public Void execute(CommandContext commandContext)
{
AuthorizationManager authorizationManager = outerInstance.spyOnSession(commandContext, typeof(AuthorizationManager));
TaskQueryImpl taskQuery = (TaskQueryImpl)spy(outerInstance.processEngine.TaskService.createTaskQuery());
AuthorizationCheck authCheck = spy(new AuthorizationCheck());
when(taskQuery.AuthCheck).thenReturn(authCheck);
taskQuery.list();
verify(authorizationManager, atLeastOnce()).filterAuthenticatedGroupIds(eq(testGroupIds));
verify(authCheck).AuthGroupIds = eq(System.Linq.Enumerable.Empty <string>());
return(null);
}
protected internal virtual void configureQuery(TaskQueryImpl query)
{
AuthorizationManager.configureTaskQuery(query);
TenantManager.configureQuery(query);
}
public virtual void testTaskFilter()
{
string testString = "test";
int? testInteger = 1;
DelegationState testDelegationState = DelegationState.PENDING;
DateTime testDate = new DateTime();
string[] testActivityInstances = new string[] { "a", "b", "c" };
string[] testKeys = new string[] { "d", "e" };
IList <string> testCandidateGroups = new List <string>();
testCandidateGroups.Add("group");
testCandidateGroups.Add("anotherGroup");
string[] variableNames = new string[] { "a", "b", "c", "d", "e", "f" };
object[] variableValues = new object[] { 1, 2, "3", "4", 5, 6 };
QueryOperator[] variableOperators = new QueryOperator[] { QueryOperator.EQUALS, QueryOperator.GREATER_THAN_OR_EQUAL, QueryOperator.LESS_THAN, QueryOperator.LIKE, QueryOperator.NOT_EQUALS, QueryOperator.LESS_THAN_OR_EQUAL };
bool[] isTaskVariable = new bool[] { true, true, false, false, false, false };
bool[] isProcessVariable = new bool[] { false, false, true, true, false, false };
TaskQueryImpl expectedOrderingPropertiesQuery = new TaskQueryImpl();
expectedOrderingPropertiesQuery.orderByExecutionId().desc();
expectedOrderingPropertiesQuery.orderByDueDate().asc();
expectedOrderingPropertiesQuery.orderByProcessVariable("var", ValueType.STRING).desc();
IList <QueryOrderingProperty> expectedOrderingProperties = expectedOrderingPropertiesQuery.OrderingProperties;
Filter filter = engineRule.FilterService.createTaskFilterQuery().filterName("filter").singleResult();
TaskQueryImpl query = filter.Query;
assertEquals(testString, query.TaskId);
assertEquals(testString, query.Name);
assertEquals(testString, query.NameNotEqual);
assertEquals(testString, query.NameNotLike);
assertEquals(testString, query.NameLike);
assertEquals(testString, query.Description);
assertEquals(testString, query.DescriptionLike);
assertEquals(testInteger, query.Priority);
assertEquals(testInteger, query.MinPriority);
assertEquals(testInteger, query.MaxPriority);
assertEquals(testString, query.Assignee);
assertEquals(testString, query.Expressions["taskAssignee"]);
assertEquals(testString, query.AssigneeLike);
assertEquals(testString, query.Expressions["taskAssigneeLike"]);
assertEquals(testString, query.InvolvedUser);
assertEquals(testString, query.Expressions["taskInvolvedUser"]);
assertEquals(testString, query.Owner);
assertEquals(testString, query.Expressions["taskOwner"]);
assertTrue(query.Unassigned);
assertTrue(query.Assigned);
assertEquals(testDelegationState, query.DelegationState);
assertEquals(testCandidateGroups, query.CandidateGroups);
assertTrue(query.WithCandidateGroups);
assertTrue(query.WithoutCandidateGroups);
assertTrue(query.WithCandidateUsers);
assertTrue(query.WithoutCandidateUsers);
assertEquals(testString, query.Expressions["taskCandidateGroupIn"]);
assertEquals(testString, query.ProcessInstanceId);
assertEquals(testString, query.ExecutionId);
assertEquals(testActivityInstances.Length, query.ActivityInstanceIdIn.Length);
for (int i = 0; i < query.ActivityInstanceIdIn.Length; i++)
{
assertEquals(testActivityInstances[i], query.ActivityInstanceIdIn[i]);
}
assertEquals(testDate, query.CreateTime);
assertEquals(testString, query.Expressions["taskCreatedOn"]);
assertEquals(testDate, query.CreateTimeBefore);
assertEquals(testString, query.Expressions["taskCreatedBefore"]);
assertEquals(testDate, query.CreateTimeAfter);
assertEquals(testString, query.Expressions["taskCreatedAfter"]);
assertEquals(testString, query.Key);
assertEquals(testKeys.Length, query.Keys.Length);
for (int i = 0; i < query.Keys.Length; i++)
{
assertEquals(testKeys[i], query.Keys[i]);
}
assertEquals(testString, query.KeyLike);
assertEquals(testString, query.ProcessDefinitionKey);
for (int i = 0; i < query.ProcessDefinitionKeys.Length; i++)
{
assertEquals(testKeys[i], query.ProcessDefinitionKeys[i]);
}
assertEquals(testString, query.ProcessDefinitionId);
assertEquals(testString, query.ProcessDefinitionName);
assertEquals(testString, query.ProcessDefinitionNameLike);
assertEquals(testString, query.ProcessInstanceBusinessKey);
assertEquals(testString, query.Expressions["processInstanceBusinessKey"]);
for (int i = 0; i < query.ProcessInstanceBusinessKeys.Length; i++)
{
assertEquals(testKeys[i], query.ProcessInstanceBusinessKeys[i]);
}
assertEquals(testString, query.ProcessInstanceBusinessKeyLike);
assertEquals(testString, query.Expressions["processInstanceBusinessKeyLike"]);
// variables
IList <TaskQueryVariableValue> variables = query.Variables;
for (int i = 0; i < variables.Count; i++)
{
TaskQueryVariableValue variable = variables[i];
assertEquals(variableNames[i], variable.Name);
assertEquals(variableValues[i], variable.Value);
assertEquals(variableOperators[i], variable.Operator);
assertEquals(isTaskVariable[i], variable.Local);
assertEquals(isProcessVariable[i], variable.ProcessInstanceVariable);
}
assertEquals(testDate, query.DueDate);
assertEquals(testString, query.Expressions["dueDate"]);
assertEquals(testDate, query.DueBefore);
assertEquals(testString, query.Expressions["dueBefore"]);
assertEquals(testDate, query.DueAfter);
assertEquals(testString, query.Expressions["dueAfter"]);
assertEquals(testDate, query.FollowUpDate);
assertEquals(testString, query.Expressions["followUpDate"]);
assertEquals(testDate, query.FollowUpBefore);
assertEquals(testString, query.Expressions["followUpBefore"]);
assertEquals(testDate, query.FollowUpAfter);
assertEquals(testString, query.Expressions["followUpAfter"]);
assertTrue(query.ExcludeSubtasks);
assertEquals(org.camunda.bpm.engine.impl.persistence.entity.SuspensionState_Fields.SUSPENDED, query.SuspensionState);
assertEquals(testString, query.CaseDefinitionKey);
assertEquals(testString, query.CaseDefinitionId);
assertEquals(testString, query.CaseDefinitionName);
assertEquals(testString, query.CaseDefinitionNameLike);
assertEquals(testString, query.CaseInstanceId);
assertEquals(testString, query.CaseInstanceBusinessKey);
assertEquals(testString, query.CaseInstanceBusinessKeyLike);
assertEquals(testString, query.CaseExecutionId);
// ordering
verifyOrderingProperties(expectedOrderingProperties, query.OrderingProperties);
}
public void execute(ProcessEngine engine, string scenarioName)
{
string testString = "test";
int? testInteger = 1;
DelegationState testDelegationState = DelegationState.PENDING;
DateTime testDate = new DateTime();
string[] testActivityInstances = new string[] { "a", "b", "c" };
string[] testKeys = new string[] { "d", "e" };
IList <string> testCandidateGroups = new List <string>();
string[] variableNames = new string[] { "a", "b", "c", "d", "e", "f" };
object[] variableValues = new object[] { 1, 2, "3", "4", 5, 6 };
testCandidateGroups.Add("group");
testCandidateGroups.Add("anotherGroup");
TaskQueryImpl query = new TaskQueryImpl();
query.taskId(testString);
query.taskName(testString);
query.taskNameNotEqual(testString);
query.taskNameLike(testString);
query.taskNameNotLike(testString);
query.taskDescription(testString);
query.taskDescriptionLike(testString);
query.taskPriority(testInteger);
query.taskMinPriority(testInteger);
query.taskMaxPriority(testInteger);
query.taskAssignee(testString);
query.taskAssigneeExpression(testString);
query.taskAssigneeLike(testString);
query.taskAssigneeLikeExpression(testString);
query.taskInvolvedUser(testString);
query.taskInvolvedUserExpression(testString);
query.taskOwner(testString);
query.taskOwnerExpression(testString);
query.taskUnassigned();
query.taskAssigned();
query.taskDelegationState(testDelegationState);
query.taskCandidateGroupIn(testCandidateGroups);
query.taskCandidateGroupInExpression(testString);
query.withCandidateGroups();
query.withoutCandidateGroups();
query.withCandidateUsers();
query.withoutCandidateUsers();
query.processInstanceId(testString);
query.executionId(testString);
query.activityInstanceIdIn(testActivityInstances);
query.taskCreatedOn(testDate);
query.taskCreatedOnExpression(testString);
query.taskCreatedBefore(testDate);
query.taskCreatedBeforeExpression(testString);
query.taskCreatedAfter(testDate);
query.taskCreatedAfterExpression(testString);
query.taskDefinitionKey(testString);
query.taskDefinitionKeyIn(testKeys);
query.taskDefinitionKeyLike(testString);
query.processDefinitionKey(testString);
query.processDefinitionKeyIn(testKeys);
query.processDefinitionId(testString);
query.processDefinitionName(testString);
query.processDefinitionNameLike(testString);
query.processInstanceBusinessKey(testString);
query.processInstanceBusinessKeyExpression(testString);
query.processInstanceBusinessKeyIn(testKeys);
query.processInstanceBusinessKeyLike(testString);
query.processInstanceBusinessKeyLikeExpression(testString);
// variables
query.taskVariableValueEquals(variableNames[0], variableValues[0]);
query.taskVariableValueGreaterThanOrEquals(variableNames[1], variableValues[1]);
query.processVariableValueLessThan(variableNames[2], variableValues[2]);
query.processVariableValueLike(variableNames[3], (string)variableValues[3]);
query.caseInstanceVariableValueNotEquals(variableNames[4], variableValues[4]);
query.caseInstanceVariableValueLessThanOrEquals(variableNames[5], variableValues[5]);
query.dueDate(testDate);
query.dueDateExpression(testString);
query.dueBefore(testDate);
query.dueBeforeExpression(testString);
query.dueAfter(testDate);
query.dueAfterExpression(testString);
query.followUpDate(testDate);
query.followUpDateExpression(testString);
query.followUpBefore(testDate);
query.followUpBeforeExpression(testString);
query.followUpAfter(testDate);
query.followUpAfterExpression(testString);
query.excludeSubtasks();
query.suspended();
query.caseDefinitionKey(testString);
query.caseDefinitionId(testString);
query.caseDefinitionName(testString);
query.caseDefinitionNameLike(testString);
query.caseInstanceId(testString);
query.caseInstanceBusinessKey(testString);
query.caseInstanceBusinessKeyLike(testString);
query.caseExecutionId(testString);
query.orderByExecutionId().desc();
query.orderByDueDate().asc();
query.orderByProcessVariable("var", ValueType.STRING).desc();
// save filter
Filter filter = engine.FilterService.newTaskFilter("filter");
filter.Query = query;
engine.FilterService.saveFilter(filter);
}
public override TaskQuery toObject(JsonObject json)
{
TaskQueryImpl query = new TaskQueryImpl();
if (json.has(OR_QUERIES))
{
foreach (JsonElement jsonElement in JsonUtil.getArray(json, OR_QUERIES))
{
query.addOrQuery((TaskQueryImpl)toObject(JsonUtil.getObject(jsonElement)));
}
}
if (json.has(TASK_ID))
{
query.taskId(JsonUtil.getString(json, TASK_ID));
}
if (json.has(NAME))
{
query.taskName(JsonUtil.getString(json, NAME));
}
if (json.has(NAME_NOT_EQUAL))
{
query.taskNameNotEqual(JsonUtil.getString(json, NAME_NOT_EQUAL));
}
if (json.has(NAME_LIKE))
{
query.taskNameLike(JsonUtil.getString(json, NAME_LIKE));
}
if (json.has(NAME_NOT_LIKE))
{
query.taskNameNotLike(JsonUtil.getString(json, NAME_NOT_LIKE));
}
if (json.has(DESCRIPTION))
{
query.taskDescription(JsonUtil.getString(json, DESCRIPTION));
}
if (json.has(DESCRIPTION_LIKE))
{
query.taskDescriptionLike(JsonUtil.getString(json, DESCRIPTION_LIKE));
}
if (json.has(PRIORITY))
{
query.taskPriority(JsonUtil.getInt(json, PRIORITY));
}
if (json.has(MIN_PRIORITY))
{
query.taskMinPriority(JsonUtil.getInt(json, MIN_PRIORITY));
}
if (json.has(MAX_PRIORITY))
{
query.taskMaxPriority(JsonUtil.getInt(json, MAX_PRIORITY));
}
if (json.has(ASSIGNEE))
{
query.taskAssignee(JsonUtil.getString(json, ASSIGNEE));
}
if (json.has(ASSIGNEE_LIKE))
{
query.taskAssigneeLike(JsonUtil.getString(json, ASSIGNEE_LIKE));
}
if (json.has(INVOLVED_USER))
{
query.taskInvolvedUser(JsonUtil.getString(json, INVOLVED_USER));
}
if (json.has(OWNER))
{
query.taskOwner(JsonUtil.getString(json, OWNER));
}
if (json.has(ASSIGNED) && JsonUtil.getBoolean(json, ASSIGNED))
{
query.taskAssigned();
}
if (json.has(UNASSIGNED) && JsonUtil.getBoolean(json, UNASSIGNED))
{
query.taskUnassigned();
}
if (json.has(DELEGATION_STATE))
{
query.taskDelegationState(Enum.Parse(typeof(DelegationState), JsonUtil.getString(json, DELEGATION_STATE)));
}
if (json.has(CANDIDATE_USER))
{
query.taskCandidateUser(JsonUtil.getString(json, CANDIDATE_USER));
}
if (json.has(CANDIDATE_GROUP))
{
query.taskCandidateGroup(JsonUtil.getString(json, CANDIDATE_GROUP));
}
if (json.has(CANDIDATE_GROUPS) && !json.has(CANDIDATE_USER) && !json.has(CANDIDATE_GROUP))
{
query.taskCandidateGroupIn(getList(JsonUtil.getArray(json, CANDIDATE_GROUPS)));
}
if (json.has(WITH_CANDIDATE_GROUPS) && JsonUtil.getBoolean(json, WITH_CANDIDATE_GROUPS))
{
query.withCandidateGroups();
}
if (json.has(WITHOUT_CANDIDATE_GROUPS) && JsonUtil.getBoolean(json, WITHOUT_CANDIDATE_GROUPS))
{
query.withoutCandidateGroups();
}
if (json.has(WITH_CANDIDATE_USERS) && JsonUtil.getBoolean(json, WITH_CANDIDATE_USERS))
{
query.withCandidateUsers();
}
if (json.has(WITHOUT_CANDIDATE_USERS) && JsonUtil.getBoolean(json, WITHOUT_CANDIDATE_USERS))
{
query.withoutCandidateUsers();
}
if (json.has(INCLUDE_ASSIGNED_TASKS) && JsonUtil.getBoolean(json, INCLUDE_ASSIGNED_TASKS))
{
query.includeAssignedTasksInternal();
}
if (json.has(PROCESS_INSTANCE_ID))
{
query.processInstanceId(JsonUtil.getString(json, PROCESS_INSTANCE_ID));
}
if (json.has(EXECUTION_ID))
{
query.executionId(JsonUtil.getString(json, EXECUTION_ID));
}
if (json.has(ACTIVITY_INSTANCE_ID_IN))
{
query.activityInstanceIdIn(getArray(JsonUtil.getArray(json, ACTIVITY_INSTANCE_ID_IN)));
}
if (json.has(CREATED))
{
query.taskCreatedOn(new DateTime(JsonUtil.getLong(json, CREATED)));
}
if (json.has(CREATED_BEFORE))
{
query.taskCreatedBefore(new DateTime(JsonUtil.getLong(json, CREATED_BEFORE)));
}
if (json.has(CREATED_AFTER))
{
query.taskCreatedAfter(new DateTime(JsonUtil.getLong(json, CREATED_AFTER)));
}
if (json.has(KEY))
{
query.taskDefinitionKey(JsonUtil.getString(json, KEY));
}
if (json.has(KEYS))
{
query.taskDefinitionKeyIn(getArray(JsonUtil.getArray(json, KEYS)));
}
if (json.has(KEY_LIKE))
{
query.taskDefinitionKeyLike(JsonUtil.getString(json, KEY_LIKE));
}
if (json.has(PARENT_TASK_ID))
{
query.taskParentTaskId(JsonUtil.getString(json, PARENT_TASK_ID));
}
if (json.has(PROCESS_DEFINITION_KEY))
{
query.processDefinitionKey(JsonUtil.getString(json, PROCESS_DEFINITION_KEY));
}
if (json.has(PROCESS_DEFINITION_KEYS))
{
query.processDefinitionKeyIn(getArray(JsonUtil.getArray(json, PROCESS_DEFINITION_KEYS)));
}
if (json.has(PROCESS_DEFINITION_ID))
{
query.processDefinitionId(JsonUtil.getString(json, PROCESS_DEFINITION_ID));
}
if (json.has(PROCESS_DEFINITION_NAME))
{
query.processDefinitionName(JsonUtil.getString(json, PROCESS_DEFINITION_NAME));
}
if (json.has(PROCESS_DEFINITION_NAME_LIKE))
{
query.processDefinitionNameLike(JsonUtil.getString(json, PROCESS_DEFINITION_NAME_LIKE));
}
if (json.has(PROCESS_INSTANCE_BUSINESS_KEY))
{
query.processInstanceBusinessKey(JsonUtil.getString(json, PROCESS_INSTANCE_BUSINESS_KEY));
}
if (json.has(PROCESS_INSTANCE_BUSINESS_KEYS))
{
query.processInstanceBusinessKeyIn(getArray(JsonUtil.getArray(json, PROCESS_INSTANCE_BUSINESS_KEYS)));
}
if (json.has(PROCESS_INSTANCE_BUSINESS_KEY_LIKE))
{
query.processInstanceBusinessKeyLike(JsonUtil.getString(json, PROCESS_INSTANCE_BUSINESS_KEY_LIKE));
}
if (json.has(TASK_VARIABLES))
{
addVariables(query, JsonUtil.getArray(json, TASK_VARIABLES), true, false);
}
if (json.has(PROCESS_VARIABLES))
{
addVariables(query, JsonUtil.getArray(json, PROCESS_VARIABLES), false, true);
}
if (json.has(CASE_INSTANCE_VARIABLES))
{
addVariables(query, JsonUtil.getArray(json, CASE_INSTANCE_VARIABLES), false, false);
}
if (json.has(DUE))
{
query.dueDate(new DateTime(JsonUtil.getLong(json, DUE)));
}
if (json.has(DUE_BEFORE))
{
query.dueBefore(new DateTime(JsonUtil.getLong(json, DUE_BEFORE)));
}
if (json.has(DUE_AFTER))
{
query.dueAfter(new DateTime(JsonUtil.getLong(json, DUE_AFTER)));
}
if (json.has(FOLLOW_UP))
{
query.followUpDate(new DateTime(JsonUtil.getLong(json, FOLLOW_UP)));
}
if (json.has(FOLLOW_UP_BEFORE))
{
query.followUpBefore(new DateTime(JsonUtil.getLong(json, FOLLOW_UP_BEFORE)));
}
if (json.has(FOLLOW_UP_AFTER))
{
query.followUpAfter(new DateTime(JsonUtil.getLong(json, FOLLOW_UP_AFTER)));
}
if (json.has(FOLLOW_UP_NULL_ACCEPTED))
{
query.FollowUpNullAccepted = JsonUtil.getBoolean(json, FOLLOW_UP_NULL_ACCEPTED);
}
if (json.has(EXCLUDE_SUBTASKS) && JsonUtil.getBoolean(json, EXCLUDE_SUBTASKS))
{
query.excludeSubtasks();
}
if (json.has(SUSPENDED) && JsonUtil.getBoolean(json, SUSPENDED))
{
query.suspended();
}
if (json.has(ACTIVE) && JsonUtil.getBoolean(json, ACTIVE))
{
query.active();
}
if (json.has(CASE_DEFINITION_KEY))
{
query.caseDefinitionKey(JsonUtil.getString(json, CASE_DEFINITION_KEY));
}
if (json.has(CASE_DEFINITION_ID))
{
query.caseDefinitionId(JsonUtil.getString(json, CASE_DEFINITION_ID));
}
if (json.has(CASE_DEFINITION_NAME))
{
query.caseDefinitionName(JsonUtil.getString(json, CASE_DEFINITION_NAME));
}
if (json.has(CASE_DEFINITION_NAME_LIKE))
{
query.caseDefinitionNameLike(JsonUtil.getString(json, CASE_DEFINITION_NAME_LIKE));
}
if (json.has(CASE_INSTANCE_ID))
{
query.caseInstanceId(JsonUtil.getString(json, CASE_INSTANCE_ID));
}
if (json.has(CASE_INSTANCE_BUSINESS_KEY))
{
query.caseInstanceBusinessKey(JsonUtil.getString(json, CASE_INSTANCE_BUSINESS_KEY));
}
if (json.has(CASE_INSTANCE_BUSINESS_KEY_LIKE))
{
query.caseInstanceBusinessKeyLike(JsonUtil.getString(json, CASE_INSTANCE_BUSINESS_KEY_LIKE));
}
if (json.has(CASE_EXECUTION_ID))
{
query.caseExecutionId(JsonUtil.getString(json, CASE_EXECUTION_ID));
}
if (json.has(TENANT_IDS))
{
query.tenantIdIn(getArray(JsonUtil.getArray(json, TENANT_IDS)));
}
if (json.has(WITHOUT_TENANT_ID))
{
query.withoutTenantId();
}
if (json.has(ORDER_BY))
{
IList <QueryOrderingProperty> orderingProperties = JsonLegacyQueryOrderingPropertyConverter.INSTANCE.fromOrderByString(JsonUtil.getString(json, ORDER_BY));
query.OrderingProperties = orderingProperties;
}
if (json.has(ORDERING_PROPERTIES))
{
JsonArray jsonArray = JsonUtil.getArray(json, ORDERING_PROPERTIES);
query.OrderingProperties = JsonQueryOrderingPropertyConverter.ARRAY_CONVERTER.toObject(jsonArray);
}
// expressions
foreach (KeyValuePair <string, JsonElement> entry in json.entrySet())
{
string key = entry.Key;
if (key.EndsWith("Expression", StringComparison.Ordinal))
{
string expression = JsonUtil.getString(json, key);
query.addExpression(key.Substring(0, key.Length - "Expression".Length), expression);
}
}
return(query);
}
public virtual JsonObject toJsonObject(TaskQuery taskQuery, bool isOrQueryActive)
{
JsonObject json = JsonUtil.createObject();
TaskQueryImpl query = (TaskQueryImpl)taskQuery;
JsonUtil.addField(json, TASK_ID, query.TaskId);
JsonUtil.addField(json, NAME, query.Name);
JsonUtil.addField(json, NAME_NOT_EQUAL, query.NameNotEqual);
JsonUtil.addField(json, NAME_LIKE, query.NameLike);
JsonUtil.addField(json, NAME_NOT_LIKE, query.NameNotLike);
JsonUtil.addField(json, DESCRIPTION, query.Description);
JsonUtil.addField(json, DESCRIPTION_LIKE, query.DescriptionLike);
JsonUtil.addField(json, PRIORITY, query.Priority);
JsonUtil.addField(json, MIN_PRIORITY, query.MinPriority);
JsonUtil.addField(json, MAX_PRIORITY, query.MaxPriority);
JsonUtil.addField(json, ASSIGNEE, query.Assignee);
JsonUtil.addField(json, ASSIGNEE_LIKE, query.AssigneeLike);
JsonUtil.addField(json, INVOLVED_USER, query.InvolvedUser);
JsonUtil.addField(json, OWNER, query.Owner);
JsonUtil.addDefaultField(json, UNASSIGNED, false, query.Unassigned);
JsonUtil.addDefaultField(json, ASSIGNED, false, query.Assigned);
JsonUtil.addField(json, DELEGATION_STATE, query.DelegationStateString);
JsonUtil.addField(json, CANDIDATE_USER, query.CandidateUser);
JsonUtil.addField(json, CANDIDATE_GROUP, query.CandidateGroup);
JsonUtil.addListField(json, CANDIDATE_GROUPS, query.CandidateGroupsInternal);
JsonUtil.addDefaultField(json, WITH_CANDIDATE_GROUPS, false, query.WithCandidateGroups);
JsonUtil.addDefaultField(json, WITHOUT_CANDIDATE_GROUPS, false, query.WithoutCandidateGroups);
JsonUtil.addDefaultField(json, WITH_CANDIDATE_USERS, false, query.WithCandidateUsers);
JsonUtil.addDefaultField(json, WITHOUT_CANDIDATE_USERS, false, query.WithoutCandidateUsers);
JsonUtil.addField(json, INCLUDE_ASSIGNED_TASKS, query.IncludeAssignedTasksInternal);
JsonUtil.addField(json, PROCESS_INSTANCE_ID, query.ProcessInstanceId);
JsonUtil.addField(json, EXECUTION_ID, query.ExecutionId);
JsonUtil.addArrayField(json, ACTIVITY_INSTANCE_ID_IN, query.ActivityInstanceIdIn);
JsonUtil.addDateField(json, CREATED, query.CreateTime);
JsonUtil.addDateField(json, CREATED_BEFORE, query.CreateTimeBefore);
JsonUtil.addDateField(json, CREATED_AFTER, query.CreateTimeAfter);
JsonUtil.addField(json, KEY, query.Key);
JsonUtil.addArrayField(json, KEYS, query.Keys);
JsonUtil.addField(json, KEY_LIKE, query.KeyLike);
JsonUtil.addField(json, PARENT_TASK_ID, query.ParentTaskId);
JsonUtil.addField(json, PROCESS_DEFINITION_KEY, query.ProcessDefinitionKey);
JsonUtil.addArrayField(json, PROCESS_DEFINITION_KEYS, query.ProcessDefinitionKeys);
JsonUtil.addField(json, PROCESS_DEFINITION_ID, query.ProcessDefinitionId);
JsonUtil.addField(json, PROCESS_DEFINITION_NAME, query.ProcessDefinitionName);
JsonUtil.addField(json, PROCESS_DEFINITION_NAME_LIKE, query.ProcessDefinitionNameLike);
JsonUtil.addField(json, PROCESS_INSTANCE_BUSINESS_KEY, query.ProcessInstanceBusinessKey);
JsonUtil.addArrayField(json, PROCESS_INSTANCE_BUSINESS_KEYS, query.ProcessInstanceBusinessKeys);
JsonUtil.addField(json, PROCESS_INSTANCE_BUSINESS_KEY_LIKE, query.ProcessInstanceBusinessKeyLike);
addVariablesFields(json, query.Variables);
JsonUtil.addDateField(json, DUE, query.DueDate);
JsonUtil.addDateField(json, DUE_BEFORE, query.DueBefore);
JsonUtil.addDateField(json, DUE_AFTER, query.DueAfter);
JsonUtil.addDateField(json, FOLLOW_UP, query.FollowUpDate);
JsonUtil.addDateField(json, FOLLOW_UP_BEFORE, query.FollowUpBefore);
JsonUtil.addDefaultField(json, FOLLOW_UP_NULL_ACCEPTED, false, query.FollowUpNullAccepted);
JsonUtil.addDateField(json, FOLLOW_UP_AFTER, query.FollowUpAfter);
JsonUtil.addDefaultField(json, EXCLUDE_SUBTASKS, false, query.ExcludeSubtasks);
addSuspensionStateField(json, query.SuspensionState);
JsonUtil.addField(json, CASE_DEFINITION_KEY, query.CaseDefinitionKey);
JsonUtil.addField(json, CASE_DEFINITION_ID, query.CaseDefinitionId);
JsonUtil.addField(json, CASE_DEFINITION_NAME, query.CaseDefinitionName);
JsonUtil.addField(json, CASE_DEFINITION_NAME_LIKE, query.CaseDefinitionNameLike);
JsonUtil.addField(json, CASE_INSTANCE_ID, query.CaseInstanceId);
JsonUtil.addField(json, CASE_INSTANCE_BUSINESS_KEY, query.CaseInstanceBusinessKey);
JsonUtil.addField(json, CASE_INSTANCE_BUSINESS_KEY_LIKE, query.CaseInstanceBusinessKeyLike);
JsonUtil.addField(json, CASE_EXECUTION_ID, query.CaseExecutionId);
addTenantIdFields(json, query);
if (query.Queries.Count > 1 && !isOrQueryActive)
{
JsonArray orQueries = JsonUtil.createArray();
foreach (TaskQueryImpl orQuery in query.Queries)
{
if (orQuery != null && orQuery.OrQueryActive)
{
orQueries.add(toJsonObject(orQuery, true));
}
}
JsonUtil.addField(json, OR_QUERIES, orQueries);
}
if (query.OrderingProperties != null && !query.OrderingProperties.Empty)
{
JsonUtil.addField(json, ORDERING_PROPERTIES, JsonQueryOrderingPropertyConverter.ARRAY_CONVERTER.toJsonArray(query.OrderingProperties));
}
// expressions
foreach (KeyValuePair <string, string> expressionEntry in query.Expressions.SetOfKeyValuePairs())
{
JsonUtil.addField(json, expressionEntry.Key + "Expression", expressionEntry.Value);
}
return(json);
}
public virtual IList <Task> findTasksByQueryCriteria(TaskQueryImpl taskQuery, Page page)
{
taskQuery.FirstResult = page.FirstResult;
taskQuery.MaxResults = page.MaxResults;
return(findTasksByQueryCriteria(taskQuery));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public java.util.List<org.camunda.bpm.engine.task.Task> findTasksByQueryCriteria(org.camunda.bpm.engine.impl.TaskQueryImpl taskQuery)
public virtual IList <Task> findTasksByQueryCriteria(TaskQueryImpl taskQuery)
{
configureQuery(taskQuery);
return(DbEntityManager.selectList("selectTaskByQueryCriteria", taskQuery));
}
public virtual long findTaskCountByQueryCriteria(TaskQueryImpl taskQuery)
{
configureQuery(taskQuery);
return((long?)DbEntityManager.selectOne("selectTaskCountByQueryCriteria", taskQuery).Value);
}
