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); }