protected override void Execute(NativeActivityContext context)
{
context.Track(CreateLookupTreeTrackingRecord(RootWorkItem.Get(context).CreateLookupTree()));
context.CreateBookmark(CancellationBookmark, OnCancellationRequested, BookmarkOptions.MultipleResume);
context.CreateBookmark(WorkItemCancellationBookmark, OnWorkItemCancellationRequested, BookmarkOptions.MultipleResume);
context.ScheduleActivity(ProgressTrackingScope, OnProgressActivityCompleted);
}
protected override void Execute(NativeActivityContext context)
{
Bookmark bookmark = context.CreateBookmark(new BookmarkCallback(this.OnMainRootComplete), BookmarkOptions.NonBlocking);
context.RegisterMainRootCompleteCallback(bookmark);
CompensationExtension extension = context.GetExtension<CompensationExtension>();
extension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(this.OnCompensate));
extension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(this.OnConfirm));
context.ResumeBookmark(extension.WorkflowCompensationScheduled, null);
}
protected override void Execute(NativeActivityContext context)
{
Bookmark continueBookmark = context.CreateBookmark(OnContinue, BookmarkOptions.MultipleResume | BookmarkOptions.NonBlocking);
Bookmark breakBookmark = context.CreateBookmark(OnBreak, BookmarkOptions.NonBlocking);
context.Properties.Add("ContinueBookmark", continueBookmark);
context.Properties.Add("BreakBookmark", breakBookmark);
context.ScheduleActivity(Condition, ConditionCompletion);
}
protected override void Execute(NativeActivityContext context)
{
this.breakRequested = false;
Bookmark onbreak = context.CreateBookmark(new BookmarkCallback(this.OnBreak), BookmarkOptions.NonBlocking);
context.Properties.Add("BreakBookmark", onbreak);
Bookmark oncontinue = context.CreateBookmark(new BookmarkCallback(this.OnContinue), BookmarkOptions.NonBlocking | BookmarkOptions.MultipleResume);
context.Properties.Add("ContinueBookmark", oncontinue);
this.StartLoop(context);
}
protected override void Execute(NativeActivityContext context)
{
Bookmark bookmark = context.CreateBookmark(new BookmarkCallback(this.OnMainRootComplete), BookmarkOptions.NonBlocking);
context.RegisterMainRootCompleteCallback(bookmark);
CompensationExtension extension = context.GetExtension <CompensationExtension>();
extension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(this.OnCompensate));
extension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(this.OnConfirm));
context.ResumeBookmark(extension.WorkflowCompensationScheduled, null);
}
private void OnTriggerCompleted(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
Pick.PickState state = (Pick.PickState)context.Properties.Find("System.Activities.Statements.Pick.PickState");
if ((completedInstance.State == ActivityInstanceState.Closed) && (state.TriggerCompletionBookmark != null))
{
context.ResumeBookmark(state.TriggerCompletionBookmark, context.ActivityInstanceId);
state.TriggerCompletionBookmark = null;
state.ExecuteActionBookmark = context.CreateBookmark(new BookmarkCallback(this.OnExecuteAction));
}
else if (!context.IsCancellationRequested)
{
context.CreateBookmark();
}
}
protected override void Execute(NativeActivityContext context)
{
Bookmark mainRootCompleteBookmark = context.CreateBookmark(OnMainRootComplete, BookmarkOptions.NonBlocking);
context.RegisterMainRootCompleteCallback(mainRootCompleteBookmark);
CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
compensationExtension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(OnCompensate));
compensationExtension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(OnConfirm));
Fx.Assert(compensationExtension.WorkflowCompensationScheduled != null, "compensationExtension.WorkflowCompensationScheduled bookmark must be setup by now");
context.ResumeBookmark(compensationExtension.WorkflowCompensationScheduled, null);
}
protected override void Execute(NativeActivityContext context)
{
var exitBookmark = context.CreateBookmark(OnExit, BookmarkOptions.NonBlocking);
context.Properties.Add(Exit.Bookmark, exitBookmark);
var nextBookmark = context.CreateBookmark(OnNext, BookmarkOptions.MultipleResume | BookmarkOptions.NonBlocking);
context.Properties.Add(Next.Bookmark, nextBookmark);
_totalIterations = Iterations.Get(context);
ExecuteNext(context);
}
// 如果活动返回值，则从 CodeActivity<TResult>
// 并从 Execute 方法返回该值。
protected override void Execute(NativeActivityContext context)
{
string str = context.GetValue(BookMarkName);
//创建书签，让工作流停下
context.CreateBookmark(str, new BookmarkCallback(BookmarkCallback));
}
protected override void Execute(NativeActivityContext context)
{
if (this.SubscriptionHandle != null)
{
var subscriptionHandle = this.SubscriptionHandle.Get(context);
if (!subscriptionHandle.IsInitialized)
{
throw new ArgumentException("Subscription",
String.Format(Properties.Resources.HandleNotInitialized, this.DisplayName));
}
var emptyList = new List <FileChangeEvent>();
this.Result.Set(context, emptyList);
var extension = context.GetExtension <Hosting.FolderWatcherExtension>();
// Enter a no persist zone to pin this activity to memory since we are setting up a delegate to receive a callback
var handle = this.noPersistHandle.Get(context);
handle.Enter(context);
Bookmark bookmark = context.CreateBookmark(this.receiveCompleteCallback, BookmarkOptions.MultipleResume);
this.receiveCompleteBookmark.Set(context, bookmark);
extension.RegisterReceiveNotification(bookmark, subscriptionHandle.Id);
if (this.Body != null)
{
context.ScheduleAction(this.Body,
new CompletionCallback(OnBodyCompleted),
new FaultCallback(OnBodyFaulted));
}
}
}
protected override void Execute(NativeActivityContext context)
{
// RECORD WORKFLOW STEPS
Workflows.Activities.CommonFunctions.WorkflowStepsAdd(
WorkflowManager.Get(context).Application,
1,
WorkQueueItemId.Get(context),
WorkflowSteps.Get(context),
"User Interaction Request: " + Server.CommonFunctions.EnumerationToString(Request.Get(context).UserInteractionType)
);
// SAVE WORKFLOW STEPS
WorkflowManager.Get(context).Application.WorkQueueItemWorkflowStepsSave(WorkQueueItemId.Get(context), WorkflowSteps.Get(context));
// SET USER INTERACTION REQUEST IN THE WORKFLOW MANAGER
WorkflowManager.Get(context).UserInteractionRequest = Request.Get(context);
// CREATE A BOOKMARK SET TO THE WORKFLOW INSTANCE ID TO MAKE IT UNIQUE
context.CreateBookmark(context.WorkflowInstanceId.ToString(), new BookmarkCallback(this.ReceiveResponse));
return;
}
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);
}
}
protected override void Execute(NativeActivityContext context)
{
var db = context.GetExtension <Db>();
var button = new ButtonEntry()
{
Id = Guid.NewGuid(),
Name = Name.Get(context),
Priority = Priority.Get(context),
Style = Style.Get(context)
};
if (string.IsNullOrEmpty(button.Style))
{
button.Style = "btn-default";
}
var userTaskId = (Guid)context.DataContext.GetProperties()["__UserTaskId"].GetValue(context.DataContext);
var userTask = db.UserTasks.Find(userTaskId);
userTask.Buttons.Add(button);
buttonId.Set(context, button.Id);
context.CreateBookmark(button.Id.ToString(), OnClick);
}
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override void Execute(NativeActivityContext context)
{
// Obtain the runtime value of the Text input argument
string text = context.GetValue(this.InBookmarkName);
context.CreateBookmark(text, new BookmarkCallback(MethodCallback));
}
protected override void Execute(NativeActivityContext context)
{
if (!String.IsNullOrEmpty(this.BookmarkName))
{
context.CreateBookmark(this.BookmarkName, new BookmarkCallback(OnResumeBookmark));
}
}
protected override void Execute(NativeActivityContext context)
{
string bookmarkName = BookmarkName.Get(context);
Bookmark bookmark = context.CreateBookmark(bookmarkName);
this.bookmark.Set(context, bookmark);
}
/// <summary>
/// Executes the Activity
/// </summary>
/// <param name="context"></param>
protected override void Execute(NativeActivityContext context)
{
//
// We must enter a NoPersist zone because it looks like we're idle while our
// Task is executing but, we aren't really
//
NoPersistHandle noPersistHandle = NoPersistHandle.Get(context);
noPersistHandle.Enter(context);
//
// Set a bookmark that we will resume when our Task is done
//
m_Bookmark = context.CreateBookmark(BookmarkResumptionCallback);
this.Bookmark.Set(context, m_Bookmark);
m_BookmarkResumptionHelper = context.GetExtension <BookmarkResumptionHelper>();
//
// Prepare to execute
//
PrepareToExecute(context);
//
// Start a Task to do the actual execution of our activity
//
CancellationTokenSource tokenSource = new CancellationTokenSource();
m_Task = Task.Factory.StartNew(ExecuteNonblocking, tokenSource.Token);
m_Task.ContinueWith(TaskCompletionCallback);
}
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override void Execute(NativeActivityContext context)
{
//Obtain the runtime value of the Text input argument
string bookMarkName = context.GetValue(this.BookMarkName);
context.CreateBookmark(bookMarkName, new BookmarkCallback(resumeCallBack));
}
protected override void Execute(NativeActivityContext context)
{
Bookmark mainRootCompleteBookmark = context.CreateBookmark(OnMainRootComplete, BookmarkOptions.NonBlocking);
context.RegisterMainRootCompleteCallback(mainRootCompleteBookmark);
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
compensationExtension.WorkflowCompensation = context.CreateBookmark(new BookmarkCallback(OnCompensate));
compensationExtension.WorkflowConfirmation = context.CreateBookmark(new BookmarkCallback(OnConfirm));
Fx.Assert(compensationExtension.WorkflowCompensationScheduled != null, "compensationExtension.WorkflowCompensationScheduled bookmark must be setup by now");
context.ResumeBookmark(compensationExtension.WorkflowCompensationScheduled, null);
}
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
/// <summary>
/// Create a bookmark
/// </summary>
/// <param name="context"></param>
protected override void Execute(NativeActivityContext context)
{
//throw new NotImplementedException();
string bookMarkName = context.GetValue(BookMarkName); // get the name of the bookmark
context.CreateBookmark(bookMarkName, ExecuteContinueBookMark);
}
sealed protected override void Execute(NativeActivityContext context)
{
//HACK:节点执行时总是首先设置当前节点索引
context.GetExtension <DataFieldExtension>().SetCurrentNode(this.FlowNodeIndex);
var e = context.GetExtension <CustomExtension>();
var setting = e.GetActivitySetting(this.DisplayName);
if (setting == null)
{
this.InternalExecuteBody(context);
return;
}
var at = setting.StartRule != null && setting.StartRule.IsValid
? setting.StartRule.GetStartTime()
: _emptyTime;
//触发节点开始规则，创建延迟书签
if (at.HasValue)
{
e.AddDelay(this.DisplayName
, context.CreateBookmark(this.GenerateBookmarkName(context)
, this.OnDelayBookmarkCallback).Name
, at.Value);
}
else
{
this.InternalExecuteBody(context);
}
}
private void OnSecondaryRootScheduled(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
long compensationId = (long)value;
CompensationTokenData compensationToken = compensationExtension.Get(compensationId);
Fx.Assert(compensationToken != null, "CompensationTokenData must be valid");
if (compensationToken.CompensationState == CompensationState.Canceling)
{
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.Canceled] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.Canceled] = context.CreateBookmark(new BookmarkCallback(OnCanceledOrCompensated));
compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.OnCancellation);
}
else if (compensationToken.CompensationState == CompensationState.Compensating)
{
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.Compensated] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(OnCanceledOrCompensated));
compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.OnCompensation);
}
}
void AddEvaluateConditionBookmark(NativeActivityContext context)
{
Bookmark bookmark = context.CreateBookmark(this.evaluateConditionCallback, BookmarkOptions.MultipleResume);
this.evaluateConditionBookmark.Set(context, bookmark);
this.EventManager.Get(context).AddActiveBookmark(bookmark);
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
protected override void Execute(NativeActivityContext context)
{
context.CreateBookmark(
this.BookmarkName.Get(context),
(activityContext, bookmark, value) =>
activityContext.ResumeBookmark(new Bookmark(this.BookmarkName.Get(activityContext)), null));
}
//Public
#region 执行创建书签 —— override void Execute(NativeActivityContext context)
/// <summary>
/// 执行创建书签
/// </summary>
/// <param name="context">活动上下文</param>
protected override void Execute(NativeActivityContext context)
{
Type bookmarkType = this.GetType();
string bookmarkTypeName = bookmarkType.FullName;
context.CreateBookmark(bookmarkTypeName, this.ResumeCallback);
}
protected override void Execute(NativeActivityContext context)
{
string bookmark = context.GetValue(bookmarkName);
context.CreateBookmark(bookmark, new BookmarkCallback(bookmarkCallback));
BLL.Document.DocumentStep(context.WorkflowInstanceId, Convert.ToInt32(this.StepID).ToString());
}
protected override void Execute(NativeActivityContext context)
{
context = CreateTrackingRecord(context.GetValue <DocumentState>(inputStep), context);
context.CreateBookmark(context.GetValue <string>(inputBookmarkName),
new BookmarkCallback(this.resumeBookmark));
}
protected override void Execute(NativeActivityContext context)
{
context.CreateBookmark("DownloadDetectorPlugin", new BookmarkCallback(OnBookmarkCallback));
var timeout = Timeout.Get(context);
if (timeout.TotalMilliseconds > 0)
{
wfApp = Plugin.client.WorkflowInstances.Where(x => x.InstanceId == context.WorkflowInstanceId.ToString()).FirstOrDefault();
if (wfApp == null)
{
throw new Exception("Fail locating current workflow instance, to create timeout activity");
}
timer = new System.Timers.Timer(timeout.TotalMilliseconds);
timer.Elapsed += (sender, e) =>
{
try
{
wfApp.ResumeBookmark("DownloadDetectorPlugin", null);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
};
timer.Start();
}
context.ScheduleAction(Body, null, null);
}
protected override void Execute(NativeActivityContext context)
{
var bookmark = context.CreateBookmark(BookmarkName.Get(context), BookmarkResumed);
var extension = context.GetExtension<Helpers.WorkflowInstanceExtensionHelper>();
//extension.WaitSome(bookmark);
}
private void ScheduleSecondaryRoot(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData token)
{
if (token.ParentCompensationId != CompensationToken.RootCompensationId)
{
CompensationTokenData parentToken = compensationExtension.Get(token.ParentCompensationId);
Fx.Assert(parentToken != null, "parentToken must be valid");
parentToken.ExecutionTracker.Add(token);
}
else
{
CompensationTokenData parentToken = compensationExtension.Get(CompensationToken.RootCompensationId);
Fx.Assert(parentToken != null, "parentToken must be valid");
parentToken.ExecutionTracker.Add(token);
}
// If we are going to Cancel, don't set the out arg...
if (Result != null && token.CompensationState == CompensationState.Completed)
{
Result.Set(context, _currentCompensationToken.Get(context));
}
Fx.Assert(token.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] == null, "Bookmark should not be already initialized in the bookmark table.");
token.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = context.CreateBookmark(new BookmarkCallback(OnSecondaryRootScheduled));
_compensationId.Set(context, token.CompensationId);
context.ScheduleSecondaryRoot(CompensationParticipant, context.Environment);
}
protected void Execute<TTask>(NativeActivityContext context, CancellationTokenSource cts, TTask resultTask,
Action<NativeActivityContext> postExecute)
where TTask : Task
{
if (resultTask.IsCompleted)
postExecute(context);
else
{
IActivityContext activityContext = context.GetActivityContext();
taskCompletionNoPersistHandle.Get(context).Enter(context);
cancellationTokenSource.Set(context, cts);
Bookmark bookmark = context.CreateBookmark(BookmarkResumptionCallback);
// continuations don't use cts, the main task is already completed, we can't cancel it
resultTask
.ContinueWith((_resultTask) => activityContext.ResumeBookmarkThroughHostAsync(bookmark, postExecute, TimeSpan.MaxValue),
TaskContinuationOptions.ExecuteSynchronously).Unwrap()
// TODO how to handle exception properly?
// AsyncCodeActivity has an AsyncOperationContext and it can call Abort on that context directly, but we are left alone now,
// we must schedule an Abort through the host, because NativeActivityContext is already disposed now
.ContinueWith((_resumeBookmarkTask) => activityContext.AbortThroughHostAsync(_resumeBookmarkTask.Exception.InnerException),
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously).Unwrap()
.ContinueWith((_abortWorkflowInstanceTask) => { var ignored = _abortWorkflowInstanceTask.Exception; },
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
}
}
public void Execute(NativeActivityContext context, Func <NativeActivityContext, CancellationToken, Task <Action <NativeActivityContext> > > onExecute, BookmarkCallback callback)
{
_noPersistHandle.Get(context).Enter(context);
Bookmark bookmark = context.CreateBookmark(callback);
BookmarkResumptionHelper bookmarkHelper = context.GetExtension <BookmarkResumptionHelper>();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
_cancellationTokenSource.Set(context, cancellationTokenSource);
_bookmarkResumed.Set(context, false);
onExecute(context, cancellationTokenSource.Token).ContinueWith(t => {
// We resume the bookmark only if the activity wasn't
// cancelled since the cancellation removes any bookmarks.
if (cancellationTokenSource.IsCancellationRequested == false)
{
object executionResult = null;
if (t.IsFaulted)
{
executionResult = t.Exception.InnerException;
}
else
{
executionResult = t.Result;
}
bookmarkHelper.ResumeBookmark(bookmark, executionResult);
}
});
}
protected override void Execute(NativeActivityContext context)
{
var broker = context.GetExtension <IEventBroker>();
try
{
var messageType = MessageType.Get(context);
var key = Key.Get <string>(context);
var agent = context.GetExtension <IMessageAgent>();
var message = agent.GetPrototype(messageType);
//todo some strange init
var init = message as IMessagePrototype;
if (init != null)
{
init.Initailize(key);
}
var eventAgent = context.GetExtension <IEventAgent>();
var e = eventAgent.GetEvent(message);
broker.Publish(e);
const string name = "Waiting";
context.CreateBookmark(name, OnResumeBookmark);
}
catch (Exception exception)
{
broker.Publish(new ExceptionEvent(exception));
}
}
// 如果活动返回值，则从 CodeActivity<TResult>
// 并从 Execute 方法返回该值。
protected override void Execute(NativeActivityContext context)
{
// 获取 Text 输入参数的运行时值
string text = context.GetValue(this.InBookmarkName);
context.CreateBookmark(text, new BookmarkCallback(MethodCallback));
}
protected override void Execute(NativeActivityContext context)
{
var model = Model.Get(context);
model.InstanceID = context.WorkflowInstanceId;
model.Owner = User.Get(context);
if (Role == UserRoleEnum.组长)
{
model.NextProcessAuthority = (int)UserService.LoadFartherRole(model.Owner).RoleEnum;
}
else
{
model.NextProcessAuthority = (int)Role;
}
model.Bookmark = Role.ToString();
if (model.ID > 0)
{
LeaveProcessService.Update(model);
}
else
{
LeaveProcessService.Create(model);
}
Model.Set(context, model);
InboxService.Create((UserRoleEnum)model.NextProcessAuthority, model.ID, RedirectType.请假流程处理, InboxService.NEED_TO_PROCESS_LEAVE, model.ID.ToString(), model.Owner.NickName);
InboxService.Create(model.Owner.ID, model.ID, RedirectType.请假流程查看, InboxService.WAIT_TO_PROCESS_LEAVE, model.ID.ToString(), ((UserRoleEnum)model.NextProcessAuthority).ToString());
context.CreateBookmark(Role.ToString(),
new BookmarkCallback(this.Continue));
}
protected override void Execute(NativeActivityContext context)
{
string name = this.BookmarkName.Get(context);
this.outputText.Set(context, "Please enter a value: ");
context.ScheduleActivity(output);
context.CreateBookmark(name, new BookmarkCallback(OnReadComplete));
}
protected override void Execute(NativeActivityContext context)
{
CompensationExtension extension = context.GetExtension<CompensationExtension>();
CompensationToken token = this.Target.Get(context);
CompensationTokenData data = extension.Get(token.CompensationId);
data.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(this.OnCompensated));
data.CompensationState = CompensationState.Compensating;
extension.NotifyMessage(context, data.CompensationId, CompensationBookmarkName.OnCompensation);
}
protected override void ExecuteBody(NativeActivityContext context)
{
//创建子流程节点实例信息
context.GetExtension<SubProcessExtension>().AddSubProcess(context
, context.CreateBookmark(this.GenerateBookmarkName(context)
, this.OnBookmarkCallback)
, this.DisplayName
, this.FlowNodeIndex);
}
protected override void Execute(NativeActivityContext context)
{
var bookMarkName = Guid.NewGuid().ToString();
var content = new WfContent() { Path = ContentPath.Get(context) };
notificationId.Set(context, context.GetExtension<ContentWorkflowExtension>().RegisterWait(content, bookMarkName));
context.CreateBookmark(bookMarkName, new BookmarkCallback(Continue));
}
protected override void Execute(NativeActivityContext context)
{
TimeSpan delay = CalculateDelay(context);
if (delay < TimeSpan.Zero)
throw new ArgumentOutOfRangeException(nameof(delay), delay, "Delay is negative.");
if (delay > TimeSpan.Zero)
{
Bookmark bookmark = context.CreateBookmark();
context.GetTimerExtension().RegisterTimer(delay, bookmark);
timerExpiredBookmark.Set(context, bookmark);
}
}
private void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
{
var eventArgs = obj as WorkflowNotificationEventArgs;
if (eventArgs.NotificationType != WorkflowNotificationObserver.CONTENTCHANGEDNOTIFICATIONTYPE)
return;
ReleaseWait(context, eventArgs.NodeId);
var count = counter.Get(context) - 1;
counter.Set(context, count);
if (count > 0)
context.CreateBookmark(bookmark.Name, new BookmarkCallback(Continue));
}
protected override void Execute(NativeActivityContext context)
{
var id = ID.Get(context);
var bookmark = UserRoleEnum.运营组成员.ToString();
var item = ProjectProcessService.GetById(id);
ProjectProcessService.LoadReference(item, i => i.Owner);
item.NextProcessAuthority = (int)UserRoleEnum.运营组成员;
item.Bookmark = bookmark;
item.ProjectProcessActivity = (int)ProjectProcessActivity.运营组设计;
ProjectProcessService.Save();
context.CreateBookmark(bookmark, new BookmarkCallback(this.Continue));
}
protected override void Execute(NativeActivityContext context)
{
string bookmarkName = BookmarkName.Get(context);
NoPersistHandle noPersistHandleToEnter = noPersistHandle.Get(context);
noPersistHandleToEnter.Enter(context);
Bookmark bookmark = context.CreateBookmark(bookmarkName,
(NativeActivityContext _callbackContext, Bookmark _bookmark, object _state) =>
{
NoPersistHandle noPersistHandleToExit = noPersistHandle.Get(_callbackContext);
noPersistHandleToExit.Exit(_callbackContext);
});
this.bookmark.Set(context, bookmark);
}
protected override void Execute(NativeActivityContext context)
{
string name = this.BookmarkName.Get(context);
if (name == null)
{
throw new Exception(
string.Format(
"ReadLine {0}: BookmarkName cannot be null",
this.DisplayName));
}
context.CreateBookmark(name, new BookmarkCallback(OnReadComplete));
}
protected override void Execute(NativeActivityContext context)
{
TimeSpan actualValue = this.Duration.Get(context);
if (actualValue < TimeSpan.Zero)
{
throw FxTrace.Exception.ArgumentOutOfRange("Duration", actualValue, System.Activities.SR.DurationIsNegative(base.DisplayName));
}
if (actualValue != TimeSpan.Zero)
{
TimerExtension timerExtension = this.GetTimerExtension(context);
Bookmark bookmark = context.CreateBookmark();
timerExtension.RegisterTimer(actualValue, bookmark);
this.timerBookmark.Set(context, bookmark);
}
}
protected override void Execute(NativeActivityContext context)
{
if (this.branchBodies.Count != 0)
{
PickState state = new PickState();
this.pickStateVariable.Set(context, state);
state.TriggerCompletionBookmark = context.CreateBookmark(new BookmarkCallback(this.OnTriggerComplete));
context.Properties.Add("System.Activities.Statements.Pick.PickState", state);
CompletionCallback onCompleted = new CompletionCallback(this.OnBranchComplete);
for (int i = this.branchBodies.Count - 1; i >= 0; i--)
{
context.ScheduleActivity(this.branchBodies[i], onCompleted);
}
}
}
protected override void Execute(NativeActivityContext context)
{
var id = ID.Get(context);
var bookmark = UserRoleEnum.运营组组长.ToString();
var item = ProjectProcessService.GetById(id);
ProjectProcessService.LoadReference(item, i => i.Owner);
item.NextProcessAuthority = (int)UserRoleEnum.运营组组长;
item.Bookmark = bookmark;
item.ProjectProcessActivity = (int)ProjectProcessActivity.运营组组长评估;
ProjectProcessService.Save();
//通知运营组组长
InboxService.Create(UserRoleEnum.运营组组长, item.ID, RedirectType.项目流程处理, InboxService.DESIGN_FINISH_PROCESS_PROJECT, item.ID.ToString(), item.Owner.NickName);
context.CreateBookmark(bookmark, new BookmarkCallback(this.Continue));
}
protected override void Execute(NativeActivityContext context)
{
var waitForAll = WaitForAll.Get(context);
var paths = ContentPaths.Get(context);
var contents = paths.Select(p => new WfContent { Path = p }).ToArray();
var ext = context.GetExtension<ContentWorkflowExtension>();
var bookMarkName = Guid.NewGuid().ToString();
var waitIds = ext.RegisterWaitForMultipleContent(contents, bookMarkName);
var waitIdString = String.Join(",", waitIds.Select(w => w.ToString()).ToArray());
var nodeIdString = String.Join(",", contents.Select(w => w.Id.ToString()).ToArray());
notificationIds.Set(context, waitIdString);
counter.Set(context, waitForAll ? contents.Length : 1);
context.CreateBookmark(bookMarkName, new BookmarkCallback(Continue));
}
protected override void Execute(NativeActivityContext context)
{
TimeSpan duration = this.Duration.Get(context);
if (duration < TimeSpan.Zero)
{
throw FxTrace.Exception.ArgumentOutOfRange("Duration", duration, SR.DurationIsNegative(this.DisplayName));
}
if (duration == TimeSpan.Zero)
{
return;
}
TimerExtension timerExtension = GetTimerExtension(context);
Bookmark bookmark = context.CreateBookmark();
timerExtension.RegisterTimer(duration, bookmark);
this.timerBookmark.Set(context, bookmark);
}
protected override void Execute(NativeActivityContext context)
{
CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
CompensationToken compensationToken = Target.Get(context);
Fx.Assert(compensationToken != null, "compensationToken must be valid");
// The compensationToken should be a valid one at this point. Ensure its validated in Confirm activity.
CompensationTokenData tokenData = compensationExtension.Get(compensationToken.CompensationId);
Fx.Assert(tokenData != null, "The compensationToken should be a valid one at this point. Ensure its validated in Confirm activity.");
Fx.Assert(tokenData.BookmarkTable[CompensationBookmarkName.Confirmed] == null, "Bookmark should not be already initialized in the bookmark table.");
tokenData.BookmarkTable[CompensationBookmarkName.Confirmed] = context.CreateBookmark(new BookmarkCallback(OnConfirmed));
tokenData.CompensationState = CompensationState.Confirming;
compensationExtension.NotifyMessage(context, tokenData.CompensationId, CompensationBookmarkName.OnConfirmation);
}
protected override void Execute(NativeActivityContext context)
{
var id = ID.Get(context);
var bookmark = UserRoleEnum.全员.ToString();
var item = ProjectProcessService.GetById(id);
ProjectProcessService.LoadReference(item, i => i.Owner);
var appraisalResult = ProjectProcessService.GetAppraisalResult(item);
item.NextProcessAuthority = (int)UserRoleEnum.全员;
item.Bookmark = bookmark;
item.InstanceID = context.WorkflowInstanceId;
item.ProjectProcessActivity = (int)ProjectProcessActivity.可行性评估;
ProjectProcessService.Save();
if (appraisalResult.Item1 == 0 && appraisalResult.Item2 == 0)
{
//通知所有用户
InboxService.Create(UserRoleEnum.全员, item.ID, RedirectType.项目流程处理, InboxService.APPRAISAL_PROCESS_PROJECT, item.ID.ToString(), item.Owner.NickName);
}
context.CreateBookmark(bookmark, new BookmarkCallback(this.Continue));
}
protected override void Execute(NativeActivityContext context)
{
var subscriptionHandle = this.SubscriptionHandle.Get(context);
string folder = context.GetValue(this.WatchFolder);
if (!System.IO.Directory.Exists(folder))
throw new OperationCanceledException(String.Format("The path \"{0}\" is not a directory or does not exist.", folder));
var extension = context.GetExtension<Hosting.FolderWatcherExtension>();
var bookmark = context.CreateBookmark(String.Format("SubscribeFileChanges_{0:N}", Guid.NewGuid()));
this.bookmark.Set(context, bookmark);
subscriptionHandle.Initialize(extension, bookmark, folder,
context.GetValue(this.WatchPattern), this.WatchSubfolders, base.DisplayName);
}
/// <summary>
/// When implemented in a derived class, runs the activity’s execution logic.
/// </summary>
/// <param name="context">
/// The execution context in which the activity executes.
/// </param>
protected override void Execute(NativeActivityContext context)
{
context.CreateBookmark(this.Trigger);
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
protected override void Execute(NativeActivityContext context)
{
this.hostContext = context.GetExtension<IHttpWorkflowHostContext>();
// Typically there is only one base address but there could be more than one.
foreach (var bookmarkName in this.hostContext.BaseAddresses.Select(this.GetBookmarkName))
{
context.CreateBookmark(bookmarkName, this.ReceiveCallback);
context.Track(new HttpReceiveMessageRecord(bookmarkName));
}
}
protected override void Execute(NativeActivityContext context)
{
var cacheName = CacheName.Get(context);
var dcf = context.GetExtension<DataCacheFactory>();
var notificationExtension = context.GetExtension<DataCacheNotificationExtension>();
var dataCache = string.IsNullOrWhiteSpace(cacheName) ? dcf.GetDefaultCache() : dcf.GetCache(cacheName);
var nd = dataCache.AddCacheLevelBulkCallback(notificationExtension.BulkNotificationCallback);
// Enter a no persist zone to pin this activity to memory since we are setting up a delegate to receive a callback
var handle = _noPersistHandle.Get(context);
handle.Enter(context);
context.CreateBookmark(GetNotificationBookmarkName(nd), NotificationBookmarkCallback);
}
protected override void Execute(NativeActivityContext context)
{
string bookmarkName = BookmarkName.Get(context);
Bookmark bookmark = context.CreateBookmark(bookmarkName);
this.bookmark.Set(context, bookmark);
}
protected override void ExecuteBody(NativeActivityContext context)
{
//var actioners = this.Actioners.Get(context);
var actioners = this.Helper.GetActioners(context);
if (actioners == null || actioners.Length == 0)
throw new InvalidOperationException("没有执行人");
//创建人工节点实例信息
context.GetExtension<HumanExtension>().AddHumanTask(context
//HACK:创建任务书签，仅用于活动暂停
//任务活动不涉及具体的工作流任务模式的实现（如会签等）,由任务执行逻辑实现
, context.CreateBookmark(this.GenerateBookmarkName(context)
, this.OnBookmarkCallback)
, this.DisplayName
, this.FlowNodeIndex
, actioners);
}
protected override void Execute(NativeActivityContext context)
{
CompensationExtension compensationExtension = context.GetExtension<CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
long compensationId = this.compensationId.Get(context);
Fx.Assert(compensationId != CompensationToken.RootCompensationId, "CompensationId passed to the SecondaryRoot must be valid");
CompensationTokenData compensationToken = compensationExtension.Get(compensationId);
Fx.Assert(compensationToken != null, "CompensationTokenData must be valid");
CompensationToken token = new CompensationToken(compensationToken);
this.currentCompensationToken.Set(context, token);
compensationToken.IsTokenValidInSecondaryRoot = true;
context.Properties.Add(CompensationToken.PropertyName, token);
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(OnConfirmation));
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(OnCompensation));
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(OnCancellation));
Bookmark onSecondaryRootScheduled = compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled];
Fx.Assert(onSecondaryRootScheduled != null, "onSecondaryRootScheduled bookmark must be already registered.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null;
context.ResumeBookmark(onSecondaryRootScheduled, compensationId);
}
protected override void Execute(NativeActivityContext context)
{
FileInfo source = new FileInfo(context.GetValue<string>(this.Source));
FileInfo target = new FileInfo(context.GetValue<string>(this.Target));
if (target.Attributes.HasFlag(FileAttributes.Directory))
target = new FileInfo(Path.Combine(target.FullName, source.Name));
this.noPersistHandle.Get(context).Enter(context);
// Set a bookmark for progress callback resuming
string bookmarkName = String.Format("FileCopy_{0:X}", source.FullName.GetHashCode());
var bookmark = context.CreateBookmark(bookmarkName, this.bookmarkProgressCallback, BookmarkOptions.MultipleResume);
bookmarkProgress.Set(context, bookmark);
var extension = context.GetExtension<Hosting.FileCopyExtension>();
extension.Resume(bookmark, source, target, this.Option, this.StepIncrement);
}
protected override void Execute(NativeActivityContext context)
{
if (this.Activities.Count > 0)
{
Bookmark bm = context.Properties.Find(Constants._ContainsChildWizard) as Bookmark;
if (bm != null)
{
context.ResumeBookmark(bm, true);
}
Bookmark parentbm = context.Properties.Find(Constants._ResumeParent) as Bookmark;
if (parentbm != null)
{
this.ResumeParent.Set(context, parentbm);
}
Bookmark ResumeParent = context.CreateBookmark(ResumeParentCallBack, BookmarkOptions.NonBlocking | BookmarkOptions.MultipleResume);
context.Properties.Update(Constants._ResumeParent, ResumeParent);
FindStepAndSchedule(context);
}
}
