/// <summary>
/// 创建Gateway节点处理类实例
/// </summary>
/// <param name="gActivity">节点</param>
/// <param name="processModel">流程模型类</param>
/// <param name="session">会话</param>
/// <returns>Gateway节点处理实例</returns>
internal static NodeMediatorGateway CreateNodeMediatorGateway(ActivityEntity gActivity,
IProcessModel processModel,
IDbSession session)
{
NodeMediatorGateway nodeMediator = null;
if (gActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
nodeMediator = new NodeMediatorAndSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrSplit)
{
nodeMediator = new NodeMediatorOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
nodeMediator = new NodeMediatorXOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndJoin)
{
nodeMediator = new NodeMediatorAndJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrJoin)
{
nodeMediator = new NodeMediatorOrJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrJoin)
{
nodeMediator = new NodeMediatorXOrJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.EOrJoin)
{
nodeMediator = new NodeMediatorEOrJoin(gActivity, processModel, session);
}
else
{
throw new XmlDefinitionException(LocalizeHelper.GetEngineMessage("nodemediatorfactory.CreateNodeMediatorGateway.uncertaingateway.warn",
gActivity.GatewayDirectionType.ToString()));
}
}
else
{
throw new XmlDefinitionException(LocalizeHelper.GetEngineMessage("nodemediatorfactory.CreateNodeMediatorGateway.uncertain.warn",
gActivity.ActivityType.ToString()));
}
return(nodeMediator);
}
/// <summary>
/// 后期当前运行接的的上一步节点列表
/// （包括多实例节点类型）
/// </summary>
/// <param name="runningNode">运行节点</param>
/// <param name="processModel">流程模型</param>
/// <param name="hasGatewayPassed">是否经过网关节点</param>
/// <returns>上一步活动列表</returns>
internal IList <ActivityEntity> GetPreviousActivityList(ActivityInstanceEntity runningNode,
IProcessModel processModel,
out Boolean hasGatewayPassed)
{
var isOfMultipleInstanceNode = false;
IList <ActivityEntity> activityList = new List <ActivityEntity>();
//判断当前节点是否是多实例节点
if (runningNode.MIHostActivityInstanceID != null)
{
if (runningNode.CompleteOrder > 1)
{
//多实例串行节点的中间节点，其上一步就是completeorder-1的节点
isOfMultipleInstanceNode = true;
}
else if (runningNode.CompleteOrder == 1 ||
runningNode.CompleteOrder == -1)
{
//第一种条件：只有串行模式下有CompleteOrder的值为 1
//串行模式多实例的第一个执行节点，此时可退回的节点是主节点的上一步
//第一种条件：只有并行模式下有CompleteOrder的值为 -1
//并行节点，此时可退回的节点是主节点的上一步
;
}
else
{
throw new ApplicationException("无效的节点CompleteOrder数值！");
}
}
//返回前置节点列表
hasGatewayPassed = false;
if (isOfMultipleInstanceNode == true)
{
//已经是中间节点，只能退回到上一步多实例子节点
var entity = GetPreviousOfMultipleInstanceNode(runningNode.MIHostActivityInstanceID.Value,
runningNode.ID,
runningNode.CompleteOrder.Value);
var activity = processModel.GetActivity(entity.ActivityGUID);
activityList.Add(activity);
}
else
{
activityList = processModel.GetPreviousActivityList(runningNode.ActivityGUID, out hasGatewayPassed);
}
return(activityList);
}
/// <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="taskView"></param>
/// <param name="processModel">流程模型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="isNotParsedByTransition">非解析流转</param>
/// <param name="session">数据会话</param>
private ActivityForwardContext(TaskViewEntity taskView,
IProcessModel processModel,
ActivityResource activityResource,
Boolean isNotParsedByTransition,
IDbSession session)
{
TaskID = taskView.TaskID;
//check task condition has load activity instance
FromActivityInstance = (new ActivityInstanceManager()).GetById(session.Connection, taskView.ActivityInstanceID, session.Transaction);
ProcessInstance = (new ProcessInstanceManager()).GetById(session.Connection, taskView.ProcessInstanceID, session.Transaction);
Activity = processModel.GetActivity(taskView.ActivityGUID);
ProcessModel = processModel;
ActivityResource = activityResource;
IsNotParsedByTransition = isNotParsedByTransition;
}
public ForecasterSheduled(ITelegram messenger,
IProcessModel processModel,
IDirectoryManager directoryManager,
IFileManager fileManager,
IPythonExec pythonExec,
IUtility utility,
IRequests requests)
{
_messenger = messenger;
_processModel = processModel;
_fileManager = fileManager;
_directoryManager = directoryManager;
_pythonExec = pythonExec;
_utility = utility;
_requestHelper = requests;
}
public Forecaster(IProcessModel processModel,
IDirectoryManager directoryManager,
IFileManager fileManager,
IPythonExec pythonExec,
IUtility utility,
IRequests requests,
ILoggerFactory logger)
{
_processModel = processModel;
_fileManager = fileManager;
_directoryManager = directoryManager;
_pythonExec = pythonExec;
_utility = utility;
_requestHelper = requests;
_logger = logger.CreateLogger("Forecasts");
}
/// <summary>
/// 创建中间事件节点处理类实例
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="eActivity">节点</param>
/// <param name="processModel">流程模型类</param>
/// <param name="session">会话</param>
/// <returns>Gateway节点处理实例</returns>
internal static NodeMediatorEvent CreateNodeMediatorEvent(ActivityForwardContext forwardContext,
ActivityEntity eActivity,
IProcessModel processModel,
IDbSession session)
{
NodeMediatorEvent nodeMediator = null;
if (eActivity.ActivityType == ActivityTypeEnum.IntermediateNode)
{
nodeMediator = new NodeMediatorIntermediate(forwardContext, eActivity, processModel, session);
}
else
{
throw new XmlDefinitionException(string.Format("不明确的节点类型！{0}", eActivity.ActivityType.ToString()));
}
return(nodeMediator);
}
/// <summary>
/// 创建中间事件节点处理类实例
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="eActivity">节点</param>
/// <param name="processModel">流程模型类</param>
/// <param name="session">会话</param>
/// <returns>Gateway节点处理实例</returns>
internal static NodeMediatorEvent CreateNodeMediatorEvent(ActivityForwardContext forwardContext,
ActivityEntity eActivity,
IProcessModel processModel,
IDbSession session)
{
NodeMediatorEvent nodeMediator = null;
if (eActivity.ActivityType == ActivityTypeEnum.IntermediateNode)
{
nodeMediator = new NodeMediatorIntermediate(forwardContext, eActivity, processModel, session);
}
else
{
throw new XmlDefinitionException(LocalizeHelper.GetEngineMessage("nodemediatorfactory.CreateNodeMediatorEvent.uncertain.warn",
eActivity.ActivityType.ToString()));
}
return(nodeMediator);
}
/// <summary>
/// 创建Gateway节点处理类实例
/// </summary>
/// <param name="gActivity">节点</param>
/// <param name="processModel">流程模型类</param>
/// <param name="session">会话</param>
/// <returns>Gateway节点处理实例</returns>
internal static NodeMediatorGateway CreateGatewayNodeMediator(ActivityEntity gActivity,
IProcessModel processModel,
IDbSession session)
{
NodeMediatorGateway nodeMediator = null;
if (gActivity.ActivityType == ActivityTypeEnum.GatewayNode)
{
if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndSplit)
{
nodeMediator = new NodeMediatorAndSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrSplit)
{
nodeMediator = new NodeMediatorOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit)
{
nodeMediator = new NodeMediatorXOrSplit(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.AndJoin)
{
nodeMediator = new NodeMediatorAndJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.OrJoin)
{
nodeMediator = new NodeMediatorOrJoin(gActivity, processModel, session);
}
else if (gActivity.GatewayDirectionType == GatewayDirectionEnum.XOrJoin)
{
nodeMediator = new NodeMediatorXOrJoin(gActivity, processModel, session);
}
else
{
throw new XmlDefinitionException(string.Format("不明确的节点分支Gateway类型！{0}", gActivity.GatewayDirectionType.ToString()));
}
}
else
{
throw new XmlDefinitionException(string.Format("不明确的节点类型！{0}", gActivity.ActivityType.ToString()));
}
return(nodeMediator);
}
/// <summary>
/// 创建ActivitySchedule
/// </summary>
/// <param name="splitJoinType"></param>
/// <returns></returns>
internal static NextActivityScheduleBase CreateActivitySchedule(IProcessModel processModel,
GatewaySplitJoinTypeEnum splitJoinType)
{
NextActivityScheduleBase activitySchedule = null;
if (splitJoinType == GatewaySplitJoinTypeEnum.Split)
{
activitySchedule = new NextActivityScheduleSplit(processModel);
}
else if (splitJoinType == GatewaySplitJoinTypeEnum.Join)
{
activitySchedule = new NextActivityScheduleJoin(processModel);
}
else
{
throw new Exception("未知的splitJoinType!");
}
return(activitySchedule);
}
/// <summary>
/// 创建ActivitySchedule
/// </summary>
/// <param name="processModel">流程模型</param>
/// <param name="splitJoinType">分支合并类型</param>
/// <returns>下一步调度类</returns>
internal static NextActivityScheduleBase CreateActivitySchedule(IProcessModel processModel,
GatewaySplitJoinTypeEnum splitJoinType)
{
NextActivityScheduleBase activitySchedule = null;
if (splitJoinType == GatewaySplitJoinTypeEnum.Split)
{
activitySchedule = new NextActivityScheduleSplit(processModel);
}
else if (splitJoinType == GatewaySplitJoinTypeEnum.Join)
{
activitySchedule = new NextActivityScheduleJoin(processModel);
}
else
{
//未知的splitJoinType
throw new Exception(LocalizeHelper.GetEngineMessage("nextactivityschedulefactory.unknownnodetype"));
}
return(activitySchedule);
}
/// <summary>
/// 设置流程的启动类型
/// </summary>
/// <param name="processModel">流程模型</param>
/// <param name="entity">流程实体</param>
/// <param name="xmlConent">XML内容</param>
private void SetProcessStartEndType(IProcessModel processModel, ProcessEntity entity, string xmlConent)
{
//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);
}
internal NodeMediatorGateway(ActivityEntity gActivity, IProcessModel processModel, IDbSession session)
{
_gatewayActivity = gActivity;
_processModel = processModel;
_session = session;
}
/// <summary>
/// 获取下一步的执行人
/// </summary>
/// <returns></returns>
public PerformerList GetPerformerOfNextStep(string processId, string nodeId, string billUid)
{
_processModel = new ProcessModel(_dataAccessor, _loggerFactory, processId, billUid);
return(_processModel.GetActivityPerformers(nodeId));
}
public DeliveryMenEvent(DeliveryMen deliveryMen)
{
_deliveryMen = deliveryMen;
deliveryMenProcess = new DeliveryMenProcess(_deliveryMen);
}
internal NodeMediatorXOrSplit(ActivityEntity activity, IProcessModel processModel, IDbSession session)
: base(activity, processModel, session)
{
}
/// <summary>
/// 创建任务执行上下文对象
/// </summary>
/// <param name="task"></param>
/// <param name="processModel"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateRunningContext(WfTask task,
IProcessModel processModel, WfProcessInstance processInstance, WfActivityInstance fromActivityInstance)
{
return(new ActivityForwardContext(task, processModel, processInstance, fromActivityInstance));
}
/// <summary>
/// 启动流程的上下文对象
/// </summary>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateStartupContext(IProcessModel processModel,
WfProcessInstance processInstance,
ActivityEntity activity)
{
return(new ActivityForwardContext(processModel, processInstance, activity));
}
/// <summary>
/// 创建流程跳转上下文对象
/// </summary>
/// <param name="jumpforwardActivity"></param>
/// <param name="processModel"></param>
/// <param name="processInstance"></param>
/// <param name="activityResource"></param>
/// <returns></returns>
internal static ActivityForwardContext CreateJumpforwardContext(ActivityEntity jumpforwardActivity,
IProcessModel processModel,
WfProcessInstance processInstance)
{
return(new ActivityForwardContext(processModel, processInstance, jumpforwardActivity));
}
internal NextActivityScheduleBase(IProcessModel processModel)
{
_processModel = processModel;
}
internal NodeMediatorAndJoinMI(ActivityEntity activity, IProcessModel processModel, IDbSession session)
: base(activity, processModel, session)
{
}
/// <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("未知的撤销场景，请报告给技术支持人员！");
}
private static WfRuntimeManager CreateRuntimeInstanceSendbackByCase(ActivityInstanceEntity runningNode,
IProcessModel processModel,
ProcessInstanceEntity processInstance,
IList <ActivityEntity> sendbackPreviousActivityList,
Boolean hasGatewayPassed,
SendbackOperationTypeEnum sendbackOperation,
WfAppRunner runner,
ref WfExecutedResult result)
{
WfRuntimeManager rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
var aim = new ActivityInstanceManager();
//以下处理，需要知道上一步是独立节点的信息
var tim = new TransitionInstanceManager();
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 previousActivityGUID = sendbackPreviousActivityList[0].ActivityGUID;
var previousActivityInstance = aim.GetActivityInstanceLatest(runner.AppInstanceID, runner.ProcessGUID, previousActivityGUID);
//普通模式的退回
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 =
hasGatewayPassed == 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);
//封装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("未知的退回场景，请报告给技术支持人员！");
}
internal NextActivityScheduleJoin(IProcessModel processModel) :
base(processModel)
{
}
internal NextActivityScheduleIntermediate(IProcessModel processModel) :
base(processModel)
{
}
/// <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("未知的退回场景，请报告给技术支持人员！");
}
internal NodeMediatorXOrSplit(ActivityEntity activity, IProcessModel processModel, WfAppRunner runner, IDbContext dbContext, ILoggerFactory loggerFactory)
: base(activity, processModel, runner, dbContext, loggerFactory)
{
}
internal NodeMediatorAndJoin(ActivityEntity activity, IProcessModel processModel, WfAppRunner runner, IServiceProvider serviceProvider)
: base(activity, processModel, runner, serviceProvider)
{
}
/// <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);
}
