コード例 #1
0
 @Test
 @Deployment(resources = {"chapter4/bookorder.bpmn20.xml"})
 public void queryHistoricVariableUpdates() {
   startAndComplete();
   HistoryService historyService = activitiRule.getHistoryService();
   List<HistoricDetail> historicVariableUpdateList =
       historyService.createHistoricDetailQuery().variableUpdates().list();
   assertNotNull(historicVariableUpdateList);
   assertEquals(3, historicVariableUpdateList.size());
   for (HistoricDetail historicDetail : historicVariableUpdateList) {
     assertTrue(historicDetail instanceof HistoricVariableUpdate);
     HistoricVariableUpdate historicVariableUpdate = (HistoricVariableUpdate) historicDetail;
     assertNotNull(historicVariableUpdate.getExecutionId());
     System.out.println(
         "historic variable update, revision "
             + historicVariableUpdate.getRevision()
             + ", variable type name "
             + historicVariableUpdate.getVariableTypeName()
             + ", variable name "
             + historicVariableUpdate.getVariableName()
             + ", Variable value '"
             + historicVariableUpdate.getValue()
             + "'");
   }
 }
コード例 #2
0
ファイル: LeaveService.java プロジェクト: Cloud-Fly/jeesite
 /**
  * 获取流程详细及工作流参数
  *
  * @param id
  */
 @SuppressWarnings("unchecked")
 public Leave get(String id) {
   Leave leave = leaveDao.get(id);
   Map<String, Object> variables = null;
   HistoricProcessInstance historicProcessInstance =
       historyService
           .createHistoricProcessInstanceQuery()
           .processInstanceId(leave.getProcessInstanceId())
           .singleResult();
   if (historicProcessInstance != null) {
     variables =
         Collections3.extractToMap(
             historyService
                 .createHistoricVariableInstanceQuery()
                 .processInstanceId(historicProcessInstance.getId())
                 .list(),
             "variableName",
             "value");
   } else {
     variables =
         runtimeService.getVariables(
             runtimeService
                 .createProcessInstanceQuery()
                 .processInstanceId(leave.getProcessInstanceId())
                 .active()
                 .singleResult()
                 .getId());
   }
   leave.setVariables(variables);
   return leave;
 }
コード例 #3
0
  public String listHistoricTasks() {
    HistoryService historyService = processEngine.getHistoryService();

    historicTaskInstances = historyService.createHistoricTaskInstanceQuery().list();

    return "listHistoricTasks";
  }
コード例 #4
0
  /**
   * 已办任务(历史任务)
   *
   * @return
   */
  public String listHistoryTasks() {
    HistoryService historyService = processEngine.getHistoryService();
    String username = SpringSecurityUtils.getCurrentUsername();
    historicTasks =
        historyService.createHistoricTaskInstanceQuery().taskAssignee(username).finished().list();

    return "listHistoryTasks";
  }
コード例 #5
0
  /**
   * 用户参与的流程(包含已经完成和未完成)
   *
   * @return
   */
  public String listInvolvedProcessInstances() {
    HistoryService historyService = processEngine.getHistoryService();

    // TODO: finished(), unfinished()
    String username = SpringSecurityUtils.getCurrentUsername();
    historicProcessInstances =
        historyService.createHistoricProcessInstanceQuery().involvedUser(username).list();

    return "listInvolvedProcessInstances";
  }
 /**
  * Get completed process instances which were finished after the given date and time
  *
  * @return BPMNProcessInstance array if the historic process instance list is not null
  */
 public BPMNProcessInstance[] getCompletedProcessInstances() {
   HistoryService historyService = BPMNServerHolder.getInstance().getEngine().getHistoryService();
   HistoricProcessInstanceQuery instanceQuery =
       historyService.createHistoricProcessInstanceQuery();
   List<HistoricProcessInstance> historicProcessInstanceList = null;
   String time =
       readPublishTimeFromRegistry(
           AnalyticsPublisherConstants.PROCESS_RESOURCE_PATH,
           AnalyticsPublisherConstants.LAST_PROCESS_INSTANCE_PUBLISH_TIME);
   if (time == null) {
     if (instanceQuery.finished().list().size() != 0) {
       // if the stored time is null in the registry file then send all completed process
       // instances.
       historicProcessInstanceList =
           instanceQuery.finished().orderByProcessInstanceStartTime().asc().list();
     }
   } else {
     Date timeInDateFormat = DateConverter.convertStringToDate(time);
     int listSize = instanceQuery.finished().startedAfter(timeInDateFormat).list().size();
     if (listSize != 0) {
       /*When using the startedAfter() method it returns the finished objects according to the time stored of
       last completed instance. But if the list length is one then it always return the same object in the
       list twice from the last updated time which stored in the carbon registry.
       (avoid to return same object repeatedly if the list has only one object)*/
       if (listSize == 1) {
         return null;
       }
       // send the process instances which were finished after the given date/time in registry
       historicProcessInstanceList =
           instanceQuery
               .finished()
               .startedAfter(timeInDateFormat)
               .orderByProcessInstanceStartTime()
               .asc()
               .listPage(1, listSize);
     }
   }
   if (historicProcessInstanceList != null) {
     if (log.isDebugEnabled()) {
       log.debug(
           "Write the published time of the last BPMN process instance to the carbon registry..."
               + historicProcessInstanceList.toString());
     }
     /*write the last published time to the registry because lets say as an example when a new process is completed,
     then the attributes belong to that process instance should be published to the DAS and if we are not stored
     the last published time, then all the completed processes which were previously published are also re-published
     to the DAS.*/
     writePublishTimeToRegistry(historicProcessInstanceList);
     // return ProcessInstances set as BPMNProcessInstance array
     return getBPMNProcessInstances(historicProcessInstanceList);
   }
   return null;
 }
