protected void setVariable(
      Execution execution,
      String name,
      Object value,
      RestVariable.RestVariableScope scope,
      boolean isNew) {
    // Create can only be done on new variables. Existing variables should be updated using PUT
    boolean hasVariable = hasVariableOnScope(execution, name, scope);
    if (isNew && hasVariable) {
      throw new ActivitiException(
          "Variable '" + name + "' is already present on execution '" + execution.getId() + "'.");
    }

    if (!isNew && !hasVariable) {
      throw new ActivitiObjectNotFoundException(
          "Execution '"
              + execution.getId()
              + "' doesn't have a variable with name: '"
              + name
              + "'.",
          null);
    }

    RuntimeService runtimeService = BPMNOSGIService.getRumtimeService();
    if (scope == RestVariable.RestVariableScope.LOCAL) {
      runtimeService.setVariableLocal(execution.getId(), name, value);
    } else {
      if (execution.getParentId() != null) {
        runtimeService.setVariable(execution.getParentId(), name, value);
      } else {
        runtimeService.setVariable(execution.getId(), name, value);
      }
    }
  }
  @Deployment(
      resources = {
        "org/activiti/examples/bpmn/event/timer/BoundaryTimerEventTest.testInterruptingTimerDuration.bpmn"
      })
  @Test
  public void testInterruptingTimerDuration() {

    // Start process instance
    RuntimeService runtimeService = activitiRule.getRuntimeService();
    ProcessInstance pi = runtimeService.startProcessInstanceByKey("escalationExample");

    // There should be one task, with a timer : first line support
    TaskService taskService = activitiRule.getTaskService();
    Task task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();
    assertEquals("First line support", task.getName());

    // Manually execute the job
    ManagementService managementService = activitiRule.getManagementService();
    Job timer = managementService.createJobQuery().singleResult();
    managementService.executeJob(timer.getId());

    // The timer has fired, and the second task (secondlinesupport) now exists
    task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();
    assertEquals("Second line support", task.getName());
  }
  protected void addGlobalVariables(
      Execution execution,
      int variableType,
      Map<String, RestVariable> variableMap,
      UriInfo uriInfo) {
    RuntimeService runtimeService = BPMNOSGIService.getRumtimeService();
    Map<String, Object> rawVariables = runtimeService.getVariables(execution.getId());
    List<RestVariable> globalVariables =
        new RestResponseFactory()
            .createRestVariables(
                rawVariables,
                execution.getId(),
                variableType,
                RestVariable.RestVariableScope.GLOBAL,
                uriInfo.getBaseUri().toString());

    // Overlay global variables over local ones. In case they are present the values are not
    // overridden,
    // since local variables get precedence over global ones at all times.
    for (RestVariable var : globalVariables) {
      if (!variableMap.containsKey(var.getName())) {
        variableMap.put(var.getName(), var);
      }
    }
  }
예제 #4
0
 /** @param args */
 public static void main(String[] args) {
   // 创建流程引擎
   ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
   // 得到流程存储服务组件
   RepositoryService repositoryService = engine.getRepositoryService();
   // 得到运行时服务组件
   RuntimeService runtimeService = engine.getRuntimeService();
   // 获取流程任务组件
   TaskService taskService = engine.getTaskService();
   // 部署流程文件
   repositoryService
       .createDeployment()
       .addClasspathResource("bpmn11.5/SignalBoundaryEvent.bpmn")
       .deploy();
   // 启动2个流程实例
   ProcessInstance pi1 = runtimeService.startProcessInstanceByKey("sbProcess");
   ProcessInstance pi2 = runtimeService.startProcessInstanceByKey("sbProcess");
   // 查找第一个流程实例中签订合同的任务
   Task pi1Task = taskService.createTaskQuery().processInstanceId(pi1.getId()).singleResult();
   taskService.complete(pi1Task.getId());
   // 查找第二个流程实例中签订合同的任务
   Task pi2Task = taskService.createTaskQuery().processInstanceId(pi2.getId()).singleResult();
   taskService.complete(pi2Task.getId());
   // 此时执行流到达确认合同任务,发送一次信号
   runtimeService.signalEventReceived("contactChangeSignal");
   // 查询全部的任务
   List<Task> tasks = taskService.createTaskQuery().list();
   // 输出结果
   for (Task task : tasks) {
     System.out.println(task.getProcessInstanceId() + "---" + task.getName());
   }
 }
