private void CreateAttachmentTo(Workflow instance)
{
TransformationEngine.IsAttached attached =
instance.IsAttached[WorkflowFactory.IndexOfActivity(device.fromIsAttached)];
// instance.IsAttached.Find(x => (x.toDevice.Equals(device.DeviceID)));
AttachedTo = new IsAttached(attached,instance);
}
/// <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);
}
}
}
private void ConnectToNextActivity(Workflow wfInstance)
{
if (myActivity.ToActivity != null)
{
if (myActivity.Type.Equals(BoundaryType.Start))
{
string activityID =
wfInstance.Call[WorkflowFactory.IndexOfActivity(myActivity.ToActivity)].activityID;
DefaultNextActivityID = activityID;
}
}
}
/// <summary>
/// Builds the connection.
/// </summary>
/// <param name="instance">The instance.</param>
private void BuildConnection(Workflow instance)
{
int key = 1;
foreach (string deviceID in myConnection.fromDevice)
{
TransformationEngine.Device aDevice = instance.Device[WorkflowFactory.IndexOfActivity(deviceID)];//.//Find(x => (x.DeviceID.Equals(deviceID)));
if (aDevice.isLocal)
deviceDictionary.Add(0, new Device(aDevice,instance));
else
{
deviceDictionary.Add(key, new Device(aDevice, instance));
key++;
}
}
}
/// <summary>
/// Creates the workflow runtime.
/// </summary>
/// <param name="wfObj">The wf obj.</param>
/// <returns></returns>
public WFRunner CreateWorkflowRuntime(Workflow wfObj)
{
WFRunner runner = null;
Exception except;
try
{
TransformationEngine.Boundary start =
wfObj.Boundary.Find(x => x.Type.Equals(BoundaryType.Start));
TransformationEngine.Boundary end =
wfObj.Boundary.Find(x => x.Type.Equals(BoundaryType.End));
ConnectTheLines(wfObj, start, end, out runner);
}
catch(Exception innerExcept)
{
throw innerExcept;
}
return runner;
}
private void ConnectTheLines(Workflow wfObj, TransformationEngine.Boundary start, TransformationEngine.Boundary end, out WFRunner runner)
{
runner = new WFRunner();
WFElement currentElement = new Boundary(start,wfObj);
WFElement endElement = new Boundary(end,wfObj);
runner.WorkflowElements.Add(currentElement);
// Recurse into the edges between the nodes....
BuildNextElement(runner, currentElement, endElement, wfObj);
//
runner.WorkflowElements.Add(endElement);
}
public void SetUp()
{
_doc = SchemaTransformer.GetObjectModel(@"C:\Documents and Settings\jeanr\Desktop\RRComSSysTeam5\RRComSSys\RRComSSys.WorkflowEngine.Tests\TestResources\AlternateWithWorkflow2.gcml");
}
public Decision( TransformationEngine.Decision aDecision, Workflow wfInstance)
{
decision = aDecision;
}
/// <summary>
/// Initializes a new instance of the <see cref="Connection"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="wfInstance">The wf instance.</param>
public Connection( TransformationEngine.Connection connection, Workflow wfInstance)
{
ConnectionType = connection;
BuildConnection(wfInstance);
}
/// <summary>
/// Builds the connection.
/// </summary>
/// <param name="instance">The instance.</param>
private void BuildConnection(Workflow instance)
{
try
{
TransformationEngine.Connection aConnection =
instance.Connection[WorkflowFactory.IndexOfActivity(myActivity.CallToConnection)];
//.Find(x => (x.ConnectionID == myActivity.CallToConnection));
CallConnection = new Connection(aConnection, instance);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Attaches to person.
/// </summary>
/// <param name="wfInstance">The wf instance.</param>
private void AttachToPerson(Workflow wfInstance)
{
TransformationEngine.Person aPerson = wfInstance.Person.Find(x => x.personID.Equals(isAttached.fromPerson));//[WorkflowFactory.IndexOfActivity(isAttached.fromPerson)];//.Find(x => (x.personID.Equals(isAttached.fromPerson)));
person = new WorkflowEngine.Person(aPerson);
}
/// <summary>
/// Initializes a new instance of the <see cref="IsAttached"/> class.
/// </summary>
/// <param name="anIsAttached">An is attached.</param>
/// <param name="wfInstance">The wf instance.</param>
public IsAttached(TransformationEngine.IsAttached anIsAttached, Workflow wfInstance)
{
isAttached = anIsAttached;
AttachToPerson(wfInstance);
}
/// <summary>
/// Deserializes workflow markup from file into an Workflow object
/// </summary>
// <param name="xml">string workflow markup to deserialize</param>
// <param name="obj">Output Workflow object</param>
// <param name="exception">output Exception value if deserialize failed</param>
// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
public static bool LoadFromFile(string fileName, out Workflow obj, out System.Exception exception)
{
exception = null;
obj = null;
try
{
System.IO.FileStream file = new System.IO.FileStream(fileName, FileMode.Open, FileAccess.Read);
System.IO.StreamReader sr = new System.IO.StreamReader(file);
string xmlString = sr.ReadToEnd();
sr.Close();
file.Close();
return Deserialize(xmlString, out obj, out exception);
}
catch (System.Exception e)
{
exception = e;
return false;
}
}
/// <summary>
/// Deserializes workflow markup into an Workflow object
/// </summary>
// <param name="xml">string workflow markup to deserialize</param>
// <param name="obj">Output Workflow object</param>
// <param name="exception">output Exception value if deserialize failed</param>
// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
public static bool Deserialize(string xml, out Workflow obj, out System.Exception exception)
{
exception = null;
obj = null;
try
{
System.IO.StringReader stringReader = new System.IO.StringReader(xml);
System.Xml.XmlTextReader xmlTextReader = new System.Xml.XmlTextReader(stringReader);
System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Workflow));
obj = ((Workflow)(xmlSerializer.Deserialize(xmlTextReader)));
return true;
}
catch (System.Exception e)
{
exception = e;
return false;
}
}
public Boundary( TransformationEngine.Boundary obj, Workflow wfInstance)
{
myActivity = obj;
ConnectToNextActivity(wfInstance);
}
/// <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);
}
}
}
/// <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
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Call"/> class.
/// </summary>
/// <param name="aCall">A call.</param>
/// <param name="wfInstance">The wf instance.</param>
public Call( TransformationEngine.Call aCall, Workflow wfInstance )
{
myActivity = aCall;
BuildConnection(wfInstance);
}
public SchemaInstantiator(Workflow doc, IMissingAttributeHandler handler)
{
Document = doc;
MissingAttributeEvt = handler.GetMissingAttribute;
}
public Device( TransformationEngine.Device aDevice, Workflow wfInstance)
{
device = aDevice;
CreateAttachmentTo(wfInstance);
}