コード例 #7
0
ファイル: Mvk_1_Test.java プロジェクト: katebutenko/i
  @Test
  @Deployment(resources = {PROCESS_RESOURCE})
  public void processRejected() throws InterruptedException {
    Map<String, Object> procVars = createStartFormVariables();

    ProcessInstance pi =
        activitiRule
            .getProcessEngine()
            .getRuntimeService()
            .startProcessInstanceByKey(PROCESS_KEY, procVars);

    //		assertNotNull(pi);

    Task task = activitiRule.getTaskService().createTaskQuery().singleResult();
    //		assertNotNull(task);

    Map<String, Object> taskVars = new HashMap<String, Object>();
    taskVars.put("decide", "reject");
    activitiRule.getProcessEngine().getTaskService().complete(task.getId(), taskVars);

    HistoryService historyService = activitiRule.getHistoryService();

    HistoricProcessInstance historicProcessInstance =
        historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceId(pi.getProcessInstanceId())
            .singleResult();

    //		assertNotNull(historicProcessInstance);
    // check that only one process running
    //		assertEquals(pi.getProcessInstanceId(), historicProcessInstance.getId());

    List<HistoricActivityInstance> activityList =
        historyService
            .createHistoricActivityInstanceQuery()
            .processInstanceId(pi.getProcessInstanceId())
            .list();

    JobQuery jquery = activitiRule.getManagementService().createJobQuery();

    // check how many tasks must be done
    //		assertEquals("done task count", 6, activityList.size());

    // and the job is done
    //		assertEquals("job is done", 0, jquery.count());

    //		assertEquals(0, activitiRule.getProcessEngine().getRuntimeService()
    //				.createProcessInstanceQuery().count());

  }
コード例 #8
0
  /** 历史任务. */
  public Page findHistoricTaskInstances(String tenantId, Page page) {
    HistoryService historyService = processEngine.getHistoryService();

    long count = historyService.createHistoricTaskInstanceQuery().taskTenantId(tenantId).count();
    List<HistoricTaskInstance> historicTaskInstances =
        historyService
            .createHistoricTaskInstanceQuery()
            .taskTenantId(tenantId)
            .listPage((int) page.getStart(), page.getPageSize());
    page.setResult(historicTaskInstances);
    page.setTotalCount(count);

    return page;
  }
コード例 #9
0
  /**
   * 查看历史【包含流程跟踪、任务列表(完成和未完成)、流程变量】
   *
   * @return
   */
  public String viewHistory() {
    HistoryService historyService = processEngine.getHistoryService();
    historicTasks =
        historyService
            .createHistoricTaskInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    historicVariableInstances =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();

    return "viewHistory";
  }