예제 #5
0
  /** 流程实例. */
  public String listProcessInstances() {
    RuntimeService runtimeService = processEngine.getRuntimeService();

    processInstances = runtimeService.createProcessInstanceQuery().list();

    return "listProcessInstances";
  }
  @Override
  protected Object doExecute() throws Exception {
    ProcessEngine processEngine = this.getProcessEngine();
    if (processEngine == null) {
      out().println("Process Engine NOT Found!");
      return null;
    }

    RuntimeService runtimeService = processEngine.getRuntimeService();

    if (this.instanceIDs != null && this.instanceIDs.length > 0) {
      for (String instanceID : instanceIDs) {
        runtimeService.deleteProcessInstance(instanceID, "Forcefully terminating the instance");
        out().printf("Process instance %s terminated\n", instanceID);
      }
      return null;
    }

    if (!killAll) {
      out().println("Process instance IDs required or use the command with -a or --all option");
      return null;
    } else {
      out().println("Signalling all executions in all active process instances...");
      List<ProcessInstance> piList =
          runtimeService.createProcessInstanceQuery().orderByProcessInstanceId().asc().list();
      for (ProcessInstance pi : piList) {
        String instanceID = pi.getProcessInstanceId();
        runtimeService.deleteProcessInstance(instanceID, "Forcefully terminating the instance");
        out().printf("Process instance %s terminated\n", instanceID);
      }
    }

    return null;
  }
예제 #7
0
 /**
  * 获取流程详细及工作流参数
  *
  * @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;
 }
  @Test
  public void BGC_transfer() throws Exception {
    fakeSparService.add(OTHER_PERSONAL_IDENTIFIER, ADDRESS);

    Map<String, Object> properties = new HashMap<>();
    properties.put("personalIdentifier", OTHER_PERSONAL_IDENTIFIER);
    String ocr = "5450897";
    properties.put("ocr", ocr);

    runtimeService.startProcessInstanceByMessage("create-insurance", ocr, properties);

    when_all_jobs_within_X_days_are_executed(10);

    Execution execution =
        runtimeService
            .createExecutionQuery()
            .messageEventSubscriptionName("bgc")
            .processVariableValueEquals("ocr", ocr)
            .singleResult();

    assertThat(execution, notNullValue());

    Map<String, Object> eventProperties = new HashMap<String, Object>();
    properties.put("amount", 56000);
    runtimeService.messageEventReceived("bgc", execution.getId(), eventProperties);
  }
예제 #9
0
 /*----------------------------------------------------------------------------------------------------*/
 private void setRepTime(Execution execution) {
   Integer repTime = (Integer) runtimeService.getVariable(execution.getId(), "repTime");
   if (repTime == null) {
     runtimeService.setVariable(execution.getId(), "repTime", 1);
   } else {
     runtimeService.setVariable(execution.getId(), "repTime", ++repTime);
   }
 }
예제 #10
0
  public static void main(String[] args) {

    ClassPathXmlApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");

    RuntimeService runtimeService = (RuntimeService) applicationContext.getBean("runtimeService");
    runtimeService.startProcessInstanceByKey("helloWorldProcess");
  }
 protected Execution getExecutionFromRequest(String executionId) {
   RuntimeService runtimeService = BPMNOSGIService.getRumtimeService();
   Execution execution =
       runtimeService.createExecutionQuery().executionId(executionId).singleResult();
   if (execution == null) {
     throw new ActivitiObjectNotFoundException(
         "Could not find an execution with id '" + executionId + "'.", Execution.class);
   }
   return execution;
 }
