public void ReplaceAssigneeExecutorTestReplay()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptor();
IWfActivityDescriptor normalActDesp = processDesp.Activities["NormalActivity"];
IUser originalApprover = (IUser)OguObjectSettings.GetConfig().Objects[OguObject.approver1.ToString()].Object;
normalActDesp.Resources.Clear();
normalActDesp.Resources.Add(new WfUserResourceDescriptor(originalApprover));
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
WfProcessTestCommon.MoveToNextDefaultActivityWithExecutor(process);
process = WfRuntime.GetProcessByProcessID(process.ID);
IUser newApprover = (IUser)OguObjectSettings.GetConfig().Objects[OguObject.approver2.ToString()].Object;
WfReplaceAssigneesExecutor executor = new WfReplaceAssigneesExecutor(process.CurrentActivity, process.CurrentActivity, originalApprover, new IUser[] { newApprover });
executor.Execute();
process = WfRuntime.GetProcessByProcessID(process.ID);
UserTaskCollection tasks = UserTaskAdapter.Instance.LoadUserTasks(build => build.AppendItem("ACTIVITY_ID", process.CurrentActivity.ID));
Assert.AreEqual(1, tasks.Count);
Assert.AreEqual(newApprover.ID, tasks[0].SendToUserID);
}
protected override void OnPrepareMoveToTasks(WfExecutorDataContext dataContext)
{
if (SaveUserTasks)
{
var userTasks = UserTaskAdapter.Instance.LoadUserTasks(builder => builder.AppendItem("ACTIVITY_ID",
this.TargetActivity.ID));
if (userTasks == null || userTasks.Count == 0)
{
userTasks = (UserTaskCollection)TargetActivity.Context["UserTasks"];
}
if (userTasks != null)
{
UserTaskCollection filteredTasks = FilterCurrentUserTasks(userTasks);
WfRuntime.ProcessContext.DeletedUserTasks.CopyFrom(filteredTasks);
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(filteredTasks);
WfRuntime.ProcessContext.MoveToUserTasks.DistinctByActivityUserAndStatus();
base.OnPrepareMoveToTasks(dataContext);
}
else
{
base.OnPrepareMoveToTasks(dataContext);
}
}
}
public override void PrepareAction(WfActionParams actionParams)
{
if (WfRuntime.ProcessContext.OriginalActivity != null)
{
UserTaskCollection currentProcessTasks =
UserTaskAdapter.Instance.LoadUserTasks(builder => builder.AppendItem("ACTIVITY_ID",
WfRuntime.ProcessContext.OriginalActivity.ID));
//删除已经发送的待办
WfRuntime.ProcessContext.DeletedUserTasks.CopyFromNotExistedTaskID(currentProcessTasks);
//对被撤回的点发送通知
this.PrepareNotifyTasks(WfRuntime.ProcessContext.OriginalActivity);
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
//对当前的活动点发送待办
if (currentActivity != null)
{
this.PrepareMoveToTasks(currentActivity);
}
WfRuntime.ProcessContext.FireWithdrawPrepareAction();
}
}
public UserTaskCollection LoadUserTasksByActivity(string activityID, Action<InSqlClauseBuilder> action)
{
action.NullCheck("action");
InSqlClauseBuilder builder = new InSqlClauseBuilder();
action(builder);
string sql = string.Format("SELECT * FROM WF.USER_TASK WHERE ACTIVITY_ID = {0}",
TSqlBuilder.Instance.CheckUnicodeQuotationMark(activityID));
if (builder.Count > 0)
sql += " AND " + builder.ToSqlStringWithInOperator(TSqlBuilder.Instance);
UserTaskCollection result = new UserTaskCollection();
DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];
foreach (DataRow row in table.Rows)
{
UserTask task = new UserTask();
ORMapping.DataRowToObject(row, task);
result.Add(task);
}
return result;
}
private string GetAfterExecutionScript(WfControlOperationType operationType)
{
string script = "top.$HBRootNS.WfProcessControlBase.close()";
switch (operationType)
{
case WfControlOperationType.Save:
script = string.Format("if (parent) parent.location.replace('{0}');",
WfClientContext.Current.ReplaceEntryPathByActivityID());
break;
case WfControlOperationType.MoveTo:
if (WfClientContext.Current.OriginalActivity.Descriptor.Properties.GetValue("ForceCloseFormAfterMoveTo", false) == false)
{
UserTaskCollection userTasks = UserTaskAdapter.Instance.GetUserTasks(UserTaskIDType.ActivityID,
UserTaskFieldDefine.SendToUserID | UserTaskFieldDefine.Status | UserTaskFieldDefine.Url,
WfClientContext.Current.CurrentActivity.ID);
UserTask task = userTasks.Find(t => t.SendToUserID == DeluxeIdentity.CurrentUser.ID && t.Status == TaskStatus.Ban);
if (task != null)
{
script = string.Format("if (parent) parent.location.replace('{0}');", task.Url);
}
}
break;
}
return(script);
}
/// <summary>
/// 发送待办
/// </summary>
/// <param name="tasks">任务列表</param>
/// <param name="context">上下文数据</param>
public void eventContainer_SendUserTasks(UserTaskCollection tasks, Dictionary<object, object> context)
{
this.ExecuteSyncOperation("SendUserTasksService", tasks, context, (p, f) =>
{
UserTaskServicePluginBroker.Instance.SendUserTasks(p, f);
});
}
/// <summary>
/// 发送待办
/// </summary>
/// <param name="tasks">任务列表</param>
/// <param name="context">上下文数据</param>
public void eventContainer_SendUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
this.ExecuteSyncOperation("SendUserTasksService", tasks, context, (p, f) =>
{
UserTaskServicePluginBroker.Instance.SendUserTasks(p, f);
});
}
public void CancelProcessInOtherActivityTest()
{
IWfProcess process = WfProcessTestCommon.StartupProcessWithAssignee();
WfRuntime.PersistWorkflows();
process = WfRuntime.GetProcessByProcessID(process.ID);
IWfActivityDescriptor nextActivityDesp = process.CurrentActivity.Descriptor.ToTransitions[0].ToActivity;
WfTransferParams tp = ProcessTestHelper.GetInstanceOfWfTransferParams(nextActivityDesp, OguObject.requestor);
process.MoveTo(tp);
WfRuntime.PersistWorkflows();
UserTaskCollection tasks = UserTaskAdapter.Instance.LoadUserTasks(b => b.AppendItem("ACTIVITY_ID", process.CurrentActivity.ID));
Console.WriteLine("Current Activity ID: {0}", process.CurrentActivity.ID);
Console.WriteLine("User Task Count: {0}", tasks.Count);
process = CancelProcess(process, false);
UserTaskCollection userAccomlishedTasks = UserTaskAdapter.Instance.GetUserAccomplishedTasks(UserTaskIDType.ActivityID, UserTaskFieldDefine.All, false, process.CurrentActivity.ID);
Console.WriteLine("User Accomplished Task Count: {0}", userAccomlishedTasks.Count);
Assert.AreEqual(tasks.Count, userAccomlishedTasks.Count);
}
private static void PrepareUserTasks(UserTaskCollection tasks, string taskUrl, string taskTitle, string taskBody)
{
tasks.ForEach(task =>
{
task.Body = taskBody;
});
}
public override void PrepareAction(WfActionParams actionParams)
{
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
if (currentActivity != null)
{
//找到当前流程所有的待办，然后删除，主要是为了删除通知
UserTaskCollection currentActivityTasks =
UserTaskAdapter.Instance.LoadUserTasks(builder => builder.AppendItem("ACTIVITY_ID",
currentActivity.ID));
WfRuntime.ProcessContext.DeletedUserTasks.CopyFrom(currentActivityTasks);
//找到当前流程所有的已办，然后转为待办
UserTaskCollection currentActivityAccomplishedTasks =
UserTaskAdapter.Instance.GetUserAccomplishedTasks(UserTaskIDType.ActivityID, UserTaskFieldDefine.All, false, currentActivity.ID);
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(currentActivityAccomplishedTasks);
if (currentActivity.Status == WfActivityStatus.Pending)
{
WfRuntime.ProcessContext.PendingActivities.Add(currentActivity);
}
WfRuntime.ProcessContext.FireRestoreProcessPrepareAction();
}
}
public void WithdrawAndCancelTest()
{
IWfProcess process = ProcessHelper.CreateFreeStepsProcessDescriptor(OguObjectSettings.GetConfig().Objects["approver1"].User).StartupProcess();
process = process.MoveToDefaultActivityByExecutor();
string activityIDBeforeWithdraw = process.CurrentActivity.ID;
Assert.AreEqual(WfActivityType.NormalActivity, process.CurrentActivity.Descriptor.ActivityType);
Console.WriteLine("ActivityID Before Withdraw = {0}, Process ID = {1}", activityIDBeforeWithdraw, process.ID);
process = process.WithdrawByExecutor(true);
Assert.AreEqual(WfActivityType.InitialActivity, process.CurrentActivity.Descriptor.ActivityType);
Assert.AreEqual(WfProcessStatus.Aborted, process.Status);
UserTaskCollection notifies = UserTaskAdapter.Instance.GetUserTasks(UserTaskIDType.ActivityID, UserTaskFieldDefine.ActivityID | UserTaskFieldDefine.Status, activityIDBeforeWithdraw);
Assert.AreEqual(1, notifies.Count);
UserTaskCollection tasks = UserTaskAdapter.Instance.GetUserTasks(UserTaskIDType.ActivityID, UserTaskFieldDefine.ActivityID | UserTaskFieldDefine.Status, process.InitialActivity.ID);
Assert.AreEqual(1, tasks.Count);
Assert.AreEqual(TaskStatus.Yue, tasks[0].Status);
UserTaskCollection accomplishedTasks = UserTaskAdapter.Instance.GetUserAccomplishedTasks(UserTaskIDType.ActivityID, UserTaskFieldDefine.ActivityID | UserTaskFieldDefine.Status, false, activityIDBeforeWithdraw);
Assert.AreEqual(1, tasks.Count);
}
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));
UserTaskCollection toAccomplishedTasks = new UserTaskCollection();
UserTaskCollection toDeletedTasks = new UserTaskCollection();
currentProcessTasks.ForEach(u =>
{
if (u.Status == TaskStatus.Ban)
{
toAccomplishedTasks.Add(u);
}
else
{
toDeletedTasks.Add(u);
}
});
WfRuntime.ProcessContext.DeletedUserTasks.CopyFromNotExistedTaskID(toDeletedTasks);
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 override void PrepareAction(WfActionParams actionParams)
{
if (WfRuntime.ProcessContext.OriginalActivity != null)
{
IWfActivity originalActivity = WfRuntime.ProcessContext.OriginalActivity;
//找到当前环节所有的待办，然后转为已办
UserTaskCollection currentActTasks =
UserTaskAdapter.Instance.LoadUserTasks(builder =>
{
builder.AppendItem("ACTIVITY_ID", originalActivity.ID);
builder.AppendItem("STATUS", (int)TaskStatus.Ban);
});
//从上下文中找到需要转已办的记录
currentActTasks.CopyFrom(WfRuntime.ProcessContext.MoveToUserTasks.FindAll(
u => string.Compare(u.ActivityID, originalActivity.ID, true) == 0));
currentActTasks.Sort((u1, u2) => u1.Level - u2.Level);
if (currentActTasks.Count == 0)
{
UserTaskCollection preparedUserTasks = (UserTaskCollection)originalActivity.Context["UserTasks"];
if (preparedUserTasks != null)
{
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(preparedUserTasks);
currentActTasks = preparedUserTasks;
}
}
currentActTasks.ForEach(u =>
{
if (u.Status == TaskStatus.Ban)
ChangeUserTaskToAccomplishedTasks(originalActivity, u);
else
WfRuntime.ProcessContext.DeletedUserTasks.Add(u);
});
UserTaskCollection notifyTasks = new UserTaskCollection();
AppendResourcesToNotifiers(originalActivity, notifyTasks, originalActivity.Descriptor.LeaveEventReceivers);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = Translator.Translate(Define.DefaultCulture,
originalActivity.Process.Descriptor.Properties.GetValue("DefaultLeaveTaskPrefix", "离开活动:")) + task.TaskTitle;
task.Context["ExtraOperationType"] = WfControlSubOperationType.Leave;
}
WfRuntime.ProcessContext.Acl.CopyFrom(notifyTasks.ToAcl());
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
WfRuntime.ProcessContext.FireLeaveActivityPrepareAction();
}
}
internal static void SyncUrlsInAssigneesFromTasks(UserTaskCollection tasks)
{
foreach (UserTask task in tasks)
{
IWfActivity activity = WfRuntime.GetProcessByActivityID(task.ActivityID).Activities[task.ActivityID];
SyncActivityAssigneesUrl(task, activity.Assignees);
}
}
/// <summary>
/// 如果请求是提醒对话框的，则处理该请求，显示提醒对话框的内容
/// </summary>
private void DoNotifyDialog()
{
if (HttpContext.Current.Request.RequestType == "POST")
{
string taskID = HttpContext.Current.Request.QueryString["taskID"];
string taskSource = WebUtility.GetRequestFormString("taskSource", "userTask");
if (string.IsNullOrEmpty(taskID) == false && GetAutoTransferToCompletedTask())
{
UserTask task = new UserTask();
task.TaskID = taskID;
UserTaskCollection tasks = new UserTaskCollection();
tasks.Add(task);
if (taskSource == "userTask")
UserTaskAdapter.Instance.DeleteUserTasks(tasks);
else
UserTaskAdapter.Instance.DeleteUserAccomplishedTasks(tasks);
}
SaveAutoTransferToCompletedTaskFlag();
//WebUtility.ResponseRefreshParentWindowScriptBlock();
HttpContext.Current.Response.Write(ExtScriptHelper.GetRefreshBridgeScript());
WebUtility.ResponseTimeoutScriptBlock("top.close();", ExtScriptHelper.DefaultResponseTimeout);
HttpContext.Current.Response.End();
}
else
{
Page page = new Page();
HtmlGenericControl html = new HtmlGenericControl("html");
WebUtility.SetCurrentPage(page);
page.Controls.Add(html);
HtmlHead head = new HtmlHead();
html.Controls.Add(head);
HtmlTitle title = new HtmlTitle();
title.Text = Translator.Translate(Define.DefaultCulture, "提醒消息");
head.Controls.Add(title);
HtmlGenericControl body = new HtmlGenericControl("body");
html.Controls.Add(body);
WebUtility.AttachPageModules(page);
string temmplate = GetNotifyDialogHtml();
string pageHtml = InitNotifyDialogPage(temmplate);
body.Controls.Add(new LiteralControl(pageHtml));
((IHttpHandler)page).ProcessRequest(HttpContext.Current);
HttpContext.Current.Response.End();
}
}
protected virtual void OnPrepareNotifyTasks(WfExecutorDataContext dataContext)
{
UserTaskCollection tasks = dataContext.NotifyTasks;
if (PrepareNotifyTasks != null)
{
PrepareNotifyTasks(dataContext, tasks);
}
}
internal static void SyncUrlsInAssigneesFromTasks(UserTaskCollection tasks)
{
foreach (UserTask task in tasks)
{
IWfActivity activity = WfRuntime.GetProcessByActivityID(task.ActivityID).Activities[task.ActivityID];
SyncActivityAssigneesUrl(task, activity.Assignees);
}
}
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 executor_PrepareNotifyTasks(WfExecutorDataContext dataContext, UserTaskCollection tasks)
{
GenericOpinion opnion = (GenericOpinion)dataContext["AbortOpinion"];
tasks.ForEach(t =>
{
if (t.Body.IsNullOrEmpty())
{
t.Body = opnion.Content;
}
});
}
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);
}
}
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 void SendUserTasks(UserTaskCollection tasks)
{
UserOpContext contexts = InitEventContexts();
contexts.OnBeforeSendUserTasks(tasks);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
contexts.OnSendUserTasks(tasks);
scope.Complete();
}
}
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);
}
private UserTaskCollection LoadOriginalUserTask()
{
UserTaskCollection result = UserTaskAdapter.Instance.LoadUserTasksByActivity(this.TargetActivity.ID,
build =>
{
build.DataField = "SEND_TO_USER";
this.OriginalAssignees.ForEach(u => build.AppendItem("SEND_TO_USER", u.ID));
}
);
return(result);
}
private UserTaskCollection GetTasksFromContextCache(string cacheKey)
{
UserTaskCollection result = (UserTaskCollection)ObjectContextCache.Instance.GetOrAddNewValue(cacheKey, (cache, key) =>
{
UserTaskCollection tasks = new UserTaskCollection();
cache.Add(key, tasks);
return(tasks);
});
return(result);
}
private static UserTaskCollection FilterCurrentUserTasks(UserTaskCollection sourceTasks)
{
UserTaskCollection result = new UserTaskCollection();
foreach (UserTask task in sourceTasks)
{
if (string.Compare(task.SourceID, DeluxeIdentity.CurrentUser.ID, true) == 0)
{
result.Add(task);
}
}
return(result);
}
private static void eventContainer_SetUserTasksAccomplished(UserTaskCollection tasks, Dictionary<object, object> context)
{
ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");
//需要删除的待办的ID
InSqlClauseBuilder deleteTaskIDs = new InSqlClauseBuilder();
StringBuilder strB = new StringBuilder();
ORMappingItemCollection mapping = ORMapping.GetMappingInfo<UserTask>().Clone();
string userTaskTableName = mapping.TableName;
mapping.TableName = "WF.USER_ACCOMPLISHED_TASK";
foreach (UserTask task in tasks)
{
UserTask clonedUserTask = GetClonedAccomplishedUserTask(task);
if (strB.Length > 0)
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
WhereSqlClauseBuilder builder = GetDeleteAccomplishedUserTaskWhereBuilder(task);
//删除已办
strB.AppendFormat("DELETE {0} WHERE {1}",
mapping.TableName,
builder.ToSqlString(TSqlBuilder.Instance));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.Append(GetUserTaskInsertSql(clonedUserTask, mapping, "Category", "TopFlag"));
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
deleteTaskIDs.AppendItem(task.TaskID);
}
if (strB.Length > 0 && deleteTaskIDs.IsEmpty == false)
{
//删除待办
strB.AppendFormat("DELETE {0} WHERE TASK_GUID {1}",
userTaskTableName,
deleteTaskIDs.ToSqlStringWithInOperator(TSqlBuilder.Instance));
}
if (strB.Length > 0)
DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
}
private static void eventContainer_DeleteUserTasks(UserTaskCollection tasks, Dictionary<object, object> context)
{
ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");
InSqlClauseBuilder builder = new InSqlClauseBuilder();
tasks.ForEach(u => builder.AppendItem(u.TaskID));
if (builder.Count > 0)
{
string sql = string.Format("DELETE WF.USER_TASK WHERE TASK_GUID {0}", builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));
DbHelper.RunSql(sql, GetConnectionName());
}
}
public void SetUserTasksAccomplished(UserTaskCollection tasks)
{
ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");
UserOpContext contexts = InitEventContexts();
contexts.OnBeforeSetUserTasksAccomplished(tasks);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
contexts.OnSetUserTasksAccomplished(tasks);
scope.Complete();
}
}
public override void PrepareAction(WfActionParams actionParams)
{
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
if (currentActivity != null)
{
if (WfRuntime.ProcessContext.TargetActivityCanMoveTo && currentActivity.Status == WfActivityStatus.Running)
{
UserTaskCollection userTasks = BuildUserTasksFromActivity(currentActivity);
UserTaskCollection notifyTasks = new UserTaskCollection();
AppendResourcesToNotifiers(currentActivity, notifyTasks, currentActivity.Descriptor.EnterEventReceivers);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = task.TaskTitle;
task.Context["ExtraOperationType"] = WfControlSubOperationType.Enter;
}
WfRuntime.ProcessContext.Acl.CopyFrom(notifyTasks.ToAcl());
//当从数据库中加载流程时，LoadingType为DataLoadingType.External。
if (CanAutoSendUserTask(currentActivity))
{
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(userTasks);
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
}
else
{
currentActivity.Context["UserTasks"] = userTasks;
currentActivity.Context["NotifyTasks"] = notifyTasks;
}
if (currentActivity.Status == WfActivityStatus.Completed)
{
WfRuntime.ProcessContext.ClosedProcesses.AddOrReplace(currentActivity.Process);
}
}
else
{
WfRuntime.ProcessContext.PendingActivities.Add(currentActivity);
}
WfRuntime.ProcessContext.FireEnterActivityPrepareAction();
}
}
public static WfClientProcess Moveto(WfClientMovetoParameters parameters)
{
IWfProcess process = WfRuntime.GetProcessByProcessID(parameters.ProcessID);
IWfActivity activity = process.CurrentActivity;
if (activity == null || activity.Assignees == null)// || !activity.Assignees.Contains(UserHelper.UserId))
{
return(null);
}
WfTransferParams transferParams = WfTransferParams.FromNextDefaultActivity(process);
UserTaskCollection userTask = new UserTaskCollection();
WfMoveToExecutor executor = new WfMoveToExecutor(activity, activity, transferParams);
//调整待办的url和标题
executor.PrepareMoveToTasks += (dataContext, tasks) =>
{
PrepareUserTasks(tasks, null, null, transferParams.NextActivityDescriptor.Name);
};
GenericOpinion serverOpinion = PrepareOpinion(process.CurrentActivity, parameters.CurrentOpinion, DeluxeIdentity.CurrentUser);
if (activity.Descriptor.ActivityType == WfActivityType.InitialActivity)
{
serverOpinion.OpinionType = "提交";
}
else if (activity.Descriptor.ActivityType == WfActivityType.CompletedActivity)
{
serverOpinion.OpinionType = string.Empty;
}
else if (activity.Descriptor.ActivityType == WfActivityType.NormalActivity)
{
serverOpinion.OpinionType = "同意";
if (serverOpinion.Content.IsNullOrEmpty())
{
serverOpinion.Content = "同意";
}
}
executor.PrepareApplicationData += dataContext => GenericOpinionAdapter.Instance.Update(serverOpinion);
return(GetClientProcess(executor.Execute()));
}
public static void SetTaskAccomplishedAfterRead(Object sender, EventArgs e)
{
WfControlBase.ResponsePostBackPlaceHolder();
string requestTaskID = HttpContext.Current.Request["taskID"];
if (string.IsNullOrEmpty(requestTaskID))
{
return;
}
UserTaskCollection usc = UserTaskAdapter.Instance.GetUserTasks(
UserTaskIDType.TaskID, UserTaskFieldDefine.Url, requestTaskID);
if (usc.Count > 0)
{
UserTask task = usc[0];
task.SendToUserID = DeluxeIdentity.CurrentUser.ID;
task.TaskID = requestTaskID;
string url = task.Url;
int removePosStart = url.IndexOf("needReadBtn");
if (removePosStart >= 0) // found request query *needReadBtn*
{
int removePosEnd = url.IndexOf('&', removePosStart);
if (removePosEnd > removePosStart) // found *needReadBtn=xxx&*, remove it
{
url = url.Remove(removePosStart, removePosEnd - removePosStart + 1);
}
else // not '&' after query string *needReadBtn*, remove all after *needReadBtn*
{
url = url.Remove(removePosStart);
}
}
task.Url = url;
//UserTaskAdapter.Instance.SetTaskAccomplished(task,
// UserTaskIDType.TaskID | UserTaskIDType.SendToUserID,
// UserTaskFieldDefine.Url);
UserTaskAdapter.Instance.SetUserTasksAccomplished(usc);
WfControlBase.ResponsePostBackPlaceHolder();
HttpContext.Current.Response.Write(ExtScriptHelper.GetRefreshBridgeScript());
WebUtility.ResponseTimeoutScriptBlock("top.close();", ExtScriptHelper.DefaultResponseTimeout);
}
}
public override void PrepareAction(WfActionParams actionParams)
{
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
if (currentActivity != null)
{
if (WfRuntime.ProcessContext.TargetActivityCanMoveTo && currentActivity.Status == WfActivityStatus.Running)
{
UserTaskCollection userTasks = BuildUserTasksFromActivity(currentActivity);
UserTaskCollection notifyTasks = new UserTaskCollection();
AppendResourcesToNotifiers(currentActivity, notifyTasks, currentActivity.Descriptor.EnterEventReceivers);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = task.TaskTitle;
task.Context["ExtraOperationType"] = WfControlSubOperationType.Enter;
}
WfRuntime.ProcessContext.Acl.CopyFrom(notifyTasks.ToAcl());
//当从数据库中加载流程时，LoadingType为DataLoadingType.External。
if (CanAutoSendUserTask(currentActivity))
{
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(userTasks);
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
}
else
{
currentActivity.Context["UserTasks"] = userTasks;
currentActivity.Context["NotifyTasks"] = notifyTasks;
}
if (currentActivity.Status == WfActivityStatus.Completed)
WfRuntime.ProcessContext.ClosedProcesses.AddOrReplace(currentActivity.Process);
}
else
{
WfRuntime.ProcessContext.PendingActivities.Add(currentActivity);
}
WfRuntime.ProcessContext.FireEnterActivityPrepareAction();
}
}
/// <summary>
/// 删除当前在上下文中的待办
/// </summary>
/// <param name="actionParams"></param>
/// <returns></returns>
private static UserTaskCollection RemoveTasksInContext(WfActionParams actionParams)
{
UserTaskCollection result = new UserTaskCollection();
actionParams.Context.MoveToUserTasks.Remove(t =>
{
bool remove = string.Compare(t.ProcessID, actionParams.Context.CurrentProcess.ID, true) == 0;
if (remove)
{
result.Add(t);
}
return(remove);
});
return(result);
}
private void PrepareUserTasksAndAcl()
{
UserTaskCollection originalUserTasks = LoadOriginalUserTask();
UserTaskCollection newTasks = null;
if (originalUserTasks.Count > 0)
{
newTasks = CreateUserTasksFromTemplate(originalUserTasks, this.TargetAssignees);
}
else
{
newTasks = CreateNewUserTasks(this.TargetActivity, this.TargetAssignees);
}
WfRuntime.ProcessContext.DeletedUserTasks.CopyFrom(originalUserTasks);
WfRuntime.ProcessContext.MoveToUserTasks.CopyFrom(newTasks);
WfRuntime.ProcessContext.Acl.CopyFrom(CreateNewAcl(this.TargetActivity, this.TargetAssignees));
}
protected override void OnPrepareNotifyTasks(WfExecutorDataContext dataContext)
{
UserTaskCollection notifyTasks = (UserTaskCollection)TargetActivity.Context["NotifyTasks"];
if (notifyTasks != null)
{
UserTaskCollection filteredTasks = FilterCurrentUserTasks(notifyTasks);
WfRuntime.ProcessContext.DeletedUserTasks.CopyFrom(filteredTasks);
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(filteredTasks);
WfRuntime.ProcessContext.NormalizeTaskTitles();
base.OnPrepareNotifyTasks(dataContext);
}
else
{
base.OnPrepareNotifyTasks(dataContext);
}
}
private static string GetProcessUrl(IWfProcess process)
{
string result = string.Empty;
if (process.CurrentActivity != null)
{
UserTaskCollection tasks = UserTaskAdapter.Instance.LoadUserTasks(
builder => builder.AppendItem("ACTIVITY_ID", process.CurrentActivity.ID));
if (tasks.Count > 0)
{
result = tasks[0].NormalizedUrl;
}
}
if (result.IsNullOrEmpty())
{
string infoID = process.ResourceID;
if (AppCommonInfoAdapter.Instance.Exists(infoID) == false)
{
infoID = process.ID;
}
if (AppCommonInfoAdapter.Instance.Exists(infoID))
{
AppCommonInfo commonInfo = AppCommonInfoAdapter.Instance.Load(infoID);
NameValueCollection uriParams = UriHelper.GetUriParamsCollection(commonInfo.Url);
uriParams["processID"] = process.ID;
result = UriHelper.CombineUrlParams(commonInfo.Url, uriParams);
}
}
if (result.IsNotEmpty())
{
result = UserTask.GetNormalizedUrl(process.Descriptor.ApplicationName, process.Descriptor.ProgramName, result);
}
return(result);
}
/// <summary>
/// 给管里员批量发送待办
/// </summary>
/// <param name="allUsers"></param>
/// <param name="itemUserTask"></param>
public static void SendUserTask(IEnumerable <IUser> allUsers, UserTask itemUserTask, string notificationID)
{
UserTaskCollection senuserTasks = new UserTaskCollection();
foreach (IUser user in allUsers)
{
UserTask item = itemUserTask.Clone();
item.TaskID = UuidHelper.NewUuidString();
item.ProcessID = item.TaskID;
item.ResourceID = item.TaskID;
item.Url = string.Format(item.Url, notificationID, item.TaskID);
item.SendToUserID = user.ID;
item.SendToUserName = user.Name;
senuserTasks.Add(item);
}
UserTaskAdapter.Instance.SendUserTasks(senuserTasks);
}
private static UserTaskCollection CreateNewUserTasks(UserTaskCollection originalTasks, IEnumerable <IUser> targetUsers)
{
UserTaskCollection result = new UserTaskCollection();
foreach (UserTask task in originalTasks)
{
foreach (IUser user in targetUsers)
{
UserTask newTask = task.Clone();
newTask.TaskID = UuidHelper.NewUuidString();
newTask.SendToUserID = user.ID;
newTask.SendToUserName = user.DisplayName;
newTask.TaskStartTime = DateTime.Now;
result.Add(newTask);
}
}
return(result);
}
public static void ExecuteReplace(ReplaceAssigneeHelperData rahd)
{
rahd.NullCheck("错误：传入参数为空");
//取原始待办人
IUser originalUser = (IUser)OguBase.CreateWrapperObject(rahd.OriginalUserID, SchemaType.Users);
//取目的待办人
List <IUser> targetUsers = new List <IUser>();
foreach (string userID in rahd.TargetUsersID)
{
IUser targetUser = (IUser)OguBase.CreateWrapperObject(userID, SchemaType.Users);
targetUsers.Add(targetUser);
}
//获取用户任务
UserTaskCollection tasks = UserTaskAdapter.Instance.LoadUserTasks(
build => build.AppendItem("TASK_GUID", rahd.TaskID, "="));
(tasks.Count > 0).FalseThrow("指定的任务ID'{0}'不存在！", rahd.TaskID);
//取出Activity
string activityID = tasks[0].ActivityID;
//待办人替换处理
try
{
IWfProcess process = WfRuntime.GetProcessByActivityID(activityID);
IWfActivity activity = process.Activities[activityID];
//创建Executor并执行
WfReplaceAssigneesExecutor replaceExec = new WfReplaceAssigneesExecutor(activity, activity,
originalUser, targetUsers);
replaceExec.Execute();
}
catch
{
}
}
public override void PrepareAction(WfActionParams actionParams)
{
IWfActivity currentActivity = WfRuntime.ProcessContext.CurrentActivity;
if (currentActivity != null)
{
//暂时对当前活动的处理人发送通知
UserTaskCollection notifyTasks = BuildUserNotifiesFromActivity(currentActivity);
AppendResourcesToNotifiers(currentActivity, notifyTasks, currentActivity.Descriptor.Process.CompleteEventReceivers);
foreach (UserTask task in notifyTasks)
{
task.Status = TaskStatus.Yue;
task.TaskTitle = Translator.Translate(Define.DefaultCulture,
currentActivity.Process.Descriptor.Properties.GetValue("DefaultCompleteTaskPrefix", "流程已办结:")) + task.TaskTitle;
}
WfRuntime.ProcessContext.NotifyUserTasks.CopyFrom(notifyTasks);
WfRuntime.ProcessContext.Acl.CopyFrom(notifyTasks.ToAcl());
}
}
public UserTaskCollection LoadUserTasks(string tableName, IConnectiveSqlClause builder)
{
UserTaskCollection result = new UserTaskCollection();
if (builder.IsEmpty == false)
{
string sql = string.Format("SELECT * FROM {0} WHERE {1}",
tableName, builder.ToSqlString(TSqlBuilder.Instance));
DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];
foreach (DataRow row in table.Rows)
{
UserTask task = new UserTask();
ORMapping.DataRowToObject(row, task);
result.Add(task);
}
}
return result;
}
internal static UserTaskCollection BuildUserTasksFromActivity(IWfActivity activity, IEnumerable<IUser> users, TaskStatus status)
{
UserTaskCollection tasks = new UserTaskCollection();
foreach (IUser user in users)
{
UserTask task = BuildOneUserTaskFromActivity(activity, status);
task.SendToUserID = user.ID;
task.SendToUserName = user.DisplayName;
task.Emergency = WfRuntime.ProcessContext.Emergency;
task.Purpose = WfRuntime.ProcessContext.Purpose;
task.Context["OperationType"] = WfRuntime.ProcessContext.OperationType;
string opName = WfRuntime.ProcessContext.OperationType.ToDescription();
switch (WfRuntime.ProcessContext.OperationType)
{
case WfControlOperationType.MoveTo:
case WfControlOperationType.ObligeEnd:
case WfControlOperationType.Return:
case WfControlOperationType.AddApprover:
case WfControlOperationType.ChangeApprover:
case WfControlOperationType.Circulate:
case WfControlOperationType.Consign:
opName = WfRuntime.ProcessContext.CurrentProcess.ApplicationRuntimeParameters.GetValue("CurrentTransitionName", opName);
break;
}
task.Context["OperationName"] = opName;
tasks.Add(task);
}
return tasks;
}
public void OnSetUserTasksAccomplished(UserTaskCollection tasks)
{
foreach (UserTaskOpEventContainer container in EventContainers)
container.OnSetUserTasksAccomplished(tasks, Context);
}
/// <summary>
/// 执行同步操作
/// </summary>
/// <param name="tasks"></param>
/// <param name="context"></param>
/// <param name="operation"></param>
private void ExecuteSyncOperation(string opName, UserTaskCollection tasks, Dictionary<object, object> context, Action<string, DictionaryEntry[]> operation)
{
Dictionary<string, object> arguments = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
if (tasks.Count > 0)
{
context.ToList().ForEach(p => arguments.Add(p.Key.ToString(), p.Value.ToString()));
//待办或通知的上下文参数
Dictionary<string, object> taskContextContainer = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
foreach (UserTask task in tasks)
{
//把每一个流程的上下文参数也添加到arguments中，是一个ProcessID和Task上下文的字典
if (arguments.ContainsKey(task.ProcessID) == false)
{
Dictionary<string, object> processArgs = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
WfRuntime.GetProcessByProcessID(task.ProcessID).ApplicationRuntimeParameters.CopyTo(processArgs,
kp => kp.Value != null && (kp.Value.GetType().IsPrimitive || kp.Value is string));
arguments.Add(task.ProcessID, ConvertDictToEntry(processArgs));
}
//把每一个待办的上下文也添加到arguments中，是一个TaskID和Task上下文的字典
if (taskContextContainer.ContainsKey(task.TaskID) == false)
taskContextContainer.Add(task.TaskID, ConvertDictToEntry(task.Context));
}
arguments["TaskContext"] = ConvertDictToEntry(taskContextContainer);
string seriTasks = JSONSerializerExecute.Serialize(tasks);
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(
opName, () => operation(seriTasks, ConvertDictToEntry(arguments)));
}
}
protected void Submitbtn_Click(object sender, EventArgs e)
{
try
{
UserTask clonedUserTask = UserTaskAdapter.Instance.LoadSingleUserTaskByID(this.UserTaskID);
UserTaskCollection tasks= new UserTaskCollection();
tasks.Add(clonedUserTask);
UserTaskAdapter.Instance.SetUserTasksAccomplished(tasks);
UserTaskAdapter.Instance.DeleteUserTasks(tasks);
/*
ORMappingItemCollection mapping = ORMapping.GetMappingInfo<UserTask>().Clone();
mapping.TableName = "WF.USER_ACCOMPLISHED_TASK";
clonedUserTask.Url = UriHelper.ReplaceUriParams(clonedUserTask.Url, nvs =>
{
nvs["isTask"] = "false";
});
mapping.Remove("CATEGORY_GUID");
mapping.Remove("TOP_FLAG");
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.Append(ORMapping.GetInsertSql(clonedUserTask, mapping, TSqlBuilder.Instance));
sqlBuilder.Append(TSqlBuilder.Instance.DBStatementSeperator);
sqlBuilder.AppendFormat("DELETE FROM WF.USER_TASK WHERE TASK_GUID =N'{0}'", clonedUserTask.TaskID);
DbHelper.RunSqlWithTransaction(sqlBuilder.ToString()); */
Page.ClientScript.RegisterStartupScript(this.GetType(), "关闭当前窗口",
string.Format("top.close();"),
true);
}
catch (Exception ex)
{
WebUtility.ShowClientError(ex.Message, ex.StackTrace, "错误");
}
}
private void executor_PrepareNotifyTasks(WfExecutorDataContext dataContext, UserTaskCollection tasks)
{
GenericOpinion opnion = (GenericOpinion)dataContext["AbortOpinion"];
tasks.ForEach(t =>
{
if (t.Body.IsNullOrEmpty())
{
t.Body = opnion.Content;
}
});
}
public void OnDeleteUserAccomplishedTasks(UserTaskCollection tasks)
{
foreach (UserTaskOpEventContainer container in EventContainers)
container.OnDeleteUserAccomplishedTasks(tasks, Context);
}
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 static UserTaskCollection FilterCurrentUserTasks(UserTaskCollection sourceTasks)
{
UserTaskCollection result = new UserTaskCollection();
foreach (UserTask task in sourceTasks)
{
if (string.Compare(task.SourceID, DeluxeIdentity.CurrentUser.ID, true) == 0)
{
result.Add(task);
}
}
return result;
}
/// <summary>
/// 删除已办事项
/// </summary>
/// <param name="task"></param>
/// <param name="idType"></param>
public void DeleteUserAccomplishedTasks(UserTaskCollection tasks)
{
tasks.NullCheck("tasks");
UserOpContext contexts = InitEventContexts();
contexts.OnBeforeDeleteUserAccomplishedTasks(tasks);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
contexts.OnDeleteUserAccomplishedTasks(tasks);
scope.Complete();
}
}
/// <summary>
/// 删除当前在上下文中的待办
/// </summary>
/// <param name="actionParams"></param>
/// <returns></returns>
private static UserTaskCollection RemoveTasksInContext(WfActionParams actionParams)
{
UserTaskCollection result = new UserTaskCollection();
actionParams.Context.MoveToUserTasks.Remove(t =>
{
bool remove = string.Compare(t.ProcessID, actionParams.Context.CurrentProcess.ID, true) == 0;
if (remove)
result.Add(t);
return remove;
});
return result;
}
private UserTaskCollection GetTasksFromContextCache(string cacheKey)
{
UserTaskCollection result = (UserTaskCollection)ObjectContextCache.Instance.GetOrAddNewValue(cacheKey, (cache, key) =>
{
UserTaskCollection tasks = new UserTaskCollection();
cache.Add(key, tasks);
return tasks;
});
return result;
}
public UserTaskCollection GetUserAccomplishedTasks(UserTaskIDType idType, UserTaskFieldDefine returnFields, bool nolock, params string[] ids)
{
ExceptionHelper.FalseThrow<ArgumentNullException>(ids != null, "ids");
UserTaskCollection utc = new UserTaskCollection();
if (ids.Length > 0)
{
ORMappingItem keyItem = GetMappingItemFromIDType(idType);
InSqlClauseBuilder iBuilder = new InSqlClauseBuilder();
iBuilder.AppendItem(ids);
string sql = string.Format("SELECT {0} FROM WF.USER_ACCOMPLISHED_TASK{1} WHERE {2} {3}",
GetUserTaskSelectFields(returnFields),
nolock ? "(NOLOCK)" : string.Empty,
GetMappingItemFromIDType(idType).DataFieldName,
iBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance));
using (DbContext dbi = DbHelper.GetDBContext(GetConnectionName()))
{
Database db = DatabaseFactory.Create(dbi);
using (IDataReader dr = db.ExecuteReader(CommandType.Text, sql))
{
while (dr.Read())
{
UserTask ut = new UserTask();
ORMapping.DataReaderToObject(dr, ut);
utc.Add(ut);
}
}
}
}
return utc;
}
private void eventContainer_DeleteUserAccomplishedTasks(UserTaskCollection tasks, Dictionary<object, object> context)
{
AttachTransactionEvent();
}
private static UserTaskCollection GetUserTasks(UserTask task, UserTaskIDType idType)
{
UserTaskCollection result = new UserTaskCollection();
foreach (EnumItemDescription desp in EnumItemDescriptionAttribute.GetDescriptionList(typeof(UserTaskIDType)))
{
UserTaskIDType enumIdType = (UserTaskIDType)desp.EnumValue;
if ((enumIdType & idType) != UserTaskIDType.None && enumIdType != UserTaskIDType.SendToUserID)
{
UserTaskIDType targetIDType = (UserTaskIDType)desp.EnumValue | (idType & UserTaskIDType.SendToUserID);
UserTaskCollection tasks = UserTaskAdapter.Instance.GetUserTasks(
targetIDType,
UserTaskFieldDefine.TaskID | UserTaskFieldDefine.SendToUserID | UserTaskFieldDefine.ActivityID,
true,
DefaultUserTaskOperationImpl.GetUserTaskIDValue(task, targetIDType));
result.CopyFrom(tasks);
}
}
return result;
}
/// <summary>
/// 根据TaskGuid得到UserAccomplishedTask
/// </summary>
/// <param name="strTaskGuid"></param>
/// <returns></returns>
public UserTaskCollection GetUserAccomplishedTasks(params string[] strTaskGuid)
{
UserTaskCollection utc = new UserTaskCollection();
if (strTaskGuid.Length > 0)
{
InSqlClauseBuilder builder = new InSqlClauseBuilder();
builder.AppendItem(strTaskGuid);
string strSql = "SELECT * FROM WF.USER_ACCOMPLISHED_TASK WHERE (TASK_GUID " + builder.ToSqlStringWithInOperator(TSqlBuilder.Instance) + ")";
using (DbContext dbi = DbHelper.GetDBContext(GetConnectionName()))
{
Database db = DatabaseFactory.Create(dbi);
using (IDataReader dr = db.ExecuteReader(CommandType.Text, strSql))
{
while (dr.Read())
{
UserTask ut = new UserTask();
ORMapping.DataReaderToObject(dr, ut);
utc.Add(ut);
}
}
}
}
return utc;
}
private void eventContainer_BeforeDeleteUserTasks(UserTaskCollection tasks, Dictionary<object, object> context)
{
ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");
tasks.ForEach(task => TaskChangedUserIDs[task.SendToUserID] = task.SendToUserID);
}
private void eventContainer_SendUserTasks(UserTaskCollection tasks, Dictionary<object, object> context)
{
AttachTransactionEvent();
}
public UserTaskCollection LoadUserTasks(Action<WhereSqlClauseBuilder> action)
{
action.NullCheck("action");
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
action(builder);
string sql = string.Format("SELECT * FROM WF.USER_TASK WHERE {0}", builder.ToSqlString(TSqlBuilder.Instance));
UserTaskCollection result = new UserTaskCollection();
DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];
foreach (DataRow row in table.Rows)
{
UserTask task = new UserTask();
ORMapping.DataRowToObject(row, task);
result.Add(task);
}
return result;
}
