예제 #1
0
  /**
   * 判断是否为第一个初始节点
   *
   * @return
   */
  public boolean isFirstTask() {
    ActivityImpl rootActivity = execution.getProcessDefinition().getInitial();
    List<PvmTransition> transitions = rootActivity.getOutgoingTransitions();

    for (PvmTransition transition : transitions) {
      TransitionImpl transitionImpl = (TransitionImpl) transition;
      ActivityImpl destinationActivity = transitionImpl.getDestination();
      String firstTaskActivityname = destinationActivity.getId();
      String currentActivityName = execution.getActivity().getId();

      return currentActivityName.equals(firstTaskActivityname);
    }

    return false;
  }
예제 #2
0
 /**
  * 根据当前节点,查询输出流向是否为并行终点,如果为并行终点,则拼装对应的并行起点ID
  *
  * @param activityImpl 当前节点
  * @return
  */
 private String findParallelGatewayId(ActivityImpl activityImpl) {
   List<PvmTransition> incomingTransitions = activityImpl.getOutgoingTransitions();
   for (PvmTransition pvmTransition : incomingTransitions) {
     TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
     activityImpl = transitionImpl.getDestination();
     String type = (String) activityImpl.getProperty("type");
     if ("parallelGateway".equals(type)) { // 并行路线
       String gatewayId = activityImpl.getId();
       String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 0);
       if ("END".equals(gatewayType.toUpperCase())) {
         return gatewayId.substring(0, gatewayId.lastIndexOf("_")) + "_start";
       }
     }
   }
   return null;
 }
예제 #3
0
  /**
   * 流程转向操作
   *
   * @param taskId 当前任务ID
   * @param activityId 目标节点任务ID
   * @param variables 流程变量
   * @throws Exception
   */
  private void turnTransition(String taskId, String activityId, Map<String, Object> variables)
      throws Exception {
    // 当前节点
    ActivityImpl currActivity = this.findActivitiImpl(taskId, null);
    // 清空当前流向
    List<PvmTransition> oriPvmTransitionList = this.clearTransition(currActivity);

    // 创建新流向
    TransitionImpl newTransition = currActivity.createOutgoingTransition();
    // 目标节点
    ActivityImpl pointActivity = this.findActivitiImpl(taskId, activityId);
    // 设置新流向的目标节点
    newTransition.setDestination(pointActivity);

    // 执行转向任务
    taskService.complete(taskId, variables);
    // 删除目标节点新流入
    pointActivity.getIncomingTransitions().remove(newTransition);

    // 还原以前流向
    this.restoreTransition(currActivity, oriPvmTransitionList);
  }
예제 #4
0
 public void createBPMNEdge(String key, List<GraphicInfo> graphicList) {
   FlowElement flowElement = bpmnModel.getFlowElement(key);
   if (flowElement != null && sequenceFlows.containsKey(key)) {
     TransitionImpl sequenceFlow = sequenceFlows.get(key);
     List<Integer> waypoints = new ArrayList<Integer>();
     for (GraphicInfo waypointInfo : graphicList) {
       waypoints.add((int) waypointInfo.getX());
       waypoints.add((int) waypointInfo.getY());
     }
     sequenceFlow.setWaypoints(waypoints);
   } else if (bpmnModel.getArtifact(key) != null) {
     // it's an association, so nothing to do
   } else {
     GraphicInfo graphicInfo = null;
     if (graphicList != null && graphicList.size() > 0) {
       graphicInfo = graphicList.get(0);
     } else {
       graphicInfo = new GraphicInfo();
     }
     bpmnModel.addProblem(
         "Invalid reference in 'bpmnElement' attribute, sequenceFlow " + key + " not found",
         graphicInfo);
   }
 }
예제 #5
0
  /**
   * 迭代循环流程树结构,查询当前节点可驳回的任务节点
   *
   * @param taskId 当前任务ID
   * @param currActivity 当前活动节点
   * @param rtnList 存储回退节点集合
   * @param tempList 临时存储节点集合(存储一次迭代过程中的同级userTask节点)
   * @return 回退节点集合
   */
  private List<ActivityImpl> iteratorBackActivity(
      String taskId,
      ActivityImpl currActivity,
      List<ActivityImpl> rtnList,
      List<ActivityImpl> tempList)
      throws Exception {
    // 查询流程定义,生成流程树结构
    ProcessInstance procInst = this.findProcInsByTaskId(taskId);

    // 当前节点的流入来源
    List<PvmTransition> incomingTransitions = currActivity.getIncomingTransitions();
    // 条件分支节点集合,userTask节点遍历完毕,迭代遍历此集合,查询条件分支对应的userTask节点
    List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();
    // 并行节点集合,userTask节点遍历完毕,迭代遍历此集合,查询并行节点对应的userTask节点
    List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();
    // 遍历当前节点所有流入路径
    for (PvmTransition pvmTransition : incomingTransitions) {
      TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
      ActivityImpl activityImpl = transitionImpl.getSource();
      String type = (String) activityImpl.getProperty("type");
      /**
       * 并行节点配置要求:<br>
       * 必须成对出现,且要求分别配置节点ID为:XXX_start(开始),XXX_end(结束)
       */
      if ("parallelGateway".equals(type)) { // 并行路线
        String gatewayId = activityImpl.getId();
        String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 0);
        if ("START".equals(gatewayType.toUpperCase())) { // 并行起点,停止递归
          return rtnList;
        } else { // 并行终点,临时存储此节点,本次循环结束,迭代集合,查询对应的userTask节点
          parallelGateways.add(activityImpl);
        }
      } else if ("startEvent".equals(type)) { // 开始节点,停止递归
        return rtnList;
      } else if ("userTask".equals(type)) { // 用户任务
        tempList.add(activityImpl);
      } else if ("exclusiveGateway".equals(type)) { // 分支路线,临时存储此节点,本次循环结束,迭代集合,查询对应的userTask节点
        currActivity = transitionImpl.getSource();
        exclusiveGateways.add(currActivity);
      }
    }

    /** 迭代条件分支集合,查询对应的userTask节点 */
    for (ActivityImpl activityImpl : exclusiveGateways) {
      iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
    }

    /** 迭代并行集合,查询对应的userTask节点 */
    for (ActivityImpl activityImpl : parallelGateways) {
      iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
    }

    /** 根据同级userTask集合,过滤最近发生的节点 */
    currActivity = filterNewestActivity(procInst, tempList);
    if (currActivity != null) {
      // 查询当前节点的流向是否为并行终点,并获取并行起点ID
      String id = findParallelGatewayId(currActivity);
      if (StringUtil.isStrEmpty(id)) { // 并行起点ID为空,此节点流向不是并行终点,符合驳回条件,存储此节点
        rtnList.add(currActivity);
      } else { // 根据并行起点ID查询当前节点,然后迭代查询其对应的userTask任务节点
        currActivity = findActivitiImpl(taskId, id);
      }

      // 清空本次迭代临时集合
      tempList.clear();
      // 执行下次迭代
      iteratorBackActivity(taskId, currActivity, rtnList, tempList);
    }
    return rtnList;
  }