예제 #12
0
  private void createNewProcess() {
    processInstance = runtimeService.startProcessInstanceByKey("myProcess");

    assertNotNull(processInstance.getId());
    identityService = processEngine.getIdentityService();
    taskService = processEngine.getTaskService();
    pid = processInstance.getProcessInstanceId();
    formService = processEngine.getFormService();
    runtimeService.setVariable(pid, "mailvar1", "value1");
    runtimeService.setVariable(pid, "mailvar2", "value2");
  }
 @Override
 public void deleteProcessInstance(Long dossierId) {
   ProcessInstance pi =
       runtimeService
           .createProcessInstanceQuery()
           .processInstanceBusinessKey(dossierId.toString())
           .singleResult();
   if (pi != null) {
     runtimeService.deleteProcessInstance(pi.getProcessInstanceId(), "delete from back office");
   }
 }
  public RestVariable getVariableFromRequest(
      String taskId, String variableName, String scope, boolean includeBinary) {

    boolean variableFound = false;
    Object value = null;
    RestVariableScope variableScope = RestVariable.getScopeFromString(scope);
    if (variableScope == null) {
      // First, check local variables (which have precedence when no scope is supplied)
      if (taskService.hasVariableLocal(taskId, variableName)) {
        value = taskService.getVariableLocal(taskId, variableName);
        variableScope = RestVariableScope.LOCAL;
        variableFound = true;
      } else {
        // Revert to execution-variable when not present local on the task
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task.getExecutionId() != null
            && runtimeService.hasVariable(task.getExecutionId(), variableName)) {
          value = runtimeService.getVariable(task.getExecutionId(), variableName);
          variableScope = RestVariableScope.GLOBAL;
          variableFound = true;
        }
      }

    } else if (variableScope == RestVariableScope.GLOBAL) {
      Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
      if (task.getExecutionId() != null
          && runtimeService.hasVariable(task.getExecutionId(), variableName)) {
        value = runtimeService.getVariable(task.getExecutionId(), variableName);
        variableFound = true;
      }

    } else if (variableScope == RestVariableScope.LOCAL) {
      if (taskService.hasVariableLocal(taskId, variableName)) {
        value = taskService.getVariableLocal(taskId, variableName);
        variableFound = true;
      }
    }

    if (!variableFound) {
      throw new ActivitiObjectNotFoundException(
          "Task '" + taskId + "' doesn't have a variable with name: '" + variableName + "'.",
          VariableInstanceEntity.class);
    } else {
      return restResponseFactory.createRestVariable(
          variableName,
          value,
          variableScope,
          taskId,
          RestResponseFactory.VARIABLE_TASK,
          includeBinary);
    }
  }
예제 #15
0
 @Test
 public void testExecutionQuery() {
   // Given
   RuntimeService runtimeService = mock(RuntimeService.class);
   ExecutionQuery executionQuery = mock(ExecutionQuery.class);
   when(processEngine.getRuntimeService()).thenReturn(runtimeService);
   when(runtimeService.createExecutionQuery()).thenReturn(executionQuery);
   // When
   ExecutionQuery createdQuery = executionQuery();
   // Then
   assertThat(createdQuery).isNotNull().isSameAs(executionQuery);
   verify(runtimeService, times(1)).createExecutionQuery();
   verifyNoMoreInteractions(runtimeService);
 }
예제 #16
0
 @Test
 public void testProcessInstanceQuery() {
   // Given
   RuntimeService runtimeService = mock(RuntimeService.class);
   ProcessInstanceQuery processInstanceQuery = mock(ProcessInstanceQuery.class);
   when(processEngine.getRuntimeService()).thenReturn(runtimeService);
   when(runtimeService.createProcessInstanceQuery()).thenReturn(processInstanceQuery);
   // When
   ProcessInstanceQuery createdQuery = processInstanceQuery();
   // Then
   assertThat(createdQuery).isNotNull().isSameAs(processInstanceQuery);
   verify(runtimeService, times(1)).createProcessInstanceQuery();
   verifyNoMoreInteractions(runtimeService);
 }
예제 #17
0
  /** 流程实例. */
  public Page findProcessInstances(String tenantId, Page page) {
    RuntimeService runtimeService = processEngine.getRuntimeService();
    long count =
        runtimeService.createProcessInstanceQuery().processInstanceTenantId(tenantId).count();
    List<ProcessInstance> processInstances =
        runtimeService
            .createProcessInstanceQuery()
            .processInstanceTenantId(tenantId)
            .listPage((int) page.getStart(), page.getPageSize());
    page.setResult(processInstances);
    page.setTotalCount(count);

    return page;
  }
