Examples of WorkflowProcess


Examples of org.fireflow.model.WorkflowProcess

  public void completeWorkItemAndJumpTo(IWorkItem workItem,
      String targetActivityId, String comments) throws EngineException,
      KernelException {
    // 首先检查是否可以正确跳转
    // 1)检查是否在同一个“执行线”上
    WorkflowProcess workflowProcess = workItem.getTaskInstance()
        .getWorkflowProcess();
    String thisActivityId = workItem.getTaskInstance().getActivityId();
    boolean isInSameLine = workflowProcess.isInSameLine(thisActivityId,
        targetActivityId);
    TaskInstance thisTaskInst = (TaskInstance) workItem.getTaskInstance();
    if (!isInSameLine) {
      throw new EngineException(
          thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Jumpto refused because of the current activitgy and the target activity are NOT in the same 'Execution Thread'.");
    }

    // 2)检查目标Activity Form Task的数量(暂时关闭该检查项目)
    // Activity targetActivity =
    // (Activity)workflowProcess.findWFElementById(activityId);
    // int count = getFormTaskCount(targetActivity);
    // if (count!=1){
    // if (!isInSameLine) throw new
    // EngineException("Jumpto refused because of the  FORM-type-task count of the target activitgy  is NOT 1; the count is "+count);
    // }

    // 3)检查当前的 taskinstance是否可以结束
    IPersistenceService persistenceService = rtCtx.getPersistenceService();

    Integer aliveWorkItemCount = persistenceService
        .getAliveWorkItemCountForTaskInstance(thisTaskInst.getId());
    if (aliveWorkItemCount != null && aliveWorkItemCount > 1) {
      throw new EngineException(
          thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Jumpto refused because of current taskinstance can NOT be completed. some workitem of this taskinstance is in runing state or initialized state");

    }

    // 4)检查当前的activity instance是否可以结束
    if (Activity.ALL.equals(workItem.getTaskInstance().getActivity()
        .getCompletionStrategy())) {

      Integer aliveTaskInstanceCount4ThisActivity = persistenceService
          .getAliveTaskInstanceCountForActivity(workItem
              .getTaskInstance().getProcessInstanceId(), workItem
              .getTaskInstance().getActivityId());
      if (aliveTaskInstanceCount4ThisActivity.intValue() > 1) {// 大于2表明当前Activity不可以complete
        throw new EngineException(
            thisTaskInst.getProcessInstanceId(),
            thisTaskInst.getWorkflowProcess(),
            thisTaskInst.getTaskId(),
            "Jumpto refused because of current activity instance can NOT be completed. some task instance of this activity instance is in runing state or initialized state");
      }
    }

    INetInstance netInstance = rtCtx.getKernelManager().getNetInstance(
        workflowProcess.getId(),
        workItem.getTaskInstance().getVersion());
    if (netInstance == null) {
      throw new EngineException(thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Not find the net instance for workflow process [id="
              + workflowProcess.getId() + ", version="
              + workItem.getTaskInstance().getVersion() + "]");
    }
    Object obj = netInstance.getWFElementInstance(targetActivityId);
    IActivityInstance targetActivityInstance = (IActivityInstance) obj;
    if (targetActivityInstance == null) {
      throw new EngineException(thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Not find the activity instance  for activity[process id="
              + workflowProcess.getId() + ", version="
              + workItem.getTaskInstance().getVersion()
              + ",activity id=" + targetActivityId + "]");
    }

    if (rtCtx.isEnableTrace()) {
View Full Code Here

Examples of org.fireflow.model.WorkflowProcess

      String targetActivityId, String comments) throws EngineException,
      KernelException {
   
    // 首先检查是否可以正确跳转 

    WorkflowProcess workflowProcess = workItem.getTaskInstance().getWorkflowProcess();
    String thisActivityId = workItem.getTaskInstance().getActivityId();
    TaskInstance thisTaskInst = (TaskInstance) workItem.getTaskInstance();
    //如果是在同一条执行线上,那么可以直接跳过去,只是重复判断了是否在同一条执行线上
    boolean isInSameLine = workflowProcess.isInSameLine(thisActivityId,targetActivityId)
    if (isInSameLine){
      this.completeWorkItemAndJumpTo(workItem, targetActivityId, comments);
      return;
    }
   
    // 1)检查是否在同一个“执行线”上(关闭该检查,20091002)   
//    if (!isInSameLine) {
//      throw new EngineException(
//          thisTaskInst.getProcessInstanceId(),
//          thisTaskInst.getWorkflowProcess(),
//          thisTaskInst.getTaskId(),
//          "Jumpto refused because of the current activitgy and the target activity are NOT in the same 'Execution Thread'.");
//    }

    // 2)检查目标Activity Form Task的数量(暂时关闭该检查项目)
    // Activity targetActivity =
    // (Activity)workflowProcess.findWFElementById(activityId);
    // int count = getFormTaskCount(targetActivity);
    // if (count!=1){
    // if (!isInSameLine) throw new
    // EngineException("Jumpto refused because of the  FORM-type-task count of the target activitgy  is NOT 1; the count is "+count);
    // }

    // 3)检查当前的 taskinstance是否可以结束
    IPersistenceService persistenceService = rtCtx.getPersistenceService();

    Integer aliveWorkItemCount = persistenceService
        .getAliveWorkItemCountForTaskInstance(thisTaskInst.getId());
    if (aliveWorkItemCount != null && aliveWorkItemCount > 1) {
      throw new EngineException(
          thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Jumpto refused because of current taskinstance can NOT be completed. some workitem of this taskinstance is in runing state or initialized state");

    }

    // 4)检查当前的activity instance是否可以结束
    if (Activity.ALL.equals(workItem.getTaskInstance().getActivity().getCompletionStrategy())) {

      Integer aliveTaskInstanceCount4ThisActivity = persistenceService
          .getAliveTaskInstanceCountForActivity(workItem
              .getTaskInstance().getProcessInstanceId(), workItem
              .getTaskInstance().getActivityId());
      if (aliveTaskInstanceCount4ThisActivity.intValue() > 1) {// 大于1表明当前Activity不可以complete
        throw new EngineException(
            thisTaskInst.getProcessInstanceId(),
            thisTaskInst.getWorkflowProcess(),
            thisTaskInst.getTaskId(),
            "Jumpto refused because of current activity instance can NOT be completed. some task instance of this activity instance is in runing state or initialized state");
      }
    }
   
    //4)首先检查目标状态M是否存在冲突,如果存在冲突则不允许跳转;如果不存在冲突,则需要调整token
    List<IToken> allTokens = persistenceService.findTokensForProcessInstance(thisTaskInst.getProcessInstanceId(), null);
    WorkflowProcess thisProcess = thisTaskInst.getWorkflowProcess();//找到当前的工作里模型
    List<String> aliveActivityIdsAfterJump = new ArrayList<String>();//计算跳转后,哪些activity节点复活
    aliveActivityIdsAfterJump.add(targetActivityId);
   
    for (int i=0;allTokens!=null && i<allTokens.size();i++){
      IToken tokenTmp = allTokens.get(i);
      IWFElement workflowElement = thisProcess.findWFElementById(tokenTmp.getNodeId()); //找到拥有此token的工作流元素
      if ((workflowElement instanceof Activity) && !workflowElement.getId().equals(thisActivityId)){
        //注意:不能自己跳转到自己,同时此工作流元素是activity类型
        aliveActivityIdsAfterJump.add(workflowElement.getId());
       
        if (thisProcess.isReachable(targetActivityId, workflowElement.getId())
          || thisProcess.isReachable(workflowElement.getId(), targetActivityId)){
          throw new EngineException(
              thisTaskInst.getProcessInstanceId(),
              thisTaskInst.getWorkflowProcess(),
              thisTaskInst.getTaskId(),
              "Jumpto refused because of the business-logic conflict!");

        }
      }
    }

    //所有检查结束,开始执行跳转操作
   
    INetInstance netInstance = rtCtx.getKernelManager().getNetInstance(
        workflowProcess.getId(),
        workItem.getTaskInstance().getVersion());
    if (netInstance == null) {
      throw new EngineException(thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Not find the net instance for workflow process [id="
              + workflowProcess.getId() + ", version="
              + workItem.getTaskInstance().getVersion() + "]");
    }
    Object obj = netInstance.getWFElementInstance(targetActivityId);
    IActivityInstance targetActivityInstance = (IActivityInstance) obj;
    if (targetActivityInstance == null) {
      throw new EngineException(thisTaskInst.getProcessInstanceId(),
          thisTaskInst.getWorkflowProcess(),
          thisTaskInst.getTaskId(),
          "Not find the activity instance  for activity[process id="
              + workflowProcess.getId() + ", version="
              + workItem.getTaskInstance().getVersion()
              + ",activity id=" + targetActivityId + "]");
    }

    if (rtCtx.isEnableTrace()) {

      ProcessInstanceTrace trace = new ProcessInstanceTrace();
      trace.setProcessInstanceId(workItem.getTaskInstance()
          .getProcessInstanceId());
      trace.setStepNumber(workItem.getTaskInstance().getStepNumber() + 1);
      trace.setType(ProcessInstanceTrace.JUMPTO_TYPE);
      trace.setFromNodeId(workItem.getTaskInstance().getActivityId());
      trace.setToNodeId(targetActivityId);
      trace.setEdgeId("");
      rtCtx.getPersistenceService().saveOrUpdateProcessInstanceTrace(
          trace);
    }

    //调整token布局
    List<Synchronizer> allSynchronizersAndEnds = new ArrayList<Synchronizer>();
    allSynchronizersAndEnds.addAll(thisProcess.getSynchronizers());
    allSynchronizersAndEnds.addAll(thisProcess.getEndNodes());
    for (int i=0;i<allSynchronizersAndEnds.size();i++){
      Synchronizer synchronizer = allSynchronizersAndEnds.get(i);

      int volumn = 0;
      if (synchronizer instanceof EndNode){
        volumn = synchronizer.getEnteringTransitions().size();
      }else{
        volumn = synchronizer.getEnteringTransitions().size()*synchronizer.getLeavingTransitions().size();
      }     
      IToken tokenTmp =  new Token();
      tokenTmp.setNodeId(synchronizer.getId());
      tokenTmp.setAlive(false);
      tokenTmp.setProcessInstanceId(thisTaskInst.getProcessInstanceId());
      tokenTmp.setStepNumber(-1);

      List<String> incomingTransitionIds = new ArrayList<String>();
      boolean reachable = false;
      List<Transition> enteringTrans = synchronizer.getEnteringTransitions();   
      for (int m=0;m<aliveActivityIdsAfterJump.size();m++){
        String aliveActivityId = aliveActivityIdsAfterJump.get(m);
        if (thisProcess.isReachable(aliveActivityId, synchronizer.getId())){         
          Transition trans = null;
          reachable = true;
          for (int j=0;j<enteringTrans.size();j++){
            trans = enteringTrans.get(j);
            Node fromNode = trans.getFromNode();
            if (thisProcess.isReachable(aliveActivityId, fromNode.getId())){
              if (!incomingTransitionIds.contains(trans.getId())){
                incomingTransitionIds.add(trans.getId());
              }
            }
          }     
View Full Code Here

Examples of org.fireflow.model.WorkflowProcess

    StringTokenizer tokenizer = new StringTokenizer(thisTaskInstance
        .getFromActivityId(), IToken.FROM_ACTIVITY_ID_SEPARATOR);
    while (tokenizer.hasMoreTokens()) {
      fromActivityIdList.add(tokenizer.nextToken());
    }
    WorkflowProcess workflowProcess = workItem.getTaskInstance()
        .getWorkflowProcess();
    for (int i = 0; i < fromActivityIdList.size(); i++) {
      String fromActivityId = (String) fromActivityIdList.get(i);
      Activity fromActivity = (Activity) workflowProcess
          .findWFElementById(fromActivityId);
      List<Task> fromTaskList = fromActivity.getTasks();
      for (int j = 0; j < fromTaskList.size(); j++) {
        Task task =  fromTaskList.get(j);
        if (Task.TOOL.equals(task.getType())
            || Task.SUBFLOW.equals(task.getType())) {
          throw new EngineException(
              thisTaskInstance.getProcessInstanceId(),
              thisTaskInstance.getWorkflowProcess(),
              thisTaskInstance.getTaskId(),
              "Reject operation refused!The previous activity contains tool-task or subflow-task");

        }
      }
    }
    // 恢复所有的FromTaskInstance
    INetInstance netInstance = rtCtx.getKernelManager().getNetInstance(
        workflowProcess.getId(),
        workItem.getTaskInstance().getVersion());
    if (netInstance == null) {
      throw new EngineException(thisTaskInstance.getProcessInstanceId(),
          thisTaskInstance.getWorkflowProcess(), thisTaskInstance
              .getTaskId(),
          "Not find the net instance for workflow process [id="
              + workflowProcess.getId() + ", version="
              + workItem.getTaskInstance().getVersion() + "]");
    }

    // 执行reject操作。
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

    //  ---------------------------------------------------------------
    //   3. validate workflowprocess beginActivity and endActivity
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      ExtendedAttribute attribute = workflowProcess.findExtendedAttribute(XPDLGlobals.ID_ACTIVITY_BEGIN);
      String activityId = null;

      if (attribute != null)
      {
        activityId = (String) attribute.getValue();
        if (activityId == null || activityId.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "process attribute '"
                + XPDLGlobals.ID_ACTIVITY_BEGIN
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "process attribute '"
              + XPDLGlobals.ID_ACTIVITY_BEGIN
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + ",processID="
              + workflowProcess.getUUID()
              + "}"));
      }

      attribute = (ExtendedAttribute) workflowProcess.findExtendedAttribute(XPDLGlobals.ID_ACTIVITY_END);
      if (attribute != null)
      {
        activityId = (String) attribute.getValue();
        if (activityId == null || activityId.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "process attribute '"
                + XPDLGlobals.ID_ACTIVITY_END
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "process attribute '"
              + XPDLGlobals.ID_ACTIVITY_END
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + ",processID="
              + workflowProcess.getUUID()
              + "}"));
      }
    }

    //  ---------------------------------------------------------------
    //   4. validate workflowActivity activity type
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          String activity_type = (String) attribute.getValue();
          if (activity_type == null || activity_type.length() == 0)
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.ACTIVITY_TYPE
                  + "' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
        else
        {
          errorList.add(
            new WorkflowException(
              "activity attribute '"
                + XPDLGlobals.ACTIVITY_TYPE
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",activityID="
                + activity.getUUID()
                + "}"));
        }
      }
    }

    //  ---------------------------------------------------------------
    //   5. validate workflowActivity performer type
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();
      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          if (!ActivityType.parse((String) attribute.getValue()).equals(ActivityType.ACTIVITY_BUSINESS))
          {
            continue;
          }
        }
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        if (attribute != null)
        {
          String performer_type = (String) attribute.getValue();
          if (performer_type == null || performer_type.length() == 0)
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.PERFORMER_TYPE
                  + "' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
        else
        {
          errorList.add(
            new WorkflowException(
              "activity attribute '"
                + XPDLGlobals.PERFORMER_TYPE
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",activityID="
                + activity.getUUID()
                + "}"));
        }
      }
    }

    //  ---------------------------------------------------------------
    //   6. validate workflowActivity Implementation referrence
    //  ---------------------------------------------------------------     
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ToolImplementation toolImpl = null;
      ToolSet toolSet = null;
      SubFlowImplementation subFlowImpl = null;

      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();

        if (impl == null)
        {
          continue;
        }

        if ((impl instanceof ToolImplementation) && ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          toolImpl = (ToolImplementation) impl;
          String appId = toolImpl.getApplicationID();
          if ((appId == null) || (workflowPackage.findWorkflowApplication(appId) == null))
          {
            errorList.add(
              new WorkflowException(
                "Tool attribute 'Id' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }

        if ((impl instanceof ToolSet) && ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          toolSet = (ToolSet) impl;
          List toolImpls = toolSet.getToolKits();
          int toolImpls_size = toolImpls.size();

          for (int k = 0; k < toolImpls_size; ++k)
          {
            toolImpl = (ToolImplementation) toolImpls.get(k);
            String appId = toolImpl.getApplicationID();
            if ((appId == null) || (workflowPackage.findWorkflowApplication(appId) == null))
            {
              errorList.add(
                new WorkflowException(
                  "Tool attribute 'Id' must be set.{packageID="
                    + workflowPackage.getUUID()
                    + ",processID="
                    + workflowProcess.getUUID()
                    + ",activityID="
                    + activity.getUUID()
                    + "}"));
            }
          }
        }

        if ((impl instanceof SubFlowImplementation)
          && ActivityType.ACTIVITY_SUBFLOW.equals(activity.getActivityType()))
        {
          subFlowImpl = (SubFlowImplementation) impl;
          String processId = subFlowImpl.getProcessID();
          if ((processId == null) || (workflowPackage.findWorkflowProcess(processId) == null))
          {
            errorList.add(
              new WorkflowException(
                "SubFlow attribute 'Id' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
      }
    }

    //  ---------------------------------------------------------------
    //   7. validate WorkflowTransition formActivity & toActivity
    //  ---------------------------------------------------------------     
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List trans = workflowProcess.getWorkflowTransitions();
      int trans_size = trans.size();

      WorkflowTransition tran = null;

      for (int j = 0; j < trans_size; ++j)
      {
        tran = (WorkflowTransition) trans.get(j);
        if (tran.getFromWorkflowActivity() == null)
        {
          errorList.add(
            new WorkflowException(
              "Transition attribute 'From' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",transitionID="
                + tran.getUUID()
                + "}"));
        }

        if (tran.getToWorkflowActivity() == null)
        {
          errorList.add(
            new WorkflowException(
              "Transition attribute 'To' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",transitionID="
                + tran.getUUID()
                + "}"));
        }
      }
    }

    //  ---------------------------------------------------------------
    //   8. validate workflowActivity activity type match performer Type
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          if (ActivityType.parse((String) attribute.getValue()).equals(ActivityType.ACTIVITY_BUSINESS))
          {
            continue;
          }

          attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
          if (attribute != null
            && !(PerformerType.parse(attribute.getValue()).equals(PerformerType.PERFORMER_AUTOMATION)))
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.PERFORMER_TYPE
                  + "' and attribute '"
                  + XPDLGlobals.ACTIVITY_TYPE
                  + "' mismatched.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

    //  ---------------------------------------------------------------
    //   1. format activity incoming transitions & Outgoing transitions
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List transitions = workflowProcess.getWorkflowTransitions();
      int tran_size = transitions.size();
      WorkflowTransition transition = null;
      WorkflowActivity fromActivity = null;
      WorkflowActivity toActivity = null;
      for (int j = 0; j < tran_size; ++j)
      {
        transition = (WorkflowTransition) transitions.get(j);

        fromActivity = transition.getFromWorkflowActivity();
        toActivity = transition.getToWorkflowActivity();
        if (fromActivity != null)
        {
          fromActivity.addOutgoingTransition(transition);
        }
        //        else
        //        {
        //          System.err.println("transition=" + transition.getUUID() + ",from=<null>");
        //        }
        if (toActivity != null)
        {
          toActivity.addIncomingTransition(transition);
        }
        //        else
        //        {
        //          System.err.println("transition=" + transition.getUUID() + ",to=<null>");
        //        }
      }
    }

    //  ---------------------------------------------------------------
    //   2. format transition condition
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List transitions = workflowProcess.getWorkflowTransitions();
      int tran_size = transitions.size();
      WorkflowTransition transition = null;

      for (int j = 0; j < tran_size; ++j)
      {
        transition = (WorkflowTransition) transitions.get(j);
        WorkflowCondition condition = transition.getCondition();
        if (condition != null && condition.getContent() != null)
        {
          ExtendedAttribute attribute = transition.findExtendedAttribute(XPDLGlobals.CONDITION_TYPE);
          if (attribute != null)
          {
            ConditionType ctype = ConditionType.parse(attribute.getValue());
            if (ConditionType.CONDITION_SCRIPT.equals(ctype))
            {
              transition.setCondition(new ScriptCondition(condition.getContent()));
            }

            transition.removeExtendedAttribute(XPDLGlobals.CONDITION_TYPE);
          }
        }
      }
    }

    //  ---------------------------------------------------------------
    //   3. format activity type
    //  ---------------------------------------------------------------   
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          activity.setActivityType(ActivityType.parse(attribute.getValue()));
          activity.removeExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        }
      }
    }

    //  ---------------------------------------------------------------
    //   4. format activity implementation
    //  ---------------------------------------------------------------
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();
        if (impl != null)
        {
          if (impl instanceof NoImplementation)
          {
            attribute = activity.findExtendedAttribute(XPDLGlobals.PAGE_URL);
            if (attribute != null)
            {
              activity.setImplementation(new PageImplementation(attribute.getValue()));
            }
          }
        }
      }
    }

    //  ---------------------------------------------------------------
    //   5. format performer type
    //  ---------------------------------------------------------------
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        if (attribute != null)
        {
          activity.setPerformerType(PerformerType.parse(attribute.getValue()));
          activity.removeExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        }
      }
    }

    //  ---------------------------------------------------------------
    //   6. format application QualifiedClassName
    //  --------------------------------------------------------------- 
    List wfApps = workflowPackage.getWorkflowApplications();
    int wfAppSize = wfApps.size();
    WorkflowApplication wfApp = null;
    for (int i = 0; i < wfAppSize; ++i)
    {
      wfApp = (WorkflowApplication) wfApps.get(i);
      ExtendedAttribute attribute = wfApp.findExtendedAttribute(XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
      if (attribute != null)
      {
        wfApp.setQualifiedClassName(attribute.getValue());
        wfApp.removeExtendedAttribute(XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
      }
    }

    //  ---------------------------------------------------------------
    //   7. validate workflowActivity Implementation & ActivityType
    //  ---------------------------------------------------------------   
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ToolImplementation toolImpl = null;
      ToolSet toolSet = null;
      SubFlowImplementation subFlowImpl = null;

      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();
        if (ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          if (impl != null && (impl instanceof SubFlowImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_BUSINESS' Implementation can not be 'SubFlow'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }

        if (ActivityType.ACTIVITY_SUBFLOW.equals(activity.getActivityType()))
        {
          if (impl != null && !(impl instanceof SubFlowImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_SUBFLOW' Implementation must be 'SubFlow'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }

        if (ActivityType.ACTIVITY_ROUTE.equals(activity.getActivityType()))
        {
          if (impl != null && !(impl instanceof NoImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_ROUTE' Implementation must be 'No'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }

      }
    }

    //  ---------------------------------------------------------------
    //   8. format workflowProcess  listener class name
    //  --------------------------------------------------------------- 
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      ExtendedAttribute attribute = workflowProcess.findExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
      if (attribute != null)
      {
        workflowProcess.setListenerClassName(attribute.getValue());
        workflowProcess.removeExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
      }
    }

    //  ---------------------------------------------------------------
    //   9. format workflowActivity  listener class name
    //  --------------------------------------------------------------- 
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();

      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

        + trueTransitions
        + "\nfalseTransitions==>"
        + falseTransitions
        + "\n\n");

    WorkflowProcess workflowProcess = dispWork.getWorkflowCase().getWorkflowProcess();

    WorkflowActivity trueJoinActivity = null;
    WorkflowActivity falseJoinActivity = null;
    WorkflowActivity orJoinActivity = null;

    List swap_trueTransitions = null;
    List swap_falseTransitions = null;

    //-------------------------------------------------------------------
    //  1.���� TRUE ·��ѡ�񷽰� ����TRUE TOKEN ����·��
    //-------------------------------------------------------------------

    trueJoinActivity = ((WorkflowTransition) trueTransitions.get(0)).getToWorkflowActivity();
    swap_trueTransitions = trueTransitions;

    boolean forceLoopTrueJoinActivity = false;
    boolean forceLoopFalseJoinActivity = false;

    LoopTrueJoinActivity : while (
      forceLoopTrueJoinActivity
        || (trueJoinActivity != null && !JoinType.JOIN_OR.equals(trueJoinActivity.getJoinType())))
    {
      forceLoopTrueJoinActivity = false;
      orJoinActivity = null;
     
      //---------------------------------------------------------------------------
      //  1.1 ���� TRUE ·��ѡ�񷽰�, ����next Activity û�� ׷�ݵ�OR Join Activity
      //  [����XPDL End Activity]
      //---------------------------------------------------------------------------
      swap_trueTransitions = trueJoinActivity.getOutgoingTransitions();
      if (swap_trueTransitions == null || swap_trueTransitions.size() == 0)
      {
        throw new WorkflowException("signalOrJoinActivity : outgoingTransitions.size()==0," + trueJoinActivity);
      }

      //---------------------------------------------------------------------------
      //  1.2 ���� TRUE ·��ѡ�񷽰�, ����next Activity û�� ׷�ݵ�OR Join Activity
      //  [��������XPDL �߼�����]
      //---------------------------------------------------------------------------
      trueJoinActivity = nextPossibleActivityFinder(trueJoinActivity, swap_trueTransitions);
      if (trueJoinActivity == null)
      {
        throw new WorkflowException("nextPossibleActivityFinder : nextOrJoinActivity is null");
      }

      //---------------------------------------------------------------------------
      //  1.3 ���� TRUE ·��ѡ�񷽰�, ѡ���next Acitivity ���� OR Join Activity
      //---------------------------------------------------------------------------
      if (!JoinType.JOIN_OR.equals(trueJoinActivity.getJoinType()))
      {
        //find next possible trueJoinActivity
        continue LoopTrueJoinActivity;
      }

      //---------------------------------------------------------------------------
      //  1.4 ���� TRUE ·��ѡ�񷽰�, ������ OR Join Activity
      //---------------------------------------------------------------------------
      log.debug("FOUND TRUE OR-JOIN-ACTIVITY : " +  trueJoinActivity.getInfo());

      //-------------------------------------------------------------------
      //  2.���� FALSE ·��ѡ�񷽰� ����FALSE TOKEN ����·��
      //------------------------------------------------------------------- 
      //---------------------------------------------------------------------------
      //  2.1 ���� FALSE ·��ѡ�񷽰�, �ַ�Activity next ·��ȫ����ѡ��
      //---------------------------------------------------------------------------
      swap_falseTransitions = falseTransitions;
      if (swap_falseTransitions == null || swap_falseTransitions.size() == 0)
      {
        //----------------------------------------
        // [����]  �������Ϸ��� OR Join Activity
        //----------------------------------------
        //or-split's all outTransitions are selected to process
        orJoinActivity = trueJoinActivity;
        break LoopTrueJoinActivity;
      }

      falseJoinActivity = ((WorkflowTransition) swap_falseTransitions.get(0)).getToWorkflowActivity();
      if(JoinType.JOIN_OR.equals(falseJoinActivity.getJoinType()))
      {
        //һ��OR Split  Activity ֱ�Ӻ�� Activity �� JoinType ��Ӧ��Ϊ OR
        throw new WorkflowException("Bad Format XPDL Data : OR Split Activity's next direct Activity's JoinType should not be 'OR'  ");
      }
     
      LoopFalseJoinActivity : while (
        forceLoopFalseJoinActivity
          || (falseJoinActivity != null && !JoinType.JOIN_OR.equals(falseJoinActivity.getJoinType())))
      {
        forceLoopFalseJoinActivity =false;
       
        swap_falseTransitions = falseJoinActivity.getOutgoingTransitions();
        //---------------------------------------------------------------------------
        //  2.2 ���� FLASE ·��ѡ�񷽰�, ���� next Activity û�� ׷�ݵ� OR Join Activity
        //      [����XPDL End Activity]
        //---------------------------------------------------------------------------
        if (swap_falseTransitions == null || swap_falseTransitions.size() == 0)
        {
          break LoopFalseJoinActivity;
        }

        falseJoinActivity = nextPossibleActivityFinder(falseJoinActivity, swap_falseTransitions);

        //---------------------------------------------------------------------------
        //  2.3 ���� FLASE ·��ѡ�񷽰�, ����next Activity û�� ׷�ݵ� OR Join Activity
        //      [��������XPDL �߼�����]
        //---------------------------------------------------------------------------
        if (falseJoinActivity == null)
        {
          break LoopFalseJoinActivity;
        }
        //---------------------------------------------------------------------------
        //  2.4 ���� FALSE ·��ѡ�񷽰�, ѡ���next Acitivity ���� OR Join Activity
        //      [����]  �ƶ� FALSE TOKEN ��ѡ����һ�� OR Join Activity ���в���
        //---------------------------------------------------------------------------
        if (!JoinType.JOIN_OR.equals(falseJoinActivity.getJoinType()))
        {
          //find next possible falseJoinActivity
          continue LoopFalseJoinActivity;
        }

        //---------------------------------------------------------------------------
        //  2.5 ���� FALSE ·��ѡ�񷽰�, ������ OR Join Activity
        //---------------------------------------------------------------------------
        log.debug("FOUND FALSE OR-JOIN-ACTIVITY : " + falseJoinActivity.getInfo());


        if (falseJoinActivity.getUUID().equals(trueJoinActivity.getUUID()))
        {
          //---------------------------------------------------------------------------
          //  2.6.1 ���� TRUE/FALSE ·��ѡ�񷽰�, ������ �Ϸ��� OR Join Activity
          //         [����]  �������Ϸ��� OR Join Activity
          //---------------------------------------------------------------------------
         
          //OR-JOIN Activity found
          orJoinActivity = falseJoinActivity;
          break LoopTrueJoinActivity;
        }
        else
        {
          //---------------------------------------------------------------------------
          //  2.6.2 ���� TRUE/FALSE ·��ѡ�񷽰�, û�м����� �Ϸ��� OR Join Activity
          //         [����]  �ƶ� FALSE TOKEN ��ѡ����һ�� OR Join Activity ���в���
          //---------------------------------------------------------------------------
          forceLoopFalseJoinActivity=true;
          continue LoopFalseJoinActivity;
        }

      } //~end while (falseJoinActivity != null && !JoinType.JOIN_OR.equals(falseJoinActivity.getJoinType()))

      //---------------------------------------------------------------------------
      //  1.5 ���� TRUE/FALSE ·��ѡ�񷽰�, û�м����� OR Join Activity
      //      [����] �ƶ� TRUE TOKEN ��ѡ����һ�� OR Join Activity ���в���
      //---------------------------------------------------------------------------               
      //find next possible orJoinActivity
      forceLoopTrueJoinActivity = true;
      continue LoopTrueJoinActivity;

      //------------------------------------------------------------------------------       
    } //~end while (trueJoinActivity != null && !JoinType.JOIN_OR.equals(trueJoinActivity.getJoinType()))

    if (orJoinActivity == null)
    {
      throw new WorkflowException("signalOrJoinActivity : orJoinActivity not found");
    }

    log.debug("orJoinActivity : " + orJoinActivity.getInfo());

    Connection conn = (Connection) userTransaction.getStoreConnection().get();
    String packageId = workflowProcess.getWorkflowPackage().getUUID();
    String processId = workflowProcess.getUUID();
    String caseId = dispWork.getWorkflowCase().getUUID();

    int size = falseTransitions.size();
    for (int i = 0; i < size; ++i)
    {
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

      }

      if (activity_dispatch_transition_id != null)
      {
        log.debug("[" + fromActivity + "] select  or-join-transition by attribute '"+XPDLGlobals.ACTIVITY_DISPATCH_TRANSITION_ID+"'");
        WorkflowProcess activity_owner_process = fromActivity.getWorkflowProcess();
        WorkflowTransition transition = activity_owner_process.findWorkflowTransition(activity_dispatch_transition_id);
        joinActivity = transition.getToWorkflowActivity();
      }
      else
      {
        log.debug("[" + fromActivity + "] select first transition as or-join-transition");
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

    //---------------------------------------------------------
    // 1. format WorkflowProcess LISTENER_QUALIFIED_CLASS_NAME
    //---------------------------------------------------------
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);

      String className = workflowProcess.getListenerClassName();

      if (className != null && className.length() > 0)
      {
        try
        {
          Class implClass = loader.loadClass(className);
          WorkflowProcessListener listener = (WorkflowProcessListener) implClass.newInstance();
          workflowProcess.addWorkflowProcessListener(listener);
        }
        catch (Throwable ex)
        {
          errorList.add(new WorkflowException("Can not load class :" + className, ex));
          System.err.println("Can not load class :" + className);
          System.err.println(loader);
        }
      }
    }
    //---------------------------------------------------------
    // 2. format WorkflowActivity LISTENER_QUALIFIED_CLASS_NAME
    //---------------------------------------------------------    
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();
      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

   
    this.attributes=workflowPackage.getExtendedAttributes();
    this.applications=workflowPackage.getWorkflowApplications();
    this.parameters=workflowPackage.getWorkflowParameters();
   
    WorkflowProcess workflowProcess = null;
    for (int i = 0; i < workflowPackage.getWorkflowProcesses().size(); ++i)
    {
      workflowProcess = (WorkflowProcess) workflowPackage.getWorkflowProcesses().get(i);
      processes.add(new SerialProcess(workflowProcess));
    }
View Full Code Here

Examples of org.huihoo.workflow.xpdl.WorkflowProcess

  public SerialWork(WorkflowWork workflowWork)
  {
    super(workflowWork);
   
    WorkflowCase workflowCase=workflowWork.getWorkflowCase();
    WorkflowProcess workflowProcess=workflowCase.getWorkflowProcess();
    this.caseID=workflowCase.getUUID();
    this.packageID=workflowProcess.getWorkflowPackage().getUUID();
    this.processID=workflowProcess.getUUID();
   
    WorkflowActivity workflowActivity=workflowWork.getWorkflowActivity();
    this.activityProcessID=workflowActivity.getWorkflowProcess().getUUID();
    this.activityID=workflowActivity.getUUID();
   
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.