private static void eventContainer_SendUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(tasks != null, "tasks");
if (tasks.Count > 0)
{
int blocks = (tasks.Count - 1) / 10 + 1;
ProcessProgress.Current.MaxStep += blocks;
ProcessProgress.Current.Response();
int i = 0;
while (i < tasks.Count)
{
i = SendBlockUserTasks(tasks, i, 10);
ProcessProgress.Current.Increment();
ProcessProgress.Current.StatusText = string.Format("保存了{0:#,##0}条待办或通知", i);
ProcessProgress.Current.Response();
}
ProcessProgress.Current.StatusText = string.Empty;
ProcessProgress.Current.Response();
}
}
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);
}
internal void OnBeforeDeleteUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
if (BeforeDeleteUserTasks != null)
{
BeforeDeleteUserTasks(tasks, context);
}
}
/// <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);
}
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);
}
public void OnDeleteUserAccomplishedTasks(UserTaskCollection tasks)
{
foreach (UserTaskOpEventContainer container in EventContainers)
{
container.OnDeleteUserAccomplishedTasks(tasks, Context);
}
}
public void OnSetUserTasksAccomplished(UserTaskCollection tasks)
{
foreach (UserTaskOpEventContainer container in EventContainers)
{
container.OnSetUserTasksAccomplished(tasks, Context);
}
}
public void OnSendUserTasks(UserTaskCollection tasks)
{
foreach (UserTaskOpEventContainer container in EventContainers)
{
container.OnSendUserTasks(tasks, Context);
}
}
internal void OnSetUserTasksAccomplished(UserTaskCollection tasks, Dictionary <object, object> context)
{
if (SetUserTasksAccomplished != null)
{
SetUserTasksAccomplished(tasks, context);
}
}
internal void OnDeleteUserAccomplishedTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
if (DeleteUserAccomplishedTasks != null)
{
DeleteUserAccomplishedTasks(tasks, context);
}
}
private static int SendBlockUserTasks(UserTaskCollection tasks, int startIndex, int count)
{
StringBuilder strB = new StringBuilder(2408);
int i = startIndex;
while (i < tasks.Count && i - startIndex < count)
{
UserTask userTask = tasks[i];
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
strB.Append(GetUserTaskInsertSql(userTask));
i++;
}
if (strB.Length > 0)
{
DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
}
return(i);
}
internal void OnSendUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
if (SendUserTasks != null)
{
SendUserTasks(tasks, context);
}
}
/// <summary>
/// 由UserTaskCollection返回各UserTask的Category子对象的CategoryID数组
/// </summary>
/// <param name="userTasks"></param>
/// <returns></returns>
private string[] GetCategoryIDsFromUserTaskCollection(UserTaskCollection userTasks)
{
string[] CategoryIDs = new string[userTasks.Count];
for (int i = 0; i < userTasks.Count; i++)
{
CategoryIDs[i] = userTasks[i].Category.CategoryID;
}
return(CategoryIDs);
}
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());
}
}
public void SendUserTasks(UserTaskCollection tasks)
{
UserOpContext contexts = InitEventContexts();
contexts.OnBeforeSendUserTasks(tasks);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
contexts.OnSendUserTasks(tasks);
scope.Complete();
}
}
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());
}
}
/// <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();
}
}
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();
}
}
private static string GetMessageContent(UserTaskCollection tasks)
{
StringBuilder strB = new StringBuilder();
if (tasks.Count > 0)
{
strB.AppendLine("UserTasks");
foreach (UserTask task in tasks)
{
strB.AppendLine(XmlHelper.SerializeObjectToXml(task).OuterXml);
}
}
return(strB.ToString());
}
private static void ProcessTaskByIDType(UserTask task, UserTaskIDType idType)
{
if ((idType & UserTaskIDType.SendToUserID) != UserTaskIDType.None)
{
TaskChangedUserIDs[task.SendToUserID] = task.SendToUserID;
}
UserTaskIDType otherType = idType & ~UserTaskIDType.SendToUserID;
if (otherType != UserTaskIDType.None)
{
UserTaskCollection tasks = GetUserTasks(task, otherType);
foreach (UserTask oneTask in tasks)
{
TaskChangedUserIDs[oneTask.SendToUserID] = oneTask.SendToUserID;
}
}
}
public UserTaskCollection LoadUserTasks(string tableName, IConnectiveSqlClause wBuilder, OrderBySqlClauseBuilder orderByBuilder, int count, bool nolock = false)
{
UserTaskCollection result = new UserTaskCollection();
string top = string.Empty;
if (count >= 0)
{
top = string.Format("TOP {0}", count);
}
if (wBuilder.IsEmpty == false)
{
if (nolock)
{
tableName += " (NOLOCK)";
}
string sql = string.Format("SELECT {0} * FROM {1} WHERE {2}",
top,
tableName,
wBuilder.ToSqlString(TSqlBuilder.Instance));
if (orderByBuilder.Count > 0)
{
sql += " ORDER BY " + orderByBuilder.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);
}
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);
}
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);
}
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);
}
private void eventContainer_DeleteUserAccomplishedTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
AttachTransactionEvent();
}
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_BeforeSendUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
Debug.WriteLine("BeforeSendUserTasks");
}
private void eventContainer_DeleteUserAccomplishedTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
Write(GetMessageContent(tasks), "DeleteUserAccomplishedTasks");
}
private void eventContainer_SetUserTasksAccomplished(UserTaskCollection tasks, Dictionary <object, object> context)
{
Write(GetMessageContent(tasks), "SetUserTasksAccomplished");
}
private void eventContainer_SendUserTasks(UserTaskCollection tasks, Dictionary <object, object> context)
{
Write(GetMessageContent(tasks), "SendUserTasks");
}
