/// <summary>
/// Add activities, variables and argument to metadata
/// </summary>
/// <param name="metadata">Metadata</param>
private void SetupMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationVariable(_request);
metadata.AddImplementationVariable(_response);
metadata.AddDelegate(OnCompleting);
var runtimeArgument = new RuntimeArgument("WfCorrelation", typeof(CorrelationHandle), ArgumentDirection.In);
metadata.Bind(CorrelationHandle, runtimeArgument);
metadata.AddArgument(runtimeArgument);
metadata.AddImplementationChild(_receive);
metadata.AddImplementationChild(_sendReply);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument activityArgument = new RuntimeArgument("Activity", typeof(InvokeDelegate), ArgumentDirection.In, true);
metadata.Bind(this.Activity, activityArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
activityArgument
});
metadata.AddImplementationChild(this.ShowWarning);
metadata.AddImplementationChild(this.ShowError);
metadata.AddImplementationVariable(this.WarningMessageVariable);
metadata.AddImplementationVariable(this.ErrorMessageVariable);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(playUrl);
metadata.AddImplementationVariable(loop);
metadata.AddImplementationChild(play);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(playUrl);
metadata.AddImplementationVariable(loop);
metadata.AddImplementationChild(play);
}
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)
{
foreach (var activity in Activities)
{
metadata.AddImplementationChild(activity);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In);
metadata.Bind(this.CorrelatesWith, argument);
metadata.AddArgument(argument);
if (this.correlationInitializers != null)
{
int num = 0;
foreach (CorrelationInitializer initializer in this.correlationInitializers)
{
if (initializer.CorrelationHandle != null)
{
RuntimeArgument argument2 = new RuntimeArgument("Parameter" + num, initializer.CorrelationHandle.ArgumentType, initializer.CorrelationHandle.Direction, true);
metadata.Bind(initializer.CorrelationHandle, argument2);
metadata.AddArgument(argument2);
num++;
}
}
}
RuntimeArgument argument3 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out);
metadata.Bind(this.Message, argument3);
metadata.AddArgument(argument3);
RuntimeArgument argument4 = new RuntimeArgument("noPersistHandle", System.ServiceModel.Activities.Constants.NoPersistHandleType, ArgumentDirection.In);
metadata.Bind(this.NoPersistHandle, argument4);
metadata.AddArgument(argument4);
metadata.AddImplementationVariable(this.receiveMessageInstance);
metadata.AddImplementationChild(this.waitForReply);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddDelegate(Body);
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);
metadata.Bind(MaxAttempts, maxAttemptsArgument);
metadata.Bind(RetryInterval, retryIntervalArgument);
Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>
{
maxAttemptsArgument,
retryIntervalArgument
};
metadata.SetArgumentsCollection(arguments);
if (Body == null)
{
ValidationError validationError = new ValidationError("No Child Activities Defined", true, "Body");
metadata.AddValidationError(validationError);
}
if (typeof(Exception).IsAssignableFrom(ExceptionType) == false)
{
ValidationError validationError = new ValidationError("Invalid Exception Type", false, "ExceptionType");
metadata.AddValidationError(validationError);
}
}
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());
}
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);
}
/// <summary>
/// The cache metadata.
/// </summary>
/// <param name="metadata">
/// The metadata.
/// </param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension <IHttpWorkflowHostContext>();
metadata.AddDelegate(this.Body);
metadata.AddImplementationVariable(this.noPersistHandle);
metadata.AddImplementationChild(this.persist);
}
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());
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var collection = new Collection <RuntimeArgument>();
var type = GetType();
ActivityHelpers.AddCacheMetadata(collection, metadata, Context, type.ExtractPropertyName(() => Context));
metadata.SetArgumentsCollection(collection);
metadata.AddImplementationChild(_terminateWorkflow);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(TempConnectionInfo);
metadata.AddImplementationVariable(TempUtterance);
metadata.AddImplementationVariable(TempParameters);
metadata.AddImplementationVariable(TempLanguage);
metadata.AddImplementationVariable(TempSpeaker);
metadata.AddImplementationChild(InnerSaySpeech);
}
/// <summary>
/// Creates and validates a description of the <see cref="Activity"/>.
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(state);
metadata.AddImplementationChild(delay = new Delay()
{
Duration = new InArgument <TimeSpan>(ctx => ctx.GetValue(Delay))
});
metadata.SetDelegatesCollection(new Collection <ActivityDelegate>(Catches.Select(i => i.GetAction()).ToList()));
metadata.AddDelegate(Body);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
var runtimeArguments = new Collection <RuntimeArgument>();
runtimeArguments.Add(new RuntimeArgument("ExpressionResult", typeof(T), ArgumentDirection.In));
metadata.Bind(this.ExpressionResult, runtimeArguments[0]);
metadata.SetArgumentsCollection(runtimeArguments);
metadata.AddImplementationChild(_body);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationChild(_w1);
RuntimeArgument exceptionArgument = new RuntimeArgument("OutcomeOnCancellation", typeof(OutcomeState), ArgumentDirection.In, true);
metadata.Bind(this.OutcomeOnCancellation, exceptionArgument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
exceptionArgument
});
//base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
if (this.Condition == null)
{
metadata.AddValidationError(string.Format("Activity {0} requiere de una condición", this.DisplayName));
return;
}
metadata.AddImplementationChild(twf);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Counter = new Variable <int>();
Delay = new Delay()
{
Duration = TimeSpan.FromSeconds(1)
};
metadata.AddImplementationChild(Delay);
metadata.AddImplementationVariable(Counter);
base.CacheMetadata(metadata);
}
/// <summary>
/// Add activities, variables and argument to metadata
/// </summary>
/// <param name="metadata">Metadata</param>
private void SetupMetadata(NativeActivityMetadata metadata)
{
metadata.AddDelegate(OnInit);
metadata.AddDelegate(OnComplete);
metadata.AddImplementationChild(_approveSequence);
metadata.AddDefaultExtensionProvider(() => new WorkflowStateData());
metadata.AddImplementationVariable(DelaySpan);
var argAssignTo = new RuntimeArgument("AssignResultTo", typeof(string), ArgumentDirection.Out);
metadata.Bind(AssignResultTo, argAssignTo);
metadata.AddArgument(argAssignTo);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
foreach (Activity act in this.ImportedChildren)
{
metadata.AddImportedChild(act);
}
if (this.Body != null)
{
metadata.AddImplementationChild(this.Body);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
Predicate = new VisualBasicValue <TResult>("ExpressionText.Length");
ResultVar = new Variable <TResult>("ResultVar");
Assign = new Assign {
To = new OutArgument <TResult>(ResultVar), Value = new InArgument <TResult>(Predicate)
};
metadata.AddImplementationVariable(ResultVar);
metadata.AddImplementationChild(Assign);
}
/// <summary>
/// Add activities, variables and argument to metadata
/// </summary>
/// <param name="metadata">Metadata</param>
private void SetupMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationChild(_startWorkflowCatch);
var workflowIdArgument = new RuntimeArgument("WorkflowId", typeof(string), ArgumentDirection.Out);
metadata.Bind(WorkflowId, workflowIdArgument);
metadata.AddArgument(workflowIdArgument);
var resultArgument = new RuntimeArgument("WorkflowResult", typeof(string), ArgumentDirection.Out);
metadata.Bind(WorkflowResult, resultArgument);
metadata.AddArgument(resultArgument);
metadata.AddImplementationVariable(_currentRequest);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Timeout", typeof(TimeSpan), ArgumentDirection.In, false);
metadata.Bind(this.Timeout, argument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
argument
});
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);
}
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)
{
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));
}
/// <summary>
/// CacheMetadata
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationChild(this.persistActivity);
metadata.AddImplementationVariable(restartActivityContext);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationChild(persist);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationChild(cancelWorkflow);
metadata.AddImplementationDelegate(terminateWorkflow);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationVariable(this.bookmarking);
metadata.AddImplementationVariable(this.noPersistHandle);
metadata.AddImplementationChild(this.cancelTimer);
metadata.AddImplementationChild(this.terminateActivity);
NativeActivityMetadata nativeActivityMetadataPointer = metadata;
nativeActivityMetadataPointer.AddDefaultExtensionProvider<PSWorkflowInstanceExtension>(() => new PSWorkflowInstanceExtension());
this.ParameterDefaults = new Variable<Dictionary<string, object>>();
metadata.AddImplementationVariable(this.ParameterDefaults);
string[] strArrays = new string[1];
strArrays[0] = "not";
this.Tracer.WriteMessage(base.GetType().Name, "CacheMetadata", Guid.Empty, "Adding PowerShell specific extensions to metadata, CommonParameters are {0} available.", strArrays);
metadata.AddImplementationVariable(this.psActivityContextImplementationVariable);
}
/// <summary>
/// Tells the workflow runtime that this activity also schedules the
/// suspend activity (which it cannot automatically detect because it is not
/// provided as a parameter).
/// </summary>
/// <param name="metadata">The metadata provided by the hosting application.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationChild(this.suspendActivity);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
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);
if (this.correlationInitializers != null)
{
int count = 0;
foreach (CorrelationInitializer correlation in this.correlationInitializers)
{
if (correlation.CorrelationHandle != null)
{
RuntimeArgument argument = new RuntimeArgument(Constants.Parameter + count,
correlation.CorrelationHandle.ArgumentType, correlation.CorrelationHandle.Direction, true);
metadata.Bind(correlation.CorrelationHandle, argument);
metadata.AddArgument(argument);
count++;
}
}
}
RuntimeArgument receiveMessageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out);
if (this.Message == null)
{
this.Message = new OutArgument<Message>();
}
metadata.Bind(this.Message, receiveMessageArgument);
metadata.AddArgument(receiveMessageArgument);
RuntimeArgument noPersistHandleArgument = new RuntimeArgument(Constants.NoPersistHandle, Constants.NoPersistHandleType, ArgumentDirection.In);
if (this.NoPersistHandle == null)
{
this.NoPersistHandle = new InArgument<NoPersistHandle>();
}
metadata.Bind(this.NoPersistHandle, noPersistHandleArgument);
metadata.AddArgument(noPersistHandleArgument);
metadata.AddImplementationVariable(this.receiveMessageInstance);
metadata.AddImplementationVariable(this.extensionReceiveBookmark);
metadata.AddImplementationChild(this.waitForReply);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.RequireExtension <IDotnetWrapperService>();
metadata.AddImplementationChild(_sequence);
}
/// <summary>
/// Create activity metadata
/// </summary>
/// <param name="metadata">Metadata</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// this is used for synchronous childs. Parent will wait until child workflow
// send a response.
_eventCompleted = _eventCompleted ?? new SendReceiveBase <WorkflowEventRequest, WorkflowEventResponse>
{
ServiceContractName = "{http://flowtasks.com/}IFlowTasksOperations",
OperationName = "WorkflowEvent",
CanCreateInstance = false,
GenerateCorrelationId = false,
UseContentCorrelation = true,
CorrelationId = CorrelationId,
MessageNamespace = "urn:flowtasks:workflowevent",
DisplayName = "WorkflowEvent",
OnCompleting = new ActivityFunc <WorkflowEventRequest, WorkflowEventResponse>
{
Argument = _request,
Handler = new CreateResponseForWorkflowEvent
{
DisplayName = "CreateResponseForWorkflowEvent",
Request = _request
}
}
};
_sync = _sync ?? new Sequence
{
DisplayName = "WaitForWf",
Activities =
{
_eventCompleted
}
};
metadata.AddImplementationChild(_sync);
var workflowIdArgument = new RuntimeArgument("WorkflowId", typeof(string), ArgumentDirection.Out);
metadata.Bind(WorkflowId, workflowIdArgument);
metadata.AddArgument(workflowIdArgument);
var resultArgument = new RuntimeArgument("WorkflowResult", typeof(string), ArgumentDirection.Out);
metadata.Bind(WorkflowResult, resultArgument);
metadata.AddArgument(resultArgument);
var workflowCodeArgument = new RuntimeArgument("WorkflowCode", typeof(string), ArgumentDirection.In);
metadata.Bind(WorkflowCode, workflowCodeArgument);
metadata.AddArgument(workflowCodeArgument);
var domainArgument = new RuntimeArgument("Domain", typeof(string), ArgumentDirection.In);
metadata.Bind(Domain, domainArgument);
metadata.AddArgument(domainArgument);
var propertiesArgument = new RuntimeArgument("Properties", typeof(Dictionary <string, string>), ArgumentDirection.In);
metadata.Bind(Properties, propertiesArgument);
metadata.AddArgument(propertiesArgument);
var asyncArgument = new RuntimeArgument("Async", typeof(bool), ArgumentDirection.In);
metadata.Bind(Async, asyncArgument);
metadata.AddArgument(asyncArgument);
metadata.AddImplementationVariable(NewWorkflowId);
}
/// <summary>
/// The cache metadata.
/// </summary>
/// <param name="metadata">
/// The metadata.
/// </param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.RequireExtension<IHttpWorkflowHostContext>();
metadata.AddDelegate(this.Body);
metadata.AddImplementationVariable(this.noPersistHandle);
metadata.AddImplementationChild(this.persist);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationChild(_innerSequence);
}
/// <summary>
/// Tells the workflow runtime that this activity also schedules the
/// suspend activity (which it cannot automatically detect because it is not
/// provided as a parameter).
/// </summary>
/// <param name="metadata">The metadata provided by the hosting application.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationChild(this.suspendActivity);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument activityArgument = new RuntimeArgument("Activity", typeof(InvokeDelegate), ArgumentDirection.In, true);
metadata.Bind(this.Activity, activityArgument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { activityArgument });
metadata.AddImplementationChild(this.ShowWarning);
metadata.AddImplementationChild(this.ShowError);
metadata.AddImplementationVariable(this.WarningMessageVariable);
metadata.AddImplementationVariable(this.ErrorMessageVariable);
}
/// <summary>
/// CacheMetadata
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
metadata.AddImplementationChild(this.persistActivity);
metadata.AddImplementationVariable(restartActivityContext);
}
/// <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)
{
this.delay = new Delay { Duration = StubDuration };
metadata.AddImplementationChild(this.delay);
base.CacheMetadata(metadata);
}
/// <summary>
/// The cache metadata.
/// </summary>
/// <param name="metadata">
/// The metadata.
/// </param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddArgument(new RuntimeArgument("UntilDate", typeof(DateTime), ArgumentDirection.In, true));
metadata.AddImplementationChild(this.delay);
metadata.AddImplementationVariable(this.delayInterval);
}