예제 #18
0
  @Override
  public void costWorkFlowStart(CostApprovalEntity costApproval, HttpServletRequest request) {
    // 由session取到登录用户id
    String applyUserId = ResourceUtil.getSessionUserName().getId();
    this.save(costApproval);
    String processKey = request.getParameter("processKey");
    if (!StringUtil.isNotEmpty(processKey)) {
      WorkFlowSetEntity workFlowSet =
          this.findUniqueByProperty(
              WorkFlowSetEntity.class, "entityName", costApproval.getClass().getSimpleName());
      processKey = workFlowSet.getProcessKey();
    }
    String businessKey = costApproval.getId().toString();
    ProcessInstance processInstance = null;
    // 用来设置启动流程的人员ID,引擎会自动把用户ID保存到activiti:initiator中
    identityService.setAuthenticatedUserId(applyUserId);

    Map<String, Object> variables = new HashMap<String, Object>();
    variables.put(ProcessConstantsUtil.getApplyUserId(), applyUserId);
    processInstance = runtimeService.startProcessInstanceByKey(processKey, businessKey, variables);
    String processInstanceId = processInstance.getId();
    costApproval.setProcessinstanceId(processInstanceId);

    // 获取并执行当前流程实例的下一步任务
    Task task = null;
    TaskQuery query =
        taskService.createTaskQuery().processInstanceBusinessKey(businessKey).active();
    task = query.singleResult();
    variables.put(
        ProcessConstantsUtil.getDeptLeaderId(),
        ResourceUtil.getSessionUserName().getCurrentDepart().getDepartManager().getId());
    taskService.complete(task.getId(), variables);
  }
  public StreamResource buildStreamResource(
      ProcessInstance processInstance,
      RepositoryService repositoryService,
      RuntimeService runtimeService) {

    StreamResource imageResource = null;

    ProcessDefinitionEntity processDefinition =
        (ProcessDefinitionEntity)
            ((RepositoryServiceImpl) repositoryService)
                .getDeployedProcessDefinition(processInstance.getProcessDefinitionId());

    if (processDefinition != null && processDefinition.isGraphicalNotationDefined()) {
      InputStream definitionImageStream =
          ProcessDiagramGenerator.generateDiagram(
              processDefinition,
              "png",
              runtimeService.getActiveActivityIds(processInstance.getId()));

      StreamSource streamSource = new InputStreamStreamSource(definitionImageStream);

      // Create image name
      String imageExtension = extractImageExtension(processDefinition.getDiagramResourceName());
      String fileName = processInstance.getId() + UUID.randomUUID() + "." + imageExtension;

      imageResource = new StreamResource(streamSource, fileName, ExplorerApp.get());
    }
    return imageResource;
  }
  private String startAndComplete() {
    RuntimeService runtimeService = activitiRule.getRuntimeService();

    Map<String, Object> variableMap = new HashMap<String, Object>();
    variableMap.put("isbn", "123456");
    String processInstanceID =
        runtimeService.startProcessInstanceByKey("bookorder", variableMap).getId();

    TaskService taskService = activitiRule.getTaskService();
    Task task = taskService.createTaskQuery().taskCandidateGroup("sales").singleResult();
    variableMap = new HashMap<String, Object>();
    variableMap.put("extraInfo", "Extra information");
    variableMap.put("isbn", "654321");
    taskService.complete(task.getId(), variableMap);
    return processInstanceID;
  }
  protected void setVariable(
      Task task, String name, Object value, RestVariableScope scope, boolean isNew) {
    // Create can only be done on new variables. Existing variables should be updated using PUT
    boolean hasVariable = hasVariableOnScope(task, name, scope);
    if (isNew && hasVariable) {
      throw new ActivitiException(
          "Variable '" + name + "' is already present on task '" + task.getId() + "'.");
    }

    if (!isNew && !hasVariable) {
      throw new ActivitiObjectNotFoundException(
          "Task '" + task.getId() + "' doesn't have a variable with name: '" + name + "'.", null);
    }

    if (scope == RestVariableScope.LOCAL) {
      taskService.setVariableLocal(task.getId(), name, value);
    } else {
      if (task.getExecutionId() != null) {
        // Explicitly set on execution, setting non-local variable on task will override
        // local-variable if exists
        runtimeService.setVariable(task.getExecutionId(), name, value);
      } else {
        // Standalone task, no global variables possible
        throw new ActivitiIllegalArgumentException(
            "Cannot set global variable '"
                + name
                + "' on task '"
                + task.getId()
                + "', task is not part of process.");
      }
    }
  }