コード例 #10
0
  /**
   * easyui AJAX请求数据 已办任务
   *
   * @param request
   * @param response
   * @param dataGrid
   */
  @RequestMapping(params = "finishedTaskDataGrid")
  public void finishedTask(
      HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {

    // String userId = "leaderuser";
    String userId = ResourceUtil.getSessionUserName().getId();
    List<HistoricTaskInstance> historicTasks =
        historyService.createHistoricTaskInstanceQuery().taskAssignee(userId).finished().list();

    StringBuffer rows = new StringBuffer();
    for (HistoricTaskInstance t : historicTasks) {
      rows.append(
          "{'name':'"
              + t.getName()
              + "','description':'"
              + t.getDescription()
              + "','taskId':'"
              + t.getId()
              + "','processDefinitionId':'"
              + t.getProcessDefinitionId()
              + "','processInstanceId':'"
              + t.getProcessInstanceId()
              + "'},");
    }
    String rowStr = StringUtils.substringBeforeLast(rows.toString(), ",");

    JSONObject jObject =
        JSONObject.fromObject("{'total':" + historicTasks.size() + ",'rows':[" + rowStr + "]}");
    responseDatagrid(response, jObject);
  }
コード例 #11
0
 public static List<HistoricTaskInstance> getHistoricTaskInstanceByProcessInstanceId(
     String processInstanceId) {
   return historyService
       .createHistoricTaskInstanceQuery()
       .processInstanceId(processInstanceId)
       .list();
 }
コード例 #12
0
 @RequestMapping(
     value = "/history/historic-task-instances/{taskId}",
     method = RequestMethod.DELETE)
 public void deleteTaskInstance(@PathVariable String taskId, HttpServletResponse response) {
   historyService.deleteHistoricTaskInstance(taskId);
   response.setStatus(HttpStatus.NO_CONTENT.value());
 }
コード例 #13
0
 /**
  * @param processInstanceId
  * @return
  */
 @Override
 public List<HistoricTaskInstance> createHistoricTaskInstanceQuery(String processInstanceId) {
   return historyService
       .createHistoricTaskInstanceQuery()
       .processInstanceId(processInstanceId)
       .list();
 }
コード例 #14
0
 public int size() {
   return (int)
       historyService
           .createHistoricProcessInstanceQuery()
           .startedBy(ExplorerApp.get().getLoggedInUser().getId())
           .unfinished()
           .count();
 }
コード例 #15
0
 protected HistoricTaskInstance getHistoricTaskInstanceFromRequest(String taskId) {
   HistoricTaskInstance taskInstance =
       historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
   if (taskInstance == null) {
     throw new ActivitiObjectNotFoundException(
         "Could not find a task instance with id '" + taskId + "'.", HistoricTaskInstance.class);
   }
   return taskInstance;
 }
 /**
  * Get completed task instances which were finished after the given date and time
  *
  * @return BPMNTaskInstance array if the historic task instance list is not null
  */
 public BPMNTaskInstance[] getCompletedTaskInstances() {
   HistoryService historyService = BPMNServerHolder.getInstance().getEngine().getHistoryService();
   HistoricTaskInstanceQuery instanceQuery = historyService.createHistoricTaskInstanceQuery();
   List<HistoricTaskInstance> historicTaskInstanceList = null;
   String time =
       readPublishTimeFromRegistry(
           AnalyticsPublisherConstants.TASK_RESOURCE_PATH,
           AnalyticsPublisherConstants.LAST_TASK_INSTANCE_END_TIME);
   if (time == null) {
     if (instanceQuery.finished().list().size() != 0) {
       historicTaskInstanceList =
           instanceQuery.finished().orderByHistoricTaskInstanceEndTime().asc().list();
     }
   } else {
     Date dateFormat = DateConverter.convertStringToDate(time);
     int listSize = instanceQuery.finished().taskCompletedAfter(dateFormat).list().size();
     if (listSize != 0) {
       /*When using the startedAfter() method it returns the finished objects according to the time stored of
       last completed instance. But if the list length is one then it always return the same object in the
       list twice from the last updated time which stored in the carbon registry.
       (avoid to return same object repeatedly if the list has only one object)*/
       if (listSize == 1) {
         return null;
       }
       historicTaskInstanceList =
           instanceQuery
               .finished()
               .taskCompletedAfter(dateFormat)
               .orderByHistoricTaskInstanceEndTime()
               .asc()
               .listPage(1, listSize);
     }
   }
   if (historicTaskInstanceList != null) {
     if (log.isDebugEnabled()) {
       log.debug(
           "Write BPMN task instance to the carbon registry..."
               + historicTaskInstanceList.toString());
     }
     writeTaskEndTimeToRegistry(historicTaskInstanceList);
     return getBPMNTaskInstances(historicTaskInstanceList);
   }
   return null;
 }
コード例 #17
0
  private Object getProccessVariableValue(String processInstance_ID, String variableName) {

    HistoricVariableInstance historicVariableInstance =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstance_ID)
            .variableName(variableName)
            .singleResult();
    return (Object) historicVariableInstance.getValue();
  }
