public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner, ProcessInstanceEntity parentProcessInstance, SubProcessNode subProcessNode, ref WfExecutedResult result) { //检查流程是否可以被启动 var rmins = new WfRuntimeManagerStartup(); rmins.WfExecutedResult = result = new WfExecutedResult(); var pim = new ProcessInstanceManager(); ProcessInstanceEntity processInstance = null; if (subProcessNode == null) { //正常流程启动 processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID, runner.ProcessGUID); } else { //子流程启动 processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID, subProcessNode.SubProcessGUID); } //不能同时启动多个主流程 if (processInstance != null && processInstance.ParentProcessInstanceID == null && processInstance.ProcessState == (short)ProcessStateEnum.Running) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Started_IsRunningAlready; result.Message = "流程已经处于运行状态,如果要重新启动,请先终止当前流程实例!"; return(rmins); } //processInstance 为空,此时继续执行启动操作 rmins.AppRunner = runner; rmins.ParentProcessInstance = parentProcessInstance; rmins.InvokedSubProcessNode = subProcessNode; //获取流程第一个可办理节点 rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID); var firstActivity = rmins.ProcessModel.GetFirstActivity(); rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID, runner.UserID, runner.UserName); rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); return(rmins); }
/// <summary> /// 获取下一步活动列表树 /// </summary> /// <param name="taskID">任务ID</param> /// <param name="condition">条件</param> /// <returns></returns> public IList <NodeView> GetNextActivityTree(int taskID, IDictionary <string, string> condition = null) { var taskView = (new TaskManager()).GetTaskView(taskID); var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version); var nextSteps = processModel.GetNextActivityTree(taskView.ProcessInstanceID, taskView.ActivityGUID, condition); return(nextSteps); }
/// <summary> /// 根据应用获取流程下一步节点列表 /// </summary> /// <param name="runner">应用执行人</param> /// <param name="condition">条件</param> /// <returns>节点列表</returns> public IList <NodeView> GetNextActivityTree(WfAppRunner runner, IDictionary <string, string> condition = null) { var tm = new TaskManager(); var taskView = tm.GetTaskOfMine(runner.AppInstanceID, runner.ProcessGUID, runner.UserID); var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version); var nextSteps = processModel.GetNextActivityTree(taskView.ProcessInstanceID, taskView.ActivityGUID, condition); return(nextSteps); }
/// <summary> /// 流程启动时获取开始节点下一步的节点角色人员列表 /// </summary> /// <param name="runner">应用执行人</param> /// <param name="condition">条件</param> /// <returns>节点列表</returns> public IList <NodeView> GetFirstActivityRoleUserTree(WfAppRunner runner, IDictionary <string, string> condition = null) { var processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version); var firstActivity = processModel.GetFirstActivity(); var 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); }
/// <summary> /// 创建运行时实例对象 /// </summary> /// <param name="runner">执行者</param> /// <param name="result">结果对象</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.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 = ProcessModelFactory.Create(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); }
/// <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="runner">运行者</param> /// <param name="parentProcessInstance">父流程</param> /// <param name="subProcessNode">子流程节点</param> /// <param name="performerList">执行者列表</param> /// <param name="session">数据库会话</param> /// <param name="result">运行结果</param> /// <returns>运行时管理器</returns> public static WfRuntimeManager CreateRuntimeInstanceStartupSub(WfAppRunner runner, ProcessInstanceEntity parentProcessInstance, SubProcessNode subProcessNode, PerformerList performerList, IDbSession session, ref WfExecutedResult result) { //检查流程是否可以被启动 var rmins = new WfRuntimeManagerStartupSub(); rmins.WfExecutedResult = result = new WfExecutedResult(); var pim = new ProcessInstanceManager(); ProcessInstanceEntity processInstance = pim.GetProcessInstanceCurrent(session.Connection, runner.AppInstanceID, subProcessNode.SubProcessGUID, session.Transaction); //不能同时启动多个主流程 if (processInstance != null && processInstance.ParentProcessInstanceID == null && processInstance.ProcessState == (short)ProcessStateEnum.Running) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Started_IsRunningAlready; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceStartup.error"); return(rmins); } //processInstance 为空,此时继续执行启动操作 rmins.AppRunner = runner; rmins.ParentProcessInstance = parentProcessInstance; rmins.InvokedSubProcessNode = subProcessNode; //获取流程第一个可办理节点 rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version); var startActivity = rmins.ProcessModel.GetStartActivity(); var firstActivity = rmins.ProcessModel.GetFirstActivity(); //子流程自动获取第一个办理节点上的人员列表 rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID, performerList); rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); return(rmins); }
/// <summary> /// 启动流程 /// </summary> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时实例对象</returns> public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner, ref WfExecutedResult result) { //检查流程是否可以被启动 var rmins = new WfRuntimeManagerStartup(); rmins.WfExecutedResult = result = new WfExecutedResult(); //正常流程启动 var pim = new ProcessInstanceManager(); ProcessInstanceEntity processInstance = pim.GetProcessInstanceCurrent(runner.AppInstanceID, runner.ProcessGUID); //不能同时启动多个主流程 if (processInstance != null && processInstance.ParentProcessInstanceID == null && processInstance.ProcessState == (short)ProcessStateEnum.Running) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Started_IsRunningAlready; result.Message = "流程已经处于运行状态,如果要重新启动,请先终止当前流程实例!"; return(rmins); } rmins.AppRunner = runner; //获取流程第一个可办理节点 rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version); var startActivity = rmins.ProcessModel.GetStartActivity(); var firstActivity = rmins.ProcessModel.GetFirstActivity(); if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.None) { rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID, runner.UserID, runner.UserName); } else if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer) { var roleList = rmins.ProcessModel.GetActivityRoles(firstActivity.ActivityGUID); rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID, roleList); } rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); return(rmins); }
/// <summary> /// 创建活动任务转移数据 /// </summary> /// <param name="toActivity">目的活动</param> /// <param name="processInstance">流程实例</param> /// <param name="fromActivityInstance">来源活动实例</param> /// <param name="transitionGUID">转移GUID</param> /// <param name="transitionType">转移类型</param> /// <param name="flyingType">飞跃类型</param> /// <param name="activityResource">活动资源</param> /// <param name="session">会话</param> internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity, ProcessInstanceEntity processInstance, ActivityInstanceEntity fromActivityInstance, string transitionGUID, TransitionTypeEnum transitionType, TransitionFlyingTypeEnum flyingType, ActivityResource activityResource, IDbSession session) { Boolean isParallel = false; if (fromActivityInstance.ActivityType == (short)ActivityTypeEnum.GatewayNode) { var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var activityNode = processModel.GetActivity(fromActivityInstance.ActivityGUID); isParallel = processModel.IsAndSplitMI(activityNode); } if (isParallel) { var entity = new ActivityInstanceEntity(); var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID]; //创建并行多实例分支 for (var i = 0; i < plist.Count; i++) { var performer = plist[i]; CreateSubProcessNode(toActivity, processInstance, fromActivityInstance, transitionGUID, transitionType, flyingType, activityResource, performer, session); } } else { if (toActivity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether) { CreateMultipleInstance(toActivity, processInstance, fromActivityInstance, transitionGUID, transitionType, flyingType, activityResource, session); } else { CreateSubProcessNode(toActivity, processInstance, fromActivityInstance, transitionGUID, transitionType, flyingType, activityResource, null, session); } } }
/// <summary> /// 使用流程定义资源添加角色用户 /// </summary> /// <param name="mainActivityInstanceID">主流程节点实例ID</param> /// <param name="mainActivityGUID">主流程节点GUID</param> /// <param name="session">数据库会话</param> /// <returns>执行用户</returns> private WfAppRunner FillNextActivityPerformersByRoleList(int mainActivityInstanceID, string mainActivityGUID, IDbSession session) { var pm = new ProcessInstanceManager(); var mainProcessInstance = pm.GetByActivity(session.Connection, mainActivityInstanceID, session.Transaction); var processModel = ProcessModelFactory.Create(mainProcessInstance.ProcessGUID, mainProcessInstance.Version); var nextSteps = processModel.GetNextActivityTree(mainActivityGUID); //获取主流程的任务 var task = (new TaskManager()).GetTaskByActivity(session.Connection, mainProcessInstance.ID, mainActivityInstanceID, session.Transaction); var runner = new WfAppRunner { AppName = mainProcessInstance.AppName, AppInstanceID = mainProcessInstance.AppInstanceID, AppInstanceCode = mainProcessInstance.AppInstanceCode, ProcessGUID = mainProcessInstance.ProcessGUID, Version = mainProcessInstance.Version, UserID = task.AssignedToUserID, UserName = task.AssignedToUserName }; foreach (var node in nextSteps) { Dictionary <string, PerformerList> dict = new Dictionary <string, PerformerList>(); var performerList = PerformerBuilder.CreatePerformerList(node.Roles); //根据节点角色定义,读取执行者列表 if (node.ActivityType != ActivityTypeEnum.EndNode && performerList.Count == 0) { throw new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediatorend.FillNextActivityPerformersByRoleList.warn", node.ActivityName)); } else { dict.Add(node.ActivityGUID, performerList); } runner.NextActivityPerformers = dict; } return(runner); }
/// <summary> /// 设置流程的启动类型 /// </summary> /// <param name="entity">流程实体</param> /// <param name="xmlConent">XML内容</param> private void SetProcessStartEndType(ProcessEntity entity, string xmlConent) { var processModel = ProcessModelFactory.Create(entity.ProcessGUID, entity.Version); //StartNode var startNode = processModel.GetActivityByType(xmlConent, entity.ProcessGUID, ActivityTypeEnum.StartNode); if (startNode != null) { if (startNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer) { entity.StartType = (byte)ProcessStartTypeEnum.Timer; entity.StartExpression = startNode.ActivityTypeDetail.Expression; } else if (startNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message) { entity.StartType = (byte)ProcessStartTypeEnum.Message; entity.StartExpression = startNode.ActivityTypeDetail.Expression; } } //EndNode var endNode = processModel.GetActivityByType(xmlConent, entity.ProcessGUID, ActivityTypeEnum.EndNode); if (endNode != null) { if (endNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer) { entity.EndType = (byte)ProcessEndTypeEnum.Timer; entity.EndExpression = endNode.ActivityTypeDetail.Expression; } else if (endNode.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message) { entity.EndType = (byte)ProcessEndTypeEnum.Message; entity.EndExpression = endNode.ActivityTypeDetail.Expression; } } }
/// <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="runningActivityInstanceList">运行节点列表</param> /// <param name="withdrawOperation">撤销类型</param> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时管理器</returns> private static WfRuntimeManager CreateRuntimeInstanceWithdrawByCase( List <ActivityInstanceEntity> runningActivityInstanceList, WithdrawOperationTypeEnum withdrawOperation, WfAppRunner runner, ref WfExecutedResult result) { WfRuntimeManager rmins = new WfRuntimeManagerWithdraw(); rmins.WfExecutedResult = result = new WfExecutedResult(); //根据当前运行节点获取 ActivityInstanceEntity runningNode = runningActivityInstanceList[0]; ProcessInstanceEntity processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID); IProcessModel processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); //不同撤销的分支场景处理 var aim = new ActivityInstanceManager(); //以下处理,需要知道上一步是独立节点的信息 //获取上一步流转节点信息,可能经过And, Or等路由节点 var tim = new TransitionInstanceManager(); bool hasGatewayNode = false; var currentNode = runningNode; if (runningNode.MIHostActivityInstanceID != null) { //如果当前运行节点是多实例子节点,则需要找到它的主节点的Transiton记录 currentNode = aim.GetById(runningNode.MIHostActivityInstanceID.Value); } var lastActivityInstanceList = tim.GetPreviousActivityInstance(currentNode, false, out hasGatewayNode).ToList(); if (lastActivityInstanceList == null || lastActivityInstanceList.Count > 1) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_HasTooMany; result.Message = "当前没有可以撤销回去的节点,或者有多个可以撤销回去的节点,无法选择!"; return(rmins); } TransitionInstanceEntity lastTaskTransitionInstance = null; if (hasGatewayNode == false) { lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName, runner.AppInstanceID, runner.ProcessGUID); if (lastTaskTransitionInstance.TransitionType == (short)TransitionTypeEnum.Loop) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_IsLoopNode; result.Message = "当前流转是自循环,无需撤销!"; return(rmins); } } var previousActivityInstance = lastActivityInstanceList[0]; if (previousActivityInstance.EndedByUserID != runner.UserID) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_NotCreatedByMine; result.Message = string.Format("上一步节点的任务办理人跟当前登录用户不一致,无法撤销回上一步!节点办理人:{0}", previousActivityInstance.EndedByUserName); return(rmins); } if (previousActivityInstance.ActivityType == (short)ActivityTypeEnum.EndNode) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_PreviousIsEndNode; result.Message = "上一步是结束节点,无法撤销!"; return(rmins); } //当前运行节点是普通节点 if (withdrawOperation == WithdrawOperationTypeEnum.Normal) { //简单串行模式下的退回 rmins = new WfRuntimeManagerWithdraw(); rmins.WfExecutedResult = result = new WfExecutedResult(); rmins.ProcessModel = processModel; rmins.AppRunner.ProcessGUID = runner.ProcessGUID; rmins.BackwardContext.ProcessInstance = processInstance; rmins.BackwardContext.BackwardToTargetTransitionGUID = hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty; rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(previousActivityInstance.ActivityGUID); rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance; rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID); rmins.BackwardContext.BackwardFromActivityInstance = runningNode; //准备状态的接收节点 rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance( previousActivityInstance.ActivityName, previousActivityInstance.EndedByUserID, previousActivityInstance.EndedByUserName); //封装AppUser对象 rmins.AppRunner.AppName = runner.AppName; rmins.AppRunner.AppInstanceID = runner.AppInstanceID; rmins.AppRunner.UserID = runner.UserID; rmins.AppRunner.UserName = runner.UserName; rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers( previousActivityInstance.ActivityGUID, runner.UserID, runner.UserName); rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); return(rmins); } //如果有其它模式,没有处理到,则直接抛出异常 throw new WorkflowException("未知的撤销场景,请报告给技术支持人员!"); }
/// <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(); var sendbackOperation = SendbackOperationTypeEnum.Default; //先查找当前用户正在办理的运行节点 var aim = new ActivityInstanceManager(); var runningNode = runner.TaskID != null?aim.GetByTask(runner.TaskID.Value) : aim.GetRunningNode(runner); if (runningNode == null) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotInRunning; result.Message = "当前没有运行状态的节点存在,流程不存在,或者已经结束或取消"; return(rmins); } if (aim.IsMineTask(runningNode, runner.UserID) == false) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotMineTask; result.Message = "不是当前登录用户的任务,无法退回!"; 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 = "当前节点不是任务类型的节点,无法退回上一步节点!"; return(rmins); } //获取当前运行主节点信息 var currentNode = runningNode; if (runningNode.MIHostActivityInstanceID != null) { currentNode = aim.GetById(runningNode.MIHostActivityInstanceID.Value); } //获取上一步流转节点信息,可能经过And, Or等路由节点 //判断前置步骤是否经过Gateway节点 var hasGatewayPassed = false; var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID); var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var previousActivityList = aim.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed); if (previousActivityList == null || previousActivityList.Count == 0) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_IsNull; result.Message = "当前没有可以退回的节点,请检查流程数据!"; return(null); } //多个退回节点存在的有效退回判断 IList <ActivityEntity> sendbackPreviousActivityList = new List <ActivityEntity>(); if (previousActivityList.Count > 1) { if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious; result.Message = "当前有多个可以退回的节点,无法选择,请明确指定!"; return(rmins); } //明确指定的退回节点,需要判断处理 var isInvalidSendBack = IsInvalidStepsInPrevousActivityList(previousActivityList, runner.NextActivityPerformers, sendbackPreviousActivityList); if (isInvalidSendBack == true) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotContainedInPreviousOrStartNode; result.Message = "指定的退回节点不在上一步节点运行列表中,或者上一步是开始节点,无法退回!"; return(rmins); } } else { //只有一个要退回去的节点 sendbackPreviousActivityList.Add(previousActivityList[0]); } //判断当前节点是否是多实例节点 if (runningNode.MIHostActivityInstanceID != null) { if (runningNode.CompleteOrder == 1) { //只有串行模式下有CompleteOrder的值为 1 //串行模式多实例的第一个执行节点,此时可退回到上一步 sendbackOperation = SendbackOperationTypeEnum.MISFirstOneIsRunning; } else if (runningNode.CompleteOrder > 1) { //已经是中间节点,只能退回到上一步多实例子节点 sendbackOperation = SendbackOperationTypeEnum.MISOneIsRunning; } else if (runningNode.CompleteOrder == -1) { sendbackOperation = SendbackOperationTypeEnum.MIPOneIsRunning; } } if (hasGatewayPassed == true) { sendbackOperation = SendbackOperationTypeEnum.GatewayFollowedByParalleledNodes; } else { sendbackOperation = SendbackOperationTypeEnum.Normal; } //根据不同分支场景,创建不同撤销运行时管理器 return(CreateRuntimeInstanceSendbackByCase(runningNode, processModel, processInstance, sendbackPreviousActivityList, hasGatewayPassed, sendbackOperation, runner, ref result)); }
/// <summary> /// 创建活动任务转移实例数据 /// </summary> /// <param name="toActivity">活动</param> /// <param name="processInstance">流程实例</param> /// <param name="fromActivityInstance">开始活动实例</param> /// <param name="transitionGUID">转移GUID</param> /// <param name="transitionType">转移类型</param> /// <param name="flyingType">跳跃类型</param> /// <param name="activityResource">活动资源</param> /// <param name="session">会话</param> internal override void CreateActivityTaskTransitionInstance(ActivityEntity toActivity, ProcessInstanceEntity processInstance, ActivityInstanceEntity fromActivityInstance, string transitionGUID, TransitionTypeEnum transitionType, TransitionFlyingTypeEnum flyingType, ActivityResource activityResource, IDbSession session) { int newActivityInstanceID = 0; Boolean isParallel = false; if (fromActivityInstance.ActivityType == (short)ActivityTypeEnum.GatewayNode) { //并发多实例分支判断(AndSplit Multiple) var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var activityNode = processModel.GetActivity(fromActivityInstance.ActivityGUID); isParallel = processModel.IsAndSplitMI(activityNode); } if (isParallel) { //并行多实例容器 var entity = new ActivityInstanceEntity(); var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID]; //创建并行多实例分支 for (var i = 0; i < plist.Count; i++) { entity = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner); entity.AssignedToUserIDs = plist[i].UserID; entity.AssignedToUserNames = plist[i].UserName; entity.ActivityState = (short)ActivityStateEnum.Ready; //插入活动实例数据 entity.ID = base.ActivityInstanceManager.Insert(entity, session); //插入任务 base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session); //插入转移数据 InsertTransitionInstance(processInstance, transitionGUID, fromActivityInstance, entity, transitionType, flyingType, activityResource.AppRunner, session); } } else { //普通任务节点 var toActivityInstance = base.CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner); //进入运行状态 toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready; toActivityInstance = GenerateActivityAssignedUserInfo(toActivityInstance, activityResource); //插入活动实例数据 newActivityInstanceID = base.ActivityInstanceManager.Insert(toActivityInstance, session); //插入任务数据 base.CreateNewTask(toActivityInstance, activityResource, session); //插入转移数据 InsertTransitionInstance(processInstance, transitionGUID, fromActivityInstance, toActivityInstance, transitionType, flyingType, activityResource.AppRunner, session); //调用外部事件的注册方法 var delegateContext = new DelegateContext { AppInstanceID = processInstance.AppInstanceID, ProcessGUID = processInstance.ProcessGUID, ProcessInstanceID = processInstance.ID, ActivityGUID = toActivity.ActivityGUID, ActivityCode = toActivity.ActivityCode, ActivityResource = activityResource }; DelegateExecutor.InvokeExternalDelegate(session, EventFireTypeEnum.OnActivityCreated, activityResource.AppRunner.DelegateEventList, delegateContext); } }
/// <summary> /// 获取活动节点下的角色数据 /// </summary> /// <param name="processGUID">流程GUID</param> /// <param name="version">版本</param> /// <param name="activityGUID">活动GUID</param> /// <returns>角色列表</returns> public IList <Role> GetActivityRoles(string processGUID, string version, string activityGUID) { var processModel = ProcessModelFactory.Create(processGUID, version); return(processModel.GetActivityRoles(activityGUID)); }
/// <summary> /// 获取上一步节点树 /// </summary> /// <param name="runningNode">运行活动</param> /// <param name="hasGatewayPassed">是否经过网关</param> /// <returns>上一步步骤列表</returns> private IList <NodeView> GetPreviousActivityTree(ActivityInstanceEntity runningNode, out Boolean hasGatewayPassed) { var aim = new ActivityInstanceManager(); //获取前置节点列表 var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID); var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var previousActivityList = GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed); //封装返回结果集合 var nodeList = new List <NodeView>(); foreach (var activity in previousActivityList) { //判断是否是会签节点 if (processModel.IsMINode(activity) == true) { //获取上一步节点的运行记录 if (processModel.IsMIParallel(activity) == true) { //并行会签节点读取所有完成的子节点 var activityInstanceList = aim.GetPreviousParallelMultipleInstanceListCompleted(runningNode, activity.ActivityGUID); foreach (var ai in activityInstanceList) { AppendNodeViewList(nodeList, activity, ai.EndedByUserID, ai.EndedByUserName); } } else if (processModel.IsMISequence(activity) == true) { if (processModel.IsTaskNode(runningNode) == true) { //当前节点是任务节点 //退回到会签节点的最后一步 var activityInstance = aim.GetPreviousActivityInstanceSimple(runningNode, activity.ActivityGUID); if (activityInstance != null) { AppendNodeViewList(nodeList, activity, activityInstance.EndedByUserID, activityInstance.EndedByUserName); } } else if (processModel.IsMISequence(activity) == true) { //串行会签节点按照CompleteOrder顺序递减读取上一步 var previousAdjacentBrotherNode = GetPreviousOfMultipleInstanceNode( runningNode.MIHostActivityInstanceID.Value, runningNode.ID, runningNode.CompleteOrder.Value); if (previousAdjacentBrotherNode != null) { AppendNodeViewList(nodeList, activity, previousAdjacentBrotherNode.EndedByUserID, previousAdjacentBrotherNode.EndedByUserName); } } } } else { if (hasGatewayPassed == true) { //跨越网关类型 var activityInstanceList = aim.GetActivityInstanceListCompletedSimple(runningNode.ProcessInstanceID, activity.ActivityGUID); foreach (var a in activityInstanceList) { AppendNodeViewList(nodeList, activity, a.EndedByUserID, a.EndedByUserName); } } else { //普通任务节点 var activityInstance = aim.GetPreviousActivityInstanceSimple(runningNode, activity.ActivityGUID); if (activityInstance != null) { AppendNodeViewList(nodeList, activity, activityInstance.EndedByUserID, activityInstance.EndedByUserName); } } } } return(nodeList); }
/// <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> 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="runner">撤销人</param> /// <param name="result">创建结果</param> /// <returns>运行时管理器</returns> internal static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner, ref WfExecutedResult result) { var rmins = new WfRuntimeManagerSendBack(); rmins.WfExecutedResult = result = new WfExecutedResult(); if (runner.TaskID == null) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_ErrorArguments; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.missingtaskid.error"); return(rmins); } //获取已经完成任务的信息 var tm = new TaskManager(); var taskDone = tm.GetTaskView(runner.TaskID.Value); if (tm.IsMine(taskDone, runner.UserID) == false) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotMineTask; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonetask.error"); return(rmins); } //赋值下一步办理列表 runner.NextActivityPerformers = NextStepUtility.CreateNextStepPerformerList(taskDone.ActivityGUID, taskDone.AssignedToUserID, taskDone.AssignedToUserName); //没有指定退回节点信息 if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_IsNull; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.noneperformer.error"); return(rmins); } //获取待办任务 var tim = new TransitionInstanceManager(); var nextStepList = tim.GetTargetActivityInstanceList(taskDone.ActivityInstanceID).ToList(); ActivityInstanceEntity runningNode = nextStepList.Count > 0 ? nextStepList[0] : null; if (runningNode == null) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotInRunning; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonerun.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.CreateRuntimeInstanceWithdraw.nottask.error"); return(rmins); } //获取待办任务(模拟待办任务用户做退回处理) var taskToDo = tm.GetTaskViewByActivity(runningNode.ProcessInstanceID, runningNode.ID); runner.UserID = taskToDo.AssignedToUserID; runner.UserName = taskToDo.AssignedToUserName; //获取上一步节点信息 var hasGatewayPassed = false; var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID); var previousStepChecker = new PreviousStepChecker(); var processModel = ProcessModelFactory.Create(taskToDo.ProcessGUID, taskToDo.Version); 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.CreateRuntimeInstanceWithdraw.empty.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.CreateRuntimeInstanceWithdraw.notunique.error"); return(rmins); } } //创建运行时 rmins.TaskView = taskToDo; 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.Withdrawed; sendbackOperation.ProcessInstance = processInstance; sendbackOperation.BackwardFromActivityInstance = runningNode; sendbackOperation.HasGatewayPassed = hasGatewayPassed; sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); sendbackOperation.ProcessModel = processModel; sendbackOperation.IsCancellingBrothersNode = true; //撤销时默认撤销各个并行分支 rmins.SendBackOperation = sendbackOperation; return(rmins); }
/// <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); }
/// <summary> /// 保存泳道流程 /// </summary> /// <param name="file">泳道流程实体</param> internal void SaveProcessFilePool(ProcessFilePool file) { var packageProcessClient = file.ProcessEntityList.Single(a => a.PackageType.Value == (short)PackageTypeEnum.MainProcess); var poolProcessListClient = file.ProcessEntityList.Where(a => a.PackageType.Value == (short)PackageTypeEnum.PoolProcess).ToList(); var session = SessionFactory.CreateSession(); try { session.BeginTrans(); var packageProcessDB = GetByVersion(session.Connection, packageProcessClient.ProcessGUID, packageProcessClient.Version, false, session.Transaction); if (packageProcessDB == null) { //插入主流程,然后插入泳道流 var packageGUID = Guid.NewGuid().ToString(); packageProcessClient.XmlContent = file.XmlContent; packageProcessClient.CreatedDateTime = System.DateTime.Now; var processModelClient = ProcessModelFactory.Create(session.Connection, packageProcessClient.ProcessGUID, packageProcessClient.Version, session.Transaction); SetProcessStartEndType(processModelClient, packageProcessClient, file.XmlContent); var newPackageProcessID = Insert(session.Connection, packageProcessClient, session.Transaction); foreach (var pool in poolProcessListClient) { pool.PackageProcessID = newPackageProcessID; pool.XmlContent = file.XmlContent; var processModelPool = ProcessModelFactory.Create(session.Connection, pool.ProcessGUID, pool.Version, session.Transaction); SetProcessStartEndType(processModelPool, pool, file.XmlContent); Insert(session.Connection, pool, session.Transaction); } } else { var poolProcessListDataBase = GetPoolProcessList(session.Connection, packageProcessDB.ID, session.Transaction); List <int> poolProcessIDs = new List <int>(); foreach (var pool in poolProcessListDataBase) { //多泳道流程变为单一流程 if (poolProcessListClient.Count() == 0) { //删除数据库中所有泳道流程 poolProcessIDs.Add(pool.ID); } else { var item = poolProcessListClient.Find(a => a.ProcessGUID == pool.ProcessGUID && a.Version == pool.Version); if (item == null) { //删除ID列表 poolProcessIDs.Add(pool.ID); } } } //删除图形中不含有的泳道流程 if (poolProcessIDs.Count() > 0) { DeletePoolProcess(session.Connection, packageProcessDB.ID, poolProcessIDs, session.Transaction); } //如果是泳道流程变为单一流程,更新PackageType和PackageProcessID if (poolProcessListClient.Count() == 0) { packageProcessDB.PackageType = null; packageProcessDB.PackageProcessID = null; } //更新主流程,更新或插入泳道流 packageProcessDB.PackageType = (byte)PackageTypeEnum.MainProcess; packageProcessDB.XmlContent = file.XmlContent; packageProcessDB.LastUpdatedDateTime = System.DateTime.Now; var processModelPackageDB = ProcessModelFactory.Create(session.Connection, packageProcessDB.ProcessGUID, packageProcessDB.Version, session.Transaction); SetProcessStartEndType(processModelPackageDB, packageProcessDB, file.XmlContent); Update(session.Connection, packageProcessDB, session.Transaction); foreach (var pool in poolProcessListClient) { var child = GetByVersion(session.Connection, pool.ProcessGUID, pool.Version, false, session.Transaction); if (child == null) { //新增泳道流程 pool.PackageType = (byte)PackageTypeEnum.PoolProcess; pool.PackageProcessID = packageProcessDB.ID; pool.XmlContent = file.XmlContent; pool.CreatedDateTime = System.DateTime.Now; var processModelPoolA = ProcessModelFactory.Create(session.Connection, pool.ProcessGUID, pool.Version, session.Transaction); SetProcessStartEndType(processModelPoolA, pool, file.XmlContent); Insert(session.Connection, pool, session.Transaction); } else { //更新泳道流程 child.ProcessName = pool.ProcessName; child.ProcessCode = pool.ProcessCode; child.Description = pool.Description; child.PackageType = (byte)PackageTypeEnum.PoolProcess; child.XmlContent = file.XmlContent; child.LastUpdatedDateTime = System.DateTime.Now; var processModelPoolChild = ProcessModelFactory.Create(session.Connection, child.ProcessGUID, child.Version, session.Transaction); SetProcessStartEndType(processModelPoolChild, child, file.XmlContent); Update(session.Connection, child, session.Transaction); } } } session.Commit(); } catch (System.Exception ex) { session.Rollback(); throw; } finally { session.Dispose(); } }
/// <summary> /// 获取当前活动实体 /// </summary> /// <param name="processGUID">流程定义GUID</param> /// <param name="version">版本</param> /// <param name="activityGUID">活动GUID</param> /// <returns>活动</returns> public ActivityEntity GetActivityEntity(string processGUID, string version, string activityGUID) { var processModel = ProcessModelFactory.Create(processGUID, version); return(processModel.GetActivity(activityGUID)); }
/// <summary> /// 根据不同退回场景创建运行时管理器 /// </summary> /// <param name="runningActivityInstanceList">运行节点列表</param> /// <param name="sendbackOperation">退回类型</param> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时管理器</returns> private static WfRuntimeManager CreateRuntimeInstanceSendbackByCase( List <ActivityInstanceEntity> runningActivityInstanceList, SendbackOperationTypeEnum sendbackOperation, WfAppRunner runner, ref WfExecutedResult result) { WfRuntimeManager rmins = new WfRuntimeManagerSendBack(); rmins.WfExecutedResult = result = new WfExecutedResult(); ActivityInstanceEntity runningNode = runningActivityInstanceList.Where(x => x.ActivityState == (int)ActivityStateEnum.Running).OrderBy(x => x.ID).FirstOrDefault(); if (runningNode == null) { runningNode = runningActivityInstanceList[0]; } ProcessInstanceEntity processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID); IProcessModel processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var aim = new ActivityInstanceManager(); //以下处理,需要知道上一步是独立节点的信息 //获取上一步流转节点信息,可能经过And, Or等路由节点 var tim = new TransitionInstanceManager(); bool hasGatewayNode = false; var currentNode = runningNode; var lastActivityInstanceList = tim.GetPreviousActivityInstance(currentNode, true, out hasGatewayNode).ToList(); if (lastActivityInstanceList == null || lastActivityInstanceList.Count == 0 || lastActivityInstanceList.Count > 1) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NullOrHasTooMany; result.Message = "当前没有可以退回的节点,或者有多个可以退回的节点,无法选择!"; return(rmins); } TransitionInstanceEntity lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName, runner.AppInstanceID, runner.ProcessGUID); if (lastTaskTransitionInstance.TransitionType == (short)TransitionTypeEnum.Loop) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_IsLoopNode; result.Message = "当前流转是自循环,无需退回!"; return(rmins); } //设置退回节点的相关信息 var previousActivityInstance = lastActivityInstanceList[0]; if (previousActivityInstance.ActivityType == (short)ActivityTypeEnum.StartNode) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_PreviousIsStartNode; result.Message = "上一步是开始节点,无需退回!"; return(rmins); } if (sendbackOperation == SendbackOperationTypeEnum.Normal) { //简单串行模式下的退回 rmins = new WfRuntimeManagerSendBack(); rmins.WfExecutedResult = result = new WfExecutedResult(); rmins.ProcessModel = processModel; rmins.BackwardContext.ProcessInstance = processInstance; rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(previousActivityInstance.ActivityGUID); rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance; rmins.BackwardContext.BackwardToTargetTransitionGUID = hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty; //如果中间有Gateway节点,则没有直接相连的TransitonGUID rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID); rmins.BackwardContext.BackwardFromActivityInstance = runningNode; rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(previousActivityInstance.ActivityName, previousActivityInstance.EndedByUserID, previousActivityInstance.EndedByUserName); //封装AppUser对象 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; rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(previousActivityInstance.ActivityGUID, previousActivityInstance.EndedByUserID, previousActivityInstance.EndedByUserName); rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); return(rmins); } //如果有其它模式,没有处理到,则直接抛出异常 throw new WorkflowException("未知的退回场景,请报告给技术支持人员!"); }
/// <summary> /// 流程返签,先检查约束条件,然后调用wfruntimeinstance执行 /// </summary> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时实例对象</returns> public static WfRuntimeManager CreateRuntimeInstanceReverse(WfAppRunner runner, ref WfExecutedResult result) { var rmins = new WfRuntimeManagerReverse(); rmins.WfExecutedResult = result = new WfExecutedResult(); var pim = new ProcessInstanceManager(); var processInstance = pim.GetProcessInstanceLatest(runner.AppInstanceID, runner.ProcessGUID); if (processInstance == null || processInstance.ProcessState != (short)ProcessStateEnum.Completed) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Reverse_NotInCompleted; result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceReverse.error"); return(rmins); } //用于注册事件时候的流程ID rmins.ProcessInstanceID = processInstance.ID; var tim = new TransitionInstanceManager(); var endTransitionInstance = tim.GetEndTransition(runner.AppName, runner.AppInstanceID, runner.ProcessGUID); var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version); var endActivity = processModel.GetActivity(endTransitionInstance.ToActivityGUID); var aim = new ActivityInstanceManager(); var endActivityInstance = aim.GetById(endTransitionInstance.ToActivityInstanceID); bool hasGatewayNode = false; var npc = new PreviousStepChecker(); var lastTaskActivityInstance = npc.GetPreviousActivityInstanceList(endActivityInstance, false, out hasGatewayNode).ToList()[0]; var lastTaskActivity = processModel.GetActivity(lastTaskActivityInstance.ActivityGUID); //封装返签结束点之前办理节点的任务接收人 rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(lastTaskActivityInstance.ActivityGUID, lastTaskActivityInstance.EndedByUserID, lastTaskActivityInstance.EndedByUserName); rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers); 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; rmins.BackwardContext.ProcessInstance = processInstance; rmins.BackwardContext.BackwardToTaskActivity = lastTaskActivity; rmins.BackwardContext.BackwardToTaskActivityInstance = lastTaskActivityInstance; rmins.BackwardContext.BackwardToTargetTransitionGUID = hasGatewayNode == false ? endTransitionInstance.TransitionGUID : String.Empty; rmins.BackwardContext.BackwardFromActivity = endActivity; rmins.BackwardContext.BackwardFromActivityInstance = endActivityInstance; rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(lastTaskActivityInstance.ActivityName, lastTaskActivityInstance.EndedByUserID, lastTaskActivityInstance.EndedByUserName); return(rmins); }