/// <summary> /// 获取正在运行中的活动实例 /// </summary> /// <param name="query"></param> /// <returns></returns> public IList <ActivityInstanceEntity> GetRunningActivityInstance(TaskQuery query) { var aim = new ActivityInstanceManager(); var list = aim.GetRunningActivityInstanceList(query.AppInstanceID, query.ProcessGUID).ToList(); return(list); }
/// <summary> /// 获取分支实例的个数 /// </summary> /// <param name="splitActivityGUID">活动GUID</param> /// <param name="processInstanceID">流程实例ID</param> /// <returns>实例数目</returns> protected int GetInstanceGatewayCount(string splitActivityGUID, int processInstanceID) { ActivityInstanceManager aim = new ActivityInstanceManager(); return(aim.GetInstanceGatewayCount(splitActivityGUID, processInstanceID)); }
/// <summary> /// 查询实例 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="id">实体主键ID</param> /// <returns>实体</returns> public override T GetInstance <T>(int id) { var aim = new ActivityInstanceManager(); var entity = aim.GetById(Session.Connection, id, Session.Transaction); return(entity as T); }
/// <summary> /// 跳转执行方法 /// </summary> /// <param name="session">会话</param> internal override void ExecuteInstanceImp(IDbSession session) { WfExecutedResult result = base.WfExecutedResult; //创建新任务节点 var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session); nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance, base.BackwardContext.BackwardFromActivityInstance, BackwardTypeEnum.Sendback, base.BackwardContext.BackwardToTargetTransitionGUID, TransitionTypeEnum.Sendback, TransitionFlyingTypeEnum.NotFlying, base.ActivityResource, session); //更新当前办理节点的状态(从准备或运行状态更新为退回状态) var aim = new ActivityInstanceManager(); aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID, base.ActivityResource.AppRunner, session); //构造回调函数需要的数据 result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver; result.Status = WfExecutedStatus.Success; }
/// <summary> /// 撤销处理具体功能实现 /// </summary> /// <param name="session">会话</param> internal override void ExecuteInstanceImp(IDbSession session) { //创建新任务节点 var backMostPreviouslyActivityInstanceID = GetBackwardMostPreviouslyActivityInstanceID(); var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session); nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance, base.BackwardContext.BackwardFromActivityInstance, BackwardTypeEnum.Withdrawed, backMostPreviouslyActivityInstanceID, base.BackwardContext.BackwardToTargetTransitionGUID, TransitionTypeEnum.Withdrawed, TransitionFlyingTypeEnum.NotFlying, base.ActivityResource, session); //普通节点情况下:更新撤销节点的状态(从准备状态更新为撤销状态) var aim = new ActivityInstanceManager(); aim.Withdraw(base.BackwardContext.BackwardFromActivityInstance.ID, base.ActivityResource.AppRunner, session); //构造回调函数需要的数据 WfExecutedResult result = base.WfExecutedResult; result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver; result.Status = WfExecutedStatus.Success; }
/// <summary> /// 获取活动实例数据 /// </summary> /// <param name="activityInstanceID"></param> /// <returns></returns> public ActivityInstanceEntity GetActivityInstance(int activityInstanceID) { var aim = new ActivityInstanceManager(); var instance = aim.GetById(activityInstanceID); return(instance); }
/// <summary> /// 获取流程当前运行节点信息 /// </summary> /// <param name="runner"></param> /// <returns></returns> public ActivityInstanceEntity GetRunningNode(WfAppRunner runner) { var aim = new ActivityInstanceManager(); var entity = aim.GetRunningNode(runner); return(entity); }
/// <summary> /// 判断是否是我的任务 /// </summary> /// <param name="entity"></param> /// <param name="userID"></param> /// <returns></returns> public bool IsMineTask(ActivityInstanceEntity entity, string userID) { var aim = new ActivityInstanceManager(); bool isMine = aim.IsMineTask(entity, userID); return(isMine); }
public bool TurnTask(string taskId, WfAppRunner runner) { TaskManager tim = new TaskManager(_dataAccessor, _loggerFactory); WfTask task = tim.GetTask(taskId); if (task == null) { throw new FapException("任务不存在"); } Performer turner = runner.Turners[0]; ActivityInstanceManager aim = new ActivityInstanceManager(_dataAccessor, _loggerFactory); WfActivityInstance activity = aim.GetByFid(task.ActivityInsUid); activity.AssignedToUserIds = activity.AssignedToUserIds.Replace(runner.UserId, turner.UserId); activity.AssignedToUserNames = activity.AssignedToUserNames.Replace(runner.UserName, turner.UserName); aim.Update(activity); task.ExecutorEmpUid = turner.UserId; task.ExecutorEmpName = turner.UserName; task.UpdateBy = runner.UserId; task.UpdateName = runner.UserName; task.UpdateDate = DateTimeUtils.CurrentDateStr; tim.Update(task); TaskAdviceManager tam = new TaskAdviceManager(_dataAccessor, _applicationContext, _loggerFactory); tam.RecordWhenTurnTask(runner.ProcessUid, runner.CurrNodeId, runner.Comment, turner.UserId, turner.UserName); return(true); }
/// <summary> /// 退回操作的处理逻辑 /// </summary> /// <param name="session">会话</param> internal override void ExecuteInstanceImp(IDbSession session) { var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session); var aim = new ActivityInstanceManager(); var backMostPreviouslyActivityInstanceID = GetBackwardMostPreviouslyActivityInstanceID(); //上一步节点是普通节点的退回处理 nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance, base.BackwardContext.BackwardFromActivityInstance, BackwardTypeEnum.Sendback, backMostPreviouslyActivityInstanceID, base.BackwardContext.BackwardToTargetTransitionGUID, TransitionTypeEnum.Sendback, TransitionFlyingTypeEnum.NotFlying, base.ActivityResource, session); //更新当前办理节点的状态(从准备或运行状态更新为退回状态) aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID, base.ActivityResource.AppRunner, session); //构造回调函数需要的数据 WfExecutedResult result = base.WfExecutedResult; result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver; result.ReturnDataContext = nodeMediatorBackward.ReturnDataContext; result.Status = WfExecutedStatus.Success; }
/// <summary> /// 构造函数 /// </summary> /// <param name="sendbackOperation">退回选项</param> /// <param name="session">数据会话</param> internal NodeSendBack(SendBackOperation sendbackOperation, IDbSession session) { _sendBackOperation = sendbackOperation; _session = session; _activityInstanceManager = new ActivityInstanceManager(); _taskManager = new TaskManager(); _transitionInstanceManager = new TransitionInstanceManager(); }
/// <summary> /// 跳转执行方法 /// </summary> /// <param name="session">会话</param> internal override void ExecuteInstanceImp(IDbSession session) { WfExecutedResult result = base.WfExecutedResult; //回跳类型的处理 if (base.IsBackward == true) { //创建新任务节点 var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session); nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance, base.BackwardContext.BackwardFromActivityInstance, BackwardTypeEnum.Sendback, base.BackwardContext.BackwardToTargetTransitionGUID, TransitionTypeEnum.Sendback, TransitionFlyingTypeEnum.NotFlying, base.ActivityResource, session); //更新当前办理节点的状态(从准备或运行状态更新为退回状态) var aim = new ActivityInstanceManager(); aim.SendBack(base.BackwardContext.BackwardFromActivityInstance.ID, base.ActivityResource.AppRunner, session); //构造回调函数需要的数据 result.BackwardTaskReceiver = base.BackwardContext.BackwardTaskReceiver; result.Status = WfExecutedStatus.Success; } else { var jumpActivityGUID = base.AppRunner.NextActivityPerformers.First().Key; var jumpforwardActivity = base.ProcessModel.GetActivity(jumpActivityGUID); var processInstance = (new ProcessInstanceManager()).GetById(base.RunningActivityInstance.ProcessInstanceID); var jumpforwardExecutionContext = ActivityForwardContext.CreateJumpforwardContext(jumpforwardActivity, base.ProcessModel, processInstance, base.ActivityResource); NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(jumpforwardExecutionContext, session); mediator.Linker.FromActivityInstance = base.RunningActivityInstance; mediator.Linker.ToActivity = jumpforwardActivity; if (mediator is NodeMediatorEnd) { //结束节点的连线转移 mediator.CreateActivityTaskTransitionInstance(jumpforwardActivity, processInstance, base.RunningActivityInstance, WfDefine.WF_XPDL_JUMP_BYPASS_GUID, TransitionTypeEnum.Forward, TransitionFlyingTypeEnum.ForwardFlying, base.ActivityResource, session); } mediator.ExecuteWorkItem(); result.Status = WfExecutedStatus.Success; result.Message = mediator.GetNodeMediatedMessage(); } }
/// <summary> /// 退回操作 /// </summary> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时实例对象</returns> internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner, ref WfExecutedResult result) { WfRuntimeManager rmins = new WfRuntimeManagerSendBack(); rmins.WfExecutedResult = result = new WfExecutedResult(); var aim = new ActivityInstanceManager(); var runningActivityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList(); SendbackOpertaionTypeEnum sendbackOperation = SendbackOpertaionTypeEnum.Default; //当前没有运行状态的节点存在,流程不存在,或者已经结束或取消 if (runningActivityInstanceList == null || runningActivityInstanceList.Count() == 0) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotInRunning; result.Message = "当前没有运行状态的节点存在,流程不存在,或者已经结束或取消"; return(rmins); } if (runningActivityInstanceList.Count() == 1) //如果只有1个运行节点 { var runningNode = runningActivityInstanceList[0]; 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); } if (aim.IsMineTask(runningNode, runner.UserID) == false) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NotMineTask; result.Message = "不是登录用户的任务,无法退回!"; return(rmins); } sendbackOperation = SendbackOpertaionTypeEnum.Normal; } else if (runningActivityInstanceList.Count() > 1) { //有其它非多实例的并行节点,暂时不处理,后期实现该功能 result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Sendback_NullOrHasTooMany; result.Message = "有多个可以退回的节点,而且不是多实例节点,此功能暂时不支持!"; return(rmins); } //根据不同分支场景,创建不同撤销运行时管理器 return(CreateRuntimeInstanceSendbackByCase(runningActivityInstanceList, sendbackOperation, runner, ref result)); }
/// <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 = string.Format("当前应用:{0},实例ID:{1}, 没有完成的流程实例,无法让流程重新运行!", runner.AppName, runner.AppInstanceID); return(rmins); } 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 lastTaskActivityInstance = tim.GetPreviousActivityInstance(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); }
/// <summary> /// 节点对象的完成方法 /// </summary> /// <param name="ActivityInstanceID">活动实例ID</param> /// <param name="runner">运行者</param> /// <param name="session">会话</param> protected virtual void CompleteActivityInstance(int ActivityInstanceID, WfAppRunner runner, IDbSession session) { //设置完成状态 ActivityInstanceManager.Complete(ActivityInstanceID, runner, session); }
/// <summary> /// 设置活动实例的定时作业为完成状态 /// (用于HangFire后台轮询任务) /// </summary> /// <param name="conn">链接</param> /// <param name="activityInstanceID">活动实例ID</param> /// <param name="trans">事务</param> public void SetActivityJobTimerCompleted(IDbConnection conn, int activityInstanceID, IDbTransaction trans) { var aim = new ActivityInstanceManager(); var activityInstance = aim.GetById(conn, activityInstanceID, trans); activityInstance.JobTimerStatus = (short)JobTimerStatusEnum.Completed; activityInstance.JobTimerTreatedDateTime = System.DateTime.Now; aim.Update(conn, activityInstance, trans); }
/// <summary> /// 读取节点的上一步节点信息 /// </summary> /// <param name="runningNode">当前节点</param> /// <param name="isLookUpBackSource">是否退回</param> /// <param name="hasPassedGatewayNode">是否经由路由节点</param> /// <returns>活动实例列表</returns> internal IList <ActivityInstanceEntity> GetPreviousActivityInstanceList(ActivityInstanceEntity runningNode, bool isLookUpBackSource, out bool hasPassedGatewayNode) { hasPassedGatewayNode = false; var tim = new TransitionInstanceManager(); var transitionList = tim.GetTransitionInstanceList(runningNode.AppInstanceID, runningNode.ProcessGUID, runningNode.ProcessInstanceID).ToList(); var backSrcActivityInstanceId = 0; if (isLookUpBackSource == true) { //退回情况下的处理 if (runningNode.MIHostActivityInstanceID != null && runningNode.CompleteOrder.Value == 1) { //多实例的第一个子节点,先找到主节点,再到transition记录表中找到上一步节点 backSrcActivityInstanceId = runningNode.MIHostActivityInstanceID.Value; } else if (runningNode.BackSrcActivityInstanceID != null) { //节点时曾经发生退回的节点 backSrcActivityInstanceId = runningNode.BackSrcActivityInstanceID.Value; } else { backSrcActivityInstanceId = runningNode.ID; } } else { backSrcActivityInstanceId = runningNode.ID; } var aim = new ActivityInstanceManager(); var runningTransitionList = transitionList .Where(o => o.ToActivityInstanceID == backSrcActivityInstanceId) .ToList(); IList <ActivityInstanceEntity> previousActivityInstanceList = new List <ActivityInstanceEntity>(); foreach (var entity in runningTransitionList) { //如果是逻辑节点,则继续查找 if (entity.FromActivityType == (short)ActivityTypeEnum.GatewayNode) { GetPreviousOfGatewayActivityInstance(transitionList, entity.FromActivityInstanceID, previousActivityInstanceList); hasPassedGatewayNode = true; } else { previousActivityInstanceList.Add(aim.GetById(entity.FromActivityInstanceID)); } } return(previousActivityInstanceList); }
/// <summary> /// 获取上一步节点树 /// </summary> /// <param name="runner">运行者</param> /// <param name="hasGatewayPassed">是否经过网关</param> /// <returns>上一步步骤列表</returns> internal IList <NodeView> GetPreviousActivityTree(WfAppRunner runner, out Boolean hasGatewayPassed) { hasGatewayPassed = false; //首先获取当前运行节点信息 var aim = new ActivityInstanceManager(); var runningNode = aim.GetRunningNode(runner); var nodeList = GetPreviousActivityTree(runningNode, out hasGatewayPassed); return(nodeList); }
/// <summary> /// 判断节点是否审批完成,可以进入下一个节点 /// </summary> /// <param name="activityInsUid"></param> /// <returns></returns> public bool NodeIsComplete(string activityInsUid) { bool result = false; ActivityInstanceManager activityInstanceManager = new ActivityInstanceManager(_dataAccessor, _loggerFactory); result = activityInstanceManager.IsComplete(activityInsUid); return(result); }
/// <summary> /// 判断节点是否审批完成,可以进入下一个节点 /// </summary> /// <param name="activityInsUid"></param> /// <returns></returns> public bool NodeIsComplete(string activityInsUid) { bool result = false; ActivityInstanceManager activityInstanceManager = new ActivityInstanceManager(_serviceProvider); result = activityInstanceManager.IsComplete(activityInsUid); return(result); }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="processInstance">流程实例</param> /// <param name="activity">活动</param> /// <param name="runner">执行者</param> protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity, WfProcessInstance processInstance, WfAppRunner runner) { WfActivityInstance entity = ActivityInstanceManager.CreateActivityInstanceObject( processInstance, activity, runner); return(entity); }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="activity">活动</param> /// <param name="processInstance">流程实例</param> /// <param name="runner">运行者</param> protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity, WfProcessInstance processInstance) { ActivityInstanceManager aim = new ActivityInstanceManager(_serviceProvider); this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance, activity, _runner); return(this.GatewayActivityInstance); }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="activity">活动</param> /// <param name="processInstance">流程实例</param> /// <param name="runner">运行者</param> protected WfActivityInstance CreateActivityInstanceObject(ActivityEntity activity, WfProcessInstance processInstance) { ActivityInstanceManager aim = new ActivityInstanceManager(_dataAccessor, _loggerFactory); this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance, activity, _runner); return(this.GatewayActivityInstance); }
/// <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); }
/// <summary> /// 复制多实例子节点数据 /// </summary> /// <param name="plist">执行人员列表</param> /// <param name="mainActivityInstance">主节点</param> /// <param name="session">数据会话</param> private void CloneChildNodeOfMI(PerformerList plist, ActivityInstanceEntity mainActivityInstance, IDbSession session) { //查询已有的子节点列表 var childNodeListOfMI = base.ActivityInstanceManager.GetValidActivityInstanceListOfMI(mainActivityInstance.ID, session); //创建活动实例 ActivityInstanceEntity entity = new ActivityInstanceEntity(); for (short i = 0; i < plist.Count; i++) { var userID = plist[i].UserID; var userName = plist[i].UserName; var isTaskExisted = IsTaskExisted(childNodeListOfMI, userID); if (isTaskExisted == true) { //如果活动或者任务已经存在,则不用创建新活动和任务 continue; } //根据主节点来复制子节点数据 entity = ActivityInstanceManager.CreateActivityInstanceObject(mainActivityInstance); entity.AssignedToUserIDs = userID; entity.AssignedToUserNames = userName; entity.MIHostActivityInstanceID = mainActivityInstance.ID; //并行串行下,多实例子节点的执行顺序设置 if (mainActivityInstance.MergeType == (short)MergeTypeEnum.Sequence) { entity.CompleteOrder = (short)(i + 1); } else if (mainActivityInstance.MergeType == (short)MergeTypeEnum.Parallel) { entity.CompleteOrder = -1; //并行模式下CompleteOrder的优先级一样,所以置为 -1 } //如果是串行会签,只有第一个节点处于运行状态,其它节点挂起 if ((i > 0) && (mainActivityInstance.MergeType.Value == (short)MergeTypeEnum.Sequence)) { entity.ActivityState = (short)ActivityStateEnum.Suspended; } //插入活动实例数据,并返回活动实例ID entity.ID = ActivityInstanceManager.Insert(entity, session); //插入任务数据 base.TaskManager.Insert(entity, plist[i], base.ActivityForwardContext.ActivityResource.AppRunner, session); } }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="processInstance">流程实例</param> /// <param name="activity">活动</param> /// <param name="runner">执行者</param> protected ActivityInstanceEntity CreateActivityInstanceObject(ActivityEntity activity, ProcessInstanceEntity processInstance, WfAppRunner runner) { ActivityInstanceEntity entity = ActivityInstanceManager.CreateActivityInstanceObject(processInstance.AppName, processInstance.AppInstanceID, processInstance.ID, activity, runner); return(entity); }
/// <summary> /// 撤销操作 /// 包括: /// 1) 正常流转 /// 2) 多实例节点流转 /// </summary> /// <param name="runner">执行者</param> /// <param name="result">结果对象</param> /// <returns>运行时实例对象</returns> internal static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner, ref WfExecutedResult result) { WfRuntimeManager rmins = new WfRuntimeManagerWithdraw(); rmins.WfExecutedResult = result = new WfExecutedResult(); var aim = new ActivityInstanceManager(); var runningActivityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList(); WithdrawOpertaionTypeEnum withdrawOperation = WithdrawOpertaionTypeEnum.Default; //当前没有运行状态的节点存在,流程不存在,或者已经结束或取消 if (runningActivityInstanceList == null || runningActivityInstanceList.Count() == 0) { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_NotInReady; result.Message = "当前没有运行状态的节点存在,流程不存在,或者已经结束或取消"; return(rmins); } if (runningActivityInstanceList.Count() == 1) //如果只有1个运行节点 { //先判断节点的状态是否是有效状态 var runningNode = runningActivityInstanceList[0]; if (runningNode.ActivityState != (short)ActivityStateEnum.Ready && runningNode.ActivityState != (short)ActivityStateEnum.Suspended) //只有准备或挂起状态的节点可以撤销 { result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_NotInReady; result.Message = string.Format("无法撤销到上一步,因为要撤销的节点为空,或不在【待办/挂起】状态,当前状态: {0}", runningNode.ActivityState);//,节点状态:{0} runningNode.ActivityState 为空报错20150514 return(rmins); } //当前运行节点是普通节点模式 withdrawOperation = WithdrawOpertaionTypeEnum.Normal; } else if (runningActivityInstanceList.Count() > 1) //有多个并行运行节点存在 { //有其它非多实例的并行节点,暂时不处理,后期实现该功能 result.Status = WfExecutedStatus.Exception; result.ExceptionType = WfExceptionType.Withdraw_HasTooMany; result.Message = "有多个可以撤销回去的节点,而且不是多实例节点,此功能暂时不支持!"; return(rmins); } //根据不同分支场景,创建不同撤销运行时管理器 return(CreateRuntimeInstanceWithdrawByCase(runningActivityInstanceList, withdrawOperation, runner, ref result)); }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="activity">活动</param> /// <param name="processInstance">流程实例</param> /// <param name="runner">运行者</param> protected ActivityInstanceEntity CreateActivityInstanceObject(ActivityEntity activity, ProcessInstanceEntity processInstance, WfAppRunner runner) { ActivityInstanceManager aim = new ActivityInstanceManager(); this.GatewayActivityInstance = aim.CreateActivityInstanceObject(processInstance.AppName, processInstance.AppInstanceID, processInstance.ID, activity, runner); return this.GatewayActivityInstance; }
/// <summary> /// 更新当前运行节点状态为退回状态 /// </summary> /// <param name="session">会话</param> private void SetRunningNodeSendBack(IDbSession session) { //更新当前任务记录为退回状态 var tm = new TaskManager(); tm.SendBack(base.TaskView.TaskID, base.SendBackOperation.ActivityResource.AppRunner, session); //更新当前办理节点的状态(从准备或运行状态更新为退回状态) var aim = new ActivityInstanceManager(); aim.SendBack(base.SendBackOperation.BackwardFromActivityInstance.ID, base.SendBackOperation.ActivityResource.AppRunner, session); }
/// <summary> /// 创建节点对象 /// </summary> /// <param name="processInstance">流程实例</param> internal ActivityInstanceEntity CreateActivityInstanceObject(ProcessInstanceEntity processInstance, WfLogonUser logonUser) { ActivityInstanceManager aim = new ActivityInstanceManager(); this.ActivityInstance = aim.CreateActivityInstanceObject(processInstance.AppName, processInstance.AppInstanceID, processInstance.ProcessInstanceGUID, Activity, logonUser); AfterActivityInstanceObjectCreated(); return(this.ActivityInstance); }