コード例 #18
0
 /**
  * 根据流程实例ID查询流程定义对象{@link ProcessDefinition}
  *
  * @param processInstanceId 流程实例ID
  * @return 流程定义对象{@link ProcessDefinition}
  */
 public ProcessDefinition findProcessDefinitionByPid(String processInstanceId) {
   HistoricProcessInstance historicProcessInstance =
       historyService
           .createHistoricProcessInstanceQuery()
           .processInstanceId(processInstanceId)
           .singleResult();
   String processDefinitionId = historicProcessInstance.getProcessDefinitionId();
   ProcessDefinition processDefinition = findProcessDefinition(processDefinitionId);
   return processDefinition;
 }
コード例 #19
0
  @Test
  @Ignore
  public void testHappyPath() {

    // Create test applicant
    Applicant applicant = new Applicant("John Doe", "*****@*****.**", "12344");
    applicantRepository.save(applicant);

    // Start process instance
    Map<String, Object> variables = new HashMap<String, Object>();
    variables.put("applicant", applicant);
    ProcessInstance processInstance =
        runtimeService.startProcessInstanceByKey("hireProcessWithJpa", variables);

    // First, the 'phone interview' should be active
    Task task =
        taskService
            .createTaskQuery()
            .processInstanceId(processInstance.getId())
            .taskCandidateGroup("dev-managers")
            .singleResult();
    Assert.assertEquals("Telephone interview", task.getName());

    // Completing the phone interview with success should trigger two new tasks
    Map<String, Object> taskVariables = new HashMap<String, Object>();
    taskVariables.put("telephoneInterviewOutcome", true);
    taskService.complete(task.getId(), taskVariables);

    List<Task> tasks =
        taskService
            .createTaskQuery()
            .processInstanceId(processInstance.getId())
            .orderByTaskName()
            .asc()
            .list();
    Assert.assertEquals(2, tasks.size());
    Assert.assertEquals("Financial negotiation", tasks.get(0).getName());
    Assert.assertEquals("Tech interview", tasks.get(1).getName());

    // Completing both should wrap up the subprocess, send out the 'welcome mail' and end the
    // process instance
    taskVariables = new HashMap<String, Object>();
    taskVariables.put("techOk", true);
    taskService.complete(tasks.get(0).getId(), taskVariables);

    taskVariables = new HashMap<String, Object>();
    taskVariables.put("financialOk", true);
    taskService.complete(tasks.get(1).getId(), taskVariables);

    // Verify email
    Assert.assertEquals(1, wiser.getMessages().size());

    // Verify process completed
    Assert.assertEquals(1, historyService.createHistoricProcessInstanceQuery().finished().count());
  }
コード例 #20
0
 public Item loadSingleResult(String id) {
   HistoricProcessInstance processInstance =
       historyService
           .createHistoricProcessInstanceQuery()
           .startedBy(ExplorerApp.get().getLoggedInUser().getId())
           .unfinished()
           .processInstanceId(id)
           .singleResult();
   if (processInstance != null) {
     return createItem(processInstance);
   }
   return null;
 }
コード例 #21
0
  /** 参与流程. */
  public Page findInvolvedProcessInstances(String userId, String tenantId, Page page) {
    HistoryService historyService = processEngine.getHistoryService();

    // TODO: finished(), unfinished()
    long count =
        historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId)
            .involvedUser(userId)
            .count();
    List<HistoricProcessInstance> historicProcessInstances =
        historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId)
            .involvedUser(userId)
            .listPage((int) page.getStart(), page.getPageSize());

    page.setResult(historicProcessInstances);
    page.setTotalCount(count);

    return page;
  }
