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 void BookmarkCallback(NativeActivityContext context, Bookmark bookmark, object bookmarkData)
{
_iteration.Set(context, _iteration.Get(context) + 1);
string dataString = bookmarkData as string;
if (dataString != null)
{
Console.WriteLine("Interation: {0}; Bookmark {1} resumed with data: {2}", _iteration.Get(context).ToString(), bookmark.Name, dataString);
if (string.Compare(dataString, "stop", true) == 0)
{
context.RemoveBookmark(bookmark.Name);
}
else
{
context.RemoveBookmark(bookmark.Name);
}
}
else
{
Console.WriteLine("Iteration: {0}; Bookmark {1} resumed with data that is not a string", _iteration.Get(context).ToString(), bookmark.Name);
}
}
private void OnExtensionProgress(NativeActivityContext context, Bookmark bookmark, Object data)
{
if (bookmarkProgress.Get(context) != bookmark)
{
return;
}
if (data is int && !context.IsCancellationRequested)
{
Track(context, data);
if (this.OnProgress != null)
{
context.ScheduleAction <int>(this.OnProgress, (int)data);
}
}
else
{
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
if (data is Exception)
{
throw data as Exception;
}
}
}
void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object obj)
{
context.RemoveBookmark(bookmark.Name);
var command = Newtonsoft.Json.JsonConvert.DeserializeObject <Interfaces.mq.RobotCommand>(obj.ToString());
if (command.data == null)
{
return;
}
if (string.IsNullOrEmpty(command.data.ToString()))
{
return;
}
var payload = JObject.Parse(command.data.ToString());
List <string> keys = payload.Properties().Select(p => p.Name).ToList();
foreach (var key in keys)
{
var myVar = context.DataContext.GetProperties().Find(key, true);
if (myVar != null)
{
//var myValue = myVar.GetValue(context.DataContext);
myVar.SetValue(context.DataContext, payload[key].ToString());
}
else
{
Log.Debug("Recived property " + key + " but no variable exists to save the value in " + payload[key]);
}
//action.setvariable(key, payload[key]);
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.timerBookmark.Get(context);
this.GetTimerExtension(context).CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
private void OnReceiveNotification(NativeActivityContext context, Bookmark bookmark, object data)
{
if (receiveCompleteBookmark.Get(context) != bookmark)
{
return;
}
if (data is FileChangeEvent && !context.IsCancellationRequested)
{
Track(context, (FileChangeEvent)data);
// Store the result...
var result = this.Result.Get(context);
result.Add((FileChangeEvent)data);
this.Result.Set(context, result);
}
else
{
UnregisterReceiveNotification(context);
context.RemoveBookmark(bookmark);
if (data is Exception)
{
throw data as Exception;
}
}
}
protected override void Execute(NativeActivityContext context)
{
var noPersistHandle = NoPersistHandle.Get(context);
noPersistHandle.Enter(context);
var bookmark = context.CreateBookmark(BookmarkResumptionCallback);
this.Bookmark.Set(context, bookmark);
BookmarkResumptionHelper helper = context.GetExtension <BookmarkResumptionHelper>();
Action <IAsyncResult> resumeBookmarkAction = (result) =>
{
helper.ResumeBookmark(bookmark, result);
};
IAsyncResult asyncResult = this.BeginExecute(context, AsyncCompletionCallback, resumeBookmarkAction);
if (asyncResult.CompletedSynchronously)
{
noPersistHandle.Exit(context);
context.RemoveBookmark(bookmark);
EndExecute(context, asyncResult);
}
}
private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark)
{
var log = context.Resolve <ILoggerFactory>() != null
? context.Resolve <ILoggerFactory>().Create(typeof(SubProcess))
: null;
var parser = context.Resolve <IScriptParser>();
var extension = context.GetExtension <DataFieldExtension>();
//完成规则解析
if (this.Result != null &&
parser != null &&
this.FinishRule != null &&
this.FinishRule.Count > 0)
{
foreach (var i in this.FinishRule)
{
if (parser.EvaluateRule(i.Value, extension))
{
this.Result.Set(context, i.Key);
if (log != null)
{
log.InfoFormat("SubProcess节点完成规则“{0}”测试通过，将进入节点“{1}”", i.Value, i.Key);
}
break;
}
}
}
//所有逻辑完成才可删除，若上述逻辑失败则将此书签用于错误恢复
context.RemoveBookmark(bookmark);
}
public void ResumeWorkflow(NativeActivityContext context, Bookmark bookmark, Object workflowManager)
{
// REMOVE THE BOOKMARK SO THAT IT CAN BE USED AGAIN
context.RemoveBookmark(context.WorkflowInstanceId.ToString());
// RESET WORKFLOW MANAGER INSTANCE
WorkflowManager.Set(context, workflowManager);
WorkflowManager.Get(context).WorkflowStatus = WorkflowStatus.Resumed;
// RECORD WORKFLOW STEPS
Workflows.Activities.CommonFunctions.WorkflowStepsAdd(
WorkflowManager.Get(context).Application,
1,
WorkQueueItem.Get(context).Id,
WorkflowSteps.Get(context),
"Resume Workflow"
);
return;
}
private void UnregisterReceiveNotification(ActivityContext context)
{
var subscriptionHandle = this.SubscriptionHandle.Get(context);
Bookmark bookmark = this.receiveCompleteBookmark.Get(context);
if (bookmark != null)
{
if (subscriptionHandle != null)
{
context.GetExtension <Hosting.FolderWatcherExtension>()
.UnregisterReceiveNotification(bookmark, subscriptionHandle.Id);
}
}
if (context is NativeActivityContext)
{
NativeActivityContext ctx = context as NativeActivityContext;
if (bookmark != null)
{
ctx.RemoveBookmark(bookmark);
}
this.noPersistHandle.Get(ctx).Exit(ctx);
}
else if (context is NativeActivityFaultContext)
{
NativeActivityFaultContext ctx = context as NativeActivityFaultContext;
if (bookmark != null)
{
ctx.RemoveBookmark(bookmark);
}
this.noPersistHandle.Get(ctx).Exit(ctx);
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.timerBookmark.Get(context);
this.GetTimerExtension(context).CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
{
if (this.Result != null)
{
this.Result.Set(context, value == null ? string.Empty : value.ToString());
}
context.RemoveBookmark(bookmark);
}
private void OnConfirmationComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
context.RemoveBookmark(compensationExtension.WorkflowCompensation);
}
internal void RemoveBookmark(NativeActivityContext context, CompensationBookmarkName bookmarkName)
{
Bookmark bookmark = this.BookmarkTable[bookmarkName];
if (bookmark != null)
{
context.RemoveBookmark(bookmark);
this.BookmarkTable[bookmarkName] = null;
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.bookmark.Get(context);
if (bookmark != null)
{
context.RemoveBookmark(bookmark);
}
base.Cancel(context);
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark timerBookmark = _timerBookmark.Get(context);
TimerExtension timerExtension = GetTimerExtension(context);
timerExtension.CancelTimer(timerBookmark);
context.RemoveBookmark(timerBookmark);
context.MarkCanceled();
}
void OnCompensationComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// Remove bookmark.... have a cleanup book mark method...
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
context.RemoveBookmark(compensationExtension.WorkflowConfirmation);
}
void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object obj)
{
try
{
context.RemoveBookmark(bookmark.Name);
var instance = obj as WorkflowInstance;
if (instance == null)
{
throw new Exception("Bookmark returned a non WorkflowInstance");
}
if (instance.Exception != null)
{
throw instance.Exception;
}
if (instance.hasError)
{
throw new Exception(instance.errormessage);
}
foreach (var prop in instance.Parameters)
{
var myVar = context.DataContext.GetProperties().Find(prop.Key, true);
if (myVar != null)
{
//var myValue = myVar.GetValue(context.DataContext);
myVar.SetValue(context.DataContext, prop.Value);
}
else
{
Log.Debug("Recived property " + prop.Key + " but no variable exists to save the value in " + prop.Value);
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
throw;
}
//var payload = JObject.Parse(obj.ToString());
//List<string> keys = payload.Properties().Select(p => p.Name).ToList();
//foreach (var key in keys)
//{
// var myVar = context.DataContext.GetProperties().Find(key, true);
// if (myVar != null)
// {
// //var myValue = myVar.GetValue(context.DataContext);
// myVar.SetValue(context.DataContext, payload[key].ToString());
// }
// else
// {
// Log.Debug("Recived property " + key + " but no variable exists to save the value in " + payload[key]);
// }
// //action.setvariable(key, payload[key]);
//}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.bookmark.Get(context);
if (bookmark != null)
{
context.RemoveBookmark(bookmark);
}
base.Cancel(context);
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = timerExpiredBookmark.Get(context);
if (bookmark != null)
{
context.GetTimerExtension().CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
}
context.MarkCanceled();
}
internal void RemoveBookmark(NativeActivityContext context, CompensationBookmarkName bookmarkName)
{
Bookmark bookmark = this.BookmarkTable[bookmarkName];
if (bookmark != null)
{
context.RemoveBookmark(bookmark);
this.BookmarkTable[bookmarkName] = null;
}
}
protected override void Cancel(NativeActivityContext context)
{
var bookmark = this.timerExpiredBookmark.Get(context);
if (bookmark != null)
{
context.GetTimerExtension().CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
}
context.MarkCanceled();
}
private void CancelInternal(NativeActivityContext context)
{
var bookmark = bookmarkWatcher.Get(context);
var extension = context.GetExtension <Hosting.FolderWatcherExtension>();
extension.UnregisterListener(bookmark, context.GetValue(this.WatchFolder),
context.GetValue(this.WatchPattern), this.WatchSubfolders);
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
}
private void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension extension = context.GetExtension <CompensationExtension>();
CompensationTokenData tokenData = extension.Get(0L);
switch (((ActivityInstanceState)value))
{
case ActivityInstanceState.Closed:
context.ResumeBookmark(extension.WorkflowConfirmation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Canceled:
context.ResumeBookmark(extension.WorkflowCompensation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Faulted:
context.RemoveBookmark(extension.WorkflowConfirmation);
context.RemoveBookmark(extension.WorkflowCompensation);
break;
}
}
protected override void Cancel(NativeActivityContext context)
{
context.CancelChildren();
var bookmark = bookmarkProgress.Get(context);
var extension = context.GetExtension <Hosting.FileCopyExtension>();
extension.Cancel(bookmark.Name);
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
private void CleanUp(NativeActivityContext context)
{
try
{
StopMonitoring(context);
}
finally
{
// Clean-up even if there is an exception in the derived class.
context.RemoveBookmark(_triggerBookmark);
context.CancelChildren();
}
}
private void BookmarkCallback(NativeActivityContext context, Bookmark bookmark, object bookmarkData)
{
Console.WriteLine("Bookmark {0} resumed", bookmark.Name);
string dataString = bookmarkData as string;
if (dataString != null)
{
if (string.Compare(dataString, "stop", true) == 0)
{
context.RemoveBookmark(bookmark.Name);
}
}
}
public void ReceiveResponse(NativeActivityContext context, Bookmark bookmark, Object workflowManager)
{
// REMOVE THE BOOKMARK SO THAT IT CAN BE USED AGAIN
context.RemoveBookmark(context.WorkflowInstanceId.ToString());
// RESET WORKFLOW MANAGER INSTANCE
WorkflowManager.Set(context, workflowManager);
Response.Set(context, WorkflowManager.Get(context).UserInteractionResponse);
// RECORD WORKFLOW STEPS
if (Response.Get(context) != null)
{
Workflows.Activities.CommonFunctions.WorkflowStepsAdd(
WorkflowManager.Get(context).Application,
1,
WorkQueueItemId.Get(context),
WorkflowSteps.Get(context),
"User Interaction Response: " + Server.CommonFunctions.EnumerationToString(Response.Get(context).UserInteractionType)
);
}
else
{
Workflows.Activities.CommonFunctions.WorkflowStepsAdd(
WorkflowManager.Get(context).Application,
1,
WorkQueueItemId.Get(context),
WorkflowSteps.Get(context),
"User Interaction Response: Unknown Response"
);
}
return;
}
void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object obj)
{
context.RemoveBookmark(bookmark.Name);
var payload = JObject.Parse(obj.ToString());
List <string> keys = payload.Properties().Select(p => p.Name).ToList();
foreach (var key in keys)
{
var myVar = context.DataContext.GetProperties().Find(key, true);
if (myVar != null)
{
//var myValue = myVar.GetValue(context.DataContext);
myVar.SetValue(context.DataContext, payload[key].ToString());
}
else
{
Log.Debug("Recived property " + key + " but no variable exists to save the value in " + payload[key]);
}
//action.setvariable(key, payload[key]);
}
}
protected override void Execute(NativeActivityContext context)
{
NoPersistHandle noPersistHandle = this.NoPersistHandle.Get(context);
noPersistHandle.Enter(context);
Bookmark bookmark = context.CreateBookmark(new BookmarkCallback(this.BookmarkResumptionCallback));
this.Bookmark.Set(context, bookmark);
BookmarkResumptionHelper helper = context.GetExtension <BookmarkResumptionHelper>();
System.Action <System.IAsyncResult> state = delegate(System.IAsyncResult result)
{
helper.ResumeBookmark(bookmark, result);
};
System.IAsyncResult asyncResult = this.BeginExecute(context, new System.AsyncCallback(this.AsyncCompletionCallback), state);
if (asyncResult.CompletedSynchronously)
{
noPersistHandle.Exit(context);
context.RemoveBookmark(bookmark);
this.EndExecute(context, asyncResult);
}
}
void BookmarkCallback(NativeActivityContext context, Bookmark bookmark, object bookmarkData)
{
int localGuess = (int)bookmarkData, localTarget = Target.Get(context);
Guess.Set(context, localGuess);
Turns.Set(context, Turns.Get(context) + 1);
if (localGuess != localTarget)
{
if (localGuess < localTarget)
{
Console.WriteLine("Your guess is too low.");
}
else
{
Console.WriteLine("Your guess is too high.");
}
}
else
{
context.RemoveBookmark(bookmark.Name);
}
}
private void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
{
var eventArgs = obj as WorkflowNotificationEventArgs;
if (eventArgs == null)
{
return;
}
// Check two things:
// 1. if the wf author wanted to monitor this event type (create, etc.)
// 2. if the current action has that event type
var childCreated = GetOptionalBoolArgument(context, WaitForChildCreated, true) &&
string.CompareOrdinal(eventArgs.NotificationType, WorkflowNotificationObserver.NotificationType.ChildCreated) == 0;
var childEdited = GetOptionalBoolArgument(context, WaitForChildEdited, true) &&
string.CompareOrdinal(eventArgs.NotificationType, WorkflowNotificationObserver.NotificationType.ChildEdited) == 0;
var childDeleted = GetOptionalBoolArgument(context, WaitForChildDeleted, true) &&
string.CompareOrdinal(eventArgs.NotificationType, WorkflowNotificationObserver.NotificationType.ChildDeleted) == 0;
// do not do anything, continue waiting
if (!childCreated && !childEdited && !childDeleted)
{
return;
}
// remove the notification from the SN db
InstanceManager.ReleaseWait(notificationId.Get(context));
// this lets the workflow move on to the next activity
context.RemoveBookmark(bookmark);
// set result values: the child in question and the operation name
Result.Set(context, new WfContent(eventArgs.Info as string));
NotificationType.Set(context, eventArgs.NotificationType);
}
void OnConfirmationComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
context.RemoveBookmark(compensationExtension.WorkflowCompensation);
}
private void OnExtensionProgress(NativeActivityContext context, Bookmark bookmark, Object data)
{
if (bookmarkProgress.Get(context) != bookmark)
return;
if (data is int && !context.IsCancellationRequested)
{
Track(context, data);
if (this.OnProgress != null)
context.ScheduleAction<int>(this.OnProgress, (int)data);
}
else
{
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
if (data is Exception)
throw data as Exception;
}
}
protected override void Cancel(NativeActivityContext context)
{
context.CancelChildren();
var bookmark = bookmarkProgress.Get(context);
var extension = context.GetExtension<Hosting.FileCopyExtension>();
extension.Cancel(bookmark.Name);
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
protected void DisposeMonitor(NativeActivityContext context)
{
context.RemoveBookmark(this._monitorBookmark);
context.CancelChildren();
}
private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark)
{
var log = context.Resolve<ILoggerFactory>() != null
? context.Resolve<ILoggerFactory>().Create(typeof(SubProcess))
: null;
var parser = context.Resolve<IScriptParser>();
var extension = context.GetExtension<DataFieldExtension>();
//完成规则解析
if (this.Result != null
&& parser != null
&& this.FinishRule != null
&& this.FinishRule.Count > 0)
{
foreach (var i in this.FinishRule)
if (parser.EvaluateRule(i.Value, extension))
{
this.Result.Set(context, i.Key);
if (log != null)
log.InfoFormat("SubProcess节点完成规则“{0}”测试通过，将进入节点“{1}”", i.Value, i.Key);
break;
}
}
//所有逻辑完成才可删除，若上述逻辑失败则将此书签用于错误恢复
context.RemoveBookmark(bookmark);
}
//错误书签回调
private void OnFaultBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
{
context.RemoveBookmark(bookmark);
//删除错误书签后直接执行主体
this.InternalExecuteBody(context);
}
//延迟书签回调
private void OnDelayBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
{
context.RemoveBookmark(bookmark);
//删除延迟书签后直接执行主体
this.InternalExecuteBody(context);
}
private void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension extension = context.GetExtension<CompensationExtension>();
CompensationTokenData tokenData = extension.Get(0L);
switch (((ActivityInstanceState) value))
{
case ActivityInstanceState.Closed:
context.ResumeBookmark(extension.WorkflowConfirmation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Canceled:
context.ResumeBookmark(extension.WorkflowCompensation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Faulted:
context.RemoveBookmark(extension.WorkflowConfirmation);
context.RemoveBookmark(extension.WorkflowCompensation);
break;
}
}
private void OnConfirmationComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
CompensationExtension extension = context.GetExtension<CompensationExtension>();
context.RemoveBookmark(extension.WorkflowCompensation);
}
protected override void Cancel(NativeActivityContext context)
{
SendReceiveExtension sendReceiveExtension = context.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension != null)
{
Bookmark pendingBookmark = this.extensionReceiveBookmark.Get(context);
if (pendingBookmark != null)
{
sendReceiveExtension.Cancel(pendingBookmark);
context.RemoveBookmark(pendingBookmark);
}
}
base.Cancel(context);
}
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 void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, object value)
{
if (this.Result != null)
this.Result.Set(context, value == null ? string.Empty : value.ToString());
context.RemoveBookmark(bookmark);
}