public ActivityTrace(string activityName, ActivityInstanceState activityStatus, TrackingRecord record)
{
_activityName = activityName;
_activityStatus = activityStatus;
if (record != null)
{
this.ActivityInstanceId = record.InstanceId.ToString();
if (record is ActivityStateRecord)
{
if ((record as ActivityStateRecord).Activity != null)
{
this.ActivityId = (record as ActivityStateRecord).Activity.Id;
this.ActivityInstanceId = (record as ActivityStateRecord).Activity.InstanceId;
}
}
if (record is ActivityScheduledRecord)
{
this.IsScheduled = true;
ActivityScheduledRecord activityScheduledRecord = record as ActivityScheduledRecord;
if (activityScheduledRecord.Activity != null)
{
this.ActivityId = activityScheduledRecord.Activity.Id;
this.ActivityInstanceId = activityScheduledRecord.Activity.InstanceId;
ChildActivityId = activityScheduledRecord.Child.Id;
ChildActivityInstanceId = activityScheduledRecord.Child.InstanceId;
}
}
}
}
internal ActivityStateRecord(Guid instanceId, ActivityInfo activity, ActivityInstanceState state)
: base(instanceId)
{
this.Activity = activity;
switch (state)
{
case ActivityInstanceState.Executing:
this.State = ActivityStates.Executing;
break;
case ActivityInstanceState.Closed:
this.State = ActivityStates.Closed;
break;
case ActivityInstanceState.Canceled:
this.State = ActivityStates.Canceled;
break;
case ActivityInstanceState.Faulted:
this.State = ActivityStates.Faulted;
break;
default:
throw Fx.AssertAndThrow("Invalid state value");
}
}
// <Snippet0>
protected override IAsyncResult OnBeginWorkflowCompleted(ActivityInstanceState completionState, IDictionary <string, object> workflowOutputs,
Exception faultedReason, TimeSpan timeout, AsyncCallback callback, object state)
{
if (completionState == ActivityInstanceState.Faulted)
{
Console.WriteLine("InstanceId :" + InstanceId + " OnBeginWorkflowTerminated");
}
else if (completionState == ActivityInstanceState.Canceled)
{
Console.WriteLine("InstanceId :" + InstanceId + " OnBeginWorkflowCanceled");
}
else
{
Console.WriteLine("InstanceId :" + InstanceId + " OnBeginWorkflowCompleted");
WorkflowHostingResponseContext responseContext = UserState as WorkflowHostingResponseContext;
if (responseContext != null)
{
foreach (object value in workflowOutputs.Values)
{
responseContext.SendResponse(value, null);
break;
}
}
}
return(base.OnBeginWorkflowCompleted(completionState, workflowOutputs, faultedReason, timeout, callback, state));
}
private void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
CompensationTokenData rootHandle = compensationExtension.Get(CompensationToken.RootCompensationId);
Fx.Assert(rootHandle != null, "rootToken must be valid");
ActivityInstanceState completionState = (ActivityInstanceState)value;
if (completionState == ActivityInstanceState.Closed)
{
context.ResumeBookmark(compensationExtension.WorkflowConfirmation, new CompensationToken(rootHandle));
}
else if (completionState == ActivityInstanceState.Canceled)
{
context.ResumeBookmark(compensationExtension.WorkflowCompensation, new CompensationToken(rootHandle));
}
else if (completionState == ActivityInstanceState.Faulted)
{
// Do nothing. Neither Compensate nor Confirm.
// Remove the bookmark to complete the WorkflowCompensationBehavior execution.
context.RemoveBookmark(compensationExtension.WorkflowConfirmation);
context.RemoveBookmark(compensationExtension.WorkflowCompensation);
}
}
private IDictionary <XName, InstanceValue> SaveWorkflow()
{
if (Controller.State == WorkflowInstanceState.Aborted)
{
throw new InvalidOperationException("Cannot generate data for an aborted instance.");
}
Dictionary <XName, InstanceValue> instanceValues = new Dictionary <XName, InstanceValue>(10);
if (Parameters.PersistWriteOnlyValues)
{
instanceValues[WorkflowNamespace.LastUpdate] = new InstanceValue(DateTime.UtcNow, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
instanceValues[WorkflowNamespace.Bookmarks] = new InstanceValue(Controller.GetBookmarks(), InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
foreach (KeyValuePair <string, LocationInfo> mappedVariable in Controller.GetMappedVariables())
{
instanceValues[WorkflowNamespace.VariablesPath.GetName(mappedVariable.Key)] = new InstanceValue(mappedVariable.Value, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
}
}
if (Controller.State != WorkflowInstanceState.Complete) // Idle || Runnable
{
instanceValues[WorkflowNamespace.Workflow] = new InstanceValue(Controller.PrepareForSerialization());
if (IsStarting)
{
instanceValues[WorkflowNamespace.IsStarting] = new InstanceValue(true);
}
instanceValues[WorkflowNamespace.Status] = new InstanceValue(Controller.State == WorkflowInstanceState.Idle ? WorkflowStatus.Idle : WorkflowStatus.Executing);
}
else // Complete
{
if (Parameters.PersistWriteOnlyValues)
{
instanceValues[WorkflowNamespace.Workflow] = new InstanceValue(Controller.PrepareForSerialization(), InstanceValueOptions.Optional);
}
ActivityInstanceState completionState = Controller.GetCompletionState(out IDictionary <string, object> outputs, out Exception terminationException);
if (completionState == ActivityInstanceState.Closed)
{
instanceValues[WorkflowNamespace.Status] = new InstanceValue(WorkflowStatus.Closed);
if (outputs != null)
{
foreach (KeyValuePair <string, object> output in outputs)
{
instanceValues[WorkflowNamespace.OutputPath.GetName(output.Key)] = new InstanceValue(output.Value);
}
}
}
else if (completionState == ActivityInstanceState.Canceled)
{
instanceValues[WorkflowNamespace.Status] = new InstanceValue(WorkflowStatus.Canceled);
}
else // Faulted
{
instanceValues[WorkflowNamespace.Status] = new InstanceValue(WorkflowStatus.Faulted);
instanceValues[WorkflowNamespace.Exception] = new InstanceValue(terminationException);
}
}
return(instanceValues);
}
private void TrackState(ActivityExecutor executor, ActivityInstanceState state, ref ActivityInfo activityInfo)
{
if (executor.ShouldTrackActivity(this.expressionActivity.DisplayName))
{
this.EnsureActivityInfo(ref activityInfo);
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, activityInfo, state));
}
}
internal WorkflowApplicationCompletedEventArgs(WorkflowApplication application, Exception terminationException, ActivityInstanceState completionState, IDictionary <string, object> outputs)
: base(application)
{
Fx.Assert(ActivityUtilities.IsCompletedState(completionState), "event should only fire for completed activities");
this.terminationException = terminationException;
this.completionState = completionState;
this.outputs = outputs;
}
internal WorkflowApplicationCompletedEventArgs(WorkflowApplication application, Exception terminationException, ActivityInstanceState completionState, IDictionary<string, object> outputs)
: base(application)
{
Fx.Assert(ActivityUtilities.IsCompletedState(completionState), "event should only fire for completed activities");
this.terminationException = terminationException;
this.completionState = completionState;
this.outputs = outputs;
}
public virtual HistoricActivityInstanceQueryImpl canceled()
{
if (activityInstanceState != null)
{
throw new ProcessEngineException("Already querying for activity instance state <" + activityInstanceState + ">");
}
this.activityInstanceState = org.camunda.bpm.engine.impl.pvm.runtime.ActivityInstanceState_Fields.CANCELED;
return(this);
}
public ActivityTrace(ActivityTrace trace)
{
this.IsScheduled = trace.IsScheduled;
_activityName = trace._activityName;
_activityStatus = trace._activityStatus;
this.ActivityId = trace.ActivityId;
this.ActivityInstanceId = trace.ActivityInstanceId;
this.ChildActivityId = trace.ChildActivityId;
this.ChildActivityInstanceId = trace.ChildActivityInstanceId;
this.Optional = trace.Optional;
}
/// <summary>
/// Retreive each type of tracking record and perform the corresponding fucntionality.
/// </summary>
/// <param name="record">Represents the tracking record.</param>
/// <param name="timeout">Time out for the tracking to be completed.</param>
protected override void Track(TrackingRecord record, TimeSpan timeout)
{
Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "{0} Emitted trackRecord: {1} Level: {2}, RecordNumber: {3}", participantName, record.GetType().FullName, record.Level, record.RecordNumber));
WorkflowInstanceRecord workflowInstanceRecord = record as WorkflowInstanceRecord;
if (workflowInstanceRecord != null)
{
if (_structuredTracer.IsEnabled)
{
if (string.Equals(WorkflowInstanceStates.Persisted, workflowInstanceRecord.State, StringComparison.OrdinalIgnoreCase))
{
_structuredTracer.WorkflowPersisted(workflowInstanceRecord.InstanceId);
}
else if (string.Equals(WorkflowInstanceStates.UnhandledException, workflowInstanceRecord.State, StringComparison.OrdinalIgnoreCase))
{
WorkflowInstanceUnhandledExceptionRecord unhandledRecord = workflowInstanceRecord as WorkflowInstanceUnhandledExceptionRecord;
if (unhandledRecord != null)
{
_structuredTracer.WorkflowActivityExecutionFailed(unhandledRecord.InstanceId,
unhandledRecord.FaultSource != null ? unhandledRecord.FaultSource.Name : unhandledRecord.ActivityDefinitionId,
System.Management.Automation.Tracing.Tracer.GetExceptionString(unhandledRecord.UnhandledException));
}
}
}
this.ProcessWorkflowInstanceRecord(workflowInstanceRecord);
}
ActivityStateRecord activityStateRecord = record as ActivityStateRecord;
if (activityStateRecord != null)
{
if (_structuredTracer.IsEnabled)
{
ActivityInstanceState activityState = ActivityInstanceState.Executing;
if (!string.IsNullOrEmpty(activityStateRecord.State) &&
Enum.TryParse <ActivityInstanceState>(activityStateRecord.State, out activityState))
{
if (activityState == ActivityInstanceState.Executing)
{
_structuredTracer.ActivityExecutionQueued(activityStateRecord.InstanceId, activityStateRecord.Activity.Name);
}
}
}
this.ProcessActivityStateRecord(activityStateRecord);
}
CustomTrackingRecord customTrackingRecord = record as CustomTrackingRecord;
if ((customTrackingRecord != null) && (customTrackingRecord.Data.Count > 0))
{
this.ProcessCustomTrackingRecord(customTrackingRecord);
}
}
//need to put this into a common utility class. which one?
private bool TryConvertToEnum(string stateAsString, out ActivityInstanceState actualState)
{
foreach (ActivityInstanceState state in Enum.GetValues(typeof(ActivityInstanceState)))
{
if (state.ToString() == stateAsString)
{
actualState = state;
return(true);
}
}
// We must have had a custom state that was tracked
actualState = default(ActivityInstanceState);
return(false);
}
private static string GetStatus(ActivityInstanceState activityInstanceState)
{
//the states b\w the wf runtime dev code & teh staus enums are not in sync.
string status = activityInstanceState.ToString();
if (activityInstanceState.ToString() == WorkflowElementStates.Executing)
{
status = ActivityStates.Schedule;
}
else if (activityInstanceState.ToString() == WorkflowElementStates.Faulted)
{
status = ActivityStates.Fault;
}
return(status);
}
public async Task LoadAsync(IDictionary <XName, InstanceValue> instanceValues, IEnumerable <object> extensions, IParameters parameters)
{
switch (instanceValues[WorkflowNamespace.Status].Value as string)
{
case WorkflowStatus.Closed:
var outputArgumentsRead = new Dictionary <string, object>();
foreach (var kvp in instanceValues.Where((iv) => iv.Key.Namespace == WorkflowNamespace.OutputPath))
{
outputArgumentsRead.Add(kvp.Key.LocalName, kvp.Value.Value);
}
if (outputArgumentsRead.Count > 0)
{
this.outputArguments = outputArgumentsRead;
}
this.completionState = ActivityInstanceState.Closed;
break;
case WorkflowStatus.Canceled:
this.completionState = ActivityInstanceState.Canceled;
break;
case WorkflowStatus.Faulted:
this.terminationException = instanceValues[WorkflowNamespace.Exception].Value as Exception;
this.completionState = ActivityInstanceState.Faulted;
break;
default:
throw new ArgumentOutOfRangeException(WorkflowNamespace.Status.ToString());
}
// Yes, IEnumerable<object> is ugly, but there is nothing common in IPersistenceParticipant and PersistenceParticipant.
var persistenceParticipants =
((IEnumerable <object>)extensions.OfType <System.Activities.Persistence.PersistenceParticipant>())
.Concat(
((IEnumerable <object>)extensions.OfType <IPersistenceParticipant>()));
// If the persistenceParticipants throw during OnLoadAsync(), the pipeline will rethrow
if (persistenceParticipants.Any())
{
var persistencePipeline = new PersistencePipeline(persistenceParticipants, instanceValues);
await persistencePipeline.OnLoadAsync(parameters.ExtensionsPersistenceTimeout);
persistencePipeline.Publish();
}
}
internal static string GetStateName(this ActivityInstanceState state)
{
switch (state)
{
case ActivityInstanceState.Executing:
return("Executing");
case ActivityInstanceState.Closed:
return("Closed");
case ActivityInstanceState.Canceled:
return("Canceled");
case ActivityInstanceState.Faulted:
return("Faulted");
default:
Fx.Assert("Don't understand ActivityInstanceState named " + state.ToString());
return(state.ToString());
}
}
internal ActivityStateRecord(Guid instanceId, System.Activities.ActivityInstance instance, ActivityInstanceState state) : base(instanceId)
{
this.Activity = new ActivityInfo(instance);
switch (state)
{
case ActivityInstanceState.Executing:
this.State = "Executing";
return;
case ActivityInstanceState.Closed:
this.State = "Closed";
return;
case ActivityInstanceState.Canceled:
this.State = "Canceled";
return;
case ActivityInstanceState.Faulted:
this.State = "Faulted";
return;
}
throw Fx.AssertAndThrow("Invalid state value");
}
internal void FinalizeState(ActivityExecutor executor, bool faultActivity, bool skipTracking)
{
if (faultActivity)
{
this.TryCancelParent();
this.state = ActivityInstanceState.Faulted;
}
if (this.state == ActivityInstanceState.Closed)
{
if ((executor.ShouldTrackActivityStateRecordsClosedState && !skipTracking) && executor.ShouldTrackActivity(this.Activity.DisplayName))
{
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
}
}
else if (executor.ShouldTrackActivityStateRecords && !skipTracking)
{
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
}
if (TD.ActivityCompletedIsEnabled())
{
TD.ActivityCompleted(this.Activity.GetType().ToString(), this.Activity.DisplayName, this.Id, this.State.ToString());
}
}
private void TrackCompletion()
{
if (this.controller.TrackingEnabled && !this.hasTrackedCompletion)
{
ActivityInstanceState state = this.executor.State;
switch (state)
{
case ActivityInstanceState.Faulted:
this.controller.Track(new WorkflowInstanceTerminatedRecord(this.Id, this.WorkflowDefinition.DisplayName, this.executor.TerminationException.Message));
break;
case ActivityInstanceState.Closed:
this.controller.Track(new WorkflowInstanceRecord(this.Id, this.WorkflowDefinition.DisplayName, "Completed"));
break;
default:
Fx.AssertAndThrow(state == ActivityInstanceState.Canceled, "Cannot be executing a workflow instance when WorkflowState was completed.");
this.controller.Track(new WorkflowInstanceRecord(this.Id, this.WorkflowDefinition.DisplayName, "Canceled"));
break;
}
this.hasTrackedCompletion = true;
}
}
void TrackCompletion()
{
if (this.controller.TrackingEnabled && !this.hasTrackedCompletion)
{
ActivityInstanceState completionState = this.executor.State;
if (completionState == ActivityInstanceState.Faulted)
{
Fx.Assert(this.executor.TerminationException != null, "must have a termination exception if we're faulted");
this.controller.Track(new WorkflowInstanceTerminatedRecord(this.Id, this.WorkflowDefinition.DisplayName, this.executor.TerminationException.Message, this.DefinitionIdentity));
}
else if (completionState == ActivityInstanceState.Closed)
{
this.controller.Track(new WorkflowInstanceRecord(this.Id, this.WorkflowDefinition.DisplayName, WorkflowInstanceStates.Completed, this.DefinitionIdentity));
}
else
{
Fx.AssertAndThrow(completionState == ActivityInstanceState.Canceled, "Cannot be executing a workflow instance when WorkflowState was completed.");
this.controller.Track(new WorkflowInstanceRecord(this.Id, this.WorkflowDefinition.DisplayName, WorkflowInstanceStates.Canceled, this.DefinitionIdentity));
}
this.hasTrackedCompletion = true;
}
}
internal ActivityStateRecord(Guid instanceId, ActivityInfo activity, ActivityInstanceState state)
: base(instanceId)
{
this.Activity = activity;
switch (state)
{
case ActivityInstanceState.Executing:
this.State = ActivityStates.Executing;
break;
case ActivityInstanceState.Closed:
this.State = ActivityStates.Closed;
break;
case ActivityInstanceState.Canceled:
this.State = ActivityStates.Canceled;
break;
case ActivityInstanceState.Faulted:
this.State = ActivityStates.Faulted;
break;
default:
throw Fx.AssertAndThrow("Invalid state value");
}
}
public async Task LoadAsync(IDictionary<XName, InstanceValue> instanceValues, IEnumerable<object> extensions, IParameters parameters)
{
switch (instanceValues[WorkflowNamespace.Status].Value as string)
{
case WorkflowStatus.Closed:
Dictionary<string, object> outputArgumentsRead = new Dictionary<string, object>();
foreach (KeyValuePair<XName, InstanceValue> kvp in instanceValues.Where((iv) => iv.Key.Namespace == WorkflowNamespace.OutputPath))
outputArgumentsRead.Add(kvp.Key.LocalName, kvp.Value.Value);
if (outputArgumentsRead.Count > 0)
outputArguments = outputArgumentsRead;
completionState = ActivityInstanceState.Closed;
break;
case WorkflowStatus.Canceled:
completionState = ActivityInstanceState.Canceled;
break;
case WorkflowStatus.Faulted:
terminationException = instanceValues[WorkflowNamespace.Exception].Value as Exception;
completionState = ActivityInstanceState.Faulted;
break;
default:
throw new ArgumentOutOfRangeException(WorkflowNamespace.Status.ToString());
}
// Yes, IEnumerable<object> is ugly, but there is nothing common in IPersistenceParticipant and PersistenceParticipant.
IEnumerable<object> persistenceParticipants =
((IEnumerable<object>)extensions.OfType<System.Activities.Persistence.PersistenceParticipant>())
.Concat(
((IEnumerable<object>)extensions.OfType<IPersistenceParticipant>()));
// If the persistenceParticipants throw during OnLoadAsync(), the pipeline will rethrow
if (persistenceParticipants.Any())
{
PersistencePipeline persistencePipeline = new PersistencePipeline(persistenceParticipants, instanceValues);
await persistencePipeline.OnLoadAsync(parameters.ExtensionsPersistenceTimeout);
persistencePipeline.Publish();
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="activity"></param>
public TwilioTestContext(Activity activity)
{
// wrap in CallScope
var arg1 = new DelegateInArgument<CallContext>();
var scope = new CallScope()
{
Body = new ActivityAction<CallContext>()
{
Argument = arg1,
Handler = activity,
},
};
// workflow needs a sync context to run on
sync = new SynchronizedSynchronizationContext();
// new invoker which uses ourself as the context
app = new WorkflowApplication(scope);
app.Extensions.Add<ITwilioContext>(() => this);
app.Completed = a => state = a.CompletionState;
response = new XElement("Response");
element = response;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="activity"></param>
public TwilioTestContext(Activity activity)
{
// wrap in CallScope
var arg1 = new DelegateInArgument <CallContext>();
var scope = new CallScope()
{
Body = new ActivityAction <CallContext>()
{
Argument = arg1,
Handler = activity,
},
};
// workflow needs a sync context to run on
sync = new SynchronizedSynchronizationContext();
// new invoker which uses ourself as the context
app = new WorkflowApplication(scope);
app.Extensions.Add <ITwilioContext>(() => this);
app.Completed = a => state = a.CompletionState;
response = new XElement("Response");
element = response;
}
internal WorkflowApplicationCompletedEventArgs(System.Activities.WorkflowApplication application, Exception terminationException, ActivityInstanceState completionState, IDictionary<string, object> outputs) : base(application)
{
this.terminationException = terminationException;
this.completionState = completionState;
this.outputs = outputs;
}
public static bool IsCompletedState(ActivityInstanceState state)
{
return(state != ActivityInstanceState.Executing);
}
public ActivityTrace(string activityName, ActivityInstanceState activityStatus)
{
_activityName = activityName;
_activityStatus = activityStatus;
}
internal ActivityInstance (string id, bool isCompleted, ActivityInstanceState state)
{
Id = id;
IsCompleted = isCompleted;
State = state;
}
internal ActivityStateRecord(Guid instanceId, ActivityInstance instance, ActivityInstanceState state)
: this(instanceId, new ActivityInfo(instance), state)
{
}
protected internal virtual IAsyncResult OnBeginWorkflowCompleted(
ActivityInstanceState completionState, IDictionary<string, object> workflowOutputs,
Exception terminationException, TimeSpan timeout, AsyncCallback callback, object state)
{
return new CompletedAsyncResult(callback, state);
}
public Task OnCompletedAsync(ActivityInstanceState completionState, IDictionary <string, object> outputArguments, Exception terminationException) => grain.OnCompletedAsync(completionState, outputArguments, terminationException);
public WorkflowCompletionState(ActivityInstanceState completionState, IDictionary<string, object> outputArguments, Exception terminationException)
{
this.completionState = completionState;
this.outputArguments = outputArguments;
this.terminationException = terminationException;
}
internal ActivityStateRecord(Guid instanceId, ActivityInstance instance, ActivityInstanceState state)
: this(instanceId, new ActivityInfo(instance), state)
{
}
/// <summary> /// Called when the workflow is completed. /// <para>Tipically executed only once, but in case of failure, there is a small chance that it is called multiple times.</para> /// </summary> /// <param name="completionState"></param> /// <param name="outputArguments">Can be null. If the workflow (as an activity) has output arguments, their values are returned here.</param> /// <param name="terminationException">Can be null.</param> /// <returns></returns> protected virtual Task OnCompletedAsync(ActivityInstanceState completionState, IDictionary <string, object> outputArguments, Exception terminationException) => TaskConstants.Completed;
public Task OnCompletedAsync(ActivityInstanceState completionState, IDictionary <string, object> outputArguments, Exception terminationException)
{
this.completionState = new WorkflowCompletionState(completionState, outputArguments, terminationException);
return(RaiseCompletedAsync(completionState, outputArguments, terminationException));
}
private Task RaiseCompletedAsync(ActivityInstanceState completionState, IDictionary <string, object> outputArguments, Exception terminationException) =>
CompletedAsync == null
? TaskConstants.Completed
: CompletedAsync(completionState, outputArguments, terminationException);
/// <summary>
/// Initializes a new instance of the <see cref="NinjectWorkflowApplicationCompletedEventArgs"/> class.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="completionState">State of the completion.</param>
/// <param name="terminationException">The termination exception.</param>
/// <param name="outputs">The outputs.</param>
public NinjectWorkflowApplicationCompletedEventArgs(Guid instanceId, ActivityInstanceState completionState, Exception terminationException, IDictionary <string, object> outputs) : base(instanceId)
{
this.CompletionState = completionState;
this.Outputs = outputs;
this.TerminationException = terminationException;
}
/// <summary>
/// Initializes a new instance of the <see cref="NinjectWorkflowApplicationCompletedEventArgs"/> class.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="completionState">State of the completion.</param>
/// <param name="terminationException">The termination exception.</param>
/// <param name="outputs">The outputs.</param>
public NinjectWorkflowApplicationCompletedEventArgs(Guid instanceId, ActivityInstanceState completionState, Exception terminationException, IDictionary<string, object > outputs) : base(instanceId)
{
this.CompletionState = completionState;
this.Outputs = outputs;
this.TerminationException = terminationException;
}
public WorkflowCompletionState(ActivityInstanceState completionState, IDictionary <string, object> outputArguments, Exception terminationException)
{
this.completionState = completionState;
this.outputArguments = outputArguments;
this.terminationException = terminationException;
}
private void AddActivityTrace(TraceEventType eventType, Guid instanceId, string displayName, ActivityInstanceState state, TrackingRecord record)
{
ActivityTrace trace = new ActivityTrace(displayName, state, record);
this.TestTraceManager.AddTrace(instanceId, trace);
TestTraceManager.OptionalLogTrace(string.Format("[TestTrackingParticipantBase]{0} : {1,-11} : {2,-9} : {3}", instanceId, eventType, state, displayName));
}
protected internal virtual IAsyncResult OnBeginWorkflowCompleted(ActivityInstanceState completionState, IDictionary <string, object> workflowOutputs, Exception terminationException, TimeSpan timeout, AsyncCallback callback, object state)
{
return(new CompletedAsyncResult(callback, state));
}
void GetCompletionState()
{
this.completionState = this.Controller.GetCompletionState(out this.workflowOutputs, out this.terminationException);
}
private void TrackState(ActivityExecutor executor, ActivityInstanceState state, ref ActivityInfo activityInfo)
{
if (executor.ShouldTrackActivity(this.expressionActivity.DisplayName))
{
this.EnsureActivityInfo(ref activityInfo);
executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, activityInfo, state));
}
}
private static bool IsActivityLocationTracked(ActivityStateQuery activityQuery, string activityName, ActivityInstanceState activityInstanceState)
{
//todo_vc
//if the activity query contains the "Executing" state we need to delete that. since there is no "Executing" state defined in product.
//The correct fix is in the product.
//this is fixed now for Beta2.
//activityQuery.States.Remove(WorkflowElementStates.Executing);
if (
(activityQuery.ActivityName == "*" || activityQuery.ActivityName == activityName)
&&
(activityQuery.States.Contains("*") || activityQuery.States.Contains(activityInstanceState.ToString()))
)
{
return(true);
}
return(false);
}