コード例 #22
0
 @Test
 @Deployment(resources = {"chapter4/bookorder.bpmn20.xml"})
 public void queryHistoricInstances() {
   String processInstanceID = startAndComplete();
   HistoryService historyService = activitiRule.getHistoryService();
   HistoricProcessInstance historicProcessInstance =
       historyService
           .createHistoricProcessInstanceQuery()
           .processInstanceId(processInstanceID)
           .singleResult();
   assertNotNull(historicProcessInstance);
   assertEquals(processInstanceID, historicProcessInstance.getId());
   System.out.println(
       "history process with definition id "
           + historicProcessInstance.getProcessDefinitionId()
           + ", started at "
           + historicProcessInstance.getStartTime()
           + ", ended at "
           + historicProcessInstance.getEndTime()
           + ", duration was "
           + historicProcessInstance.getDurationInMillis());
 }
コード例 #23
0
  public List<Item> loadItems(int start, int count) {
    List<HistoricProcessInstance> processInstances =
        historyService
            .createHistoricProcessInstanceQuery()
            .startedBy(ExplorerApp.get().getLoggedInUser().getId())
            .unfinished()
            .list();

    List<Item> items = new ArrayList<Item>();
    for (HistoricProcessInstance processInstance : processInstances) {
      items.add(createItem(processInstance));
    }
    return items;
  }
コード例 #24
0
 @Test
 public void exportJavaDelegate() throws Exception {
   // wait for deployment to be done
   Thread.sleep(5000);
   ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("osgiProcess");
   assertTrue(processInstance.isEnded());
   HistoricVariableInstance variable =
       historyService
           .createHistoricVariableInstanceQuery()
           .processInstanceId(processInstance.getId())
           .variableName("visited")
           .singleResult();
   assertTrue((Boolean) variable.getValue());
 }
コード例 #25
0
 @Test
 @Deployment(resources = {"chapter4/bookorder.bpmn20.xml"})
 public void queryHistoricActivities() {
   startAndComplete();
   HistoryService historyService = activitiRule.getHistoryService();
   List<HistoricActivityInstance> activityList =
       historyService.createHistoricActivityInstanceQuery().list();
   assertEquals(4, activityList.size());
   for (HistoricActivityInstance historicActivityInstance : activityList) {
     assertNotNull(historicActivityInstance.getActivityId());
     System.out.println(
         "history activity "
             + historicActivityInstance.getActivityName()
             + ", type "
             + historicActivityInstance.getActivityType()
             + ", starttime "
             + historicActivityInstance.getStartTime()
             + ", endtime "
             + historicActivityInstance.getEndTime()
             + ", duration was "
             + historicActivityInstance.getDurationInMillis());
   }
 }
コード例 #26
0
  /** 未结流程. */
  public Page findRunningProcessInstances(String userId, String tenantId, Page page) {
    HistoryService historyService = processEngine.getHistoryService();

    // TODO: 改成通过runtime表搜索,提高效率
    long count =
        historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId)
            .startedBy(userId)
            .unfinished()
            .count();
    List<HistoricProcessInstance> historicProcessInstances =
        historyService
            .createHistoricProcessInstanceQuery()
            .processInstanceTenantId(tenantId)
            .startedBy(userId)
            .unfinished()
            .listPage((int) page.getStart(), page.getPageSize());

    page.setResult(historicProcessInstances);
    page.setTotalCount(count);

    return page;
  }
コード例 #27
0
  public List<KickstartWorkflowInfo> convertToWorkflowInfoList(
      List<ProcessDefinition> processDefinitions) {
    List<KickstartWorkflowInfo> infoList = new ArrayList<KickstartWorkflowInfo>();
    for (ProcessDefinition processDefinition : processDefinitions) {
      KickstartWorkflowInfo workflowInfo = new KickstartWorkflowInfo();
      workflowInfo.setId(processDefinition.getId());
      workflowInfo.setKey(processDefinition.getKey());
      workflowInfo.setName(processDefinition.getName());
      workflowInfo.setVersion(processDefinition.getVersion());
      workflowInfo.setDeploymentId(processDefinition.getDeploymentId());

      Date deploymentTime =
          repositoryService
              .createDeploymentQuery()
              .deploymentId(processDefinition.getDeploymentId())
              .singleResult()
              .getDeploymentTime();
      workflowInfo.setCreateTime(deploymentTime);

      workflowInfo.setNrOfRuntimeInstances(
          historyService
              .createHistoricProcessInstanceQuery()
              .processDefinitionId(processDefinition.getId())
              .unfinished()
              .count());
      workflowInfo.setNrOfHistoricInstances(
          historyService
              .createHistoricProcessInstanceQuery()
              .processDefinitionId(processDefinition.getId())
              .finished()
              .count());

      infoList.add(workflowInfo);
    }
    return infoList;
  }
