public void FlowDecisionAsStartElement()
{
TestFlowchart flowchart1 = new TestFlowchart("flowChart1");
TestWriteLine w2True = new TestWriteLine("True", "True will execute");
TestWriteLine w2False = new TestWriteLine("False", "False wont execute");
Variable <int> margin = VariableHelper.CreateInitialized <int>("Margin", 10);
flowchart1.Variables.Add(margin);
TestFlowConditional flowDecision = new TestFlowConditional(HintTrueFalse.True);
flowDecision.ConditionExpression = (context => margin.Get(context) > 0);
TestFlowElement tCond = flowchart1.AddConditionalLink(null, flowDecision, w2True, w2False);
TestRuntime.RunAndValidateWorkflow(flowchart1);
}
//<Snippet1>
static Activity CreateWF()
{
Variable <string> name = new Variable <string>();
Sequence body = new Sequence
{
Variables = { name },
Activities =
{
new WriteLine {
Text = "What is your name? (You have 5 seconds to answer)"
},
new Pick
{
Branches =
{
new PickBranch
{
Trigger = new ReadString
{
Result = name,
BookmarkName = bookmarkName
},
Action = new WriteLine
{
Text = new InArgument <string>(env => "Hello " + name.Get(env))
}
},
new PickBranch
{
Trigger = new Delay
{
Duration = TimeSpan.FromSeconds(5)
},
Action = new WriteLine
{
Text = "Time is up."
}
}
}
}
}
};
return(body);
}
// Workflow variable by Linq
public void VariableByLinq()
{
// Linq treats local variable with special syntax.
// See comment in LeafHelper.GetMemberAccessVariableExpression for more info.
// The purpose test is to use real compiler generated lambda expression.
Variable <string> var = new Variable <string>()
{
Name = "var",
Default = "Linq var test"
};
Expression <Func <ActivityContext, string> > expression = (env) => var.Get(env);
CoreWf.Statements.Sequence expectedSequence = new CoreWf.Statements.Sequence()
{
Variables =
{
var
},
Activities =
{
new WriteLine()
{
Text = var
}
}
};
CoreWf.Statements.Sequence actualSequence = new CoreWf.Statements.Sequence()
{
Variables =
{
var
},
Activities =
{
new WriteLine()
{
Text = ExpressionServices.Convert(expression)
}
}
};
ExpressionTestRuntime.ValidateActivity(expectedSequence, actualSequence);
}
private void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
IEnumerator<NMElement> _enum = _elements.Get(context);
if (_enum == null) return;
bool more = _enum.MoveNext();
if (more)
{
context.ScheduleAction<NMElement>(Body, _enum.Current, OnBodyComplete);
}
else
{
if (LoopAction != null)
{
var allelements = context.GetValue(_allelements);
context.ScheduleActivity(LoopAction, LoopActionComplete);
}
}
}
private void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
IEnumerator <SAPElement> _enum = _elements.Get(context);
bool more = _enum.MoveNext();
if (more && !breakRequested)
{
IncIndex(context);
context.ScheduleAction <SAPElement>(Body, _enum.Current, OnBodyComplete);
}
else
{
if (LoopAction != null && !breakRequested)
{
context.ScheduleActivity(LoopAction, LoopActionComplete);
}
}
}
/// <summary>
/// Gets the code for the activity that is responsible for getting the location and executable name
/// of the devenv version we need
/// </summary>
/// <param name="devEnvPathVariable">the variable that holds the dev env path</param>
/// <param name="logFileLocationVariable">the variable that holds the complete path of the log filePath</param>
/// <param name="devEnvCommandPathVariable">the variable that holds the path+exec name to be executed</param>
/// <param name="devEnvArgumentsVariable">the arguments that holds the arguments to be passed to devenv</param>
/// <returns>the activity</returns>
private GetDevEnvCallingParameters GetDevEnvCallingParametersBody(Variable <string> devEnvPathVariable, Variable <string> logFileLocationVariable, Variable <string> devEnvCommandPathVariable, Variable <string> devEnvArgumentsVariable)
{
return(new GetDevEnvCallingParameters
{
DevEnvPath = new InArgument <string>(env => devEnvPathVariable.Get(env)),
FilePath = new InArgument <string>(env => this.FilePath.Get(env)),
ProjectPath = new InArgument <string>(env => this.ProjectPath.Get(env)),
Configuration = new InArgument <string>(env => this.Configuration.Get(env)),
ProjectConfiguration = new InArgument <string>(env => this.ProjectConfiguration.Get(env)),
Platform = new InArgument <string>(env => this.Platform.Get(env)),
Action = new InArgument <VSDevEnvAction>(this.Action),
OutputFile = new InArgument <string>(logFileLocationVariable),
DevEnvCommandPath = new OutArgument <string>(devEnvCommandPathVariable),
Arguments = new OutArgument <string>(devEnvArgumentsVariable)
});
}
private void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
var session = _elements.Get(context);
if (session == null)
{
return;
}
string WorkflowInstanceId = context.WorkflowInstanceId.ToString();
if (session.WorkflowInstanceId != WorkflowInstanceId)
{
return;
}
session.Disconnect();
GenericTools.RunUI(session.Close);
RunPlugin.Sessions.Remove(session);
}
public void WhileInfiniteLoopFaultAfterHundredLoops()
{
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("Seq");
TestIncrement increment = new TestIncrement("test increment");
TestSequence inNestedSequence = new TestSequence("Sequence in Nested while");
TestThrow <ArithmeticException> throwTestActivity = new TestThrow <ArithmeticException>();
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestWhile whileAct = new TestWhile("while act")
{
ConditionExpression = ((env) => ((int)counter.Get(env)) < 200),
Body = innerSequence,
HintIterationCount = 200,
};
inNestedSequence.Activities.Add(whileAct);
inNestedSequence.Activities.Add(throwTestActivity);
TestWhile whileActNested = new TestWhile("while act")
{
ConditionExpression = ((env) => (true)),
Body = inNestedSequence,
HintIterationCount = 200,
};
TestWriteLine writeLine = new TestWriteLine("write hello")
{
Message = "Its a small world after all"
};
increment.CounterVariable = counter;
innerSequence.Activities.Add(writeLine);
innerSequence.Activities.Add(increment);
outerSequence.Variables.Add(counter);
outerSequence.Activities.Add(whileActNested);
TestRuntime.RunAndValidateAbortedException(outerSequence, typeof(ArithmeticException), new Dictionary <string, string>());
}
private void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
{
var eventArgs = obj as WorkflowNotificationEventArgs;
if (eventArgs == null || string.CompareOrdinal(eventArgs.NotificationType, WorkflowNotificationObserver.NotificationType.ContentChanged) != 0)
{
return;
}
ReleaseWait(context, eventArgs.NodeId);
var count = counter.Get(context) - 1;
counter.Set(context, count);
if (count > 0)
{
context.CreateBookmark(bookmark.Name, new BookmarkCallback(Continue));
}
}
public void AddSameElementToParentAndChild()
{
TestFlowchart flowchart1 = new TestFlowchart("flowChart1");
TestFlowchart flowchart2 = new TestFlowchart("flowChart2");
TestWriteLine w1 = new TestWriteLine("W1", "Executing W1");
TestFlowElement fStep = new TestFlowStep(w1);
flowchart2.Elements.Add(fStep);
Variable <int> margin = VariableHelper.CreateInitialized <int>("Margin", 10);
flowchart1.Variables.Add(margin);
TestFlowConditional flowDecision = new TestFlowConditional(HintTrueFalse.True);
flowDecision.ConditionExpression = (context => margin.Get(context) > 0);
TestFlowElement tCond = flowchart1.AddConditionalLink(null, flowDecision, fStep, flowchart2);
TestRuntime.ValidateInstantiationException(flowchart1, string.Format(ErrorStrings.FlowNodeCannotBeShared, flowchart1.DisplayName, flowchart2.DisplayName));
}
private void ActionFailed(NativeActivityFaultContext faultContext, Exception propagatedexception, ActivityInstance propagatedfrom)
{
Int32 currentAttemptCount = _attemptCount.Get(faultContext);
Int32 maxAttempts = MaxAttempts.Get(faultContext);
Type[] exceptionType = ExceptionType.Get(faultContext);
//Increment and track the count
currentAttemptCount++;
_attemptCount.Set(faultContext, currentAttemptCount);
if (currentAttemptCount >= maxAttempts)
{
// There are no further attempts to make
return;
}
if (ShouldRetryAction(exceptionType, propagatedexception) == false)
{
_log.Error("Will only retry exception of type '" + exceptionType.ToCSV() + "'. Unhandled type of '" + propagatedexception.GetType().FullName + "' was found.", propagatedexception);
return;
}
faultContext.CancelChild(propagatedfrom);
faultContext.HandleFault();
TimeSpan retryInterval = _delayOverrideForUnitTests == null?RetryInterval.Get(faultContext) : _delayOverrideForUnitTests.Value;
_log.Debug("Retrying in " + retryInterval.TotalSeconds + " seconds due to " + propagatedexception.GetType().FullName + ". " + currentAttemptCount + " of " + maxAttempts);
if (retryInterval == TimeSpan.Zero)
{
ExecuteAttempt(faultContext);
}
else
{
// We are going to wait before trying again
_delayDuration.Set(faultContext, retryInterval);
faultContext.ScheduleActivity(
_internalDelay,
DelayCompleted);
}
}
private void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
{
var eventArgs = obj as WorkflowNotificationEventArgs;
if (eventArgs.NotificationType != WorkflowNotificationObserver.CONTENTCHANGEDNOTIFICATIONTYPE)
{
return;
}
ReleaseWait(context, eventArgs.NodeId);
var count = counter.Get(context) - 1;
counter.Set(context, count);
if (count > 0)
{
context.CreateBookmark(bookmark.Name, new BookmarkCallback(Continue));
}
}
private void BookmarkCallback(NativeActivityContext context, Bookmark bookmark, object bookmarkData)
{
_iteration.Set(context, _iteration.Get(context) + 1);
string dataString = bookmarkData as string;
if (dataString != null)
{
Console.WriteLine("Interation: {0}; Bookmark {1} resumed with data: {2}", _iteration.Get(context).ToString(), bookmark.Name, dataString);
if (string.Compare(dataString, "stop", true) == 0)
{
context.RemoveBookmark(bookmark.Name);
}
}
else
{
Console.WriteLine("Iteration: {0}; Bookmark {1} resumed with data that is not a string", _iteration.Get(context).ToString(), bookmark.Name);
}
}
public void IfInWhileWithPersistence()
{
// Test case description:
// Above scenario with persistence to see if there will be any change in the behavior and if we are able
// tp preserve the state and the rules fine.
Variable <int> count = new Variable <int> {
Name = "Counter", Default = 0
};
TestWhile whileAct = new TestWhile
{
Variables = { count },
Body = new TestSequence
{
Activities =
{
new TestIf(HintThenOrElse.Then)
{
Condition = true,
ThenActivity = new TestBlockingActivity("Bookmark"),
},
new TestIncrement {
CounterVariable = count, IncrementCount = 1
}
}
},
ConditionExpression = (e => count.Get(e) < 1),
HintIterationCount = 1
};
JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(whileAct, null, jsonStore, PersistableIdleAction.None))
{
runtime.ExecuteWorkflow();
runtime.WaitForIdle();
runtime.PersistWorkflow();
runtime.ResumeBookMark("Bookmark", null);
runtime.WaitForCompletion();
}
}
public void UseBaseTypeAsDerivedType()
{
Variable <Derived> result = new Variable <Derived>()
{
Name = "Result"
};
Variable <string> output = new Variable <string>()
{
Name = "Output"
};
TestInvokeMethod invokeMethod = new TestInvokeMethod
{
TargetObjectVariable = result,
MethodName = "MethodInDerivedType"
};
invokeMethod.SetResultVariable <string>(output);
//Base b = new Derived();
//string result = (b as Derived).MethodInDerivedType
TestSequence seq = new TestSequence
{
Variables = { result, output },
Activities =
{
new TestAs <Base, Derived>
{
OperandExpression = context => new Derived(),
Result = result
},
invokeMethod,
new TestWriteLine
{
MessageExpression = (e => output.Get(e)),
HintMessage = "Ola"
}
}
};
TestRuntime.RunAndValidateWorkflow(seq);
}
protected virtual void OnExecutedCompleted(NativeActivityContext context, bool hasError, bool isResumable)
{
var dataListExecutionID = DataListExecutionID.Get(context);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var dataObject = context.GetExtension <IDSFDataObject>();
if (dataObject.ForceDeleteAtNextNativeActivityCleanup)
{
// Used for web-pages to signal a force delete after checks of what would become a zombie datalist ;)
dataObject.ForceDeleteAtNextNativeActivityCleanup = false; // set back
compiler.ForceDeleteDataListByID(dataListExecutionID);
}
if (!dataObject.IsDebugNested)
{
dataObject.ParentInstanceID = _previousParentInstanceID;
}
dataObject.NumberOfSteps = dataObject.NumberOfSteps + 1;
//Disposes of all used data lists
int threadID = Thread.CurrentThread.ManagedThreadId;
if (dataObject.IsDebugMode())
{
List <Guid> datlistIds;
if (!dataObject.ThreadsToDispose.TryGetValue(threadID, out datlistIds))
{
dataObject.ThreadsToDispose.Add(threadID, new List <Guid> {
dataObject.DataListID
});
}
else
{
if (!datlistIds.Contains(dataObject.DataListID))
{
datlistIds.Add(dataObject.DataListID);
dataObject.ThreadsToDispose[threadID] = datlistIds;
}
}
}
}
public void DecisionTrueEvaluation()
{
TestFlowchart flowchart = new TestFlowchart("Flow1");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 3);
flowchart.Variables.Add(counter);
TestWriteLine writeLine1 = new TestWriteLine("hello1", "Hello1");
TestWriteLine writeLine2 = new TestWriteLine("hello2", "Hello2");
TestWriteLine writeLine3 = new TestWriteLine("hello3", "Hello3");
TestFlowConditional flowDecision = new TestFlowConditional();
flowDecision.ConditionExpression = ((env) => (counter.Get(env) == 3));
flowchart.AddConditionalLink(writeLine1, flowDecision, writeLine2, writeLine3);
TestRuntime.RunAndValidateWorkflow(flowchart);
}
public void FlowDecisionWithTrueElementNullEvaluationTrue()
{
// This is a valid testcase and we don't expect error.
TestFlowchart flowchart1 = new TestFlowchart("flowChart1");
TestWriteLine w2True = new TestWriteLine("True", "True will execute");
TestWriteLine w2False = new TestWriteLine("False", "False wont execute");
Variable <int> margin = new Variable <int> {
Name = "margin", Default = 10
};
flowchart1.Variables.Add(margin);
TestFlowConditional flowDecision = new TestFlowConditional((HintTrueFalse[])null); // null here means neither True or False will happen as the action is null
flowDecision.ConditionExpression = (context => margin.Get(context) > 0);
TestFlowElement tCond = flowchart1.AddConditionalLink(null, flowDecision, null, w2False);
TestRuntime.RunAndValidateWorkflow(flowchart1);
}
public void FlowDecisionConnectedToFlowStep()
{
TestFlowchart flowchart = new TestFlowchart("Flow1");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 3);
flowchart.Variables.Add(counter);
TestWriteLine writeLine1 = new TestWriteLine("hello1", "Hello1");
TestWriteLine writeLine2 = new TestWriteLine("hello2", "Hello2");
TestWriteLine writeLine3 = new TestWriteLine("hello3", "Hello3");
TestFlowConditional flowDecision = new TestFlowConditional(HintTrueFalse.True);
flowDecision.ConditionExpression = (context => counter.Get(context) > 0);
flowchart.AddStartLink(writeLine1);
flowchart.AddConditionalLink(writeLine1, flowDecision, writeLine2, writeLine3);
TestRuntime.RunAndValidateWorkflow(flowchart);
}
public void SetPublicPropertyOnValueType()
{
//
// Test case description:
// Set a public property on value type.
TheStruct valueType = new TheStruct
{
PublicProperty = 123
};
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypePropertyReference <TheStruct, int> valueTypePropertyReference = new TestValueTypePropertyReference <TheStruct, int>()
{
PropertyName = "PublicProperty",
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypePropertyReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx).PublicProperty.ToString()),HintMessage = value.ToString()
}
}
};
TestRuntime.RunAndValidateWorkflow(seq);
}
public void SetPublicEnumFieldOnValueType()
{
//
// Test case description:
// Set a public enum field on value type.
TheStruct valueType = new TheStruct
{
enumField = FileAccess.Write
};
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeFieldReference <TheStruct, FileAccess> valueTypeFieldReference = new TestValueTypeFieldReference <TheStruct, FileAccess>()
{
FieldName = "enumField",
OperandLocationVariable = var,
};
System.IO.FileAccess value = System.IO.FileAccess.ReadWrite;
TestAssign <System.IO.FileAccess> testAssign = new TestAssign <FileAccess>()
{
ToLocation = valueTypeFieldReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx).enumField.ToString()),HintMessage = value.ToString()
}
}
};
TestRuntime.RunAndValidateWorkflow(seq);
}
public void ThrowFromIndexer()
{
//
// Test case description:
// Throw from ‘this’ property
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
OperandLocationVariable = var,
};
valueTypeIndexerReference.Indices.Add(new TestArgument <float>(Direction.In, null, 2));
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference,
Value = value,
ExpectedOutcome = Outcome.UncaughtException(typeof(Exception)),
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx)[2].ToString()),HintMessage = value.ToString()
}
}
};
TestRuntime.RunAndValidateAbortedException(seq, typeof(Exception), null);
}
public static TestSequence GetTraceableBoolResultActivity(ITestBoolReturningActivity activity, string expectedResult)
{
Variable <bool> result = new Variable <bool>()
{
Name = "Result"
};
activity.Result = result;
return(new TestSequence()
{
Variables = { result },
Activities =
{
(TestActivity)activity,
new TestWriteLine {
MessageExpression = e => result.Get(e).ToString(),HintMessage = expectedResult
}
}
});
}
private void OnBranchComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
if (this.CompletionCondition != null && !_hasCompleted.Get(context))
{
// If we haven't completed, we've been requested to cancel, and we've had a child
// end in a non-Closed state then we should cancel ourselves.
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
context.MarkCanceled();
_hasCompleted.Set(context, true);
return;
}
if (_onConditionComplete == null)
{
_onConditionComplete = new CompletionCallback <bool>(OnConditionComplete);
}
context.ScheduleActivity(this.CompletionCondition, _onConditionComplete);
}
}
public static TestSequence GetTraceableUnaryExpressionActivity <TOperand, TResult>(ITestUnaryExpression <TOperand, TResult> unaryActivity, string expectedResult)
{
Variable <TResult> result = new Variable <TResult>()
{
Name = "Result"
};
unaryActivity.Result = result;
return(new TestSequence()
{
Variables = { result },
Activities =
{
(TestActivity)unaryActivity,
new TestWriteLine {
MessageExpression = e => result.Get(e).ToString(),HintMessage = expectedResult
}
}
});
}
public static TestSequence GetTraceablePropertyValue <TOperand, TResult>(TestPropertyValue <TOperand, TResult> propertyValue, string expectedResult)
{
Variable <TResult> result = new Variable <TResult>()
{
Name = "Result"
};
propertyValue.Result = result;
return(new TestSequence
{
Variables = { result },
Activities =
{
propertyValue,
new TestWriteLine {
MessageExpression = e => result.Get(e).ToString(),HintMessage = expectedResult
}
}
});
}
private TestSequence GetTraceableTestNew <T>(TestNew <T> testNew, string expectedResult)
{
Variable <T> result = new Variable <T>()
{
Name = "Result"
};
testNew.Result = result;
return(new TestSequence
{
Variables = { result },
Activities =
{
testNew,
new TestWriteLine {
MessageExpression = e => result.Get(e).ToString(),HintMessage = expectedResult
}
}
});
}
public void Cancel(NativeActivityContext context)
{
bool bookmarkResumed = _bookmarkResumed.Get(context);
if (!bookmarkResumed)
{
CancellationTokenSource cancellationTokenSource = _cancellationTokenSource.Get(context);
cancellationTokenSource.Cancel();
cancellationTokenSource.Dispose();
}
context.MarkCanceled();
// Overriding the Cancel method inhibits the propagation of cancellation requests to children.
context.CancelChildren();
if (!bookmarkResumed)
{
_noPersistHandle.Get(context).Exit(context);
}
}
public void SetPublicPropertyOnAStruct()
{
TheStruct myStruct = new TheStruct {
PublicProperty = 23
};
Variable <TheStruct> customType = new Variable <TheStruct>()
{
Name = "Custom", Default = myStruct
};
TestPropertyReference <TheStruct, int> propReference = new TestPropertyReference <TheStruct, int>
{
OperandVariable = customType,
PropertyName = "PublicProperty"
};
TestSequence seq = new TestSequence
{
Variables = { customType },
Activities =
{
new TestAssign <int> {
ToLocation = propReference, Value = 27
},
new TestWriteLine {
MessageExpression = e => customType.Get(e).publicField.ToString(), HintMessage = "0"
}
}
};
string error = string.Format(ErrorStrings.TargetTypeIsValueType, typeof(PropertyReference <TheStruct, int>).Name, propReference.DisplayName);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>();
constraints.Add(new TestConstraintViolation(
error,
propReference.ProductActivity));
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void IfConditionExpressionInConstructor()
{
Variable <bool> var = new Variable <bool>("var", false);
TestSequence seq = new TestSequence()
{
Activities =
{
new TestIf(env => var.Get(env).Equals(true), HintThenOrElse.Else)
{
ThenActivity = new TestWriteLine("w", "I'm Funny"),
ElseActivity = new TestWriteLine("w2", "I'm not Funny!")
}
},
Variables =
{
var
}
};
TestRuntime.RunAndValidateWorkflow(seq);
}
static Constraint CompensateWithNoTarget()
{
DelegateInArgument<Compensate> element = new DelegateInArgument<Compensate> { Name = "element" };
DelegateInArgument<ValidationContext> validationContext = new DelegateInArgument<ValidationContext> { Name = "validationContext" };
Variable<bool> assertFlag = new Variable<bool> { Name = "assertFlag" };
Variable<IEnumerable<Activity>> elements = new Variable<IEnumerable<Activity>>() { Name = "elements" };
Variable<int> index = new Variable<int>() { Name = "index" };
return new Constraint<Compensate>
{
Body = new ActivityAction<Compensate, ValidationContext>
{
Argument1 = element,
Argument2 = validationContext,
Handler = new Sequence
{
Variables =
{
assertFlag,
elements,
index
},
Activities =
{
new If
{
Condition = new InArgument<bool>((env) => element.Get(env).Target != null),
Then = new Assign<bool>
{
To = assertFlag,
Value = true
},
Else = new Sequence
{
Activities =
{
new Assign<IEnumerable<Activity>>
{
To = elements,
Value = new GetParentChain
{
ValidationContext = validationContext,
},
},
new While(env => (assertFlag.Get(env) != true) && index.Get(env) < elements.Get(env).Count())
{
Body = new Sequence
{
Activities =
{
new If(env => (elements.Get(env).ElementAt(index.Get(env))).GetType() == typeof(CompensationParticipant))
{
Then = new Assign<bool>
{
To = assertFlag,
Value = true
},
},
new Assign<int>
{
To = index,
Value = new InArgument<int>(env => index.Get(env) + 1)
},
}
}
}
}
}
},
new AssertValidation
{
Assertion = new InArgument<bool>(assertFlag),
Message = new InArgument<string>(SR.CompensateWithNoTargetConstraint)
}
}
}
}
};
}
/// <summary>
/// 创建人工节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="actioner"></param>
/// <param name="humanResultTo"></param>
/// <param name="nexts"></param>
/// <param name="defaultFlowNode"></param>
/// <returns></returns>
public static FlowStep CreateHuman(ActivitySetting setting
, string displayName
, IActionersHelper actioner//Activity<string[]> actioner
, Variable<string> humanResultTo
, IDictionary<string, FlowNode> nexts
, FlowNode defaultFlowNode)
{
var human = CreateHuman(setting, displayName, actioner, humanResultTo);
var step = new FlowStep();
step.Action = human;
if (nexts == null && defaultFlowNode == null) return step;
//设置finish cases
//HACK:在进入switch之前就已经计算出任务结果
var flowSwitch = new FlowSwitch<string>(o => humanResultTo.Get(o));
if (defaultFlowNode != null)
flowSwitch.Default = defaultFlowNode;
if (nexts != null)
nexts.ToList().ForEach(o => flowSwitch.Cases.Add(o.Key, o.Value));
step.Next = flowSwitch;
return step;
}
/// <summary>
/// 创建SubProcess子流程节点
/// </summary>
/// <param name="setting"></param>
/// <param name="displayName"></param>
/// <param name="serverScript">节点执行内容脚本</param>
/// <param name="finishRule">节点完成规则</param>
/// <param name="serverScriptResultTo">执行内容的结果输出到指定变量</param>
/// <param name="serverResultTo">节点执行结果输出到变量</param>
/// <param name="nexts"></param>
/// <param name="defaultFlowNode"></param>
/// <returns></returns>
public static FlowStep CreateSubProcess(ActivitySetting setting
, string displayName
, IDictionary<string, string> finishRule
, Variable<string> resultTo
, IDictionary<string, FlowNode> nexts
, FlowNode defaultFlowNode)
{
var server = CreateSubProcess(setting, displayName, finishRule, resultTo);
var step = new FlowStep();
step.Action = server;
if (nexts == null && defaultFlowNode == null) return step;
//设置finish cases
var flowSwitch = new FlowSwitch<string>(o => resultTo.Get(o));
if (defaultFlowNode != null)
flowSwitch.Default = defaultFlowNode;
if (nexts != null)
nexts.ToList().ForEach(o => flowSwitch.Cases.Add(o.Key, o.Value));
step.Next = flowSwitch;
return step;
}