예제 #22
0
  /**
   * easyui 运行中流程列表数据
   *
   * @param request
   * @param response
   * @param dataGrid
   */
  @RequestMapping(params = "runningProcessDataGrid")
  public void runningProcessDataGrid(
      HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {

    /*
     * List<HistoricProcessInstance> historicProcessInstances =
     * historyService .createHistoricProcessInstanceQuery()
     * .unfinished().list();
     */
    ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery();
    List<ProcessInstance> list = processInstanceQuery.list();

    StringBuffer rows = new StringBuffer();
    for (ProcessInstance hi : list) {
      rows.append(
          "{'id':"
              + hi.getId()
              + ",'processDefinitionId':'"
              + hi.getProcessDefinitionId()
              + "','processInstanceId':'"
              + hi.getProcessInstanceId()
              + "','activityId':'"
              + hi.getActivityId()
              + "'},");
    }

    String rowStr = StringUtils.substringBeforeLast(rows.toString(), ",");

    JSONObject jObject =
        JSONObject.fromObject("{'total':" + list.size() + ",'rows':[" + rowStr + "]}");
    responseDatagrid(response, jObject);
  }
예제 #23
0
  @Test
  public void person_missing_in_SPAR() throws Exception {
    Optional<SparResult> existing = fakeSparService.findBy(MISSING_PERSONAL_IDENTIFIER);
    assertThat(existing, isAbsent());

    Map<String, Object> properties = new HashMap<>();
    properties.put("personalIdentifier", MISSING_PERSONAL_IDENTIFIER);
    properties.put("ocr", OCR);

    runtimeService.startProcessInstanceByMessage("create-insurance", OCR, properties);

    when_all_jobs_within_X_days_are_executed(10);

    List<Message> messages = outbox.receivedAfter(Instant.now().minus(Duration.ofHours(1)));

    assertThat(messages, hasSize(1));
    String payload = messages.get(0).getPayload();
    assertThat(payload, isJson(withProperty("messageType", equalTo("\"person-does-not-exist\""))));
    assertThat(
        payload,
        isJson(
            withProperty(
                "personalIdentifier",
                equalTo("\"" + MISSING_PERSONAL_IDENTIFIER.getValue() + "\""))));
    assertThat(payload, isJson(withProperty("ocr", equalTo("\"" + OCR + "\""))));
  }
  /**
   * 跳转到任务执行页面
   *
   * @param request
   * @return
   */
  @RequestMapping(value = "/form.do")
  public String from(
      HttpServletRequest request, @RequestParam("taskId") String taskId, Model model) {

    List<Task> taskList = taskService.createTaskQuery().taskId(taskId).list();
    Task task = taskList.get(0);
    // 获取表单数据
    TaskFormData tfd = formService.getTaskFormData(taskId);
    List<FormProperty> fpList = tfd.getFormProperties();

    Map map = runtimeService.getVariables(task.getExecutionId());

    List<ActivityImpl> activityList = new ArrayList<ActivityImpl>();

    try {
      // 查找所有可驳回的节点
      activityList = processExtensionService.findBackActivity(taskId);
      // model.addAttribute("activityList",activityList);
    } catch (Exception e) {
      e.printStackTrace();
    }

    //        model.addAttribute("task",task);
    //        model.addAttribute("fpList",fpList);
    //        model.addAttribute("map",map);
    //        model.addAttribute("taskId",taskId);

    request.setAttribute("task", task);
    request.setAttribute("fpList", fpList);
    request.setAttribute("map", map);
    request.setAttribute("taskId", taskId);
    request.setAttribute("activityList", activityList);

    return "/simple/form";
  }
  @Override
  @Transactional(readOnly = false)
  public Defect reviewDefect(Long defectId, String assignedTo) {
    Defect existingDefect = defectRepository.getById(defectId);
    String existingAsignee = existingDefect.getAssignedTo();

    existingDefect.setStatus(DefectStatus.ASSIGNED);
    existingDefect.setAssignedTo(assignedTo);
    defectRepository.update(existingDefect);

    for (Task task : taskService.createTaskQuery().taskAssignee(existingAsignee).list()) {
      if (task.getName().equalsIgnoreCase("reviewDefect")) {
        Long taskDefectId = (Long) runtimeService.getVariable(task.getExecutionId(), "defectId");
        if (taskDefectId.equals(defectId)) {
          taskService.complete(task.getId());
          logger.info("Reviewed Defect: " + task.getName() + " Defect Id: " + taskDefectId);
        }
      }
    }
    logger.info(
        "Task assigned to: "
            + existingAsignee
            + " : "
            + taskService.createTaskQuery().taskAssignee(existingAsignee));
    logger.info(
        "Task assigned to: "
            + assignedTo
            + " : "
            + taskService.createTaskQuery().taskAssignee(assignedTo));

    return existingDefect;
  }
  @Test
  @Rollback(value = false)
  public void testDeploy() throws Exception {
    String path = ProcessDefManagerTest.class.getClassLoader().getResource("bpmnsub.xml").getPath();
    String value = FileUtils.readFileToString(new File(path));

    Deployment deployment =
        repositoryService
            .createDeployment()
            .addString("sub-model.bpmn", value)
            .name("子流程")
            .category("行政")
            .enableDuplicateFiltering()
            .deploy();
    //
    //        // 4. Start a process instance
    Map<String, Object> map = new HashMap<String, Object>();
    //        map.put("signAssignee", Arrays.asList("hr", "dep", "user"));
    identityService.setAuthenticatedUserId("dynamic");
    ProcessDefinition definition =
        repositoryService
            .createProcessDefinitionQuery()
            .deploymentId(deployment.getId())
            .singleResult();

    ProcessInstance processInstance =
        runtimeService.startProcessInstanceById(definition.getId(), map);
    int i = 0;
    System.out.println(processInstance.getId());
  }
예제 #27
0
  /**
   * 读取资源,通过部署ID
   *
   * @param processDefinitionId 流程定义ID
   * @param processInstanceId 流程实例ID
   * @param resourceType 资源类型(xml|image)
   */
  public InputStream resourceRead(String procDefId, String proInsId, String resType)
      throws Exception {

    if (StringUtils.isBlank(procDefId)) {
      ProcessInstance processInstance =
          runtimeService.createProcessInstanceQuery().processInstanceId(proInsId).singleResult();
      procDefId = processInstance.getProcessDefinitionId();
    }
    ProcessDefinition processDefinition =
        repositoryService
            .createProcessDefinitionQuery()
            .processDefinitionId(procDefId)
            .singleResult();

    String resourceName = "";
    if (resType.equals("image")) {
      resourceName = processDefinition.getDiagramResourceName();
    } else if (resType.equals("xml")) {
      resourceName = processDefinition.getResourceName();
    }

    InputStream resourceAsStream =
        repositoryService.getResourceAsStream(processDefinition.getDeploymentId(), resourceName);
    return resourceAsStream;
  }
예제 #28
0
  /**
   * 启动流程
   *
   * @param entity
   */
  @Transactional(readOnly = false)
  public void save(Leave leave, Map<String, Object> variables) {

    // 保存业务数据
    if (StringUtils.isBlank(leave.getId())) {
      leave.preInsert();
      leaveDao.insert(leave);
    } else {
      leave.preUpdate();
      leaveDao.update(leave);
    }
    logger.debug("save entity: {}", leave);

    // 用来设置启动流程的人员ID,引擎会自动把用户ID保存到activiti:initiator中
    identityService.setAuthenticatedUserId(leave.getCurrentUser().getLoginName());

    // 启动流程
    String businessKey = leave.getId().toString();
    variables.put("type", "leave");
    variables.put("busId", businessKey);
    ProcessInstance processInstance =
        runtimeService.startProcessInstanceByKey(ActUtils.PD_LEAVE[0], businessKey, variables);
    leave.setProcessInstance(processInstance);

    // 更新流程实例ID
    leave.setProcessInstanceId(processInstance.getId());
    leaveDao.updateProcessInstanceId(leave);

    logger.debug(
        "start process of {key={}, bkey={}, pid={}, variables={}}",
        new Object[] {ActUtils.PD_LEAVE[0], businessKey, processInstance.getId(), variables});
  }
예제 #29
0
 @Test
 public void test() {
   ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
   RepositoryService repositoryService = engine.getRepositoryService();
   RuntimeService runtimeService = engine.getRuntimeService();
   TaskService taskService = engine.getTaskService();
   repositoryService.createDeployment().addClasspathResource("bpmn/first.bpmn").deploy();
   runtimeService.startProcessInstanceByKey("process1");
   Task task = taskService.createTaskQuery().singleResult();
   System.out.println("第一个任务完成前,当前任务名称:" + task.getName());
   taskService.complete(task.getId());
   task = taskService.createTaskQuery().singleResult();
   System.out.println("第二个任务完成前,当前任务名称:" + task.getName());
   taskService.complete(task.getId());
   task = taskService.createTaskQuery().singleResult();
   System.out.println("流程结束后,查找任务:" + task);
 }
  protected boolean hasVariableOnScope(
      Execution execution, String variableName, RestVariable.RestVariableScope scope) {
    boolean variableFound = false;
    RuntimeService runtimeService = BPMNOSGIService.getRumtimeService();
    if (scope == RestVariable.RestVariableScope.GLOBAL) {
      if (execution.getParentId() != null
          && runtimeService.hasVariable(execution.getParentId(), variableName)) {
        variableFound = true;
      }

    } else if (scope == RestVariable.RestVariableScope.LOCAL) {
      if (runtimeService.hasVariableLocal(execution.getId(), variableName)) {
        variableFound = true;
      }
    }
    return variableFound;
  }