/// <summary>
/// 获取我的任务
/// </summary>
/// <param name="conn">数据库链接</param>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="userID">用户ID</param>
/// <param name="trans">数据库事务</param>
/// <returns>任务视图实体</returns>
internal TaskViewEntity GetTaskOfMine(IDbConnection conn,
int activityInstanceID,
string userID,
IDbTransaction trans)
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
// string whereSql = @"SELECT
// TOP 1 *
// FROM vwWfActivityInstanceTasks
// WHERE ActivityInstanceID=@activityInstanceID
// AND AssignedToUserID=@userID
// AND ProcessState=2
// AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6)
// AND (ActivityState=1 OR ActivityState=2)
// ORDER BY TASKID DESC";
TaskViewEntity entity = null;
var list = Repository.GetAll <TaskViewEntity>(conn, trans).Where <TaskViewEntity>(e => e.ActivityInstanceID == activityInstanceID &&
e.AssignedToUserID == userID &&
e.ProcessState == 2 &&
(e.ActivityType == 3 || e.ActivityType == 4 || e.ActivityType == 5 || e.ActivityType == 6 || e.WorkItemType == 1) &&
(e.ActivityState == 1 || e.ActivityState == 2))
.OrderByDescending(e => e.TaskID)
.ToList();
if (list.Count() > 0)
{
entity = list[0];
}
return(entity);
}
/// <summary>
/// 完成任务实例
/// </summary>
/// <param name="taskView">任务视图</param>
/// <param name="activityResource">活动资源</param>
/// <param name="session">会话</param>
internal bool CompleteWorkItem(TaskViewEntity taskView,
ActivityResource activityResource,
IDbSession session)
{
bool canContinueForwardCurrentNode = true;
WfAppRunner runner = new WfAppRunner
{
UserID = activityResource.AppRunner.UserID, //避免taskview为空
UserName = activityResource.AppRunner.UserName
};
//流程强制拉取向前跳转时，没有运行人的任务实例
if (taskView != null)
{
//完成本任务，返回任务已经转移到下一个会签任务，不继续执行其它节点
base.TaskManager.Complete(taskView.TaskID, activityResource.AppRunner, session);
}
//设置活动节点的状态为完成状态
base.ActivityInstanceManager.Complete(base.Linker.FromActivityInstance.ID,
activityResource.AppRunner,
session);
base.Linker.FromActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
return(canContinueForwardCurrentNode);
}
/// <summary>
/// 获取我的任务
/// </summary>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="userID">用户ID</param>
/// <returns>任务视图实体</returns>
internal TaskViewEntity GetTaskOfMine(int activityInstanceID,
string userID)
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
//将ActivityType 修改为 WorkItemType，以处理多类型的任务节点，包括普通任务，多实例，子流程节点
//string sql = @"SELECT
// TOP 1 *
// FROM vwWfActivityInstanceTasks
// WHERE ActivityInstanceID=@activityInstanceID
// AND AssignedToUserID=@userID
// AND ProcessState=2
// AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6 OR WorkItemType=1)
// AND (ActivityState=1 OR ActivityState=2)
// ORDER BY TASKID DESC";
using (var session = DbFactory.CreateSession())
{
TaskViewEntity entity = null;
var list = GetTaskViewList(session).Where <TaskViewEntity>(e => e.ActivityInstanceID == activityInstanceID &&
e.AssignedToUserID == userID &&
e.ProcessState == 2 &&
(e.ActivityType == 4 || e.ActivityType == 5 || e.ActivityType == 6 || e.WorkItemType == 1) &&
(e.ActivityState == 1 || e.ActivityState == 2))
.OrderByDescending(e => e.ID)
.ToList();
if (list != null && list.Count() > 0)
{
entity = list[0];
}
return(entity);
}
}
/// <summary>
/// 根据流程信息获取任务
/// </summary>
/// <param name="conn">链接</param>
/// <param name="processInstanceID">流程实例ID</param>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="trans">事务</param>
/// <returns>任务实体</returns>
internal TaskViewEntity GetTaskViewByActivity(IDbConnection conn,
int processInstanceID,
int activityInstanceID,
IDbTransaction trans)
{
TaskViewEntity taskView = null;
//string sql = @"SELECT
// *
// FROM vwWfActivityInstanceTasks
// WHERE ActivityInstanceID=@activityInstanceID
// AND ProcessInstanceID=@processInstanceID
// ";
//var list = Repository.Query<TaskViewEntity>(sql,
//new
//{
// processInstanceID = processInstanceID,
// activityInstanceID = activityInstanceID
//}).ToList();
var sqlQuery = (from tv in Repository.GetAll <TaskViewEntity>(conn, trans)
where tv.ActivityInstanceID == activityInstanceID &&
tv.ProcessInstanceID == processInstanceID
select tv
);
var list = sqlQuery.ToList <TaskViewEntity>();
if (list.Count() > 0)
{
taskView = list[0];
}
return(taskView);
}
/// <summary>
/// 获取我的任务
/// </summary>
/// <param name="activityInstanceID"></param>
/// <param name="userID"></param>
/// <returns></returns>
internal TaskViewEntity GetTaskOfMine(int activityInstanceID,
string userID)
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
string whereSql = @"SELECT TOP 1 * FROM vwWfActivityInstanceTasks
WHERE ActivityInstanceID=@activityInstanceID
AND AssignedToUserID=@userID
AND ProcessState=2 AND (ActivityType=4 OR ActivityType=5)
AND (ActivityState=1 OR ActivityState=2)
ORDER BY TASKID DESC";
var list = Repository.Query <TaskViewEntity>(
whereSql,
new
{
activityInstanceID = activityInstanceID,
userID = userID
}).ToList <TaskViewEntity>();
//取出唯一待办任务记录，并返回。
TaskViewEntity task = null;
if (list != null && list.Count == 1)
{
task = list[0];
}
return(task);
}
/// <summary>
/// 获取我的任务
/// </summary>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="userID">用户ID</param>
/// <returns>任务视图实体</returns>
internal TaskViewEntity GetTaskOfMine(int activityInstanceID,
string userID)
{
//2015.09.10 besley
//将ActivityType 修改为 WorkItemType，以处理多类型的任务节点，包括普通任务，多实例，子流程节点
string sql = @"SELECT
TOP 1 *
FROM vwWfActivityInstanceTasks
WHERE ActivityInstanceID=@activityInstanceID
AND AssignedToUserID=@userID
AND ProcessState=2
AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6 OR WorkItemType=1)
AND (ActivityState=1 OR ActivityState=2)
ORDER BY TASKID DESC";
sql = SqlDataProvider.GetSqlTaskOfMineByAtcitivityInstance(sql);
var list = Repository.Query <TaskViewEntity>(
sql,
new
{
activityInstanceID = activityInstanceID,
userID = userID
}).ToList <TaskViewEntity>();
//取出唯一待办任务记录，并返回。
TaskViewEntity task = null;
if (list != null && list.Count == 1)
{
task = list[0];
}
return(task);
}
/// <summary>
/// 创建任务执行上下文对象
/// </summary>
/// <param name="taskView">任务</param>
/// <param name="processModel">流程模型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="isNotParsedForward">不需要解析的流转</param>
/// <param name="session">数据会话</param>
/// <returns>活动上下文</returns>
internal static ActivityForwardContext CreateRunningContextByTask(TaskViewEntity taskView,
IProcessModel processModel,
ActivityResource activityResource,
Boolean isNotParsedForward,
IDbSession session)
{
return(new ActivityForwardContext(taskView, processModel, activityResource, isNotParsedForward, session));
}
/// <summary>
/// 获取流程当前运行节点信息
/// </summary>
/// <param name="runner">执行者</param>
/// <returns></returns>
internal ActivityInstanceEntity GetRunningNode(WfAppRunner runner)
{
//如果流程在运行状态，则返回运行时信息
TaskViewEntity task = null;
var entity = GetRunningNode(runner, out task);
return(entity);
}
/// <summary>
/// 根据应用实例、流程GUID，办理用户Id获取任务列表
/// </summary>
/// <param name="conn">链接</param>
/// <param name="appInstanceID">App实例ID</param>
/// <param name="processGUID">流程定义GUID</param>
/// <param name="userID">用户Id</param>
/// <param name="taskID">任务ID</param>
/// <param name="trans">事务</param>
/// <returns>任务实体</returns>
internal TaskViewEntity GetTaskOfMine(IDbConnection conn,
string appInstanceID,
string processGUID,
string userID,
Nullable <int> taskID,
IDbTransaction trans)
{
TaskViewEntity taskView = null;
if (taskID != null)
{
taskView = GetTaskView(conn, taskID.Value, trans);
}
else
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
//2015.09.10 besley
//将ActivityType 修改为 WorkItemType，以处理多类型的任务节点，包括普通任务，多实例，子流程节点
//string sql = @"SELECT
// TOP 1 *
// FROM vwWfActivityInstanceTasks
// WHERE AppInstanceID=@appInstanceID
// AND ProcessGUID=@processGUID
// AND AssignedToUserID=@userID
// AND ProcessState=2
// AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6 OR WorkItemType=1)
// AND (ActivityState=1 OR ActivityState=2)
// ORDER BY TASKID DESC";
var taskList = Repository.GetAll <TaskViewEntity>(conn, trans).Where <TaskViewEntity>(e => e.AppInstanceID == appInstanceID &&
e.ProcessGUID == processGUID &&
e.AssignedToUserID == userID &&
e.ProcessState == 2 &&
(e.ActivityType == 4 || e.ActivityType == 5 || e.ActivityType == 6 || e.WorkItemType == 1) &&
(e.ActivityState == 1 || e.ActivityState == 2))
.OrderByDescending(e => e.TaskID)
.ToList();
if (taskList.Count == 0)
{
var message = LocalizeHelper.GetEngineMessage("taskmanager.gettaskofmine.error");
throw new WorkflowException(
string.Format("{0}，AppInstanceID: {1}", message, appInstanceID.ToString())
);
}
else if (taskList.Count > 1)
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("taskmanager.gettaskofmine.toomoretasks.error"));
}
else
{
taskView = taskList[0];
}
}
return(taskView);
}
/// <summary>
/// 根据应用实例、流程GUID，办理用户Id获取任务列表
/// </summary>
/// <param name="conn">链接</param>
/// <param name="appInstanceID">App实例ID</param>
/// <param name="processGUID">流程定义GUID</param>
/// <param name="userID">用户Id</param>
/// <param name="taskID">任务ID</param>
/// <param name="trans">事务</param>
/// <returns>任务实体</returns>
internal TaskViewEntity GetTaskOfMine(IDbConnection conn,
string appInstanceID,
string processGUID,
string userID,
Nullable <int> taskID,
IDbTransaction trans)
{
TaskViewEntity taskView = null;
if (taskID != null)
{
taskView = GetTaskView(conn, taskID.Value, trans);
}
else
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
//2015.09.10 besley
//将ActivityType 修改为 WorkItemType，以处理多类型的任务节点，包括普通任务，多实例，子流程节点
string sql = @"SELECT
TOP 1 *
FROM vwWfActivityInstanceTasks
WHERE AppInstanceID=@appInstanceID
AND ProcessGUID=@processGUID
AND AssignedToUserID=@userID
AND ProcessState=2
AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6 OR WorkItemType=1)
AND (ActivityState=1 OR ActivityState=2)
ORDER BY TASKID DESC";
sql = SqlDataProvider.GetSqlTaskOfMineByAppInstance(sql);
var taskList = Repository.Query <TaskViewEntity>(conn,
sql,
new
{
appInstanceID = appInstanceID,
processGUID = processGUID,
userID = userID
},
trans).ToList();
if (taskList == null || taskList.Count == 0)
{
throw new WorkflowException(
string.Format("当前没有你要办理的任务，业务单据标识ID: {0}", appInstanceID.ToString())
);
}
else if (taskList.Count > 1)
{
throw new WorkflowException(string.Format("当前办理任务的数目: {0} 大于1，无法确定下一步节点！", taskList.Count));
}
taskView = taskList[0];
}
return(taskView);
}
/// <summary>
/// 判断任务是否属于某个用户
/// </summary>
/// <param name="entity">任务</param>
/// <param name="userID">用户Id</param>
/// <returns>是否标志</returns>
internal bool IsMine(TaskViewEntity entity, string userID)
{
var isMine = false;
if (entity.AssignedToUserID == userID)
{
isMine = true;
}
return(isMine);
}
/// <summary>
/// 创建实例
/// </summary>
/// <param name="taskView"></param>
/// <param name="previousActivityInstance"></param>
/// <param name="nextActivityTree"></param>
/// <returns></returns>
public static CurrentRunningNodeMapComplex Instance(TaskViewEntity taskView,
IList <ActivityInstanceEntity> previousActivityInstance,
IList <NodeView> nextActivityTree)
{
var runningNode = new CurrentRunningNodeMapComplex();
runningNode.IsMine = false;
runningNode.PreviousActivityInstance = previousActivityInstance;
runningNode.NextActivityTree = nextActivityTree;
return(runningNode);
}
/// <summary>
/// 加签操作
/// </summary>
/// <param name="runner"></param>
/// <param name="result"></param>
/// <returns></returns>
public static WfRuntimeManager CreateRuntimeInstanceSignForward(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSignForward();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.SignForward_ErrorArguments;
result.Message = "方法参数错误，无法加签流程！";
return(rmins);
}
if (runner.NextActivityPerformers.Count() == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.SignForward_NoneSigners;
result.Message = "没有添加要发送加签的人员";
return(rmins);
}
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUserIDs.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = "当前没有登录用户要办理的任务，无法运行流程！";
return(rmins);
}
var processModel = new ProcessModel(taskView.ProcessGUID, taskView.Version);
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions, runner.DynamicVariables);
var tm = new TaskManager();
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
internal ActivityInstanceEntity GetRunningNodeOfMine(WfAppRunner runner, out TaskViewEntity taskView)
{
var appInstanceID = runner.AppInstanceID;
var processGUID = runner.ProcessGUID;
var taskID = runner.TaskID;
taskView = null;
ActivityInstanceEntity activityInstance = null;
//如果流程在运行状态，则返回运行时信息
var tm = new TaskManager();
var aim = new ActivityInstanceManager();
var activityList = aim.GetRunningActivityInstanceList(runner).ToList();
if ((activityList != null) && (activityList.Count == 1))
{
activityInstance = activityList[0];
taskView = tm.GetTaskOfMine(activityInstance.ID, runner.UserID);
}
else if (activityList.Count > 0)
{
if (runner.TaskID != null && runner.TaskID.Value != 0)
{
taskView = tm.GetTaskView(taskID.Value);
foreach (var ai in activityList)
{
if (ai.ID == taskView.ActivityInstanceID)
{
activityInstance = ai;
break;
}
}
}
else
{
//当前流程运行节点不唯一
var e = new WorkflowException("当前流程有多个运行节点，但没有TaskID传入，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
}
else
{
//当前没有运行状态的节点存在，流程不存在，或者已经结束或取消
var e = new WorkflowException("当前流程没有运行节点，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
return(activityInstance);
}
/// <summary>
/// 获取流程当前运行节点信息
/// </summary>
/// <param name="runner">执行者</param>
/// <returns>活动实例</returns>
internal ActivityInstanceEntity GetRunningNode(WfAppRunner runner)
{
var appInstanceID = runner.AppInstanceID;
var processGUID = runner.ProcessGUID;
var taskID = runner.TaskID;
//如果流程在运行状态，则返回运行时信息
TaskViewEntity task = null;
var aim = new ActivityInstanceManager();
var entity = GetRunningNode(runner, out task);
return(entity);
}
/// <summary>
/// 任务执行的上下文对象
/// </summary>
/// <param name="task"></param>
/// <param name="processModel"></param>
/// <param name="activityResource"></param>
private ActivityForwardContext(TaskViewEntity task,
ProcessModel processModel,
ActivityResource activityResource)
{
this.TaskView = task;
//check task condition has load activity instance
this.FromActivityInstance = (new ActivityInstanceManager()).GetById(task.ActivityInstanceID);
this.ProcessInstance = (new ProcessInstanceManager()).GetById(task.ProcessInstanceID);
this.Activity = processModel.GetActivity(task.ActivityGUID);
this.ProcessModel = processModel;
this.ActivityResource = activityResource;
}
/// <summary>
/// 判断任务处于运行状态
/// </summary>
/// <param name="task">任务</param>
/// <returns>是否可运行</returns>
internal Boolean CheckTaskStateInRunningState(TaskViewEntity task)
{
var isRunning = true;
if (task.TaskState == (short)TaskStateEnum.Completed)
{
isRunning = false;
}
else if (task.ActivityState == (short)ActivityStateEnum.Completed)
{
isRunning = false;
}
return(isRunning);
}
/// <summary>
/// 获取我的任务
/// </summary>
/// <param name="conn">数据库链接</param>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="userID">用户ID</param>
/// <param name="trans">数据库事务</param>
/// <returns>任务视图实体</returns>
internal TaskViewEntity GetTaskOfMine(IDbConnection conn,
int activityInstanceID,
string userID,
IDbTransaction trans)
{
//processState:2 -running 流程处于运行状态
//activityType:4 -表示“任务”类型的节点
//activityState: 1-ready（准备）, 2-running（）运行；
// string whereSql = @"SELECT
// TOP 1 *
// FROM vwWfActivityInstanceTasks
// WHERE ActivityInstanceID=@activityInstanceID
// AND AssignedToUserID=@userID
// AND ProcessState=2
// AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6)
// AND (ActivityState=1 OR ActivityState=2)
// ORDER BY TASKID DESC";
//2015.09.10 besley
//将ActivityType 修改为 WorkItemType，以处理多类型的任务节点，包括普通任务，多实例，子流程节点
string sql = @"SELECT
TOP 1 *
FROM vwWfActivityInstanceTasks
WHERE ActivityInstanceID=@activityInstanceID
AND AssignedToUserID=@userID
AND ProcessState=2
AND (ActivityType=4 OR ActivityType=5 OR ActivityType=6 OR WorkItemType=1)
AND (ActivityState=1 OR ActivityState=2)
ORDER BY TASKID DESC";
sql = SqlDataProvider.GetSqlTaskOfMineByAtcitivityInstance(sql);
var list = Repository.Query <TaskViewEntity>(conn,
sql,
new
{
activityInstanceID = activityInstanceID,
userID = userID
},
trans).ToList <TaskViewEntity>();
//取出唯一待办任务记录，并返回。
TaskViewEntity task = null;
if (list != null && list.Count == 1)
{
task = list[0];
}
return(task);
}
/// <summary>
/// 获取预选步骤人员列表
/// </summary>
/// <param name="runner">当前运行用户</param>
/// <returns>步骤预选人员列表</returns>
private IDictionary <string, PerformerList> GetNextActivityPerformersPriliminary(WfAppRunner runner)
{
IDictionary <string, PerformerList> nextSteps = null;
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(runner);
//读取活动实例中记录的步骤预选数据
var aim = new ActivityInstanceManager();
if (taskView.MIHostActivityInstanceID != null)
{
var mainActivityInstanceID = taskView.MIHostActivityInstanceID.Value;
var mainActivityInstance = aim.GetById(mainActivityInstanceID);
if (mainActivityInstance != null)
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(mainActivityInstance.NextStepPerformers);
}
}
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var nextActivity = processModel.GetNextActivity(taskView.ActivityGUID);
if (nextActivity != null)
{
if (nextActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
//获取网关节点信息
var gatewayActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (gatewayActivityInstance != null &&
!string.IsNullOrEmpty(gatewayActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(gatewayActivityInstance.NextStepPerformers);
}
}
else if (XPDLHelper.IsInterTimerEventComponentNode(nextActivity) == true)
{
//中间Timer事件节点
var timerActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (timerActivityInstance != null &&
!string.IsNullOrEmpty(timerActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(timerActivityInstance.NextStepPerformers);
}
}
}
return(nextSteps);
}
/// <summary>
/// 创建运行时实例对象
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="session">数据库会话</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceAppRunning(WfAppRunner runner,
IDbSession session,
ref WfExecutedResult result)
{
//检查传人参数是否有效
var rmins = new WfRuntimeManagerAppRunning();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.missing.error");
return(rmins);
}
//传递runner变量
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, session, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUserIDs.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.nonetask.error");
return(rmins);
}
//用于流程注册事件时的流程实例ID提供
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
var activityResource = new ActivityResource(runner,
runner.NextActivityPerformers,
runner.Conditions);
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
/// <summary>
/// 获取任务视图
/// </summary>
/// <param name="conn">链接</param>
/// <param name="runner">当前运行者</param>
/// <param name="trans">事务</param>
/// <returns>任务视图</returns>
internal TaskViewEntity GetTaskOfMine(IDbConnection conn,
WfAppRunner runner,
IDbTransaction trans)
{
TaskViewEntity taskView = null;
if (runner.TaskID != null)
{
taskView = GetTaskView(conn, runner.TaskID.Value, trans);
}
else
{
taskView = GetTaskOfMine(conn, runner.AppInstanceID, runner.ProcessGUID, runner.UserID, trans);
}
return(taskView);
}
/// <summary>
/// 任务执行的上下文对象
/// </summary>
/// <param name="taskView"></param>
/// <param name="processModel">流程模型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="isNotParsedByTransition">非解析流转</param>
/// <param name="session">数据会话</param>
private ActivityForwardContext(TaskViewEntity taskView,
IProcessModel processModel,
ActivityResource activityResource,
Boolean isNotParsedByTransition,
IDbSession session)
{
TaskID = taskView.TaskID;
//check task condition has load activity instance
FromActivityInstance = (new ActivityInstanceManager()).GetById(session.Connection, taskView.ActivityInstanceID, session.Transaction);
ProcessInstance = (new ProcessInstanceManager()).GetById(session.Connection, taskView.ProcessInstanceID, session.Transaction);
Activity = processModel.GetActivity(taskView.ActivityGUID);
ProcessModel = processModel;
ActivityResource = activityResource;
IsNotParsedByTransition = isNotParsedByTransition;
}
/// <summary>
/// 创建运行时实例
/// </summary>
/// <param name="appName"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="userID"></param>
/// <param name="userName"></param>
/// <param name="nextActivityPerformers"></param>
/// <returns></returns>
public static WfRuntimeManager CreateRuntimeInstanceAppRunning(
WfAppRunner runner,
ref WfExecutedResult result)
{
//检查传人参数是否有效
var rmins = new WfRuntimeManagerAppRunning();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_ErrorArguments;
result.Message = "方法参数错误，无法运行流程！";
return(rmins);
}
//传递runner变量
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNodeOfMine(runner, out taskView);
//判断是否是当前登录用户的任务
if (runningNode.AssignedToUsers.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = "当前没有登录用户要办理的任务，无法运行流程！";
return(rmins);
}
var processModel = new ProcessModel(runningNode.ProcessGUID);
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
var tm = new TaskManager();
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
/// <summary>
/// 获取预选步骤人员列表
/// </summary>
/// <param name="nextActivityTree">下一步活动节点树</param>
/// <param name="runner">当前运行用户</param>
/// <returns>步骤预选人员列表</returns>
private IDictionary <string, PerformerList> GetNextActivityPerformers(IList <NodeView> nextActivityTree,
WfAppRunner runner)
{
IDictionary <string, PerformerList> nextSteps = null;
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(runner);
//读取活动实例中记录的步骤预选数据
var aim = new ActivityInstanceManager();
if (taskView.MIHostActivityInstanceID != null)
{
var mainActivityInstanceID = taskView.MIHostActivityInstanceID.Value;
var mainActivityInstance = aim.GetById(mainActivityInstanceID);
if (mainActivityInstance != null)
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(mainActivityInstance.NextStepPerformers);
}
}
//获取网关节点信息
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var nextActivity = processModel.GetNextActivity(taskView.ActivityGUID);
if (nextActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
var gatewayActivityInstance = aim.GetActivityInstanceLatest(taskView.ProcessInstanceID, nextActivity.ActivityGUID);
if (gatewayActivityInstance != null &&
!string.IsNullOrEmpty(gatewayActivityInstance.NextStepPerformers))
{
nextSteps = NextStepUtility.DeserializeNextStepPerformers(gatewayActivityInstance.NextStepPerformers);
}
}
return(nextSteps);
}
/// <summary>
/// 创建跳转实例信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceJump(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerJump();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
//缺失方法参数
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.missing.error");
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.jump.error",
runner.NextActivityPerformers.Count().ToString());
return(rmins);
}
//获取当前运行节点信息
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//传递runner变量
rmins.TaskView = taskView;
rmins.AppRunner = runner;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
//用于流程注册时间调用时候的流程实例ID提供
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
//获取跳转节点信息
var jumpBackActivityGUID = runner.NextActivityPerformers.First().Key;
var jumpBackActivityInstance = aim.GetActivityInstanceLatest(runningNode.ProcessInstanceID, jumpBackActivityGUID);
if (jumpBackActivityInstance != null)
{
//跳转到曾经执行过的节点上,可以作为跳回方式处理
rmins.IsBackward = true;
rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpBackActivityGUID);
//获取当前运行节点的上一步节点
bool hasGatewayNode = false;
var tim = new TransitionInstanceManager();
var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
runner.AppInstanceID, runner.ProcessGUID);
var npc = new PreviousStepChecker();
var previousActivityInstance = npc.GetPreviousActivityInstanceList(runningNode, true,
out hasGatewayNode).ToList()[0];
//仅仅是回跳到上一步节点，即按SendBack方式处理
if (previousActivityInstance.ActivityGUID == jumpBackActivityGUID)
{
rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : WfDefine.WF_XPDL_GATEWAY_BYPASS_GUID; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
previousActivityInstance.ActivityGUID,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
}
else
{
//回跳到早前节点
if (jumpBackActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
{
//回跳节点不在完成状态
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_NotActivityBackCompleted;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.back.error");
return(rmins);
}
rmins.BackwardContext.BackwardToTaskActivityInstance = jumpBackActivityInstance;
//判断两个节点是否有Transition的定义存在
var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, jumpBackActivityGUID);
rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : WfDefine.WF_XPDL_GATEWAY_BYPASS_GUID;
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
jumpBackActivityInstance.ActivityName,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.EndedByUserName);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
jumpBackActivityInstance.ActivityGUID,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.EndedByUserName);
}
//获取资源数据
var activityResourceBack = new ActivityResource(rmins.AppRunner,
rmins.AppRunner.NextActivityPerformers,
runner.Conditions);
rmins.ActivityResource = activityResourceBack;
}
else
{
//跳转到从未执行过的节点上
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
rmins.ActivityResource = activityResource;
rmins.RunningActivityInstance = runningNode;
}
#endregion
return(rmins);
}
/// <summary>
/// 创建跳转实例信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceJump(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerJump();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_ErrorArguments;
result.Message = "方法参数错误，无法运行流程！";
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = string.Format("不能跳转到多个节点！节点数:{0}",
runner.NextActivityPerformers.Count());
return(rmins);
}
//获取当前运行节点信息
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//传递runner变量
rmins.TaskView = taskView;
rmins.AppRunner = runner;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
////获取跳转节点信息
//var jumpActivityGUID = runner.NextActivityPerformers.First().Key;
//var jumpActivityInstanceList = aim.GetActivityInstance(runner.AppInstanceID, runner.ProcessGUID, jumpActivityGUID);
//if (jumpActivityInstanceList != null
// && jumpActivityInstanceList.Count > 0)
//{
// //跳转到曾经执行过的节点上,可以作为跳回方式处理
// rmins.IsBackward = true;
// rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
// rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpActivityGUID);
// //获取当前运行节点的上一步节点
// bool hasGatewayNode = false;
// var tim = new TransitionInstanceManager();
// var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
// runner.AppInstanceID, runner.ProcessGUID);
// var previousActivityInstance = tim.GetPreviousActivityInstance(runningNode, true,
// out hasGatewayNode).ToList()[0];
// //仅仅是回跳到上一步节点，即按SendBack方式处理
// if (previousActivityInstance.ActivityGUID == jumpActivityGUID)
// {
// rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
// rmins.BackwardContext.BackwardToTargetTransitionGUID =
// hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : System.Guid.Empty; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// previousActivityInstance.ActivityName,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// previousActivityInstance.ActivityGUID,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// }
// else
// {
// //回跳到早前节点
// var jumptoActivityInstance = jumpActivityInstanceList[0];
// if (jumptoActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
// {
// result.Status = WfExecutedStatus.Exception;
// result.Exception = WfJumpException.NotActivityBackCompleted;
// result.Message = string.Format("回跳到的节点不在完成状态，无法重新回跳！");
// return rmins;
// }
// rmins.BackwardContext.BackwardToTaskActivityInstance = jumptoActivityInstance;
// //判断两个节点是否有Transition的定义存在
// var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, runner.JumpbackActivityGUID.Value);
// rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : System.Guid.Empty;
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// jumptoActivityInstance.ActivityName,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// jumptoActivityInstance.ActivityGUID,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// }
// //获取资源数据
// var activityResourceBack = new ActivityResource(rmins.AppRunner,
// rmins.AppRunner.NextActivityPerformers,
// runner.Conditions);
// rmins.ActivityResource = activityResourceBack;
//}
//else
//{
// //跳转到从未执行过的节点上
// var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
// rmins.ActivityResource = activityResource;
// rmins.RunningActivityInstance = runningNode;
//}
#endregion
//跳转到从未执行过的节点上
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
rmins.ActivityResource = activityResource;
rmins.RunningActivityInstance = runningNode;
return(rmins);
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
//没有指定退回节点信息
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced &&
(runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0))
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.null.error");
return(rmins);
}
//先查找当前用户正在办理的运行节点
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonerun.error");
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonetask.error");
return(rmins);
}
var activityType = EnumHelper.ParseEnum <ActivityTypeEnum>(runningNode.ActivityType.ToString());
if (XPDLHelper.IsSimpleComponentNode(activityType) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nottask.error");
return(rmins);
}
//获取上一步节点信息
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousStepChecker = new PreviousStepChecker();
var previousActivityList = previousStepChecker.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//判断退回是否有效
if (previousActivityList == null || previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.empty.error");
return(rmins);
}
//前端用户指定退回步骤的模式
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced)
{
if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.noneperformer.error");
return(rmins);
}
//检查节点是否一致
if (previousActivityList.Count == 1)
{
var onlyActivityGUID = previousActivityList[0].ActivityGUID;
var isOnly = true;
foreach (var step in runner.NextActivityPerformers)
{
if (step.Key != onlyActivityGUID)
{
isOnly = false;
break;
}
}
//存在不一致的退回节点
if (isOnly == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.notunique.error");
return(rmins);
}
}
}
else
{
//Traced 用于直接返回上一步使用，测试模式
var prevActivity = previousActivityList[0];
var performerList = PerformerBuilder.CreatePerformerList(runningNode.CreatedByUserID, runningNode.CreatedByUserName);
runner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(prevActivity.ActivityGUID, performerList);
}
//创建运行时
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
rmins.ProcessInstance = processInstance;
rmins.ProcessModel = processModel;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = runner.NextActivityPerformers;
//设置退回选项类
var sendbackOperation = new SendBackOperation();
sendbackOperation.BackwardType = BackwardTypeEnum.Sendback;
sendbackOperation.ProcessInstance = processInstance;
sendbackOperation.BackwardFromActivityInstance = runningNode;
sendbackOperation.HasGatewayPassed = hasGatewayPassed;
sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
sendbackOperation.ProcessModel = processModel;
sendbackOperation.IsCancellingBrothersNode = (runner.ControlParameterSheet != null &&
runner.ControlParameterSheet.IsCancellingBrothersNode == 1) ? true : false;
rmins.SendBackOperation = sendbackOperation;
return(rmins);
}
/// <summary>
/// 创建任务执行上下文对象
/// </summary>
/// <param name="task"></param>
/// <param name="processModel"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateRunningContext(TaskViewEntity task,
ProcessModel processModel,
ActivityResource activityResource)
{
return(new ActivityForwardContext(task, processModel, activityResource));
}
/// <summary>
/// 获取流程当前运行节点信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="taskView">任务视图</param>
/// <returns>活动实例</returns>
internal ActivityInstanceEntity GetRunningNode(WfAppRunner runner,
out TaskViewEntity taskView)
{
var appInstanceID = runner.AppInstanceID;
var processGUID = runner.ProcessGUID;
var taskID = runner.TaskID;
taskView = null;
ActivityInstanceEntity activityInstance = null;
//如果流程在运行状态，则返回运行时信息
var tm = new TaskManager();
var aim = new ActivityInstanceManager();
var activityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList();
if ((activityInstanceList != null) && (activityInstanceList.Count == 1))
{
activityInstance = activityInstanceList[0];
taskView = tm.GetTaskOfMine(activityInstance.ID, runner.UserID);
}
else if (activityInstanceList.Count > 0)
{
if (runner.TaskID != null && runner.TaskID.Value != 0)
{
taskView = tm.GetTaskView(taskID.Value);
foreach (var ai in activityInstanceList)
{
if (ai.ID == taskView.ActivityInstanceID)
{
activityInstance = ai;
break;
}
}
//判断是否有并行节点存在，如果有并行节点存在，取并行节点的主节点（并行会签）
if (activityInstance == null && activityInstanceList[0].MIHostActivityInstanceID != null)
{
var mainActivityInstanceID = activityInstanceList[0].MIHostActivityInstanceID;
activityInstance = aim.GetById(mainActivityInstanceID.Value);
}
}
else
{
//并行模式处理
//根据当前执行者身份取出(他或她)要办理的活动实例（并行模式下有多个处于待办或运行状态的节点）
foreach (var ai in activityInstanceList)
{
if (ai.AssignedToUserIDs == runner.UserID)
{
activityInstance = ai;
break;
}
}
if (activityInstance != null)
{
//获取taskview
taskView = tm.GetTaskOfMine(activityInstance.ID, runner.UserID);
}
else
{
//当前用户的待办任务不唯一，抛出异常，需要TaskID唯一界定
var e = new WorkflowException("当前流程有多个运行节点，但没有TaskID传入，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
}
}
else
{
//当前没有运行状态的节点存在，流程不存在，或者已经结束或取消
var e = new WorkflowException("当前流程没有运行节点，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
return(activityInstance);
}
/// <summary>
/// 根据应用获取流程下一步节点列表，包含角色用户
/// </summary>
/// <param name="resourceService">资源服务</param>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
internal IList <NodeView> GetNextActivityRoleUserTree(IResourceService resourceService,
WfAppRunner runner,
IDictionary <string, string> condition = null)
{
//判断应用数据是否缺失
if (string.IsNullOrEmpty(runner.AppInstanceID) ||
string.IsNullOrEmpty(runner.ProcessGUID))
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("nextstepparser.getnextactivityroleusertree.error"));
}
//条件参数一致
if (condition == null && runner.Conditions != null)
{
condition = runner.Conditions;
}
IList <NodeView> nextSteps = new List <NodeView>();
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
using (var session = SessionFactory.CreateSession())
{
var pim = new ProcessInstanceManager();
var processInstanceList = pim.GetProcessInstance(session.Connection,
runner.AppInstanceID,
runner.ProcessGUID,
session.Transaction).ToList();
var processInstanceEntity = EnumHelper.GetFirst <ProcessInstanceEntity>(processInstanceList);
//判断流程是否创建还是已经运行
if (processInstanceEntity != null &&
processInstanceEntity.ProcessState == (short)ProcessStateEnum.Running)
{
//运行状态的流程实例
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(session.Connection, runner, session.Transaction);
//获取下一步列表
nextSteps = processModel.GetNextActivityTree(taskView.ActivityGUID, condition);
foreach (var ns in nextSteps)
{
if (ns.ReceiverType == ReceiverTypeEnum.ProcessInitiator) //下一步执行人为流程发起人
{
ns.Users = AppendUserList(ns.Users, pim.GetProcessInitiator(session.Connection,
taskView.ProcessInstanceID,
session.Transaction)); //获取流程发起人
}
else
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
if (roleIDs.Count() > 0)
{
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
}
else
{
//流程准备启动，获取第一个办理节点的用户列表
var firstActivity = processModel.GetFirstActivity();
nextSteps = processModel.GetNextActivityTree(firstActivity.ActivityGUID,
condition);
foreach (var ns in nextSteps)
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
return(nextSteps);
}
