Exemplo n.º 1
0
        /// <summary>
        /// Builds the next element.
        /// </summary>
        /// <param name="runner">The runner.</param>
        /// <param name="currentElement">The current element.</param>
        /// <param name="endElement">The end element.</param>
        /// <param name="wfInstance">The wf instance.</param>
        private void BuildNextElement(WFRunner runner, WFElement currentElement,WFElement endElement, Workflow wfInstance)
        {
            WFElement outElement = null;

              if (currentElement.GetType() == typeof (Boundary))
              {
              // This should only be entered into during the top level invocation
              // i.e. for the "Start" boundary itself.

              string nextActivity = currentElement.NextActivityID();
              //TransformationEngine.Call aCall =
              // wfInstance.Call.Find(x => x.activityID.Equals(nextActivity));
              TransformationEngine.Call aCall = wfInstance.Call.Find(x=>x.activityID.Equals(nextActivity));//[WorkflowFactory.IndexOfActivity(nextActivity)];
              if ( null != aCall )
              {
                // Create and add the new call...set this boundary as one of it's predecessors
                outElement = new Call(aCall, wfInstance);
                outElement.PreviousElements.Add(currentElement);
                runner.WorkflowElements.Add(outElement);
                BuildNextElement(runner, outElement, endElement, wfInstance);
              }
              else
              {
                if (currentElement.NextActivityID().Equals(endElement.GetActivityID()))
                {
                  // Empty workflow...just add the start as a previous element to the end.
                  endElement.PreviousElements.Add(currentElement);
                }
              }
              }
              else if (currentElement.GetType() == typeof(Call))
              {
             ConstructCall(runner, currentElement, endElement, wfInstance);
              }
              else if (currentElement.GetType() == typeof(Decision))
              {
            TransformationEngine.Decision decision = ((Decision) currentElement).DecisionModel;
            string successID = decision.successPathID;
            string failID = decision.failPathID;

            currentElement.DefaultNextActivityID = successID;

            if (null == runner.WorkflowElements.Find(x => (x.GetActivityID().Equals(successID))))
            {
              // Find the item that this is
              // Construct the Success Branch
              ConstructDecisionBranch(runner,currentElement,successID,endElement,wfInstance);
            }
            if (null == runner.WorkflowElements.Find(x => x.GetActivityID().Equals(failID)))
            {
              // Find the item that this is
              // Construct the Fail Branch
              ConstructDecisionBranch(runner, currentElement, failID, endElement, wfInstance);
            }
              }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Constructs the decision branch.
        /// </summary>
        /// <param name="runner">The runner.</param>
        /// <param name="currentElement">The current element.</param>
        /// <param name="elementActivityID">The element activity ID.</param>
        /// <param name="endElement">The end element.</param>
        /// <param name="wfInstance">The wf instance.</param>
        private void ConstructDecisionBranch(WFRunner runner, WFElement currentElement, string elementActivityID, WFElement endElement, Workflow wfInstance)
        {
            TransformationEngine.Call possibleCall = wfInstance.Call.Find(x => x.activityID.Equals(elementActivityID));
            if (null != possibleCall)
            {
              // We know it's a call
              // See if it's already within the workflow
              WFElement possibleElement = ElementExistsInWorkflow(runner,possibleCall.activityID);
              if (null == possibleElement)
              {
                // If it isn't, add it, and keep recursing.
                WFElement outElement = new Call(possibleCall, wfInstance);
                outElement.PreviousElements.Add(currentElement);
                currentElement.DefaultNextActivityID = outElement.GetActivityID();
                runner.WorkflowElements.Add(outElement);
                BuildNextElement(runner, outElement, endElement, wfInstance);
              }
            }
            else
            {
              // MUST be the "End" boundary
              // Add this Decision to the "End" boundaries previousElements

              endElement.PreviousElements.Add(currentElement);
              // return
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Determines the next activity.
        /// </summary>
        /// <returns></returns>
        private WFElement DetermineNextActivity()
        {
            WFElement nextElement = null;

              Boundary end = (Boundary)elements.Find(x => ((x.TypeOfActivity() == typeof(Boundary)) && ((Boundary)x).Ends()));
              if ( currentElement.TypeOfActivity().Equals(typeof(Decision)))
              {
              Decision decisionElement = (Decision) currentElement;
              WFElement callElement = FindPreviousActivity(decisionElement);
              if (callElement.Outcome)
              {
                nextElement = elements.Find(x => x.GetActivityID().Equals(decisionElement.DecisionModel.successPathID));
                if (null != nextElement)
                {
                  currentElement = nextElement;
                }
                else
                  currentElement = null; // THIS SHOULD NOT HAPPEN
              }
              else
              {
                nextElement = elements.Find(x => x.GetActivityID().Equals(decisionElement.DecisionModel.failPathID));
                if (null != nextElement)
                {
                  currentElement = nextElement;
                }
                else
                  currentElement = null; // THIS SHOULD NOT HAPPEN
              }
              }
              else if (currentElement.DefaultNextActivityID.Equals(end.GetActivityID()))
              {
            // Hit the end element.....exit the workflow
            currentElement = null;
            return currentElement;
              }
              else
              {
            nextElement = elements.Find(x => x.GetActivityID().Equals(currentElement.NextActivityID()));
            if (null != nextElement)
              currentElement = nextElement;
            else
            {
              currentElement = null; // THIS SHOULD NOT HAPPEN
            }
              }

              return currentElement;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Constructs the call.
        /// </summary>
        /// <param name="runner">The runner.</param>
        /// <param name="currentElement">The current element.</param>
        /// <param name="endElement">The end element.</param>
        /// <param name="wfInstance">The wf instance.</param>
        private void ConstructCall(WFRunner runner, WFElement currentElement, WFElement endElement, Workflow wfInstance)
        {
            WFElement outElement = null;
              Call theCall = (Call) currentElement;
              string callToDecision = theCall.CallModel().CallToDecision;
              string callToBoundary = theCall.CallModel().CallToBoundary;

              TransformationEngine.Boundary calledBoundary = (!string.IsNullOrEmpty(callToBoundary)) ? wfInstance.Boundary[WorkflowFactory.IndexOfActivity(callToBoundary)]
                                                                                                : null;

              TransformationEngine.Decision calledDecision = (!string.IsNullOrEmpty(callToDecision)) ? wfInstance.Decision[WorkflowFactory.IndexOfActivity(callToDecision)]
                                                                                                : null;

              if (null != calledBoundary )
              {
              if (calledBoundary.Type.Equals(TransformationEngine.BoundaryType.End))
              {
                  if( (null != calledDecision ) && (null == currentElement.PreviousElements.Find(x=>x.GetActivityID().Equals(calledDecision.activityID))))
                  {
                      throw new Exception(
                          "Call Cannot be Connected to a Decision and End Elements without having parsed the Decision");
                  }
                  currentElement.DefaultNextActivityID = endElement.GetActivityID();
                  endElement.PreviousElements.Add(currentElement);
                  return; // If I've hit an END Boundary node, no need to look at the Decision node
              }
              }

              if (null != calledDecision)
              {
              if (null !=
                  currentElement.PreviousElements.Find(x => x.GetActivityID().Equals(calledDecision.activityID)))
              {
                  throw new Exception("Decision was already connected to this Call");

              }
              else
              {
                    outElement = new Decision(calledDecision, wfInstance);

                    // Add the Call to the Decision's PreviousElements
                    outElement.PreviousElements.Add(currentElement);
                    // Set Default Next Activity ID
                    currentElement.DefaultNextActivityID = outElement.GetActivityID();
                    // Add the Decision to the Workflow
                    runner.WorkflowElements.Add(outElement);

                    // Try to build next Element
                    BuildNextElement(runner, outElement, endElement, wfInstance);
              }
              }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Processes the element.
        /// </summary>
        /// <param name="currentElem">The current elem.</param>
        private void processElement(WFElement currentElem)
        {
            currentElement = currentElem;
              // Simple workflow loop
              do
              {
              currentElement.ProcessActivity();
              currentElement = DetermineNextActivity();

              } while (null != currentElement);
        }