private static IWfTransitionDescriptor CreateMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
bool useOriginal = true;
IWfTransitionDescriptor resultTransition = null;
if (activityToAppend.Process.MainStream != null)
{
IWfActivityDescriptor startActDesp = startActivity.GetMainStreamActivityDescriptor();
IWfActivityDescriptor endActDesp = endActivity.GetMainStreamActivityDescriptor();
if (startActDesp != null && endActDesp != null)
{
WfCopyMainStreamContext context = new WfCopyMainStreamContext(startActDesp, endActivity.Descriptor, entryTransition, true);
FillCopyContext(context.StartActivityDescriptor, endActDesp, context, operationType);
resultTransition = context.StartActivityDescriptor.GenerateCopiedActivitiesDescriptors(activityToAppend.Process, activityToAppend.Descriptor, context, operationType);
useOriginal = false;
}
}
if (useOriginal)
OriginalCreateMainStreamActivities(activityToAppend, startActivity, endActivity, entryTransition, operationType);
return resultTransition;
}
public WfControlNextStep(IWfActivity toActivity)
{
toActivity.NullCheck("toActivity");
this.ActivityDescriptor = toActivity.Descriptor;
this._Candidates = toActivity.Candidates.GetSelectedAssignees();
}
public WfClientAuthorizationInfo GetAuthorizationInfo(IWfProcess process, IWfActivity originalActivity, WfClientUser user)
{
string userID = user.IsNotNullOrEmpty() ? user.ID : string.Empty;
string originalActivityID = originalActivity != null ? originalActivity.ID : string.Empty;
return GetAuthorizationInfo(process, originalActivityID, userID);
}
protected WfAddAndEditActivityExecutorBase(IWfActivity operatorActivity, IWfActivity targetActivity, WfActivityDescriptorCreateParams createParams, WfControlOperationType operationType)
: base(operatorActivity, targetActivity, operationType)
{
createParams.NullCheck("createParams");
this.CreateParams = createParams;
}
public WfAddApproverExecutor(IWfActivity operatorActivity, IWfActivity targetActivity, WfAssigneeCollection assignees)
: base(operatorActivity, targetActivity, WfControlOperationType.AddApprover)
{
assignees.NullCheck("assingees");
this.Assignees.CopyFrom(assignees);
}
public WfAdminDeleteActivityExecutor(IWfActivity operatorActivity, IWfActivityDescriptor targetActivityDescriptor, bool syncMSObject) :
base(operatorActivity, WfControlOperationType.AdminDeleteActivity)
{
targetActivityDescriptor.NullCheck("targetActivityDescriptor");
this._TargetActivityDescriptor = targetActivityDescriptor;
this._SyncMainStreamObject = syncMSObject;
}
/// <summary>
/// 历史实现规则。当流程不存在MainStream属性时，采用从当前流程活动中爬出来
/// </summary>
/// <param name="activityToAppend"></param>
/// <param name="startActivity"></param>
/// <param name="endActivity"></param>
/// <param name="operationType"></param>
private static void OriginalCreateMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
WfCopyMainStreamContext context = new WfCopyMainStreamContext(startActivity.Descriptor, endActivity.Descriptor, entryTransition, false);
FillCopyContext(context.StartActivityDescriptor, endActivity.Descriptor, context, operationType);
context.StartActivityDescriptor.GenerateCopiedActivitiesDescriptors(activityToAppend.Process, activityToAppend.Descriptor, context, operationType);
}
protected WfTransition(SerializationInfo info, StreamingContext context)
{
this._ID = info.GetString("ID");
this._FromActivity = (WfActivityBase)info.GetValue("FromActivity", typeof(WfActivityBase));
this._ToActivity = (WfActivityBase)info.GetValue("ToActivity", typeof(WfActivityBase));
this._IsAborted = info.GetBoolean("IsAborted");
this._StartTime = info.GetDateTime("StartTime");
}
public WfCirculateExecutor(IWfActivity operatorActivity,
IWfActivity targetActivity,
IEnumerable<IUser> circulators)
: base(operatorActivity, targetActivity, WfControlOperationType.Circulate)
{
circulators.NullCheck("circulators");
this.Circulators = circulators;
}
public WfStartBranchProcessExecutor(IWfActivity operatorActivity, IWfActivity ownerActivity, IWfBranchProcessTemplateDescriptor template)
: base(operatorActivity, WfControlOperationType.StartBranchProcess)
{
ownerActivity.NullCheck("ownerActivity");
template.NullCheck("template");
this.OwnerActivity = ownerActivity;
this.BranchTransferParams = new WfBranchProcessTransferParams(template);
}
public WfControlNextStep(IWfTransitionDescriptor transition, IWfActivity toActivity)
{
transition.NullCheck("transition");
toActivity.NullCheck("toActivity");
this.ActivityDescriptor = toActivity.Descriptor;
this._Candidates = toActivity.Candidates.GetSelectedAssignees();;
this.TransitionDescriptor = transition;
}
protected WfActivityRelativeExecutorBase(IWfActivity operatorActivity, IWfActivity targetActivity, WfControlOperationType operationType) :
base(operatorActivity, operationType)
{
targetActivity.NullCheck("targetActivity");
TargetActivity = targetActivity;
if (OperatorActivity == null)
OperatorActivity = targetActivity;
}
/// <summary>
/// 在指定的活动点之后，添加从startActivity与endActivity之间复制出来的
/// </summary>
/// <param name="activityToAppend">复制的活动需要添加到哪一个活动之后</param>
/// <param name="startActivity">需要复制的活动的起始点</param>
/// <param name="endActivity">需要复制的活动的终止点</param>
/// <param name="entryTransition"></param>
/// <param name="operationType">操作类型</param>
/// <returns>返回的第一个Clone活动的出线</returns>
public IWfTransitionDescriptor CopyMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
activityToAppend.NullCheck("activityToAppend");
//沈峥注释，和WfMoveToExecutor中，是否按退回线进行的判断进行匹配
ExceptionHelper.TrueThrow(startActivity.Status == WfActivityStatus.NotRunning, "退件时所指定活动必须是已执行过的活动");
//沈峥重构后的实现
return CreateMainStreamActivities(activityToAppend, startActivity, endActivity, entryTransition, operationType);
}
public WfPauseProcessExecutor(IWfActivity operatorActivity, IWfProcess pauseProcess)
: base(operatorActivity, WfControlOperationType.PauseProcess)
{
pauseProcess.NullCheck("pauseProcess");
this.PauseProcess = pauseProcess;
if (OperatorActivity == null)
OperatorActivity = PauseProcess.CurrentActivity;
}
public WfAsyncCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess process)
: base(operatorActivity, WfControlOperationType.AsyncCancelProcess)
{
process.NullCheck("process");
this.Process = process;
if (this.OperatorActivity == null)
this.OperatorActivity = process.CurrentActivity;
}
public WfResumeProcessExecutor(IWfActivity operatorActivity, IWfProcess resumeProcess)
: base(operatorActivity, WfControlOperationType.ResumeProcess)
{
resumeProcess.NullCheck("resumeProcess");
this.ResumeProcess = resumeProcess;
if (OperatorActivity == null)
OperatorActivity = ResumeProcess.CurrentActivity;
}
/// <summary>
/// 得到某个流程实例点的送阅人
/// </summary>
/// <param name="activity"></param>
/// <returns></returns>
public static OguDataCollection <IUser> GetActivityCirculators(IWfActivity activity)
{
OguDataCollection <IUser> result = new OguDataCollection <IUser>();
if (activity != null)
{
result = activity.Context.GetValue("circulators", result);
}
return(result);
}
private static IWfActivity GetDefaultActivity()
{
IWfActivity result = null;
if (WfClientContext.Current.CurrentActivity != null)
{
result = WfClientContext.Current.CurrentActivity.ApprovalRootActivity;
}
return(result);
}
private static int FindTargetActivityIndex(IWfActivity currentActivity)
{
int targetIndex = currentActivity.Process.ElapsedActivities.Count - 1;
if (currentActivity.Descriptor.ActivityType == WfActivityType.CompletedActivity)
{
targetIndex--;
}
return(targetIndex);
}
protected WfActivityRelativeExecutorBase(IWfActivity operatorActivity, IWfActivity targetActivity, WfControlOperationType operationType) :
base(operatorActivity, operationType)
{
targetActivity.NullCheck("targetActivity");
TargetActivity = targetActivity;
if (OperatorActivity == null)
{
OperatorActivity = targetActivity;
}
}
public WfExitMaintainingStatusExecutor(IWfActivity operatorActivity, IWfProcess process, bool autoProcessPendingActivity)
: base(operatorActivity, WfControlOperationType.ExitMaintainingStatus)
{
process.NullCheck("process");
this.Process = process;
this.AutoProcessPendingActivity = autoProcessPendingActivity;
if (this.OperatorActivity == null)
this.OperatorActivity = process.CurrentActivity;
}
public WfCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess cancelProcess, bool cancelAllBranchProcesses)
: base(operatorActivity, WfControlOperationType.CancelProcess)
{
cancelProcess.NullCheck("cancelProcess");
this.CancelProcess = cancelProcess;
this.CancelAllBranchProcesses = cancelAllBranchProcesses;
if (OperatorActivity == null)
OperatorActivity = CancelProcess.CurrentActivity;
}
public override void PrepareAction(WfActionParams actionParams)
{
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
if (currentActivity != null)
{
//找到当前流程所有的待办，然后转为已办
UserTaskCollection currentProcessTasks =
UserTaskAdapter.Instance.LoadUserTasks(builder => builder.AppendItem("PROCESS_ID",
currentActivity.Process.ID));
WfRuntime.ProcessContext.DeletedUserTasks.CopyFromNotExistedTaskID(currentProcessTasks);
UserTaskCollection toAccomplishedTasks = new UserTaskCollection();
currentProcessTasks.ForEach(u =>
{
if (u.Status == TaskStatus.Ban)
{
toAccomplishedTasks.Add(u);
}
});
UserTaskCollection userTasksInContext = RemoveTasksInContext(actionParams);
//将上下文中的待办转到已办中
userTasksInContext.ForEach(t => toAccomplishedTasks.Add(t));
//将上下文中标记为已删除的从准备转已办的记录中删除
toAccomplishedTasks.RemoveExistedTasks(WfRuntime.ProcessContext.DeletedUserTasks);
//将待办转到已办中，便于事后恢复
toAccomplishedTasks.ForEach(u => LeaveActivityUserTaskAction.ChangeUserTaskToAccomplishedTasks(currentActivity, u));
WfRuntime.ProcessContext.AccomplishedUserTasks.CopyFromNotExistedTaskID(toAccomplishedTasks);
//暂时对当前活动的处理人发送通知
UserTaskCollection notifyTasks = BuildUserNotifiesFromActivity(currentActivity);
AppendResourcesToNotifiers(currentActivity, notifyTasks, currentActivity.Descriptor.Process.CancelEventReceivers);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = Translator.Translate(Define.DefaultCulture,
currentActivity.Process.Descriptor.Properties.GetValue("DefaultCancelTaskPrefix", "流程被取消:")) + task.TaskTitle;
}
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
WfRuntime.ProcessContext.Acl.CopyFrom(notifyTasks.ToAcl());
WfRuntime.ProcessContext.AbortedProcesses.AddOrReplace(currentActivity.Process);
WfRuntime.ProcessContext.FireCancelProcessPrepareAction();
}
}
public WfClientProcessInfo GetProcessInfoByActivityID(string activityID, WfClientUser user)
{
activityID.CheckStringIsNullOrEmpty("activityID");
OperationContext.Current.FillContextToOguServiceContext();
IWfProcess process = WfRuntime.GetProcessByActivityID(activityID);
IWfActivity activity = process.Activities[activityID];
return(process.ToClientProcessInfo(activity, user).FillCurrentOpinion(activity, user));
}
protected IWfActivity GetDefaultActivity()
{
IWfActivity result = null;
if (WfClientContext.Current.OriginalActivity != null)
{
result = WfClientContext.Current.OriginalActivity.ApprovalRootActivity;
}
return(result);
}
internal IWfActivity InnerMoveTo(WfTransferParamsBase transferParams)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(transferParams != null, "transferParams");
//如果流程没有启动，且一个点都没有，则自动设为运行状态
if (this.Status == WfProcessStatus.NotRunning && this.Activities.Count == 0)
{
this.Status = WfProcessStatus.Running;
}
else
if (this.Status == WfProcessStatus.Completed) //如果流程已经结束，那么流程状态应该变为运行状态
{
this.Status = WfProcessStatus.Running;
}
CheckProcessRunningStatus();
CheckActivityMoveToCondition();
IWfActivity activity = null;
//生成下一个新的活动点
if (transferParams.NextActivityDescriptor is IWfAnchorActivityDescriptor)
{
activity = this.Factory.CreateAnchorActivity(this, (WfBranchesTransferParams)transferParams);
}
else
{
activity = this.Factory.CreateActivity(this, transferParams.NextActivityDescriptor);
}
activity.Operator = transferParams.Operator;
//当前点与新的活动点连接,并设置好相关指针
if (CurrentActivity != null)
{
((WfActivityBase)CurrentActivity).ConnectToNextActivity(activity);
((WfActivityBase)CurrentActivity).Status = WfActivityStatus.Completed;
}
//加入点集合并设置好新的活动点
Activities.Add(activity);
activity.Assignees.CopyFrom(transferParams.Receivers);
///设置的
if (transferParams.FromTransitionDescriptor != null)
{
activity.Context["FromTransitionDescriptor"] = transferParams.FromTransitionDescriptor.Key;
}
DoComplete(activity);
return(activity);
}
public WfAdminDeleteTransitionExecutor(IWfActivity operatorActivity, IWfProcessDescriptor processDescriptor, IWfTransitionDescriptor targetTransitionDescriptor, bool syncMSObject) :
base(operatorActivity, WfControlOperationType.AdminDeleteTransition)
{
processDescriptor.NullCheck("processDescriptor");
targetTransitionDescriptor.NullCheck("targetTransitionDescriptor");
this._TargetTransitionDescriptor = targetTransitionDescriptor;
this._ProcessDescriptor = processDescriptor;
this._SyncMainStreamObject = syncMSObject;
}
private static void ValidateAggressProcessBTransitions(IWfActivity activityB, int count)
{
Assert.AreEqual(2, activityB.Descriptor.ToTransitions.Count,
string.Format("第{0}次退回。B的衍生线必须也是两根，BC和BA", count));
WfTransitionDescriptor transitionBC = (WfTransitionDescriptor)activityB.Descriptor.ToTransitions.Find(t => t.ToActivity.GetAssociatedActivity().Key == "C");
WfTransitionDescriptor transitionBA = (WfTransitionDescriptor)activityB.Descriptor.ToTransitions.Find(t => t.ToActivity.GetAssociatedActivity().Key == "A");
Assert.IsNotNull(transitionBC);
Assert.IsNotNull(transitionBA);
}
public WfEditPropertiesExecutorBase(IWfActivity operatorActivity, IWfProcess process, T descriptor, bool syncMSObject, WfControlOperationType operationType)
: base(operatorActivity, operationType)
{
process.NullCheck("process");
descriptor.NullCheck("descriptor");
this._Process = process;
this._Descriptor = descriptor;
this._SyncMainStreamObject = syncMSObject;
descriptor.SyncPropertiesToFields();
}
private static IWfActivity FindClonedRootActivity(IWfActivity clondedActivity)
{
IWfActivity result = clondedActivity;
IWfProcess process = clondedActivity.Process;
while (result != null && result.Descriptor.ClonedKey.IsNotEmpty())
{
result = process.Activities.Find(act => string.Compare(clondedActivity.Descriptor.ClonedKey, act.Descriptor.Key, true) == 0);
}
return(result);
}
public WfClientProcessInfo ReplaceAssignees(string activityID, WfClientUser originalUser, List <WfClientUser> targetUsers, WfClientRuntimeContext runtimeContext)
{
OperationContext.Current.FillContextToOguServiceContext();
IWfProcess process = WfRuntime.GetProcessByActivityID(activityID);
IWfActivity targetActivity = process.Activities[activityID];
ExecuteExecutor(process, runtimeContext,
(p) => new WfReplaceAssigneesExecutor(targetActivity, targetActivity, (IUser)originalUser.ToOguObject(), targetUsers.ToOguObjects <WfClientUser, IUser>()));
return(process.ToClientProcessInfo(runtimeContext.Operator).FillCurrentOpinion(process.CurrentActivity, runtimeContext.Operator));
}
public WfRestoreProcessExecutor(IWfActivity operatorActivity, IWfProcess restoreProcess)
: base(operatorActivity, WfControlOperationType.RestoreProcess)
{
restoreProcess.NullCheck("restoreProcess");
this.Process = restoreProcess;
if (OperatorActivity == null)
{
OperatorActivity = Process.CurrentActivity;
}
}
public WfPauseProcessExecutor(IWfActivity operatorActivity, IWfProcess pauseProcess)
: base(operatorActivity, WfControlOperationType.PauseProcess)
{
pauseProcess.NullCheck("pauseProcess");
this.PauseProcess = pauseProcess;
if (OperatorActivity == null)
{
OperatorActivity = PauseProcess.CurrentActivity;
}
}
internal void CreateWfResource(IWfActivity wfactivity)
{
if (wfactivity.Type == ActdefType.INTERACTION)
{
Actdef defineOject = wfactivity.GetDefineOject() as Actdef;
if (StringHelper.IsNull(defineOject.ParticipantId))
{
throw new WfException("The Actdef (" + defineOject.Id + "-" + defineOject.Name + ") Participant cannot be null");
}
WfFactory.GetWfResource(wfactivity, defineOject.ParticipantId);
}
}
public WfAsyncCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess process)
: base(operatorActivity, WfControlOperationType.AsyncCancelProcess)
{
process.NullCheck("process");
this.Process = process;
if (this.OperatorActivity == null)
{
this.OperatorActivity = process.CurrentActivity;
}
}
internal static void AppendResourcesToNotifiers(IWfActivity currentActivity, UserTaskCollection notifyTasks, WfResourceDescriptorCollection resources)
{
foreach (IUser user in resources.ToUsers())
{
UserTask task = BuildOneUserNotifyFromActivity(currentActivity);
task.SendToUserID = user.ID;
task.SendToUserName = user.DisplayName;
notifyTasks.Add(task);
}
}
private void executor_AfterModifyWorkflow(WfExecutorDataContext dataContext)
{
if (this.OriginalActivity == null)
{
OriginalActivity = dataContext.CurrentProcess.CurrentActivity;
}
if (this._OriginalCurrentActivity == null)
{
this._OriginalCurrentActivity = dataContext.CurrentProcess.CurrentActivity;
}
}
internal static UserTaskCollection BuildUserNotifiesFromActivity(IWfActivity activity)
{
UserTaskCollection tasks = BuildUserTasksFromActivity(activity, TaskStatus.Yue);
foreach (UserTask task in tasks)
{
task.Level = TaskLevel.Low;
task.Url = GenerateNotifyUrl(task, activity);
}
return(tasks);
}
private void InitOriginalActivityByResourceID(string resourceID, string processID)
{
if (processID.IsNotEmpty())
{
IWfProcess process = WfRuntime.GetProcessByProcessID(processID);
process.NullCheck <WfRuntimeException>("不能找到ID为'{0}'的流程", processID);
OriginalActivity = process.CurrentActivity;
this._OriginalCurrentActivity = OriginalActivity;
}
}
/// <summary>
/// 写打开表单的日志
/// </summary>
/// <param name="currentActivity"></param>
/// <param name="logOpType"></param>
private static void WriteOpenFormLog(IWfActivity currentActivity, MCS.Library.SOA.DataObjects.OperationType logOpType)
{
if (currentActivity != null)
{
UserOperationLog log = UserOperationLog.FromActivity(currentActivity);
log.OperationType = logOpType;
log.OperationName = EnumItemDescriptionAttribute.GetDescription(logOpType);
UserOperationLogAdapter.Instance.Update(log);
}
}
public WfStartBranchProcessExecutor(IWfActivity operatorActivity, IWfActivity ownerActivity, WfBranchProcessTransferParams branchTransferParams)
: base(operatorActivity, WfControlOperationType.StartBranchProcess)
{
ownerActivity.NullCheck("ownerActivity");
branchTransferParams.NullCheck("branchTransferParams");
this.OwnerActivity = ownerActivity;
this.BranchTransferParams = branchTransferParams;
if (this.OperatorActivity == null)
this.OperatorActivity = ownerActivity;
}
private static string GenerateNotifyUrl(UserTask task, IWfActivity activity)
{
NameValueCollection uriParams = UriHelper.GetUriParamsCollection(task.Url);
uriParams.Clear();
uriParams["resourceID"] = activity.Process.ResourceID;
uriParams["processID"] = activity.Process.ID;
uriParams["_op"] = "notifyDialog";
uriParams["taskID"] = task.TaskID;
return(UriHelper.CombineUrlParams(task.Url, false, uriParams));
}
internal static UserTaskCollection BuildUserNotifiesFromActivity(IWfActivity activity)
{
UserTaskCollection tasks = BuildUserTasksFromActivity(activity, TaskStatus.Yue);
foreach (UserTask task in tasks)
{
task.Level = TaskLevel.Low;
task.Url = GenerateNotifyUrl(task, activity);
}
return tasks;
}
public void ReturnTwiceThenWithdrawTwiceTest()
{
IWfActivity activityD = ReturnExecutorTestHelper.PrepareAndMoveToSpecialActivity();
int originalActivityCount = activityD.Process.Activities.Count;
Assert.AreEqual("D", activityD.Descriptor.Key);
ReturnExecutorTestHelper.OutputMainStream(activityD.Process);
ReturnExecutorTestHelper.OutputEveryActivities(activityD.Process);
//第一次退回
ReturnExecutorTestHelper.ExecuteReturnOperation(activityD, "A");
Console.WriteLine("第一次退回后");
ReturnExecutorTestHelper.OutputMainStream(activityD.Process);
ReturnExecutorTestHelper.OutputEveryActivities(activityD.Process);
WfProcessTestCommon.MoveToNextDefaultActivity(activityD.Process); //B1
WfProcessTestCommon.MoveToNextDefaultActivity(activityD.Process); //C1
WfProcessTestCommon.MoveToNextDefaultActivity(activityD.Process); //D1
Assert.AreEqual("D", activityD.Process.CurrentActivity.Descriptor.AssociatedActivityKey);
//在B的出线C和E之间选择E
activityD.Process.ApplicationRuntimeParameters["IsCLine"] = false;
//第二次退回
ReturnExecutorTestHelper.ExecuteReturnOperation(activityD, "A");
Console.WriteLine("第二次退回后");
ReturnExecutorTestHelper.OutputMainStream(activityD.Process);
ReturnExecutorTestHelper.OutputEveryActivities(activityD.Process);
IWfProcess process = process = DoWithdrawExecutor(activityD.Process);
Console.WriteLine("第一组撤回之后");
ReturnExecutorTestHelper.OutputMainStream(process);
ReturnExecutorTestHelper.OutputEveryActivities(process);
process = DoWithdrawExecutor(activityD.Process); //C1;
process = DoWithdrawExecutor(activityD.Process); //B1
process = DoWithdrawExecutor(activityD.Process); //A1
process = DoWithdrawExecutor(activityD.Process);
Console.WriteLine("第二组撤回之后");
ReturnExecutorTestHelper.OutputMainStream(process);
ReturnExecutorTestHelper.OutputEveryActivities(process);
Assert.AreEqual(originalActivityCount, process.Activities.Count, "撤回后与退件前的活动数一样");
Assert.AreEqual(originalActivityCount, process.Descriptor.Activities.Count, "撤回后与退件前的活动数一样");
}
private void PrepareNotifyTasks(IWfActivity originalActivity)
{
UserTaskCollection notifyTasks = BuildUserNotifiesFromActivity(originalActivity);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = Translator.Translate(Define.DefaultCulture,
originalActivity.Process.Descriptor.Properties.GetValue("DefaultWithtrawTaskPrefix", "流程被撤回:")) + task.TaskTitle;
}
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
}
internal void ConnectToNextActivity(IWfActivity nextActivity)
{
IWfTransitionDescriptor transDescriptor =
this.Descriptor.ToTransitions.GetTransitionByToActivity(nextActivity.Descriptor.Key);
WfTransition transition = new WfTransition(transDescriptor);
transition.FromActivity = this;
transition.ToActivity = nextActivity;
this._ToTransition = transition;
((WfActivityBase)nextActivity)._FromTransition = transition;
}
private WfActivityCollection DoWithdraw(IWfActivity destinationActivity)
{
WfActivityCollection deletedActivities = new WfActivityCollection();
while (string.Compare(this.CurrentActivity.ID, destinationActivity.ID, true) != 0)
{
deletedActivities.Add(this.LastActivity);
Activities.Remove(this.LastActivity);
}
return(deletedActivities);
}
public WfCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess cancelProcess, bool cancelAllBranchProcesses)
: base(operatorActivity, WfControlOperationType.CancelProcess)
{
cancelProcess.NullCheck("cancelProcess");
this.CancelProcess = cancelProcess;
this.CancelAllBranchProcesses = cancelAllBranchProcesses;
if (OperatorActivity == null)
{
OperatorActivity = CancelProcess.CurrentActivity;
}
}
public WfAdminAddActivityExecutor(IWfActivity operatorActivity,
IWfProcess process,
IWfActivityDescriptor fromActivityDesp,
IWfActivityDescriptor newActivityDesp,
bool syncMSObject)
: base(operatorActivity, process, newActivityDesp, syncMSObject, WfControlOperationType.AdminAddActivity)
{
this._FromActivityDescriptor = fromActivityDesp;
newActivityDesp.NullCheck("newActivityDesp");
this._NewActivityDescriptor = newActivityDesp;
}
public static void LoadActions(IWfActivity activity)
{
WfActivityConfigurationElement activityElement = WfActivitySettings.GetConfig().Activities[activity.Descriptor.ActivityType.ToString()];
if (WfRuntime.Parameters.AutoloadActions && activityElement != null)
{
activity.LeaveActions.CopyFrom(activityElement.GetLeaveActions());
activity.EnterActions.CopyFrom(activityElement.GetEnterActions());
activity.WithdrawActions.CopyFrom(activityElement.GetWithdrawActions());
activity.BeWithdrawnActions.CopyFrom(activityElement.GetBeWithdrawnActions());
}
}
/// <summary>
/// 在当前活动之前插入活动。当前活动不能是起始点。
/// </summary>
/// <param name="actDesp"></param>
public IWfActivity InsertBefore(IWfActivityDescriptor actDesp)
{
this.Descriptor.InsertBefore(actDesp);
IWfActivity newActivity = CreateActivityInstance(actDesp, this.Process);
if (newActivity.Descriptor.ActivityType == WfActivityType.InitialActivity)
{
((WfProcess)this.Process).InitialActivity = newActivity;
}
return(newActivity);
}
protected void SetReadOnlyScene(IWfActivity activity)
{
string scene = activity.Descriptor.InheritedReadOnlyScene;
if (scene.IsNullOrEmpty())
{
if (SceneInfo != null)
scene = SceneInfo.ReadOnlySceneID;
}
if (scene.IsNotEmpty())
OnSetScene(scene);
}
private static IWfActivity FindRelativeActivityByKey(IWfActivity currentActivity, string key)
{
IWfActivity result = null;
IWfActivityDescriptor actDesp = FindAssociatedActivityByKey(currentActivity.Descriptor, key);
if (actDesp != null)
{
result = actDesp.Instance;
}
return(result);
}
public static void LoadActions(IWfActivity activity)
{
WfActivityConfigurationElement activityElement = WfActivitySettings.GetConfig().Activities[activity.Descriptor.ActivityType.ToString()];
if (WfRuntime.Parameters.AutoloadActions && activityElement != null)
{
activity.LeaveActions.CopyFrom(activityElement.GetLeaveActions());
activity.EnterActions.CopyFrom(activityElement.GetEnterActions());
activity.WithdrawActions.CopyFrom(activityElement.GetWithdrawActions());
activity.BeWithdrawnActions.CopyFrom(activityElement.GetBeWithdrawnActions());
}
}
public void CancelProcess(string processID, bool cancelAllBranchProcesses)
{
processID.CheckStringIsNullOrEmpty("processID");
IWfProcess process = WfRuntime.GetProcessByProcessID(processID);
IWfActivity currentActivity = process.CurrentActivity;
//仅作废当前流程
WfCancelProcessExecutor executor = new WfCancelProcessExecutor(process.CurrentActivity, process, cancelAllBranchProcesses);
executor.Execute();
}
private void PrepareNotifyTasks(IWfActivity originalActivity)
{
UserTaskCollection notifyTasks = BuildUserNotifiesFromActivity(originalActivity);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = Translator.Translate(Define.DefaultCulture,
originalActivity.Process.Descriptor.Properties.GetValue("DefaultWithtrawTaskPrefix", "流程被撤回:")) + task.TaskTitle;
}
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
}
protected void SetSceneByActivity(IWfActivity activity)
{
activity.NullCheck("activity");
string scene = activity.Descriptor.InheritedScene;
if (scene.IsNullOrEmpty())
{
if (SceneInfo != null)
scene = SceneInfo.DefaultWorkflowSceneID;
}
if (scene.IsNotEmpty())
OnSetScene(scene);
}
protected override IWfActivity PrepareInstanceActivity()
{
ExceptionHelper.TrueThrow(this.TargetActivity.Descriptor.ActivityType == WfActivityType.CompletedActivity, "不能在结束活动后添加活动");
IWfProcess process = this.TargetActivity.Process;
IWfActivityDescriptor newActDesp = PrepareActivityDescriptor(this.TargetActivity.Descriptor);
IWfActivity newActivity = WfActivityBase.CreateActivityInstance(newActDesp, process);
if (WfRuntime.ProcessContext != null)
WfRuntime.ProcessContext.AffectedProcesses.AddOrReplace(process);
this.AddedActivity = newActivity;
return newActivity;
}
private void WriteAssignees(IWfActivity activity, WfSimulationContext context)
{
StringBuilder strB = new StringBuilder();
foreach (WfAssignee assignee in activity.Assignees)
{
if (assignee.User != null)
{
if (strB.Length > 0)
strB.AppendFormat(", ");
strB.AppendFormat("{0}({1})", assignee.User.DisplayName, assignee.User.ID);
}
}
if (strB.Length > 0)
WriteTextInTag(context.Writer, "div", "流转给: {0}", strB.ToString());
}
/// <summary>
/// 得到在当前活动的意见信息
/// </summary>
/// <param name="originalActivity"></param>
/// <param name="user"></param>
/// <returns></returns>
public WfClientOpinion GetUserActivityOpinion(IWfActivity originalActivity, WfClientUser user)
{
WfClientOpinion opinion = null;
if (originalActivity != null && user != null)
{
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("ACTIVITY_ID", originalActivity.ID);
builder.AppendItem("ISSUE_PERSON_ID", user.ID);
GenericOpinion serverOpinion = GenericOpinionAdapter.Instance.LoadByBuilder(builder).FirstOrDefault();
if (serverOpinion != null)
WfClientOpinionConverter.Instance.ServerToClient(serverOpinion, ref opinion);
}
return opinion;
}
