/// <summary>
/// 查询实例
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="id">实体主键ID</param>
/// <returns>实体</returns>
public override T GetInstance <T>(int id)
{
var pim = new ProcessInstanceManager();
var entity = pim.GetById(id);
return(entity as T);
}
/// <summary>
/// 启动流程
/// </summary>
/// <param name="user"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="nextActivityGUID"></param>
/// <returns></returns>
public WfRuntimeManager GetRuntimeInstanceStartup(WfAppRunner runner)
{
//检查流程是否可以被启动
var pim = new ProcessInstanceManager();
var processInstance = pim.GetRunningProcess(runner.AppName, runner.AppInstanceID, runner.ProcessGUID);
if (processInstance != null)
{
throw new WfRuntimeException("当前应用已经有流程实例在运行中，除非终止或取消流程，否则流程不能被再次启动。");
}
this.AppRunner = runner;
//获取流程第一个可办理节点
this.ProcessModel = new ProcessModel(runner.ProcessGUID);
var firstActivity = this.ProcessModel.GetFirstActivity();
this.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
this.ActivityResource = new ActivityResource(runner.UserID, runner.UserName, this.AppRunner.NextActivityPerformers);
return(this);
}
/// <summary>
/// 获取流程实例数据
/// </summary>
/// <param name="appInstanceID">业务实例ID</param>
/// <returns>流程实例实体</returns>
public IList <ProcessInstanceEntity> GetProcessInstance(string appInstanceID)
{
var pim = new ProcessInstanceManager();
var list = pim.GetProcessInstance(appInstanceID).ToList();
return(list);
}
/// <summary>
/// 获取流程实例数据
/// </summary>
/// <param name="processInstanceID"></param>
/// <returns></returns>
public ProcessInstanceEntity GetProcessInstance(int processInstanceID)
{
var pim = new ProcessInstanceManager();
var instance = pim.GetById(processInstanceID);
return(instance);
}
/// <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="runner">运行者</param>
/// <returns>流程实例实体</returns>
public ProcessInstanceEntity GetRunningProcessInstance(WfAppRunner runner)
{
var pim = new ProcessInstanceManager();
var entity = pim.GetRunningProcessInstance(runner.AppInstanceID, runner.ProcessGUID);
return(entity);
}
/// <summary>
/// 执行子流程节点
/// </summary>
internal override void ExecuteWorkItem()
{
try
{
if (base.Linker.FromActivity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//检查子流程是否结束
var pim = new ProcessInstanceManager(_dataAccessor, _loggerFactory);
bool isCompleted = pim.CheckSubProcessInstanceCompleted(
base.Linker.FromActivityInstance.Fid,
base.Linker.FromActivityInstance.NodeId);
if (isCompleted == false)
{
throw new WfRuntimeException(string.Format("当前子流程:[{0}]并没有到达结束状态，主流程无法向下执行。",
base.Linker.FromActivity.ActivityName));
}
}
//完成当前的任务节点
bool canContinueForwardCurrentNode = CompleteWorkItem(ActivityForwardContext.TaskView.Fid);
if (canContinueForwardCurrentNode)
{
//获取下一步节点列表：并继续执行
ContinueForwardCurrentNode(false);
}
}
catch
{
throw;
}
}
internal override void ExecuteInstanceImp(IDbSession session)
{
//修改流程实例为返签状态
var pim = new ProcessInstanceManager();
pim.Reverse(base.BackwardContext.ProcessInstance.ID,
base.ActivityResource.AppRunner,
session);
//创建新任务节点
var backMostPreviouslyActivityInstanceID = GetBackwardMostPreviouslyActivityInstanceID();
var nodeMediatorBackward = new NodeMediatorBackward(base.BackwardContext, session);
nodeMediatorBackward.CreateBackwardActivityTaskTransitionInstance(base.BackwardContext.ProcessInstance,
base.BackwardContext.BackwardFromActivityInstance,
BackwardTypeEnum.Reversed,
backMostPreviouslyActivityInstanceID,
base.BackwardContext.BackwardToTargetTransitionGUID,
TransitionTypeEnum.Backward,
TransitionFlyingTypeEnum.NotFlying,
base.ActivityResource,
session);
//构造回调函数需要的数据
WfExecutedResult result = base.WfExecutedResult;
result.BackwardTaskReciever = base.BackwardContext.BackwardTaskReciever;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 节点内部业务逻辑执行
/// </summary>
internal override void ExecuteWorkItem()
{
//执行前Action列表
OnBeforeExecuteWorkItem();
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
var processInstance = pim.Complete(ActivityForwardContext.ProcessInstance.ID,
ActivityForwardContext.ActivityResource.AppRunner,
Session);
//如果当前流程是子流程，则子流程完成，主流程流转到下一节点
if (pim.IsSubProcess(processInstance) == true)
{
ContinueMainProcessRunning(processInstance, this.Session);
}
//执行后Action列表
OnAfterExecuteWorkItem();
//调用流程结束事件
DelegateExecutor.InvokeExternalDelegate(Session,
EventFireTypeEnum.OnProcessCompleted,
ActivityForwardContext.ActivityResource.AppRunner.DelegateEventList,
ActivityForwardContext.ProcessInstance.ID);
}
/// <summary>
/// 执行开始节点
/// </summary>
internal override void ExecuteWorkItem()
{
try
{
//写入流程实例
ProcessInstanceManager pim = new ProcessInstanceManager();
var newID = pim.Insert(this.Session.Connection, ActivityForwardContext.ProcessInstance,
this.Session.Transaction);
ActivityForwardContext.ProcessInstance.ID = newID;
//执行前Action列表
OnBeforeExecuteWorkItem();
CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
ActivityForwardContext.ActivityResource,
this.Session);
//执行后Action列表
OnAfterExecuteWorkItem();
//执行开始节点之后的节点集合
ContinueForwardCurrentNode(ActivityForwardContext.IsNotParsedByTransition, this.Session);
}
catch (System.Exception ex)
{
throw;
}
}
/// <summary>
/// 执行开始节点
/// </summary>
internal override void ExecuteWorkItem()
{
try
{
//写入流程实例
ProcessInstanceManager pim = new ProcessInstanceManager(_dataAccessor, _loggerFactory);
var newInstance = pim.Insert(ActivityForwardContext.ProcessInstance);
//写入流程图实例
DiagramInstanceManager dim = new DiagramInstanceManager(_dataAccessor, _loggerFactory);
dim.Insert(dim.CreateDiagramInstance(newInstance.ProcessUid, newInstance.Fid));
ActivityForwardContext.ProcessInstance.Id = newInstance.Id;
CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
ActivityForwardContext.Activity, base.AppRunner);
//执行开始节点之后的节点集合
ContinueForwardCurrentNode(false);
//执行Action列表
//ExecteActionList(ActivityForwardContext.Activity.ActionList,
// ActivityForwardContext.ActivityResource.AppRunner.ActionMethodParameters);
}
catch (System.Exception ex)
{
throw ex;
}
}
public ProcessInstanceEntity GetProcessInstanceByActivity(int activityInstanceID)
{
var pim = new ProcessInstanceManager();
var instance = pim.GetByActivity(activityInstanceID);
return(instance);
}
/// <summary>
/// 执行子流程节点
/// </summary>
internal override void ExecuteWorkItem()
{
try
{
if (base.Linker.FromActivity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//检查子流程是否结束
var pim = new ProcessInstanceManager();
bool isCompleted = pim.CheckSubProcessInstanceCompleted(Session.Connection,
base.Linker.FromActivityInstance.ID,
base.Linker.FromActivityInstance.ActivityGUID,
Session.Transaction);
if (isCompleted == false)
{
throw new WfRuntimeException(string.Format("当前子流程:[{0}]并没有到达结束状态，主流程无法向下执行。",
base.Linker.FromActivity.ActivityName));
}
}
//完成当前的任务节点
bool canContinueForwardCurrentNode = CompleteWorkItem(ActivityForwardContext.TaskID,
ActivityForwardContext.ActivityResource,
this.Session);
//获取下一步节点列表：并继续执行
if (canContinueForwardCurrentNode)
{
ContinueForwardCurrentNode(ActivityForwardContext.IsNotParsedByTransition);
}
}
catch (System.Exception ex)
{
throw;
}
}
/// <summary>
/// 自动完成结束节点
/// </summary>
/// <param name="processInstance"></param>
/// <param name="fromActivityInstance"></param>
/// <param name="activityResource"></param>
/// <param name="wfLinqDataContext"></param>
public GatewayExecutedResult CompleteAutomaticlly(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityInstanceEntity fromActivityInstance,
ActivityResource activityResource,
IDbSession session)
{
GatewayExecutedResult result = null;
var toActivityInstance = base.CreateActivityInstanceObject(base.Linker.ToActivity,
processInstance, activityResource.AppRunner);
base.ActivityInstanceManager.Insert(toActivityInstance, session);
base.ActivityInstanceManager.Complete(toActivityInstance.ID,
activityResource.AppRunner,
session);
//写节点转移实例数据
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
activityResource.AppRunner,
session);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(processInstance.ID, activityResource.AppRunner, session);
//发送流程结束消息给流程启动人
return(result);
}
internal override void ExecuteInstanceImp(ISession session)
{
//构造流程实例
var processInstance = new ProcessInstanceManager()
.CreateNewProcessInstanceObject(base.AppRunner.AppName, base.AppRunner.AppInstanceID,
base.ProcessModel.ProcessEntity,
base.AppRunner.UserID,
base.AppRunner.UserName);
//构造活动实例
//1. 获取开始节点活动
var startActivity = base.ProcessModel.GetStartActivity();
var startExecutionContext = ActivityForwardContext.CreateStartupContext(base.ProcessModel,
processInstance,
startActivity,
base.ActivityResource);
base.ExecuteWorkItemIteraly(startExecutionContext, session);
//构造回调函数需要的数据
base.WfExecutedResult = WfExecutedResult.Success();
base.WfExecutedResult.ProcessInstanceGUID = processInstance.ProcessInstanceGUID;
base.WfExecutedResult.NextActivityTree = GetNextActivityTree(base.AppRunner.Conditions, session);
}
/// <summary>
/// 执行开始节点
/// </summary>
/// <param name="activityExecutionObject"></param>
/// <param name="processInstance"></param>
internal override void ExecuteWorkItem()
{
try
{
//写入流程实例
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Insert(WfExecutionContext.ProcessInstance,
this.Session);
//自动完成开始节点(开始节点不参与Task)
NodeBase startNode = CreateNewNode(WfExecutionContext.Activity);
ICompleteAutomaticlly autoStartNode = (ICompleteAutomaticlly)startNode;
autoStartNode.CompleteAutomaticlly(WfExecutionContext.ProcessInstance,
null,
null,
WfExecutionContext.ActivityResource,
this.Session);
//执行开始节点之后的节点集合
ContinueForwardCurrentNode(startNode,
WfExecutionContext.ActivityResource);
}
catch (System.Exception ex)
{
throw;
}
}
/// <summary>
/// 根据应用获取流程下一步节点列表，包含角色用户
/// </summary>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
public IList <NodeView> GetNextActivityRoleUserTree(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);
foreach (var ns in nextSteps)
{
if (ns.ReceiverType == ReceiverTypeEnum.ProcessInitiator) //下一步执行人为流程发起人
{
var pim = new ProcessInstanceManager();
ns.Users = AppendUserList(ns.Users, pim.GetProcessInitiator(taskView.ProcessInstanceID)); //获取流程发起人
}
else
{
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>
/// <returns></returns>
public ProcessInstanceEntity GetRunningProcessInstance(WfAppRunner runner)
{
using (var session = DbFactory.CreateSession())
{
var pim = new ProcessInstanceManager();
return(pim.GetRunningProcessInstance(runner.AppInstanceID, runner.ProcessGUID, session));
}
}
/// <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>
internal override void ExecuteWorkItem()
{
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(ActivityForwardContext.ProcessInstance.ID,
ActivityForwardContext.ActivityResource.AppRunner,
Session);
}
/// <summary>
/// 获取流程实例数据
/// </summary>
/// <param name="activityInstanceID">活动实例ID</param>
/// <returns>流程实例实体</returns>
public ProcessInstanceEntity GetProcessInstanceByActivity(int activityInstanceID)
{
using (var session = SessionFactory.CreateSession())
{
var pim = new ProcessInstanceManager();
var instance = pim.GetByActivity(session.Connection, activityInstanceID, session.Transaction);
return(instance);
}
}
/// <summary>
/// 获取流程实例数据
/// </summary>
/// <param name="conn">链接</param>
/// <param name="processInstanceID">流程实例ID</param>
/// <param name="trans">事务</param>
/// <returns>流程实例实体</returns>
public ProcessInstanceEntity GetProcessInstance(IDbConnection conn,
int processInstanceID,
IDbTransaction trans)
{
var pim = new ProcessInstanceManager();
var instance = pim.GetById(conn, processInstanceID, trans);
return(instance);
}
/// <summary>
/// 设置活动实例的定时作业为完成状态
/// (用于HangFire后台轮询任务)
/// </summary>
/// <param name="conn">链接</param>
/// <param name="processInstanceID">流程实例ID</param>
/// <param name="trans">事务</param>
public void SetProcessJobTimerCompleted(IDbConnection conn, int processInstanceID, IDbTransaction trans)
{
var pim = new ProcessInstanceManager();
var processInstance = pim.GetById(conn, processInstanceID, trans);
processInstance.JobTimerStatus = (short)JobTimerStatusEnum.Completed;
processInstance.JobTimerTreatedDateTime = System.DateTime.Now;
pim.Update(conn, processInstance, trans);
}
/// <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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceStartup.error");
return(rmins);
}
rmins.AppRunner = runner;
//获取流程第一个可办理节点
rmins.ProcessModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
var startActivity = rmins.ProcessModel.GetStartActivity();
var firstActivity = rmins.ProcessModel.GetFirstActivity();
//var firstActivityList = rmins.ProcessModel.GetFirstActivityList(startActivity, runner.Conditions);
if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.None)
{
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
}
else if (startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Timer ||
startActivity.ActivityTypeDetail.TriggerType == TriggerTypeEnum.Message)
{
if (!string.IsNullOrEmpty(runner.UserID))
{
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityGUID,
runner.UserID,
runner.UserName);
}
else
{
rmins.AppRunner.NextActivityPerformers = rmins.ProcessModel.GetActivityPerformers(firstActivity.ActivityGUID);
}
}
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
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.AppName,
runner.AppInstanceID,
runner.ProcessGUID);
}
else
{
//子流程启动
processInstance = pim.GetProcessInstanceLatest(runner.AppName,
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);
}
public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner, IServiceProvider serviceProvider,
WfProcessInstance parentProcessInstance,
SubProcessNode subProcessNode,
ref WfExecutedResult result)
{
//检查流程是否可以被启动
var rmins = new WfRuntimeManagerStartup(serviceProvider);
rmins.WfExecutedResult = result = new WfExecutedResult();
var pim = new ProcessInstanceManager(serviceProvider);
WfProcessInstance processInstance = null;
if (subProcessNode == null)
{
//正常流程启动
processInstance = pim.GetProcessInstanceLatest(
runner.ProcessUid,
runner.BillUid);
}
else
{
//子流程启动
processInstance = pim.GetProcessInstanceLatest(
subProcessNode.SubProcessId, runner.BillUid);
}
//不能同时启动多个主流程
if (processInstance != null &&
processInstance.ParentProcessInsUid == null &&
processInstance.ProcessState == WfProcessInstanceState.Running)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Started_IsRunningAlready;
result.Message = "流程已经处于运行状态，不要重复提交！";
}
else
{
//processInstance 为空，此时继续执行启动操作
rmins.AppRunner = runner;
rmins.ParentProcessInstance = parentProcessInstance;
rmins.InvokedSubProcessNode = subProcessNode;
//获取流程第一个可办理节点
rmins.ProcessModel = new ProcessModel(serviceProvider, runner.ProcessUid, runner.BillUid);
}
//var firstActivity = rmins.ProcessModel.GetFirstActivity();
//rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(firstActivity.ActivityID,
// runner.UserId,
// runner.UserName);
return(rmins);
}
/// <summary>
/// 节点内部业务逻辑执行
/// </summary>
internal override void ExecuteWorkItem()
{
//执行Action列表
//ExecteActionList(Linker.ToActivity.ActionList,
// ActivityForwardContext.ActivityResource.AppRunner.ActionMethodParameters);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager(_serviceProvider);
pim.Complete(ActivityForwardContext.ProcessInstance.Fid, AppRunner.BillUid);
}
/// <summary>
/// 删除流程实例（先要进行取消操作）
/// </summary>
/// <param name="processInstanceGUID"></param>
/// <returns></returns>
public static bool DeleteProcessInstance(Guid processInstanceGUID)
{
try
{
ProcessInstanceManager pim = new ProcessInstanceManager();
return(pim.Delete(processInstanceGUID));
}
catch (System.Exception)
{
throw;
}
}
/// <summary>
/// 撤销处理具体功能实现
/// </summary>
/// <param name="session">会话</param>
internal override void ExecuteInstanceImp()
{
//如果审批人还没有人审批 则可以撤销回草稿态
ProcessInstanceManager manager = new ProcessInstanceManager(_serviceProvider);
manager.Withdrawn(AppRunner);
//构造回调函数需要的数据
WfExecutedResult result = base.WfExecutedResult;
//result.BackwardTaskReciever = base.BackwardContext.BackwardTaskReciever;
result.Status = WfExecutedStatus.Success;
}
/// <summary>
/// 节点内部业务逻辑执行
/// </summary>
internal override void ExecuteWorkItem()
{
//执行Action列表
ExecteActionList(Linker.ToActivity.ActionList,
ActivityForwardContext.ActivityResource.AppRunner.ActionMethodParameters);
//设置流程完成
ProcessInstanceManager pim = new ProcessInstanceManager();
pim.Complete(ActivityForwardContext.ProcessInstance.ID,
ActivityForwardContext.ActivityResource.AppRunner,
Session);
}
