/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <param name="dataContext"></param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode)
{
return new NodeMediatorStart(forwardContext, session);
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode)
{
//加签节点特殊处理
if (forwardContext.Activity.ActivityTypeDetail.ComplexType == Xpdl.ComplexTypeEnum.SignForward)
{
//加签的动态变量传入
if (forwardContext.ActivityResource.DynamicVariables != null
&& !string.IsNullOrEmpty(forwardContext.ActivityResource.DynamicVariables["SignForwardType"]))
{
return new NodeMediatorSignForward(forwardContext, session);
}
else
{
return new NodeMediatorTask(forwardContext, session);
}
}
else
return new NodeMediatorTask(forwardContext, session);
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
return new NodeMediatorSubProcess(forwardContext, session);
}
else
{
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
}
/// <summary>
/// 向前流转时的NodeMediator的构造函数
/// </summary>
/// <param name="forwardContext"></param>
/// <param name="session"></param>
internal NodeMediator(ActivityForwardContext forwardContext, IDbSession session)
{
_activityForwardContext = forwardContext;
_session = session;
_processModel = forwardContext.ProcessModel;
Linker.FromActivity = forwardContext.Activity;
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="session">会话</param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode) //开始节点
{
return(new NodeMediatorStart(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode) //任务节点
{
return(new NodeMediatorTask(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
return(new NodeMediatorSubProcess(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.EndNode)
{
return(new NodeMediatorEnd(forwardContext, session));
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("nodemediatorfactory.CreateNodeMediator.uncertain.warn",
forwardContext.Activity.ActivityType.ToString()));
}
}
/// <summary>
/// 启动执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
//构造流程实例
var processInstance = new ProcessInstanceManager()
.CreateNewProcessInstanceObject(base.AppRunner, base.ProcessModel.ProcessEntity,
base.ParentProcessInstance,
base.InvokedSubProcessNode.ActivityInstance);
//构造活动实例
//1. 获取开始节点活动
var startActivity = base.ProcessModel.GetStartActivity();
var startExecutionContext = ActivityForwardContext.CreateStartupContext(base.ProcessModel,
processInstance,
startActivity,
base.ActivityResource);
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(startExecutionContext, session);
mediator.Linker.FromActivityInstance = RunningActivityInstance;
mediator.ExecuteWorkItem();
//构造回调函数需要的数据
WfExecutedResult result = base.WfExecutedResult;
result.ProcessInstanceIDStarted = processInstance.ID;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 跳转执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
WfExecutedResult result = base.WfExecutedResult;
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);
jumpforwardExecutionContext.FromActivityInstance = base.RunningActivityInstance;
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>
/// 向前流转时的NodeMediator的构造函数
/// </summary>
/// <param name="forwardContext"></param>
/// <param name="session"></param>
internal NodeMediator(ActivityForwardContext forwardContext, IDbSession session)
{
_activityForwardContext = forwardContext;
_session = session;
_processModel = forwardContext.ProcessModel;
Linker.FromActivity = forwardContext.Activity;
}
/// <summary>
/// 运行执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
try
{
var runningExecutionContext = ActivityForwardContext.CreateRunningContext(base.TaskView,
base.ProcessModel,
base.ActivityResource);
//执行节点
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(runningExecutionContext, session);
mediator.Linker.FromActivityInstance = RunningActivityInstance;
mediator.ExecuteWorkItem();
//构造回调函数需要的数据
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Success;
result.Message = mediator.GetNodeMediatedMessage();
}
catch (WfRuntimeException rx)
{
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = rx.Message;
throw rx;
}
catch (System.Exception ex)
{
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = ex.Message;
throw ex;
}
}
/// <summary>
/// 运行执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
var result = base.WfExecutedResult;
result.ProcessInstanceIDStarted = RunningActivityInstance.ProcessInstanceID;
try
{
//创建运行时上下文
ActivityForwardContext runningExecutionContext = null;
if (base.TaskView != null)
{
//有TaskID的任务类型执行上下文
runningExecutionContext = ActivityForwardContext.CreateRunningContextByTask(base.TaskView,
base.ProcessModel,
base.ActivityResource,
false,
session);
}
else
{
//Interrupt事件类型的活动执行上下文
runningExecutionContext = ActivityForwardContext.CreateRunningContextByActivity(base.RunningActivityInstance,
base.ProcessModel,
base.ActivityResource,
false,
session);
}
//执行流程运行事件
OnProcessRunning(session);
//执行节点流转过程
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(runningExecutionContext, session);
mediator.Linker.FromActivityInstance = RunningActivityInstance;
mediator.ExecuteWorkItem();
//执行流程完成事件
OnProcessCompleted(session);
//构造回调函数需要的数据
result.Status = WfExecutedStatus.Success;
result.Message = mediator.GetNodeMediatedMessage();
}
catch (WfRuntimeException rx)
{
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = rx.Message;
throw;
}
catch (System.Exception ex)
{
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = ex.Message;
throw;
}
}
/// <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>
/// 向前流转时的NodeMediator的构造函数
/// </summary>
/// <param name="forwardContext">前进上下文</param>
/// <param name="session">Session</param>
internal NodeMediator(ActivityForwardContext forwardContext, WfAppRunner appRunner, IDbContext dbContext, ILoggerFactory loggerFactory)
{
_activityForwardContext = forwardContext;
AppRunner = appRunner;
_dataAccessor = dbContext;
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger <NodeMediator>();
Linker.FromActivity = forwardContext.Activity;
}
/// <summary>
/// 调用外部业务应用的程序方法
/// </summary>
/// <param name="session">数据会话</param>
/// <param name="eventType">事件类型</param>
/// <param name="context">活动上下文</param>
internal static void InvokeExternalDelegate(IDbSession session,
EventFireTypeEnum eventType,
ActivityForwardContext context)
{
InvokeExternalDelegate(session, eventType,
context.ActivityResource.AppRunner.DelegateEventList,
context.FromActivityInstance.ID,
context.Activity.ActivityCode,
context.ActivityResource);
}
/// <summary>
/// 向前流转时的NodeMediator的构造函数
/// </summary>
/// <param name="forwardContext">前进上下文</param>
/// <param name="session">Session</param>
internal NodeMediator(ActivityForwardContext forwardContext, WfAppRunner appRunner, IServiceProvider serviceProvider)
{
_activityForwardContext = forwardContext;
_serviceProvider = serviceProvider;
AppRunner = appRunner;
_dataAccessor = _serviceProvider.GetService <IDbContext>();
_loggerFactory = _serviceProvider.GetService <ILoggerFactory>();
_logger = _loggerFactory.CreateLogger <NodeMediator>();
Linker.FromActivity = forwardContext.Activity;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="forwardContext">上下文</param>
/// <param name="eActivity">活动</param>
/// <param name="processModel">流程模型</param>
/// <param name="session">会话</param>
internal NodeMediatorEvent(ActivityForwardContext forwardContext,
ActivityEntity eActivity,
IProcessModel processModel,
IDbSession session)
{
_activityFowardContext = forwardContext;
_eventActivity = eActivity;
_processModel = processModel;
_session = session;
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <param name="dataContext"></param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode)
return new NodeMediatorStart(forwardContext, session);
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode)
return new NodeMediatorTask(forwardContext, session);
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
return new NodeMediatorSubProcess(forwardContext, session);
else
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
/// <summary>
/// 运行执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
var result = base.WfExecutedResult;
result.ProcessInstanceIDStarted = RunningActivityInstance.ProcessInstanceID;
try
{
//创建运行时上下文
var runningExecutionContext = ActivityForwardContext.CreateRunningContext(base.TaskView,
base.ProcessModel,
base.ActivityResource,
false,
session);
//----> 节点开始流转，调用活动开始执行的委托事件
DelegateExecutor.InvokeExternalDelegate(session,
EventFireTypeEnum.OnActivityExecuting,
runningExecutionContext);
//执行节点流转过程
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(runningExecutionContext, session);
mediator.Linker.FromActivityInstance = RunningActivityInstance;
mediator.ExecuteWorkItem();
//----> 节点流转完成后，调用活动完成执行的委托事件
DelegateExecutor.InvokeExternalDelegate(session,
EventFireTypeEnum.OnActivityExecuted,
runningExecutionContext);
//构造回调函数需要的数据
result.Status = WfExecutedStatus.Success;
result.Message = mediator.GetNodeMediatedMessage();
}
catch (WfRuntimeException rx)
{
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = rx.Message;
throw rx;
}
catch (System.Exception ex)
{
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.RunApp_RuntimeError;
result.Message = ex.Message;
throw ex;
}
}
/// <summary>
/// 创建结束事件节点处理类实例
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="endActivity">节点</param>
/// <param name="session">会话</param>
/// <returns>节点处理实例</returns>
internal static NodeMediator CreateNodeMediatorEnd(ActivityForwardContext forwardContext,
ActivityEntity endActivity,
IDbSession session)
{
if (endActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.None)
{
return(new NodeMediatorEnd(forwardContext, session));
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("nodemediatorfactory.CreateNodeMediator.uncertain.warn",
string.Format("ActivityType:{0},trigger:{1}", endActivity.ActivityType.ToString(),
endActivity.ActivityTypeDetail.TriggerType)
));
}
}
/// <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>
/// 调用外部业务应用的程序方法
/// </summary>
/// <param name="session">数据会话</param>
/// <param name="eventType">事件类型</param>
/// <param name="context">活动上下文</param>
internal static void InvokeExternalDelegate(IDbSession session,
EventFireTypeEnum eventType,
ActivityForwardContext context)
{
var delegateContext = new DelegateContext
{
AppInstanceID = context.ProcessInstance.AppInstanceID,
ProcessGUID = context.ProcessInstance.ProcessGUID,
ProcessInstanceID = context.ProcessInstance.ID,
ActivityGUID = context.FromActivityInstance.ActivityGUID,
ActivityName = context.Activity.ActivityName,
ActivityCode = context.Activity.ActivityCode,
ActivityResource = context.ActivityResource
};
InvokeExternalDelegate(session, eventType,
context.ActivityResource.AppRunner.DelegateEventList,
delegateContext);
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="session">会话</param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode) //开始节点
{
return(new NodeMediatorStart(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode) //任务节点
{
return(new NodeMediatorTask(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
return(new NodeMediatorSubProcess(forwardContext, session));
}
else
{
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
}
/// <summary>
/// 调用外部业务应用的程序方法
/// </summary>
/// <param name="session">数据会话</param>
/// <param name="eventType">事件类型</param>
/// <param name="currentActivity">当前活动节点</param>
/// <param name="context">活动上下文</param>
internal static void InvokeExternalDelegate(IDbSession session,
EventFireTypeEnum eventType,
ActivityEntity currentActivity,
ActivityForwardContext context)
{
//默认为linker.FromActivity表示执行当前运行节点
//linker.ToActivity != null 为运行事件类型的节点
var delegateContext = new DelegateContext
{
AppInstanceID = context.ProcessInstance.AppInstanceID,
ProcessGUID = context.ProcessInstance.ProcessGUID,
ProcessInstanceID = context.ProcessInstance.ID,
ActivityGUID = currentActivity.ActivityGUID,
ActivityName = currentActivity.ActivityName,
ActivityCode = currentActivity.ActivityCode,
ActivityResource = context.ActivityResource
};
InvokeExternalDelegate(session, eventType,
context.ActivityResource.AppRunner.DelegateEventList,
delegateContext);
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="session">会话</param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext, WfAppRunner runner, IServiceProvider serviceProvider)
{
var activityType = forwardContext.Activity.ActivityType;
if (activityType == ActivityTypeEnum.StartNode) //开始节点
{
return(new NodeMediatorStart(forwardContext, runner, serviceProvider));
}
else if (activityType == ActivityTypeEnum.TaskNode || activityType == ActivityTypeEnum.TimerNode || activityType == ActivityTypeEnum.SignNode) //任务节点
{
return(new NodeMediatorTask(forwardContext, runner, serviceProvider));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//return new NodeMediatorSubProcess(forwardContext, session);
}
else
{
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
return(null);
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="processInstance"></param>
/// <param name="activity"></param>
/// <param name="activityResource"></param>
/// <param name="dataContext"></param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode)
{
return(new NodeMediatorStart(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode)
{
//加签节点特殊处理
if (forwardContext.Activity.ActivityTypeDetail.ComplexType == Xpdl.ComplexTypeEnum.SignForward)
{
//加签的动态变量传入
if (forwardContext.ActivityResource.DynamicVariables != null &&
!string.IsNullOrEmpty(forwardContext.ActivityResource.DynamicVariables["SignForwardType"]))
{
return(new NodeMediatorSignForward(forwardContext, session));
}
else
{
return(new NodeMediatorTask(forwardContext, session));
}
}
else
{
return(new NodeMediatorTask(forwardContext, session));
}
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
return(new NodeMediatorSubProcess(forwardContext, session));
}
else
{
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
}
/// <summary>
/// 加签执行方法
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
//根据加签类型选项，生成新的ActivityInstance记录
//加签类型有前加签，后加签和并加签
try
{
var signforwardExecutionContext = ActivityForwardContext.CreateRunningContext(base.TaskView,
base.ProcessModel,
base.ActivityResource,
false,
session);
NodeMediator mediator = NodeMediatorFactory.CreateNodeMediator(signforwardExecutionContext, session);
mediator.ExecuteWorkItem();
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Success;
result.Message = mediator.GetNodeMediatedMessage();
}
catch (WfRuntimeException rx)
{
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.SignForward_RuntimeError;
result.Message = rx.Message;
throw rx;
}
catch (System.Exception ex)
{
var result = base.WfExecutedResult;
result.Status = WfExecutedStatus.Failed;
result.ExceptionType = WfExceptionType.SignForward_RuntimeError;
result.Message = ex.Message;
throw ex;
}
}
internal NodeMediatorStart(ActivityForwardContext forwardContext, IDbSession session)
: base(forwardContext, session)
{
}
internal NodeMediatorEnd(ActivityForwardContext forwardContext, IDbSession session)
: base(forwardContext, session)
{
}
internal NodeMediatorStart(ActivityForwardContext forwardContext, WfAppRunner appRunner, IServiceProvider serviceProvider)
: base(forwardContext, appRunner, serviceProvider)
{
}
internal NodeMediatorMISignTogether(ActivityForwardContext forwardContext, IDbSession session)
: base(forwardContext, session)
{
}
internal NodeMediatorEnd(ActivityForwardContext forwardContext, WfAppRunner runner, IDbContext dbContext, ILoggerFactory loggerFactory)
: base(forwardContext, runner, dbContext, loggerFactory)
{
}
internal NodeMediatorIntermediate(ActivityForwardContext forwardContext, ActivityEntity activity,
IProcessModel processModel, IDbSession session)
: base(forwardContext, activity, processModel, session)
{
}
/// <summary>
/// 创建节点执行器的抽象类
/// </summary>
/// <param name="forwardContext">活动上下文</param>
/// <param name="session">会话</param>
/// <returns></returns>
internal static NodeMediator CreateNodeMediator(ActivityForwardContext forwardContext,
IDbSession session)
{
if (forwardContext.Activity.ActivityType == ActivityTypeEnum.StartNode) //开始节点
{
return(new NodeMediatorStart(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.TaskNode) //任务节点
{
return(new NodeMediatorTask(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.MultipleInstanceNode) //多实例节点
{
if (forwardContext.FromActivityInstance.MIHostActivityInstanceID != null)
{
if (forwardContext.Activity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignTogether) //会签子节点
{
return(new NodeMediatorMISignTogether(forwardContext, session));
}
else if (forwardContext.Activity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignForward) //加签子节点
{
return(new NodeMediatorMISignForward(forwardContext, session));
}
else
{
throw new ApplicationException("未知的多实例节点类型！");
}
}
else if (forwardContext.FromActivityInstance.MIHostActivityInstanceID == null &&
forwardContext.Activity.ActivityTypeDetail.ComplexType == ComplexTypeEnum.SignForward) //加签主节点的分发操作
{
//加签的动态变量传入
var controlParamSheet = forwardContext.ActivityResource.AppRunner.ControlParameterSheet;
if (controlParamSheet != null)
{
if (!string.IsNullOrEmpty(controlParamSheet.SignForwardType) &&
controlParamSheet.SignForwardType.ToUpper() != "NONE")
{
return(new NodeMediatorSignForward(forwardContext, session));
}
else
{
return(new NodeMediatorTask(forwardContext, session));
}
}
else
{
throw new ApplicationException("加签类型的动态变量未传入，不能确定加签的子类型！");
}
}
else
{
throw new ApplicationException("未知的多实例节点类型！");
}
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
return(new NodeMediatorSubProcess(forwardContext, session));
}
else if (forwardContext.Activity.ActivityType == ActivityTypeEnum.EndNode)
{
return(new NodeMediatorEnd(forwardContext, session));
}
else
{
throw new ApplicationException(string.Format("不明确的节点类型: {0}", forwardContext.Activity.ActivityType.ToString()));
}
}
internal NodeMediatorEnd(ActivityForwardContext forwardContext, WfAppRunner runner, IServiceProvider serviceProvider)
: base(forwardContext, runner, serviceProvider)
{
}
