protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(notificationIds);
metadata.AddImplementationVariable(nodeIds);
metadata.AddImplementationVariable(counter);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(playUrl);
metadata.AddImplementationVariable(loop);
metadata.AddImplementationChild(play);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.branchBodies == null)
{
this.branchBodies = new Collection<Activity>();
}
else
{
this.branchBodies.Clear();
}
foreach (PickBranch branch in this.Branches)
{
if (branch.Trigger == null)
{
metadata.AddValidationError(System.Activities.SR.PickBranchRequiresTrigger(branch.DisplayName));
}
PickBranchBody item = new PickBranchBody {
Action = branch.Action,
DisplayName = branch.DisplayName,
Trigger = branch.Trigger,
Variables = branch.Variables
};
this.branchBodies.Add(item);
}
metadata.SetChildrenCollection(this.branchBodies);
metadata.AddImplementationVariable(this.pickStateVariable);
}
/// <summary>
/// The cache metadata.
/// </summary>
/// <param name="metadata">
/// The metadata.
/// </param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension<IMessagingStub>();
var parametersContent = this.Content as ReceiveParametersContent;
if (parametersContent != null)
{
foreach (var pair in parametersContent.Parameters)
{
var argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out);
metadata.Bind(pair.Value, argument);
metadata.AddArgument(argument);
}
}
var messageContent = this.Content as ReceiveMessageContent;
if (messageContent != null)
{
var runtimeArgumentType = (messageContent.Message == null) ? typeof(object) : messageContent.Message.ArgumentType;
var argument = new RuntimeArgument("Message", runtimeArgumentType, ArgumentDirection.Out);
metadata.Bind(messageContent.Message, argument);
metadata.AddArgument(argument);
}
// Note: Not adding other properties here as arguments
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Result != null)
{
RuntimeArgument argument = new RuntimeArgument("Result", this.Result.ArgumentType, ArgumentDirection.In);
metadata.Bind(this.Result, argument);
metadata.AddArgument(argument);
}
if (this.parameters != null)
{
int num = 0;
foreach (InArgument argument2 in this.parameters)
{
RuntimeArgument argument3 = new RuntimeArgument("Parameter" + num++, argument2.ArgumentType, ArgumentDirection.In);
metadata.Bind(argument2, argument3);
metadata.AddArgument(argument3);
}
}
RuntimeArgument argument4 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out, true);
metadata.Bind(this.Message, argument4);
metadata.AddArgument(argument4);
RuntimeArgument argument5 = new RuntimeArgument("CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In);
metadata.Bind(this.CorrelatesWith, argument5);
metadata.AddArgument(argument5);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (GetBatchingStrategyFactory.IsNull()) metadata.AddValidationError("GetBatchingStrategyFactory function is expected.");
if (GetNextVectors.IsNull()) metadata.AddValidationError("GetNextVectors function is expected.");
if (ItemCount == null) metadata.AddValidationError("ItemCount expression expected.");
metadata.AddDelegate(GetBatchingStrategyFactory);
metadata.AddDelegate(GetNextVectors);
metadata.AddDelegate(ReinitializeVectorProvider);
RuntimeArgument arg;
metadata.AddArgument(arg = new RuntimeArgument("LastResult", typeof(BatchExecutionResult), ArgumentDirection.In));
metadata.Bind(LastResult, arg);
metadata.AddArgument(arg = new RuntimeArgument("ReinitializationFrequency", typeof(int), ArgumentDirection.In));
metadata.Bind(ReinitializationFrequency, arg);
metadata.AddArgument(arg = new RuntimeArgument("UseCache", typeof(bool), ArgumentDirection.In));
metadata.Bind(UseCache, arg);
metadata.AddChild(ItemCount);
metadata.AddImplementationVariable(cachedVectors);
metadata.AddImplementationVariable(strategyHasJustInited);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationVariable(outputText);
this.output = new WriteLine { Text = new InArgument<string>(outputText) };
metadata.AddImplementationChild(this.output);
metadata.SetArgumentsCollection(metadata.GetArgumentsWithReflection());
}
/// <summary>
/// Create internal states
/// </summary>
public static void ProcessChildStates(NativeActivityMetadata metadata, Collection<State> childStates,
Collection<InternalState> internalStates, Collection<ActivityFunc<string, StateMachineEventManager, string>> internalStateFuncs)
{
foreach (State state in childStates)
{
InternalState internalState = state.InternalState;
internalStates.Add(internalState);
DelegateInArgument<string> toStateId = new DelegateInArgument<string>();
DelegateInArgument<StateMachineEventManager> eventManager = new DelegateInArgument<StateMachineEventManager>();
internalState.ToState = toStateId;
internalState.EventManager = eventManager;
ActivityFunc<string, StateMachineEventManager, string> activityFunc = new ActivityFunc<string, StateMachineEventManager, string>
{
Argument1 = toStateId,
Argument2 = eventManager,
Handler = internalState,
};
if (state.Reachable)
{
//If this state is not reached, we should not add it as child because it's even not well validated.
metadata.AddDelegate(activityFunc);
}
internalStateFuncs.Add(activityFunc);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.AddChild(this.CancellationHandler);
metadata.SetVariablesCollection(this.Variables);
metadata.AddImplementationVariable(this.suppressCancel);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument;
argument = new RuntimeArgument("JobGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.JobGuid, argument);
metadata.AddArgument(argument);
argument = new RuntimeArgument("UserGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.UserGuid, argument);
metadata.AddArgument(argument);
if (this.Try != null)
{
metadata.AddChild(this.Try);
}
if (this.Finally != null)
{
metadata.AddChild(this.Finally);
}
argument = new RuntimeArgument("MaxRetries", typeof(int), ArgumentDirection.In);
metadata.Bind(this.MaxRetries, argument);
metadata.AddArgument(argument);
metadata.AddImplementationVariable(this.retries);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In);
metadata.Bind(this.Target, targetArgument);
metadata.SetArgumentsCollection(
new Collection<RuntimeArgument>
{
targetArgument
});
metadata.SetImplementationVariablesCollection(
new Collection<Variable>
{
this.currentCompensationToken
});
Fx.Assert(DefaultConfirmation != null, "DefaultConfirmation must be valid");
Fx.Assert(InternalConfirm != null, "InternalConfirm must be valid");
metadata.SetImplementationChildrenCollection(
new Collection<Activity>
{
DefaultConfirmation,
InternalConfirm
});
}
// Returns true if this is the first time we've visited this node during this pass
internal bool Open(Flowchart owner, NativeActivityMetadata metadata)
{
if (this.cacheId == owner.CacheId)
{
// We've already visited this node during this pass
if (!object.ReferenceEquals(this.owner, owner))
{
metadata.AddValidationError(SR.FlowNodeCannotBeShared(this.owner.DisplayName, owner.DisplayName));
}
// Whether we found an issue or not we don't want to change
// the metadata during this pass.
return false;
}
// if owner.ValidateUnconnectedNodes - Flowchart will be responsible for calling OnOpen for all the Nodes (connected and unconnected)
if (!owner.ValidateUnconnectedNodes)
{
OnOpen(owner, metadata);
}
this.owner = owner;
this.cacheId = owner.CacheId;
this.Index = -1;
return true;
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//call base.CacheMetadata to add the Activities and Variables to this activity's metadata
base.CacheMetadata(metadata);
//add the private implementation variable: currentIndex
metadata.AddImplementationVariable(this.currentIndex);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// The Body introduces another layer of scope. Method metadata.AddImplementationChild
// (instead of metadata.AddChild) enable access to LoopVariable from the inner
// block scope of Body.
if (this.Body != null && this.Body.Handler != null)
{
this.invokeBody.Action = this.Body;
metadata.AddImplementationChild(this.invokeBody);
}
// Need to bind the arguments to the custom activity variables explicitly
// and then add them to the metadata.
RuntimeArgument startArg = new RuntimeArgument("Start", typeof(int), ArgumentDirection.In, true);
metadata.Bind(this.Start, startArg);
metadata.AddArgument(startArg);
RuntimeArgument stopArg = new RuntimeArgument("Stop", typeof(int), ArgumentDirection.In, true);
metadata.Bind(this.Stop, stopArg);
metadata.AddArgument(stopArg);
RuntimeArgument stepArg = new RuntimeArgument("Step", typeof(int), ArgumentDirection.In, true);
metadata.Bind(this.Step, stepArg);
metadata.AddArgument(stepArg);
// Register variables used in the custom activity.
metadata.AddImplementationVariable(this.loopVariable);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument subInstanceArgument = new RuntimeArgument("Scope", typeof(BookmarkScope), ArgumentDirection.In);
metadata.Bind(this.Scope, subInstanceArgument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { subInstanceArgument });
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument valuesArgument = new RuntimeArgument("Values", typeof(IEnumerable), ArgumentDirection.In, true);
metadata.Bind(this.Values, valuesArgument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { valuesArgument });
// declare the CompletionCondition as a child
if (this.CompletionCondition != null)
{
metadata.SetChildrenCollection(new Collection<Activity> { this.CompletionCondition });
}
// declare the hasCompleted variable
if (this.CompletionCondition != null)
{
if (this.hasCompleted == null)
{
this.hasCompleted = new Variable<bool>();
}
metadata.AddImplementationVariable(this.hasCompleted);
}
metadata.AddDelegate(this.Body);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
this.internalStateFuncs.Clear();
this.internalStates.Clear();
this.PassNumber++;
this.TraverseViaTransitions(new Action<System.Activities.Statements.State>(StateMachine.ClearState), new Action<Transition>(StateMachine.ClearTransition));
this.PassNumber++;
bool checkReached = false;
this.TraverseStates((m, states) => ClearStates(states), (m, state) => ClearTransitions(state), metadata, checkReached);
this.PassNumber++;
bool flag2 = false;
this.TraverseStates(new Action<NativeActivityMetadata, Collection<System.Activities.Statements.State>>(this.MarkStatesViaChildren), (m, state) => MarkTransitionsInState(state), metadata, flag2);
this.PassNumber++;
this.TraverseViaTransitions(state => MarkStateViaTransition(state), null);
this.PassNumber++;
Action<Transition> actionForTransition = null;
this.TraverseViaTransitions(state => ValidateTransitions(metadata, state), actionForTransition);
this.PassNumber++;
NativeActivityMetadata metadata2 = metadata;
bool flag3 = true;
this.TraverseStates(new Action<NativeActivityMetadata, Collection<System.Activities.Statements.State>>(StateMachine.ValidateStates), delegate (NativeActivityMetadata m, System.Activities.Statements.State state) {
if (!state.Reachable)
{
ValidateTransitions(m, state);
}
}, metadata2, flag3);
this.ValidateStateMachine(metadata);
this.ProcessStates(metadata);
metadata.AddImplementationVariable(this.eventManager);
foreach (Variable variable in this.Variables)
{
metadata.AddVariable(variable);
}
metadata.AddDefaultExtensionProvider<StateMachineExtension>(getDefaultExtension);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.branchBodies == null)
{
this.branchBodies = new Collection<Activity>();
}
else
{
this.branchBodies.Clear();
}
foreach (PickBranch branch in this.Branches)
{
if (branch.Trigger == null)
{
metadata.AddValidationError(new ValidationError(SR.PickBranchRequiresTrigger(branch.DisplayName), false, null, branch));
}
PickBranchBody pickBranchBody = new PickBranchBody
{
Action = branch.Action,
DisplayName = branch.DisplayName,
Trigger = branch.Trigger,
Variables = branch.Variables,
};
this.branchBodies.Add(pickBranchBody);
metadata.AddChild(pickBranchBody, origin: branch);
}
metadata.AddImplementationVariable(this.pickStateVariable);
}
internal override void OnOpen(Flowchart owner, NativeActivityMetadata metadata)
{
if (this.Condition == null)
{
metadata.AddValidationError(SR.FlowDecisionRequiresCondition(owner.DisplayName));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In);
metadata.Bind(this.Target, argument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument });
metadata.SetImplementationVariablesCollection(new Collection<Variable> { this.toConfirmToken });
metadata.SetImplementationChildrenCollection(new Collection<Activity> { this.Body });
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Duration", typeof(TimeSpan), ArgumentDirection.In, true);
metadata.Bind(this.Duration, argument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument });
metadata.AddImplementationVariable(this.timerBookmark);
metadata.AddDefaultExtensionProvider<TimerExtension>(getDefaultTimerExtension);
}
protected virtual void CacheMetadata(NativeActivityMetadata metadata)
{
Activity.ReflectedInformation information = new Activity.ReflectedInformation(this);
base.SetArgumentsCollection(information.GetArguments(), metadata.CreateEmptyBindings);
base.SetChildrenCollection(information.GetChildren());
base.SetDelegatesCollection(information.GetDelegates());
base.SetVariablesCollection(information.GetVariables());
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension<ICountModel>();
var currentCountArg = new RuntimeArgument(
"CurrentCount", typeof(Int32), ArgumentDirection.In);
metadata.AddArgument(currentCountArg);
metadata.Bind(this.CurrentCount, currentCountArg);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//call base.CacheMetadata to add the Activities and Variables to this activity's metadata
base.CacheMetadata(metadata);
string errorMessage = AutomationActivityValidation();
if (!string.IsNullOrEmpty(errorMessage))
metadata.AddValidationError(errorMessage);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument valuesArgument = new RuntimeArgument("Values", typeof(IEnumerable), ArgumentDirection.In, true);
metadata.Bind(this.Values, valuesArgument);
metadata.AddArgument(valuesArgument);
metadata.AddDelegate(this.Body);
metadata.AddImplementationVariable(this.valueEnumerator);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (GetNextVectors.IsNull()) metadata.AddValidationError("GetNextVectors function is expected.");
base.CacheMetadata(metadata);
metadata.AddDelegate(GetNextVectors);
metadata.AddImplementationVariable(vectorList);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (variables != null)
{
foreach (var v in Variables)
{
metadata.AddVariable(v);
}
}
}
/// <summary>
/// Creates and validates a description of the activity’s arguments, variables, child activities, and activity delegates.
/// </summary>
/// <param name="metadata">The activity’s metadata that encapsulates the activity’s arguments, variables, child activities, and activity delegates.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
foreach (var kvp in this.Arguments)
{
metadata.AddArgument(new RuntimeArgument(kvp.Key, kvp.Value.ArgumentType, kvp.Value.Direction));
}
metadata.SetVariablesCollection(this.Variables);
metadata.AddChild(this.StateMachine);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.SetArgumentsCollection(
new Collection<RuntimeArgument>
{
this.toValidate,
this.violationList,
this.toValidateContext
});
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Body == null)
{
metadata.AddValidationError("The Body property must contain an Activity.");
}
else if (impl == null)
{
CreateImplementation();
metadata.AddChild(impl);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Condition", typeof(bool), ArgumentDirection.In, true);
metadata.Bind(this.Condition, argument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
argument
});
Collection <Activity> collection = null;
if (this.Then != null)
{
ActivityUtilities.Add <Activity>(ref collection, this.Then);
}
if (this.Else != null)
{
ActivityUtilities.Add <Activity>(ref collection, this.Else);
}
metadata.SetChildrenCollection(collection);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationDelegate(Algorithm);
metadata.AddRuntimeArgument(Input, typeof(T), nameof(Input), true);
metadata.AddRuntimeArgument(TextEncoding, nameof(TextEncoding), false);
if (Key == null)
{
metadata.AddRuntimeArgument(Key, typeof(string), nameof(Key), true);
}
else if (Key.IsArgumentTypeAnyCompatible <string, SecureString>())
{
metadata.AddRuntimeArgument(Key, Key.ArgumentType, nameof(Key), true);
}
if (Algorithm == null || Algorithm.Handler == null)
{
metadata.AddValidationError(Resources.EncryptionBase_ErrorMsg_AlgorithmMissing);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddDelegate(Body);
//Add the delay in so it can try again and persist.
metadata.AddImplementationChild(_internalDelay);
metadata.AddImplementationVariable(_attemptCount);
metadata.AddImplementationVariable(_delayDuration);
RuntimeArgument maxAttemptsArgument = new RuntimeArgument("MaxAttempts", typeof(Int32), ArgumentDirection.In, true);
RuntimeArgument retryIntervalArgument = new RuntimeArgument("RetryInterval", typeof(TimeSpan), ArgumentDirection.In, true);
RuntimeArgument exceptionTypeArgument = new RuntimeArgument("ExceptionType", typeof(Type[]), ArgumentDirection.In, true);
metadata.Bind(MaxAttempts, maxAttemptsArgument);
metadata.Bind(RetryInterval, retryIntervalArgument);
metadata.Bind(ExceptionType, exceptionTypeArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
maxAttemptsArgument, retryIntervalArgument, exceptionTypeArgument
});
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var collection = new Collection <RuntimeArgument>();
var type = GetType();
ActivityHelpers.AddCacheMetadata(collection, metadata, DialogResult, type.ExtractPropertyName(() => DialogResult));
ActivityHelpers.AddCacheMetadata(collection, metadata, Source, type.ExtractPropertyName(() => Source));
ActivityHelpers.AddCacheMetadata(collection, metadata, DialogWidth, type.ExtractPropertyName(() => DialogWidth));
ActivityHelpers.AddCacheMetadata(collection, metadata, DialogHeight, type.ExtractPropertyName(() => DialogHeight));
ActivityHelpers.AddCacheMetadata(collection, metadata, PrintTE, type.ExtractPropertyName(() => PrintTE));
ActivityHelpers.AddCacheMetadata(collection, metadata, MandantID, type.ExtractPropertyName(() => MandantID));
ActivityHelpers.AddCacheMetadata(collection, metadata, PlaceFilter, type.ExtractPropertyName(() => PlaceFilter));
ActivityHelpers.AddCacheMetadata(collection, metadata, InvoicePlace, type.ExtractPropertyName(() => InvoicePlace));
ActivityHelpers.AddCacheMetadata(collection, metadata, BatchcodeWorkflowCode, type.ExtractPropertyName(() => BatchcodeWorkflowCode));
ActivityHelpers.AddCacheMetadata(collection, metadata, SkuChangeMpWorkflowCode, type.ExtractPropertyName(() => SkuChangeMpWorkflowCode));
ActivityHelpers.AddCacheMetadata(collection, metadata, IsMigration, type.ExtractPropertyName(() => IsMigration));
ActivityHelpers.AddCacheMetadata(collection, metadata, OperationCode, type.ExtractPropertyName(() => OperationCode));
metadata.SetArgumentsCollection(collection);
}
private void ProcessTransitions(NativeActivityMetadata metadata)
{
for (int i = 0; i < this.Transitions.Count; i++)
{
Transition transition = this.Transitions[i];
InternalTransition transition2 = null;
Activity activeTrigger = transition.ActiveTrigger;
if (!this.triggerInternalTransitionMapping.TryGetValue(activeTrigger, out transition2))
{
metadata.AddChild(activeTrigger);
transition2 = new InternalTransition {
Trigger = activeTrigger,
InternalTransitionIndex = this.internalTransitions.Count
};
this.triggerInternalTransitionMapping.Add(activeTrigger, transition2);
this.internalTransitions.Add(transition2);
}
AddTransitionData(metadata, transition2, transition);
}
}
void ProcessTransitions(NativeActivityMetadata metadata)
{
for (int i = 0; i < this.Transitions.Count; i++)
{
Transition transition = this.Transitions[i];
InternalTransition internalTransition = null;
if (!triggerInternalTransitionMapping.TryGetValue(transition.Trigger, out internalTransition))
{
metadata.AddChild(transition.Trigger);
internalTransition = new InternalTransition
{
Trigger = transition.Trigger,
InternalTransitionIndex = this.internalTransitions.Count,
};
triggerInternalTransitionMapping.Add(transition.Trigger, internalTransition);
this.internalTransitions.Add(internalTransition);
}
AddTransitionData(metadata, internalTransition, transition);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension <INotifyReferenceSoundMarkup>();
// Register In arguments
RuntimeArgument episodeArg = new RuntimeArgument("LocalEpisode", typeof(LocalEpisode), ArgumentDirection.In);
metadata.AddArgument(episodeArg);
metadata.Bind(this.LocalEpisode, episodeArg);
// [Text] Argument must be set
if (this.LocalEpisode == null)
{
metadata.AddValidationError(
new System.Activities.Validation.ValidationError(
"[LocalEpisode] argument must be set!",
false,
"LocalEpisode"));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (String.IsNullOrWhiteSpace(this.Name))
{
metadata.AddValidationError(Properties.Resources.ExternalVariableNameRequired);
}
else
{
this.implementationChild = new Assign <T>
{
To = new OutArgument <T>(new ExternalVariableReference <T>()
{
Name = this.Name
}),
Value = new System.Activities.Expressions.LambdaValue <T>(ctx => this.Value.Get(ctx))
};
metadata.AddImplementationChild(implementationChild);
}
metadata.AddArgument(new RuntimeArgument("Value", typeof(T), ArgumentDirection.In, true));
}
private void ValidateStateMachine(NativeActivityMetadata metadata)
{
if (this.InitialState == null)
{
metadata.AddValidationError(System.Activities.SR.StateMachineMustHaveInitialState(base.DisplayName));
}
else
{
if (this.InitialState.IsFinal)
{
bool isWarning = false;
metadata.AddValidationError(new ValidationError(System.Activities.SR.InitialStateCannotBeFinalState(this.InitialState.DisplayName), isWarning));
}
if (!this.States.Contains(this.InitialState))
{
bool flag2 = false;
metadata.AddValidationError(new ValidationError(System.Activities.SR.InitialStateNotInStatesCollection(this.InitialState.DisplayName), flag2));
}
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument timeoutArgument = new RuntimeArgument("Timeout", typeof(TimeSpan), ArgumentDirection.In, false);
metadata.Bind(this.Timeout, timeoutArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
timeoutArgument
});
metadata.AddImplementationChild(this.NestedScopeTimeoutWorkflow);
if (this.Body != null)
{
metadata.AddChild(this.Body);
}
metadata.AddImplementationVariable(this.runtimeTransactionHandle);
metadata.AddImplementationVariable(this.nestedScopeTimeout);
metadata.AddImplementationVariable(this.delayWasScheduled);
metadata.AddImplementationVariable(this.nestedScopeTimeoutActivityInstance);
}
private void MarkStatesViaChildren(NativeActivityMetadata metadata, Collection <System.Activities.Statements.State> states)
{
if (states.Count > 0)
{
for (int i = 0; i < states.Count; i++)
{
System.Activities.Statements.State state = states[i];
if (string.IsNullOrEmpty(state.StateId))
{
state.StateId = StateMachineIdHelper.GenerateStateId("0", i);
state.StateMachineName = base.DisplayName;
}
else
{
bool isWarning = false;
metadata.AddValidationError(new ValidationError(System.Activities.SR.StateCannotBeAddedTwice(state.DisplayName), isWarning));
}
}
}
}
/// <summary>
/// Do validation and if validation is successful, create internal representations for states and transitions.
/// </summary>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//cleanup
this.internalStateFuncs.Clear();
this.internalStates.Clear();
//clear Ids and Flags via transitions
this.PassNumber++;
TraverseViaTransitions(ClearState, ClearTransition);
//clear Ids and Flags via children
this.PassNumber++;
TraverseViaChildren(ClearStates, null, ClearTransitions, false);
//Mark via children and do some check
this.PassNumber++;
TraverseViaChildren(MarkStatesViaChildren,
delegate(State state) { StateCannotHaveMultipleParents(metadata, state); }, null, false);
this.PassNumber++;
//Mark via transition
TraverseViaTransitions(delegate(State state) { MarkStateViaTransition(metadata, state); }, null);
//Do validation via children
//need not check the violation of state which is not reached
this.PassNumber++;
TraverseViaChildren(delegate(Collection <State> states) { ValidateStates(metadata, states); }, null,
delegate(State state) { ValidateTransitions(metadata, state); }, true);
//Validate the root state machine itself
ValidateStateMachine(metadata);
if (!metadata.HasViolations)
{
StateMachineHelper.ProcessChildStates(metadata, this.States, this.internalStates, this.internalStateFuncs);
}
metadata.AddImplementationVariable(this.eventManager);
foreach (Variable variable in this.Variables)
{
metadata.AddVariable(variable);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (OrchestratorName == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(OrchestratorName)));
}
if (ClientID == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(ClientID)));
}
if (UserKey == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(UserKey)));
}
if (TenantName == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(TenantName)));
}
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var arguments = new Collection <RuntimeArgument>();
var messageArgument = new RuntimeArgument("Message", typeof(string), ArgumentDirection.In);
metadata.Bind(this.Message, messageArgument);
arguments.Add(messageArgument);
var isWarningArgument = new RuntimeArgument("IsWarning", typeof(bool), ArgumentDirection.In, false);
metadata.Bind(this.IsWarning, isWarningArgument);
arguments.Add(isWarningArgument);
var propertyNameArgument = new RuntimeArgument("PropertyName", typeof(string), ArgumentDirection.In, false);
metadata.Bind(this.PropertyName, propertyNameArgument);
arguments.Add(propertyNameArgument);
metadata.SetArgumentsCollection(arguments);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (HostName == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(HostName)));
}
if (PortNumber == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(PortNumber)));
}
if (UserName == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(UserName)));
}
if (Password == null)
{
metadata.AddValidationError(string.Format(Resources.ValidationValue_Error, nameof(Password)));
}
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>();
RuntimeArgument argument = new RuntimeArgument("Assertion", typeof(bool), ArgumentDirection.In);
metadata.Bind(this.Assertion, argument);
arguments.Add(argument);
RuntimeArgument argument2 = new RuntimeArgument("Message", typeof(string), ArgumentDirection.In);
metadata.Bind(this.Message, argument2);
arguments.Add(argument2);
RuntimeArgument argument3 = new RuntimeArgument("IsWarning", typeof(bool), ArgumentDirection.In, false);
metadata.Bind(this.IsWarning, argument3);
arguments.Add(argument3);
RuntimeArgument argument4 = new RuntimeArgument("PropertyName", typeof(string), ArgumentDirection.In, false);
metadata.Bind(this.PropertyName, argument4);
arguments.Add(argument4);
metadata.SetArgumentsCollection(arguments);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var collection = new Collection <RuntimeArgument>();
var type = GetType();
ActivityHelpers.AddCacheMetadata(collection, metadata, FontSize, type.ExtractPropertyName(() => FontSize));
ActivityHelpers.AddCacheMetadata(collection, metadata, ArtCodePropertyName, type.ExtractPropertyName(() => ArtCodePropertyName));
ActivityHelpers.AddCacheMetadata(collection, metadata, OperationCode, type.ExtractPropertyName(() => OperationCode));
ActivityHelpers.AddCacheMetadata(collection, metadata, Entities, type.ExtractPropertyName(() => Entities));
ActivityHelpers.AddCacheMetadata(collection, metadata, MaxRowsOnPage, type.ExtractPropertyName(() => MaxRowsOnPage));
ActivityHelpers.AddCacheMetadata(collection, metadata, Result, type.ExtractPropertyName(() => Result));
metadata.SetArgumentsCollection(collection);
var typeT = typeof(T);
if (!typeof(WMSBusinessObject).IsAssignableFrom(typeT))
{
metadata.AddValidationError(new ValidationError(string.Format("Тип '{0}' не поддерживается.", typeT)));
}
}
/// <summary>
/// Validates the syntax of the script text for this activity.
/// </summary>
/// <param name="metadata">Activity metadata for this activity</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
if (!string.IsNullOrWhiteSpace(Expression))
{
var errors = new Collection <PSParseError>();
PSParser.Tokenize(Expression, out errors);
if (errors != null && errors.Count > 0)
{
string compositeErrorString = "";
foreach (var e in errors)
{
// Format and add each error message...
compositeErrorString += string.Format(CultureInfo.InvariantCulture,
"[{0}, {1}]: {2}\n", e.Token.StartLine, e.Token.StartColumn, e.Message);
}
metadata.AddValidationError(compositeErrorString);
}
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.InOut, true);
metadata.Bind(this.Message, argument);
metadata.AddArgument(argument);
if (this.parameters != null)
{
int num = 0;
foreach (OutArgument argument2 in this.parameters)
{
RuntimeArgument argument3 = new RuntimeArgument("Parameter" + num++, argument2.ArgumentType, ArgumentDirection.Out);
metadata.Bind(argument2, argument3);
metadata.AddArgument(argument3);
}
}
RuntimeArgument argument4 = new RuntimeArgument("noPersistHandle", System.ServiceModel.Activities.Constants.NoPersistHandleType, ArgumentDirection.In);
metadata.Bind(this.NoPersistHandle, argument4);
metadata.AddArgument(argument4);
}
/// <summary>
/// Register activity's metadata
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension <INotifyParagraphSplited>();
// Register In arguments
RuntimeArgument ecArg = new RuntimeArgument("EpisodeContent", typeof(EpisodeContent), ArgumentDirection.In);
metadata.AddArgument(ecArg);
metadata.Bind(this.EpisodeContent, ecArg);
// [Text] Argument must be set
if (this.EpisodeContent == null)
{
metadata.AddValidationError(
new System.Activities.Validation.ValidationError(
"[EpisodeContent] argument must be set!",
false,
"EpisodeContent"));
}
// TODO : Add arguments ... etc ...
}
/// <summary>
/// Validates the contents of the script block for this command.
/// </summary>
/// <param name="metadata">Metadata for this activity</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
if (!string.IsNullOrWhiteSpace(Command))
{
Token[] tokens;
ParseError[] errors;
Parser.ParseInput(Command, out tokens, out errors);
if (errors != null && errors.Length > 0)
{
string compositeErrorString = "";
foreach (var e in errors)
{
// Format and add each error message...
compositeErrorString += string.Format(CultureInfo.InvariantCulture,
"[{0}, {1}]: {2}\n", e.Extent.StartLineNumber, e.Extent.StartColumnNumber, e.Message);
}
metadata.AddValidationError(compositeErrorString);
}
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var collection = new Collection <RuntimeArgument>();
var type = GetType();
ActivityHelpers.AddCacheMetadata(collection, metadata, ProductList,
type.ExtractPropertyName(() => ProductList));
ActivityHelpers.AddCacheMetadata(collection, metadata, OperationCode,
type.ExtractPropertyName(() => OperationCode));
ActivityHelpers.AddCacheMetadata(collection, metadata, NeedShowSelectGrid,
type.ExtractPropertyName(() => NeedShowSelectGrid));
ActivityHelpers.AddCacheMetadata(collection, metadata, GridFields,
type.ExtractPropertyName(() => GridFields));
ActivityHelpers.AddCacheMetadata(collection, metadata, DialogResult,
type.ExtractPropertyName(() => DialogResult));
ActivityHelpers.AddCacheMetadata(collection, metadata, OutGroupProductList,
type.ExtractPropertyName(() => OutGroupProductList));
ActivityHelpers.AddCacheMetadata(collection, metadata, OutProductList,
type.ExtractPropertyName(() => OutProductList));
metadata.SetArgumentsCollection(collection);
}
/// <summary>
/// Register activity's metadata
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension <INotifyRecognizeStateChanged>();
// Register In arguments
RuntimeArgument transitionArg = new RuntimeArgument("Transition", typeof(RecognizeTransition), ArgumentDirection.In);
metadata.AddArgument(transitionArg);
metadata.Bind(this.Transition, transitionArg);
// [Text] Argument must be set
if (this.Transition == null)
{
metadata.AddValidationError(
new System.Activities.Validation.ValidationError(
"[Transition] argument must be set!",
false,
"Transition"));
}
// TODO : Add arguments ... etc ...
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In);
metadata.Bind(this.Target, targetArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
targetArgument
});
metadata.SetImplementationVariablesCollection(new Collection <Variable> {
this.currentCompensationToken
});
Fx.Assert(DefaultCompensation != null, "DefaultCompensation must be valid");
Fx.Assert(InternalCompensate != null, "InternalCompensate must be valid");
metadata.SetImplementationChildrenCollection(
new Collection <Activity>
{
DefaultCompensation,
InternalCompensate
});
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
this.internalStateFuncs.Clear();
this.internalStates.Clear();
this.PassNumber++;
this.TraverseViaTransitions(new Action <System.Activities.Statements.State>(StateMachine.ClearState), new Action <Transition>(StateMachine.ClearTransition));
this.PassNumber++;
bool checkReached = false;
this.TraverseStates((m, states) => ClearStates(states), (m, state) => ClearTransitions(state), metadata, checkReached);
this.PassNumber++;
bool flag2 = false;
this.TraverseStates(new Action <NativeActivityMetadata, Collection <System.Activities.Statements.State> >(this.MarkStatesViaChildren), (m, state) => MarkTransitionsInState(state), metadata, flag2);
this.PassNumber++;
this.TraverseViaTransitions(state => MarkStateViaTransition(state), null);
this.PassNumber++;
Action <Transition> actionForTransition = null;
this.TraverseViaTransitions(state => ValidateTransitions(metadata, state), actionForTransition);
this.PassNumber++;
NativeActivityMetadata metadata2 = metadata;
bool flag3 = true;
this.TraverseStates(new Action <NativeActivityMetadata, Collection <System.Activities.Statements.State> >(StateMachine.ValidateStates), delegate(NativeActivityMetadata m, System.Activities.Statements.State state) {
if (!state.Reachable)
{
ValidateTransitions(m, state);
}
}, metadata2, flag3);
this.ValidateStateMachine(metadata);
this.ProcessStates(metadata);
metadata.AddImplementationVariable(this.eventManager);
foreach (Variable variable in this.Variables)
{
metadata.AddVariable(variable);
}
metadata.AddDefaultExtensionProvider <StateMachineExtension>(getDefaultExtension);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//performing validation checks
if (GetAllProperties == false && InputDictionary == null)
{
ValidationError error = new ValidationError(WpfFormCreatorResources.ErrorMessage_NoInputGiven);
metadata.AddValidationError(error);
}
if (GetAllProperties == true && ElementsToRetrieve == null)
{
ValidationError error = new ValidationError(WpfFormCreatorResources.ErrorMessage_ElementsToRetrieveMissing);
metadata.AddValidationError(error);
}
if (GetAllProperties == false && ElementsToRetrieve != null)
{
ValidationError error = new ValidationError(WpfFormCreatorResources.ErrorMessage_ElementsToRetrieveError);
metadata.AddValidationError(error);
}
base.CacheMetadata(metadata);
}
private static void ValidateState(NativeActivityMetadata metadata, State state)
{
Fx.Assert(!string.IsNullOrEmpty(state.StateId), "StateId should have been set.");
if (state.Reachable)
{
if (state.IsFinal)
{
if (state.Exit != null)
{
metadata.AddValidationError(new ValidationError(
SR.FinalStateCannotHaveProperty(state.DisplayName, ExitProperty),
isWarning: false,
propertyName: string.Empty,
sourceDetail: state));
}
if (state.Transitions.Count > 0)
{
metadata.AddValidationError(new ValidationError(
SR.FinalStateCannotHaveTransition(state.DisplayName),
isWarning: false,
propertyName: string.Empty,
sourceDetail: state));
}
}
else
{
if (state.Transitions.Count == 0)
{
metadata.AddValidationError(new ValidationError(
SR.SimpleStateMustHaveOneTransition(state.DisplayName),
isWarning: false,
propertyName: string.Empty,
sourceDetail: state));
}
}
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Result != null)
{
RuntimeArgument resultArgument = new RuntimeArgument(Constants.Result, this.Result.ArgumentType, ArgumentDirection.In);
metadata.Bind(this.Result, resultArgument);
metadata.AddArgument(resultArgument);
}
if (this.parameters != null)
{
int count = 0;
foreach (InArgument parameter in this.parameters)
{
RuntimeArgument parameterArgument = new RuntimeArgument(Constants.Parameter + count++, parameter.ArgumentType, ArgumentDirection.In);
metadata.Bind(parameter, parameterArgument);
metadata.AddArgument(parameterArgument);
}
}
RuntimeArgument messageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out, true);
if (this.Message == null)
{
this.Message = new OutArgument <Message>();
}
metadata.Bind(this.Message, messageArgument);
metadata.AddArgument(messageArgument);
RuntimeArgument correlatesWithArgument = new RuntimeArgument(Constants.CorrelatesWith, Constants.CorrelationHandleType, ArgumentDirection.In);
if (this.CorrelatesWith == null)
{
this.CorrelatesWith = new InArgument <CorrelationHandle>();
}
metadata.Bind(this.CorrelatesWith, correlatesWithArgument);
metadata.AddArgument(correlatesWithArgument);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>();
RuntimeArgument reasonArgument = new RuntimeArgument("Reason", typeof(string), ArgumentDirection.In, false);
metadata.Bind(this.Reason, reasonArgument);
RuntimeArgument exceptionArgument = new RuntimeArgument("Exception", typeof(Exception), ArgumentDirection.In, false);
metadata.Bind(this.Exception, exceptionArgument);
arguments.Add(reasonArgument);
arguments.Add(exceptionArgument);
metadata.SetArgumentsCollection(arguments);
if ((this.Reason == null || this.Reason.IsEmpty) &&
(this.Exception == null || this.Exception.IsEmpty))
{
metadata.AddValidationError(SR.OneOfTwoPropertiesMustBeSet("Reason", "Exception", "TerminateWorkflow", this.DisplayName));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument expressionArgument = new RuntimeArgument("Expression", typeof(T), ArgumentDirection.In, true);
metadata.Bind(Expression, expressionArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
expressionArgument
});
Collection <Activity> children = new Collection <Activity>();
foreach (Activity child in Cases.Values)
{
children.Add(child);
}
if (Default != null)
{
children.Add(Default);
}
metadata.SetChildrenCollection(children);
}
