Java Filter.setQuery方法代码示例

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendStoredFilterByExpression() {

    // given a stored filter
    TaskQuery taskQuery = taskService.createTaskQuery().dueAfterExpression("${now()}");
    Filter filter = filterService.newTaskFilter("filter");
    filter.setQuery(taskQuery);
    filterService.saveFilter(filter);

    // it is possible to execute the stored query with an expression
    assertEquals(new Long(0), filterService.count(filter.getId()));
    assertEquals(0, filterService.list(filter.getId()).size());

    // but it is not possible to executed the filter with an extended query that uses expressions
    extendFilterAndValidateFailingQuery(filter, taskService.createTaskQuery().dueAfterExpression(STATE_MANIPULATING_EXPRESSION));

    // cleanup
    filterService.deleteFilter(filter.getId());
  }
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendStoredFilterByScalar() {
  // given a stored filter
  TaskQuery taskQuery = taskService.createTaskQuery().dueAfterExpression("${now()}");
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(taskQuery);
  filterService.saveFilter(filter);

  // it is possible to execute the stored query with an expression
  assertEquals(new Long(0), filterService.count(filter.getId()));
  assertEquals(0, filterService.list(filter.getId()).size());

  // and it is possible to extend the filter query when not using an expression
  assertEquals(new Long(0), filterService.count(filter.getId(), taskService.createTaskQuery().dueAfter(new Date())));
  assertEquals(0, filterService.list(filter.getId(), taskService.createTaskQuery().dueAfter(new Date())).size());

  // cleanup
  filterService.deleteFilter(filter.getId());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testUpdateFilterWithExpression() {
  // given a stored filter
  TaskQuery taskQuery = taskService.createTaskQuery().dueAfter(new Date());
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(taskQuery);
  filterService.saveFilter(filter);

  // updating the filter with an expression does not suceed
  filter.setQuery(taskQuery.dueBeforeExpression(STATE_MANIPULATING_EXPRESSION));
  assertEquals(1, filterService.createFilterQuery().count());

  try {
    filterService.saveFilter(filter);
  } catch (ProcessEngineException e) {
    assertTextPresent(EXPECTED_STORED_QUERY_FAILURE_MESSAGE, e.getMessage());
  }
  assertTrue(fieldIsUnchanged());

  // cleanup
  filterService.deleteFilter(filter.getId());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testTaskQueryByBusinessKeyExpression() {
  // given
  String aBusinessKey = "business key";
  Mocks.register("aBusinessKey", aBusinessKey);

  createDeploymentWithBusinessKey(aBusinessKey);

  // when
  TaskQueryImpl extendedQuery = (TaskQueryImpl)taskService.createTaskQuery()
    .processInstanceBusinessKeyExpression("${ " + Mocks.getMocks().keySet().toArray()[0] + " }");

  Filter filter = filterService.newTaskFilter("aFilterName");
  filter.setQuery(extendedQuery);
  filterService.saveFilter(filter);

  TaskQueryImpl filterQuery = filterService.getFilter(filter.getId()).getQuery();

  // then
  assertEquals(extendedQuery.getExpressions().get("processInstanceBusinessKey"),
    filterQuery.getExpressions().get("processInstanceBusinessKey"));
  assertEquals(1, filterService.list(filter.getId()).size());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testTaskQueryByBusinessKeyExpressionInAdhocQuery() {
  // given
  processEngineConfiguration.setEnableExpressionsInAdhocQueries(true);

  String aBusinessKey = "business key";
  Mocks.register("aBusinessKey", aBusinessKey);

  createDeploymentWithBusinessKey(aBusinessKey);

  // when
  Filter filter = filterService.newTaskFilter("aFilterName");
  filter.setQuery(taskService.createTaskQuery());
  filterService.saveFilter(filter);

  TaskQueryImpl extendingQuery = (TaskQueryImpl)taskService.createTaskQuery()
    .processInstanceBusinessKeyExpression("${ " + Mocks.getMocks().keySet().toArray()[0] + " }");

  // then
  assertEquals(extendingQuery.getExpressions().get("processInstanceBusinessKey"),
    "${ " + Mocks.getMocks().keySet().toArray()[0] + " }");
  assertEquals(1, filterService.list(filter.getId(), extendingQuery).size());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testTaskQueryByBusinessKeyLikeExpression() {
  // given
  String aBusinessKey = "business key";
  Mocks.register("aBusinessKeyLike", "%" + aBusinessKey.substring(5));

  createDeploymentWithBusinessKey(aBusinessKey);

  // when
  TaskQueryImpl extendedQuery = (TaskQueryImpl)taskService.createTaskQuery()
    .processInstanceBusinessKeyLikeExpression("${ " + Mocks.getMocks().keySet().toArray()[0] + " }");

  Filter filter = filterService.newTaskFilter("aFilterName");
  filter.setQuery(extendedQuery);
  filterService.saveFilter(filter);

  TaskQueryImpl filterQuery = filterService.getFilter(filter.getId()).getQuery();

  // then
  assertEquals(extendedQuery.getExpressions().get("processInstanceBusinessKeyLike"),
    filterQuery.getExpressions().get("processInstanceBusinessKeyLike"));
  assertEquals(1, filterService.list(filter.getId()).size());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testTaskQueryByBusinessKeyLikeExpressionInAdhocQuery() {
  // given
  processEngineConfiguration.setEnableExpressionsInAdhocQueries(true);

  String aBusinessKey = "business key";
  Mocks.register("aBusinessKeyLike", "%" + aBusinessKey.substring(5));

  createDeploymentWithBusinessKey(aBusinessKey);

  // when
  Filter filter = filterService.newTaskFilter("aFilterName");
  filter.setQuery(taskService.createTaskQuery());
  filterService.saveFilter(filter);

  TaskQueryImpl extendingQuery = (TaskQueryImpl)taskService.createTaskQuery()
    .processInstanceBusinessKeyLikeExpression("${ " + Mocks.getMocks().keySet().toArray()[0] + " }");

  // then
  assertEquals(extendingQuery.getExpressions().get("processInstanceBusinessKeyLike"),
    "${ " + Mocks.getMocks().keySet().toArray()[0] + " }");
  assertEquals(1, filterService.list(filter.getId(), extendingQuery).size());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendTaskQueryWithCandidateUserExpressionAndIncludeAssignedTasks() {
  // create an empty query and save it as a filter
  TaskQuery emptyQuery = taskService.createTaskQuery();
  Filter emptyFilter = filterService.newTaskFilter("empty");
  emptyFilter.setQuery(emptyQuery);

  // create a query with candidate user expression and include assigned tasks
  // and save it as filter
  TaskQuery query = taskService.createTaskQuery();
  query.taskCandidateUserExpression("${'test'}").includeAssignedTasks();
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(query);

  // extend empty query by query with candidate user expression and include assigned tasks
  Filter extendedFilter = emptyFilter.extend(query);
  TaskQueryImpl extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateUser"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());

  // extend query with candidate user expression and include assigned tasks with empty query
  extendedFilter = filter.extend(emptyQuery);
  extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateUser"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendTaskQueryWithCandidateGroupExpressionAndIncludeAssignedTasks() {
  // create an empty query and save it as a filter
  TaskQuery emptyQuery = taskService.createTaskQuery();
  Filter emptyFilter = filterService.newTaskFilter("empty");
  emptyFilter.setQuery(emptyQuery);

  // create a query with candidate group expression and include assigned tasks
  // and save it as filter
  TaskQuery query = taskService.createTaskQuery();
  query.taskCandidateGroupExpression("${'test'}").includeAssignedTasks();
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(query);

  // extend empty query by query with candidate group expression and include assigned tasks
  Filter extendedFilter = emptyFilter.extend(query);
  TaskQueryImpl extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateGroup"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());

  // extend query with candidate group expression and include assigned tasks with empty query
  extendedFilter = filter.extend(emptyQuery);
  extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateGroup"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendTaskQueryWithCandidateGroupInAndCandidateGroup() {
  // create an query with candidate group in and save it as a filter
  TaskQueryImpl candidateGroupInQuery = (TaskQueryImpl)taskService.createTaskQuery().taskCandidateGroupIn(Arrays.asList("testGroup", "testGroup2"));
  assertEquals(2, candidateGroupInQuery.getCandidateGroups().size());
  assertEquals("testGroup", candidateGroupInQuery.getCandidateGroups().get(0));
  assertEquals("testGroup2", candidateGroupInQuery.getCandidateGroups().get(1));
  Filter candidateGroupInFilter = filterService.newTaskFilter("Groups filter");
  candidateGroupInFilter.setQuery(candidateGroupInQuery);

  // create a query with candidate group
  // and save it as filter
  TaskQuery candidateGroupQuery = taskService.createTaskQuery().taskCandidateGroup("testGroup2");

  // extend candidate group in filter by query with candidate group
  Filter extendedFilter = candidateGroupInFilter.extend(candidateGroupQuery);
  TaskQueryImpl extendedQuery = extendedFilter.getQuery();
  assertEquals(1, extendedQuery.getCandidateGroups().size());
  assertEquals("testGroup2", extendedQuery.getCandidateGroups().get(0));
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testExtendTaskQueryWithCandidateGroupInExpressionAndIncludeAssignedTasks() {
  // create an empty query and save it as a filter
  TaskQuery emptyQuery = taskService.createTaskQuery();
  Filter emptyFilter = filterService.newTaskFilter("empty");
  emptyFilter.setQuery(emptyQuery);

  // create a query with candidate group in expression and include assigned tasks
  // and save it as filter
  TaskQuery query = taskService.createTaskQuery();
  query.taskCandidateGroupInExpression("${'test'}").includeAssignedTasks();
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(query);

  // extend empty query by query with candidate group in expression and include assigned tasks
  Filter extendedFilter = emptyFilter.extend(query);
  TaskQueryImpl extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateGroupIn"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());

  // extend query with candidate group in expression and include assigned tasks with empty query
  extendedFilter = filter.extend(emptyQuery);
  extendedQuery = extendedFilter.getQuery();
  assertEquals("${'test'}", extendedQuery.getExpressions().get("taskCandidateGroupIn"));
  assertTrue(extendedQuery.isIncludeAssignedTasks());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testOrderByVariables() {
  // given
  TaskQueryImpl query = (TaskQueryImpl) taskService.createTaskQuery()
      .orderByProcessVariable("foo", ValueType.STRING).asc()
      .orderByExecutionVariable("foo", ValueType.STRING).asc()
      .orderByCaseInstanceVariable("foo", ValueType.STRING).asc()
      .orderByCaseExecutionVariable("foo", ValueType.STRING).asc()
      .orderByTaskVariable("foo", ValueType.STRING).asc();

  Filter filter = filterService.newTaskFilter("extendedOrFilter");
  filter.setQuery(query);
  filterService.saveFilter(filter);

  // when
  filter = filterService.getFilter(filter.getId());

  // then
  List<QueryOrderingProperty> expectedOrderingProperties =
      new ArrayList<QueryOrderingProperty>(query.getOrderingProperties());

  verifyOrderingProperties(expectedOrderingProperties, ((TaskQueryImpl) filter.getQuery()).getOrderingProperties());

  for (QueryOrderingProperty prop : ((TaskQueryImpl) filter.getQuery()).getOrderingProperties()) {
    assertTrue(prop instanceof VariableOrderProperty);
  }
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
/**
 * creates a task query to select task to the logged in user.
 * Otherwise you would have to manually create a filter in TaskList after each boot up
 */
private void createAssignedTaskQuery() {
    TaskQuery query = taskService.createTaskQuery().taskAssignee(adminUsername);
    Filter taskFilter = filterService.newTaskFilter("assigned Tasks");
    taskFilter.setOwner(adminUsername);
    taskFilter.setQuery(query);
    filterService.saveFilter(taskFilter);
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testStoreFilterWithoutExpression() {
  TaskQuery taskQuery = taskService.createTaskQuery().dueAfter(new Date());
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(taskQuery);

  // saving the filter suceeds
  filterService.saveFilter(filter);
  assertEquals(1, filterService.createFilterQuery().count());

  // cleanup
  filterService.deleteFilter(filter.getId());
}
 

import org.camunda.bpm.engine.filter.Filter; //导入方法依赖的package包/类
public void testStoreFilterWithExpression() {
  TaskQuery taskQuery = taskService.createTaskQuery().dueAfterExpression(STATE_MANIPULATING_EXPRESSION);
  Filter filter = filterService.newTaskFilter("filter");
  filter.setQuery(taskQuery);

  try {
    filterService.saveFilter(filter);
  } catch (ProcessEngineException e) {
    assertTextPresent(EXPECTED_STORED_QUERY_FAILURE_MESSAGE, e.getMessage());
  }
  assertTrue(fieldIsUnchanged());
}