コード例 #28
0
ファイル: LeaveService.java プロジェクト: Cloud-Fly/jeesite
  public Page<Leave> find(Page<Leave> page, Leave leave) {

    leave.getSqlMap().put("dsf", dataScopeFilter(leave.getCurrentUser(), "o", "u"));

    leave.setPage(page);
    page.setList(leaveDao.findList(leave));

    for (Leave item : page.getList()) {
      String processInstanceId = item.getProcessInstanceId();
      Task task =
          taskService
              .createTaskQuery()
              .processInstanceId(processInstanceId)
              .active()
              .singleResult();
      item.setTask(task);
      HistoricProcessInstance historicProcessInstance =
          historyService
              .createHistoricProcessInstanceQuery()
              .processInstanceId(processInstanceId)
              .singleResult();
      if (historicProcessInstance != null) {
        item.setHistoricProcessInstance(historicProcessInstance);
        item.setProcessDefinition(
            repositoryService
                .createProcessDefinitionQuery()
                .processDefinitionId(historicProcessInstance.getProcessDefinitionId())
                .singleResult());
      } else {
        ProcessInstance processInstance =
            runtimeService
                .createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .active()
                .singleResult();
        if (processInstance != null) {
          item.setProcessInstance(processInstance);
          item.setProcessDefinition(
              repositoryService
                  .createProcessDefinitionQuery()
                  .processDefinitionId(processInstance.getProcessDefinitionId())
                  .singleResult());
        }
      }
    }
    return page;
  }
コード例 #29
0
  /**
   * Generic method which will figure out to which task page must be jumped, based on the task data.
   *
   * <p>Note that, if possible, it is always more performant to use the more specific showXXXPage()
   * methods.
   */
  public void showTaskPage(String taskId) {
    Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
    String loggedInUserId = ExplorerApp.get().getLoggedInUser().getId();

    if (task == null) {
      // If no runtime task exists, our only hope is the archive page
      boolean isOwner =
          historyService
                  .createHistoricTaskInstanceQuery()
                  .taskId(taskId)
                  .taskOwner(loggedInUserId)
                  .count()
              == 1;
      if (isOwner) {
        showArchivedPage(taskId);
      } else {
        showNavigationError(taskId);
      }
    } else if (loggedInUserId.equals(task.getOwner())) {
      showTasksPage(taskId);
    } else if (loggedInUserId.equals(task.getAssignee())) {
      showInboxPage(taskId);
    } else if (taskService.createTaskQuery().taskInvolvedUser(loggedInUserId).count() == 1) {
      showInvolvedPage(taskId);
    } else {
      // queued
      List<String> groupIds = getGroupIds(loggedInUserId);
      List<IdentityLink> identityLinks = taskService.getIdentityLinksForTask(task.getId());
      Iterator<IdentityLink> identityLinkIterator = identityLinks.iterator();

      boolean pageFound = false;
      while (!pageFound && identityLinkIterator.hasNext()) {
        IdentityLink identityLink = identityLinkIterator.next();
        if (identityLink.getGroupId() != null && groupIds.contains(identityLink.getGroupId())) {
          showQueuedPage(identityLink.getGroupId(), task.getId());
          pageFound = true;
        }
      }

      // We've tried hard enough, the user now gets a notification. He deserves it.
      if (!pageFound) {
        showNavigationError(taskId);
      }
    }
  }
コード例 #30
0
 @RequestMapping(value = "/list")
 @ResponseBody
 public Map<String, Object> list(
     @RequestParam("page") int curPage,
     @RequestParam("rows") int pageSize,
     HttpServletRequest req) {
   HistoricTaskInstanceQuery historicTaskInstanceQuery =
       historyService.createHistoricTaskInstanceQuery(); // .taskAssignee("5")
   long total = historicTaskInstanceQuery.count();
   List<HistoricTaskInstance> list =
       historicTaskInstanceQuery
           .orderByTaskCreateTime()
           .desc()
           .listPage((curPage - 1) * pageSize, pageSize);
   Map<String, Object> obj = new HashMap<String, Object>();
   obj.put("total", total);
   obj.put("list", list);
   return obj;
 }