Examples of org.huihoo.workflow.xpdl.WorkflowProcess

org.huihoo.workflow.xpdl.WorkflowProcess
@author reicTo change the template for this generated type comment go to Window - Preferences - Java - Code Generation - Code and Comments

    //  ---------------------------------------------------------------
    //   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

    //  ---------------------------------------------------------------
    //   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

        + 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

      }


      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

    //---------------------------------------------------------
    // 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

    
    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

  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

    
    public SerialTransition(WorkflowTransition workflowTransition)
    {
      super(workflowTransition);
      
      WorkflowProcess workflowProcess=workflowTransition.getWorkflowProcess();
      this.packageID=workflowProcess.getWorkflowPackage().getUUID();
      this.processID=workflowProcess.getUUID();
      
      WorkflowActivity tempActivity=workflowTransition.getFromWorkflowActivity();
      fromActivityID=(tempActivity==null?null:tempActivity.getUUID());
      
      tempActivity=workflowTransition.getToWorkflowActivity();

View Full Code Here

    log.debug(" SplitType.SPLIT_XOR  select (single) specific  out transitions");


    List outTrans = new ArrayList();
    WorkflowActivity workActivity = workflowWork.getWorkflowActivity();
    List transList = workActivity.getOutgoingTransitions();
    WorkflowProcess workflowProcess = workActivity.getWorkflowProcess();
    WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
    ScriptInterpretor interpretor = workflowService.getScriptInterpretor();


    RuntimeContext context = null;
    WorkflowCase workflowCase = workflowWork.getWorkflowCase();
    WorkflowCaseContext caseContext = workflowCase.getCaseContext();

View Full Code Here

    log.debug(" SplitType.SPLIT_OR  select out transitions based on condition evaluation");


    List outTrans = new ArrayList();
    WorkflowActivity workActivity = workflowWork.getWorkflowActivity();
    List transList = workActivity.getOutgoingTransitions();
    WorkflowProcess workflowProcess = workActivity.getWorkflowProcess();
    WorkflowPackage workflowPackage = workflowProcess.getWorkflowPackage();
    ScriptInterpretor interpretor = workflowService.getScriptInterpretor();


    RuntimeContext context = null;
    WorkflowCase workflowCase = workflowWork.getWorkflowCase();
    WorkflowCaseContext caseContext = workflowCase.getCaseContext();

View Full Code Here

0 1 2 3

TOP

Related Classes of org.huihoo.workflow.xpdl.WorkflowProcess

org.huihoo.willow.client.SerialCaseDatabaseImpl

org.huihoo.workflow.client.serial.model.SerialActivity

org.huihoo.workflow.client.serial.model.SerialPackage

org.huihoo.workflow.client.serial.model.SerialTransition

org.huihoo.workflow.client.serial.model.SerialWork

org.huihoo.workflow.impl.store.spi.InternalCaseDatabase

org.huihoo.workflow.impl.store.util.ContexManager

org.huihoo.workflow.impl.store.util.DefaultActivityController

org.huihoo.workflow.impl.store.util.DispatchController

org.huihoo.workflow.impl.store.util.JoinActivityFinder

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.