/// <summary>
/// 启动流程
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner, IDbContext dbContext, ILoggerFactory loggerFactory,
ref WfExecutedResult result)
{
return(CreateRuntimeInstanceStartup(runner, dbContext, loggerFactory, null, null, ref result));
}
/// <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="discarder">执行操作的用户</param>
/// <returns>执行结果的标志</returns>
public bool DiscardProcess(WfAppRunner runner)
{
var pim = new ProcessInstanceManager();
return(pim.Discard(runner));
}
public void RegisterWfAppRunner(WfAppRunner runner)
{
WfAppRunner = runner;
}
/// <summary>
/// 恢复流程实例（只针对挂起操作）
/// </summary>
/// <param name="processInstanceId">挂起操作的实例ID</param>
/// <param name="runner">执行者</param>
public bool ResumeProcess(int processInstanceId, WfAppRunner runner)
{
var pim = new ProcessInstanceManager();
return(pim.Resume(processInstanceId, runner));
}
internal NodeMediatorXOrSplit(ActivityEntity activity, IProcessModel processModel, WfAppRunner runner, IDbContext dbContext, ILoggerFactory loggerFactory)
: base(activity, processModel, runner, dbContext, loggerFactory)
{
}
/// <summary>
/// 打样
/// </summary>
/// <param name="entity"></param>
public WfAppResult Sample(ProductOrderEntity entity)
{
var appResult = WfAppResult.Default();
var wfas = new WfAppInteropService();
var session = SessionFactory.CreateSession();
try
{
session.BeginTrans();
//流程运行
var result = wfas.RunProcess(session, WfAppRunner, WfAppRunner.Conditions);
if (result.Status == WfExecutedStatus.Success)
{
//写步骤记录表
Write(session, WfAppRunner, "打样", entity.ID.ToString(), entity.OrderCode, "完成打样");
//业务数据处理部分，此处是简单示例...
short status = GetProductOrderStatusByActivityCode(WfAppRunner.ProcessGUID, WfAppRunner.Version,
WfAppRunner.NextActivityPerformers.Keys.ElementAt <string>(0));
UpdateStatus(entity.ID, status, session);
session.Commit();
appResult = WfAppResult.Success();
try
{
//调用工厂作业流程节点：
//流程节点:OrderFactoryMessageCaught
//流程ProcessGUID:0f5829c7-17df-43eb-bfe5-1f2870fb2a0e Version:1
var invokeAppRunner = new WfAppRunner();
invokeAppRunner.UserID = WfAppRunner.UserID;
invokeAppRunner.UserName = WfAppRunner.UserName;
invokeAppRunner.ProcessGUID = "0f5829c7-17df-43eb-bfe5-1f2870fb2a0e";
invokeAppRunner.Version = "1";
invokeAppRunner.AppName = WfAppRunner.AppName;
invokeAppRunner.AppInstanceID = WfAppRunner.AppInstanceID;
invokeAppRunner.AppInstanceCode = WfAppRunner.AppInstanceCode;
invokeAppRunner.DynamicVariables["ActivityCode"] = "OrderFactoryMessageCaught";
var httpClient = HttpClientHelper.CreateHelper("http://localhost/sfsweb2/api/wfservice/invokejob");
var invokeResult = httpClient.Post(invokeAppRunner);
}
catch (System.Exception ex)
{
//记录异常日志
;
}
}
else
{
session.Rollback();
appResult = WfAppResult.Error(result.Message);
}
}
catch (System.Exception ex)
{
session.Rollback();
appResult = WfAppResult.Error(ex.Message);
}
finally
{
session.Dispose();
}
return(appResult);
}
/// <summary>
/// 创建子流程节点数据以及子流程记录
/// </summary>
/// <param name="toActivity">目的活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="fromActivityInstance">来源活动实例</param>
/// <param name="transitionGUID">转移GUID</param>
/// <param name="transitionType">转移类型</param>
/// <param name="flyingType">飞跃类型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="performer">执行者</param>
/// <param name="session">会话</param>
private void CreateSubProcessNode(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
string transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
Performer performer,
IDbSession session)
{
WfExecutedResult startedResult = WfExecutedResult.Default();
//实例化Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity, processInstance, activityResource.AppRunner);
//进入运行状态
toActivityInstance.ActivityState = (short)ActivityStateEnum.Ready;
if (performer != null)
{
//并行容器中的子流程节点，每个人发起一个子流程
toActivityInstance.AssignedToUserIDs = performer.UserID;
toActivityInstance.AssignedToUserNames = performer.UserName;
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
this.TaskManager.Insert(toActivityInstance, performer, activityResource.AppRunner, session);
}
else
{
toActivityInstance = GenerateActivityAssignedUserInfo(toActivityInstance, activityResource);
//插入活动实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入任务数据
base.CreateNewTask(toActivityInstance, activityResource, session);
}
//插入转移数据
var newTransitionInstanceID = InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//启动子流程
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = toActivityInstance;
WfAppRunner subRunner = null;
var performerList = new PerformerList();
if (performer != null)
{
subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
new Performer(performer.UserID,
performer.UserName),
subProcessNode);
performerList.Add(performer);
}
else
{
subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
new Performer(activityResource.AppRunner.UserID,
activityResource.AppRunner.UserName),
subProcessNode);
performerList = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
}
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartupSub(subRunner,
processInstance,
subProcessNode,
performerList,
session,
ref startedResult);
runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessStarted;
runtimeInstance.Execute(session);
void runtimeInstance_OnWfProcessStarted(object sender, WfEventArgs args)
{
startedResult = args.WfExecutedResult;
}
}
/// <summary>
/// 会签类型的主节点, 多实例节点处理
/// </summary>
/// <param name="toActivity">目的活动</param>
/// <param name="processInstance">流程实例</param>
/// <param name="fromActivityInstance">来源活动实例</param>
/// <param name="transitionGUID">转移GUID</param>
/// <param name="transitionType">转移类型</param>
/// <param name="flyingType">飞跃类型</param>
/// <param name="activityResource">活动资源</param>
/// <param name="session">会话</param>
internal new void CreateMultipleInstance(ActivityEntity toActivity,
ProcessInstanceEntity processInstance,
ActivityInstanceEntity fromActivityInstance,
String transitionGUID,
TransitionTypeEnum transitionType,
TransitionFlyingTypeEnum flyingType,
ActivityResource activityResource,
IDbSession session)
{
//实例化主节点Activity
var toActivityInstance = CreateActivityInstanceObject(toActivity,
processInstance, activityResource.AppRunner);
//主节点实例数据
toActivityInstance.ActivityState = (short)ActivityStateEnum.Suspended;
toActivityInstance.ComplexType = (short)ComplexTypeEnum.SignTogether;
if (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Parallel)
{
toActivityInstance.CompleteOrder = toActivity.ActivityTypeDetail.CompleteOrder;
}
toActivityInstance = GenerateActivityAssignedUserInfo(toActivityInstance, activityResource);
//插入主节点实例数据
base.ActivityInstanceManager.Insert(toActivityInstance, session);
//插入主节点转移数据
InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
toActivityInstance,
transitionType,
flyingType,
activityResource.AppRunner,
session);
//插入会签子节点实例数据
var plist = activityResource.NextActivityPerformers[toActivity.ActivityGUID];
ActivityInstanceEntity entity = new ActivityInstanceEntity();
for (short i = 0; i < plist.Count; i++)
{
entity = base.ActivityInstanceManager.CreateActivityInstanceObject(toActivityInstance);
entity.AssignedToUserIDs = plist[i].UserID;
entity.AssignedToUserNames = plist[i].UserName;
entity.MIHostActivityInstanceID = toActivityInstance.ID;
entity.CompleteOrder = (short)(i + 1);
//只有第一个节点处于运行状态，其它节点挂起
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
entity.ActivityState = (short)ActivityStateEnum.Suspended;
}
//插入活动实例数据，并返回活动实例ID
entity.ID = base.ActivityInstanceManager.Insert(entity, session);
//插入任务数据
base.TaskManager.Insert(entity, plist[i], activityResource.AppRunner, session);
//启动子流程
IDbSession subSession = SessionFactory.CreateSession();
var subProcessNode = (SubProcessNode)toActivity.Node;
subProcessNode.ActivityInstance = entity; //在流程实例表中记录激活子流程的活动节点ID
WfAppRunner subRunner = CopyActivityForwardRunner(activityResource.AppRunner,
plist[i],
subProcessNode);
WfExecutedResult startedResult = WfExecutedResult.Default();
var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartupSub(subRunner,
processInstance,
subProcessNode,
plist,
session,
ref startedResult);
if (runtimeInstance.WfExecutedResult.Status == WfExecutedStatus.Exception)
{
throw new WfRuntimeException(runtimeInstance.WfExecutedResult.Message);
}
runtimeInstance.Execute(subSession);
//如果是串行会签，只有第一个子流程可以运行，其它子流程处于挂起状态
if ((i > 0) && (toActivity.ActivityTypeDetail.MergeType == MergeTypeEnum.Sequence))
{
base.ProcessInstanceManager.Suspend(startedResult.ProcessInstanceIDStarted, subRunner, subSession);
}
}
}
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("未知的退回场景，请报告给技术支持人员！");
}
//提交请假信息
protected void btnSave_Click(object sender, EventArgs e)
{
try
{
string processGUID = this.txtProcessGUID.Value.ToString();
string stepGuid = this.hiddenStepGuid.Value.ToString();
int stepUserID = Helper.ConverToInt32(this.hiddenStepUser.Value.ToString().Trim());
decimal days = Helper.ConverToDecimal(this.txtDays.Value);
int leaveType = Helper.ConverToInt32(selectLeaveType.Value);
int nextUserID = 0;
string nextUserName = string.Empty;
SysUserEntity userEntity = WorkFlows.GetSysUserModel(stepUserID);
if (userEntity != null && userEntity.ID > 0)
{
nextUserID = userEntity.ID;
nextUserName = userEntity.UserName;
}
DateTime now = DateTime.Now;
//请假业务数据
HrsLeaveEntity hrsLeaveEntity = new HrsLeaveEntity();
hrsLeaveEntity.LeaveType = leaveType;
hrsLeaveEntity.Days = days;
try
{
hrsLeaveEntity.FromDate = Helper.ConvertToDateTime(this.txtFromDate.Value, now);
}
catch (Exception ex)
{
hrsLeaveEntity.FromDate = now;
}
try
{
hrsLeaveEntity.ToDate = Helper.ConvertToDateTime(this.txtToDate.Value, now);
}
catch (Exception ex)
{
hrsLeaveEntity.ToDate = now;
}
hrsLeaveEntity.CurrentActivityText = string.Empty;
hrsLeaveEntity.Status = 0;
hrsLeaveEntity.CreatedUserID = LoginUserID;
hrsLeaveEntity.CreatedUserName = this.LoginUserName;
hrsLeaveEntity.CreatedDate = now;
int instanceId = WorkFlows.AddHrsLeave(hrsLeaveEntity);
if (instanceId > 0)
{
//调用流程
IWorkflowService service = new WorkflowService();
WfAppRunner initiator = new WfAppRunner();
initiator.AppName = "请假流程";
initiator.AppInstanceID = instanceId.ToString();
initiator.ProcessGUID = processGUID;
initiator.UserID = LoginUserID.ToString();
initiator.UserName = LoginUserName;
initiator.Conditions = GetCondition(string.Format("days-{0}", days));
WfExecutedResult startedResult = service.StartProcess(initiator);
if (startedResult.Status != WfExecutedStatus.Success)
{
base.RegisterStartupScript("", "<script>alert('" + startedResult.Message + "');</script>");
return;
}
//送往下一步
PerformerList pList = new PerformerList();
pList.Add(new Performer(nextUserID.ToString(), nextUserName));
initiator.NextActivityPerformers = new Dictionary <String, PerformerList>();
initiator.NextActivityPerformers.Add(stepGuid, pList);
WfExecutedResult runAppResult = service.RunProcessApp(initiator);
if (runAppResult.Status != WfExecutedStatus.Success)
{
base.RegisterStartupScript("", "<script>alert('" + runAppResult.Message + "');</script>");
return;
}
//保存业务数据
BizAppFlowEntity AppFlowEntity = new Entity.BizAppFlowEntity();
AppFlowEntity.AppName = "流程发起";
AppFlowEntity.AppInstanceID = instanceId.ToString();
AppFlowEntity.ActivityName = "流程发起";
AppFlowEntity.Remark = string.Format("申请人:{0}-{1}", LoginUserID, LoginUserName);
AppFlowEntity.ChangedTime = now;
AppFlowEntity.ChangedUserID = LoginUserID;
AppFlowEntity.ChangedUserName = LoginUserName;
WorkFlows.AddBizAppFlow(AppFlowEntity);
base.RegisterStartupScript("", "<script>alert('流程发起成功');window.location.href='FlowList.aspx';</script>");
}
}
catch (Exception ex)
{
base.RegisterStartupScript("", "<script>alert('流程发起出现异常 EXCEPTION:" + ex.ToString() + "');</script>");
}
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
internal static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
var sendbackOperation = SendbackOperationTypeEnum.Default;
//先查找当前用户正在办理的运行节点
var aim = new ActivityInstanceManager();
var runningNode = runner.TaskID != null?aim.GetByTask(runner.TaskID.Value)
: aim.GetRunningNode(runner);
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = "当前没有运行状态的节点存在，流程不存在，或者已经结束或取消";
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = "不是当前登录用户的任务，无法退回！";
return(rmins);
}
var activityType = EnumHelper.ParseEnum <ActivityTypeEnum>(runningNode.ActivityType.ToString());
if (XPDLHelper.IsSimpleComponentNode(activityType) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = "当前节点不是任务类型的节点，无法退回上一步节点！";
return(rmins);
}
//获取当前运行主节点信息
var currentNode = runningNode;
if (runningNode.MIHostActivityInstanceID != null)
{
currentNode = aim.GetById(runningNode.MIHostActivityInstanceID.Value);
}
//获取上一步流转节点信息，可能经过And, Or等路由节点
//判断前置步骤是否经过Gateway节点
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousActivityList = aim.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
if (previousActivityList == null ||
previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = "当前没有可以退回的节点，请检查流程数据！";
return(null);
}
//多个退回节点存在的有效退回判断
IList <ActivityEntity> sendbackPreviousActivityList = new List <ActivityEntity>();
if (previousActivityList.Count > 1)
{
if (runner.NextActivityPerformers == null ||
runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = "当前有多个可以退回的节点，无法选择，请明确指定！";
return(rmins);
}
//明确指定的退回节点，需要判断处理
var isInvalidSendBack = IsInvalidStepsInPrevousActivityList(previousActivityList,
runner.NextActivityPerformers,
sendbackPreviousActivityList);
if (isInvalidSendBack == true)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotContainedInPreviousOrStartNode;
result.Message = "指定的退回节点不在上一步节点运行列表中，或者上一步是开始节点，无法退回！";
return(rmins);
}
}
else
{
//只有一个要退回去的节点
sendbackPreviousActivityList.Add(previousActivityList[0]);
}
//判断当前节点是否是多实例节点
if (runningNode.MIHostActivityInstanceID != null)
{
if (runningNode.CompleteOrder == 1)
{
//只有串行模式下有CompleteOrder的值为 1
//串行模式多实例的第一个执行节点，此时可退回到上一步
sendbackOperation = SendbackOperationTypeEnum.MISFirstOneIsRunning;
}
else if (runningNode.CompleteOrder > 1)
{
//已经是中间节点，只能退回到上一步多实例子节点
sendbackOperation = SendbackOperationTypeEnum.MISOneIsRunning;
}
else if (runningNode.CompleteOrder == -1)
{
sendbackOperation = SendbackOperationTypeEnum.MIPOneIsRunning;
}
}
if (hasGatewayPassed == true)
{
sendbackOperation = SendbackOperationTypeEnum.GatewayFollowedByParalleledNodes;
}
else
{
sendbackOperation = SendbackOperationTypeEnum.Normal;
}
//根据不同分支场景，创建不同撤销运行时管理器
return(CreateRuntimeInstanceSendbackByCase(runningNode, processModel, processInstance,
sendbackPreviousActivityList, hasGatewayPassed, sendbackOperation, runner, ref result));
}
/// <summary>
/// 退回操作
/// </summary>
/// <param name="appName"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="userID"></param>
/// <param name="userName"></param>
/// <param name="result"></param>
/// <returns></returns>
public static WfRuntimeManager CreateRuntimeInstanceSendBack(WfAppRunner runner,
ref WfExecutedResult result)
{
//检查当前运行节点信息
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
var aim = new ActivityInstanceManager();
var runningNode = aim.GetRunningNodeOfMine(runner);
if (runningNode.ActivityType != (short)ActivityTypeEnum.TaskNode)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotTaskNode;
result.Message = "当前节点不是任务节点，无法退回上一步节点！";
return(rmins);
}
if (!(runningNode.ActivityState == (short)ActivityStateEnum.Ready ||
runningNode.ActivityState == (short)ActivityStateEnum.Running))
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = string.Format("当前节点的状态不在运行状态，无法退回上一步节点！当前节点状态：{0}",
runningNode.ActivityState);
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = "不是登录用户的任务，无法退回！";
return(rmins);
}
var tim = new TransitionInstanceManager();
var 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);
}
//设置退回节点的相关信息
bool hasGatewayNode = false;
var sendbackToActivityInstance = tim.GetPreviousActivityInstance(runningNode, true,
out hasGatewayNode).ToList()[0];
if (sendbackToActivityInstance.ActivityType == (short)ActivityTypeEnum.StartNode)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_PreviousIsStartNode;
result.Message = "上一步是开始节点，无需退回！";
return(rmins);
}
var processModel = (new ProcessModel(runner.ProcessGUID));
rmins.ProcessModel = processModel;
rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(lastTaskTransitionInstance.ProcessInstanceID);
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(sendbackToActivityInstance.ActivityGUID);
rmins.BackwardContext.BackwardToTaskActivityInstance = sendbackToActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(sendbackToActivityInstance.ActivityName,
sendbackToActivityInstance.EndedByUserID, sendbackToActivityInstance.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(sendbackToActivityInstance.ActivityGUID,
sendbackToActivityInstance.EndedByUserID,
sendbackToActivityInstance.EndedByUserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
/// <summary>
/// 撤销操作
/// </summary>
/// <param name="appName"></param>
/// <param name="appInstanceID"></param>
/// <param name="processGUID"></param>
/// <param name="userID"></param>
/// <param name="userName"></param>
/// <param name="result"></param>
/// <returns></returns>
public static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner,
ref WfExecutedResult result)
{
//获取当前运行节点信息
var rmins = new WfRuntimeManagerWithdraw();
rmins.WfExecutedResult = result = new WfExecutedResult();
var aim = new ActivityInstanceManager();
var runningNode = aim.GetRunningNodeOfMine(runner);
if ((runningNode == null) || (runningNode.ActivityState != (short)ActivityStateEnum.Ready))
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_NotInReady;
result.Message = string.Format("要撤销的节点不在【待办】状态，已经无法撤销到上一步，节点状态：{0}",
runningNode.ActivityState);
}
//获取上一步流转节点信息，可能经过And, Or等路由节点
var tim = new TransitionInstanceManager();
bool hasGatewayNode = false;
var lastActivityInstanceList = tim.GetPreviousActivityInstance(runningNode, 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);
}
var withdrawActivityInstance = lastActivityInstanceList[0];
if (withdrawActivityInstance.EndedByUserID != runner.UserID)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_NotCreatedByMine;
result.Message = string.Format("上一步节点的任务办理人跟当前登录用户不一致，无法撤销回上一步！节点办理人：{0}",
withdrawActivityInstance.EndedByUserName);
return(rmins);
}
if (withdrawActivityInstance.ActivityType == (short)ActivityTypeEnum.EndNode)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_PreviousIsEndNode;
result.Message = "上一步是结束节点，无法撤销！";
return(rmins);
}
//准备撤销节点的相关信息
var processModel = (new ProcessModel(runner.ProcessGUID));
rmins.ProcessModel = processModel;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : String.Empty;
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(withdrawActivityInstance.ActivityGUID);
rmins.BackwardContext.BackwardToTaskActivityInstance = withdrawActivityInstance;
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode; //准备状态的接收节点
rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
withdrawActivityInstance.ActivityName,
withdrawActivityInstance.EndedByUserID,
withdrawActivityInstance.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(
withdrawActivityInstance.ActivityGUID,
runner.UserID,
runner.UserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
/// <summary>
/// 重新使节点处于挂起状态
/// 说明：会签最后一个子节点撤销时候用到
/// </summary>
/// <param name="activityInstanceID">活动实例节点ID</param>
/// <param name="session">会话</param>
/// <param name="runner">执行者</param>
internal void Resuspend(int activityInstanceID, IDbSession session, WfAppRunner runner)
{
SetActivityState(activityInstanceID, ActivityStateEnum.Suspended, runner, session);
}
/// <summary>
/// 创建跳转实例信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceJump(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerJump();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null ||
runner.NextActivityPerformers == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_ErrorArguments;
result.Message = "方法参数错误，无法运行流程！";
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = string.Format("不能跳转到多个节点！节点数:{0}",
runner.NextActivityPerformers.Count());
return(rmins);
}
//获取当前运行节点信息
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
//传递runner变量
rmins.TaskView = taskView;
rmins.AppRunner = runner;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
////获取跳转节点信息
//var jumpActivityGUID = runner.NextActivityPerformers.First().Key;
//var jumpActivityInstanceList = aim.GetActivityInstance(runner.AppInstanceID, runner.ProcessGUID, jumpActivityGUID);
//if (jumpActivityInstanceList != null
// && jumpActivityInstanceList.Count > 0)
//{
// //跳转到曾经执行过的节点上,可以作为跳回方式处理
// rmins.IsBackward = true;
// rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
// rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpActivityGUID);
// //获取当前运行节点的上一步节点
// bool hasGatewayNode = false;
// var tim = new TransitionInstanceManager();
// var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
// runner.AppInstanceID, runner.ProcessGUID);
// var previousActivityInstance = tim.GetPreviousActivityInstance(runningNode, true,
// out hasGatewayNode).ToList()[0];
// //仅仅是回跳到上一步节点，即按SendBack方式处理
// if (previousActivityInstance.ActivityGUID == jumpActivityGUID)
// {
// rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
// rmins.BackwardContext.BackwardToTargetTransitionGUID =
// hasGatewayNode == false ? lastTaskTransitionInstance.TransitionGUID : System.Guid.Empty; //如果中间有Gateway节点，则没有直接相连的TransitonGUID
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// previousActivityInstance.ActivityName,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// previousActivityInstance.ActivityGUID,
// previousActivityInstance.EndedByUserID.Value,
// previousActivityInstance.EndedByUserName);
// }
// else
// {
// //回跳到早前节点
// var jumptoActivityInstance = jumpActivityInstanceList[0];
// if (jumptoActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
// {
// result.Status = WfExecutedStatus.Exception;
// result.Exception = WfJumpException.NotActivityBackCompleted;
// result.Message = string.Format("回跳到的节点不在完成状态，无法重新回跳！");
// return rmins;
// }
// rmins.BackwardContext.BackwardToTaskActivityInstance = jumptoActivityInstance;
// //判断两个节点是否有Transition的定义存在
// var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, runner.JumpbackActivityGUID.Value);
// rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : System.Guid.Empty;
// rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
// rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
// rmins.BackwardContext.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
// jumptoActivityInstance.ActivityName,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
// jumptoActivityInstance.ActivityGUID,
// jumptoActivityInstance.EndedByUserID.Value,
// jumptoActivityInstance.EndedByUserName);
// }
// //获取资源数据
// var activityResourceBack = new ActivityResource(rmins.AppRunner,
// rmins.AppRunner.NextActivityPerformers,
// runner.Conditions);
// rmins.ActivityResource = activityResourceBack;
//}
//else
//{
// //跳转到从未执行过的节点上
// var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
// rmins.ActivityResource = activityResource;
// rmins.RunningActivityInstance = runningNode;
//}
#endregion
//跳转到从未执行过的节点上
var activityResource = new ActivityResource(runner, runner.NextActivityPerformers, runner.Conditions);
rmins.ActivityResource = activityResource;
rmins.RunningActivityInstance = runningNode;
return(rmins);
}
/// <summary>
/// 获取流程当前运行节点信息
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="taskView">任务视图</param>
/// <returns>活动实例</returns>
internal ActivityInstanceEntity GetRunningNode(WfAppRunner runner, out TaskViewEntity taskView)
{
var appInstanceID = runner.AppInstanceID;
var processGUID = runner.ProcessGUID;
var taskID = runner.TaskID;
taskView = null;
ActivityInstanceEntity activityInstance = null;
//如果流程在运行状态，则返回运行时信息
var tm = new TaskManager();
var aim = new ActivityInstanceManager();
var activityInstanceList = aim.GetRunningActivityInstanceList(runner.AppInstanceID, runner.ProcessGUID).ToList();
if ((activityInstanceList != null) && (activityInstanceList.Count == 1))
{
activityInstance = activityInstanceList[0];
taskView = tm.GetTaskOfMine(activityInstance.ID, runner.UserID);
}
else if (activityInstanceList.Count > 0)
{
if (runner.TaskID != null && runner.TaskID.Value != 0)
{
taskView = tm.GetTaskView(taskID.Value);
foreach (var ai in activityInstanceList)
{
if (ai.ID == taskView.ActivityInstanceID)
{
activityInstance = ai;
break;
}
}
}
else
{
//并行模式处理
//根据当前执行者身份取出(他或她)要办理的活动实例（并行模式下有多个处于待办或运行状态的节点）
foreach (var ai in activityInstanceList)
{
if (ai.AssignedToUserIDs == runner.UserID)
{
activityInstance = ai;
break;
}
}
if (activityInstance != null)
{
//获取taskview
taskView = tm.GetTaskOfMine(activityInstance.ID, runner.UserID);
}
else
{
//当前用户的待办任务不唯一，抛出异常，需要TaskID唯一界定
var e = new WorkflowException("当前流程有多个运行节点，但没有TaskID传入，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
}
}
else
{
//当前没有运行状态的节点存在，流程不存在，或者已经结束或取消
var e = new WorkflowException("当前流程没有运行节点，状态异常！");
LogManager.RecordLog("获取当前运行节点信息异常", LogEventType.Exception, LogPriority.Normal, null, e);
throw e;
}
return(activityInstance);
}
/// <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,
WithdrawOpertaionTypeEnum 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);
//以下处理，需要知道上一步是独立节点的信息
//获取上一步流转节点信息，可能经过And, Or等路由节点
var tim = new TransitionInstanceManager();
bool hasGatewayNode = false;
var currentNode = runningNode;
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 == WithdrawOpertaionTypeEnum.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.BackwardTaskReciever = WfBackwardTaskReciever.Instance(
previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
//封装AppUser对象
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
previousActivityInstance.ActivityGUID,
runner.UserID,
runner.UserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
//如果有其它模式，没有处理到，则直接抛出异常
throw new WorkflowException("未知的撤销场景，请报告给技术支持人员！");
}
/// <summary>
/// 根据应用获取流程下一步节点列表，包含角色用户
/// </summary>
/// <param name="resourceService">资源服务</param>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns>节点列表</returns>
internal IList <NodeView> GetNextActivityRoleUserTree(IResourceService resourceService,
WfAppRunner runner,
IDictionary <string, string> condition = null)
{
//判断应用数据是否缺失
if (string.IsNullOrEmpty(runner.AppInstanceID) ||
string.IsNullOrEmpty(runner.ProcessGUID))
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("nextstepparser.getnextactivityroleusertree.error"));
}
//条件参数一致
if (condition == null && runner.Conditions != null)
{
condition = runner.Conditions;
}
IList <NodeView> nextSteps = new List <NodeView>();
IProcessModel processModel = ProcessModelFactory.Create(runner.ProcessGUID, runner.Version);
using (var session = SessionFactory.CreateSession())
{
var pim = new ProcessInstanceManager();
var processInstanceList = pim.GetProcessInstance(session.Connection,
runner.AppInstanceID,
runner.ProcessGUID,
session.Transaction).ToList();
var processInstanceEntity = EnumHelper.GetFirst <ProcessInstanceEntity>(processInstanceList);
//判断流程是否创建还是已经运行
if (processInstanceEntity != null &&
processInstanceEntity.ProcessState == (short)ProcessStateEnum.Running)
{
//运行状态的流程实例
var tm = new TaskManager();
TaskViewEntity taskView = tm.GetTaskOfMine(session.Connection, runner, session.Transaction);
//获取下一步列表
nextSteps = processModel.GetNextActivityTree(taskView.ActivityGUID, condition);
foreach (var ns in nextSteps)
{
if (ns.ReceiverType == ReceiverTypeEnum.ProcessInitiator) //下一步执行人为流程发起人
{
ns.Users = AppendUserList(ns.Users, pim.GetProcessInitiator(session.Connection,
taskView.ProcessInstanceID,
session.Transaction)); //获取流程发起人
}
else
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
if (roleIDs.Count() > 0)
{
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
}
else
{
//流程准备启动，获取第一个办理节点的用户列表
var firstActivity = processModel.GetFirstActivity();
nextSteps = processModel.GetNextActivityTree(firstActivity.ActivityGUID,
condition);
foreach (var ns in nextSteps)
{
var roleIDs = ns.Roles.Select(x => x.ID).ToArray();
ns.Users = resourceService.GetUserListByRoleReceiverType(roleIDs, runner.UserID, (int)ns.ReceiverType); //增加转移前置过滤条件
}
}
}
return(nextSteps);
}
/// <summary>
/// 根据不同退回场景创建运行时管理器
/// </summary>
/// <param name="runningActivityInstanceList">运行节点列表</param>
/// <param name="sendbackOperation">退回类型</param>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时管理器</returns>
private static WfRuntimeManager CreateRuntimeInstanceSendbackByCase(
List <ActivityInstanceEntity> runningActivityInstanceList,
SendbackOpertaionTypeEnum 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 = null;
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 == SendbackOpertaionTypeEnum.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.BackwardTaskReciever = WfBackwardTaskReciever.Instance(previousActivityInstance.ActivityName,
previousActivityInstance.EndedByUserID, previousActivityInstance.EndedByUserName);
//封装AppUser对象
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(previousActivityInstance.ActivityGUID,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
return(rmins);
}
//如果有其它模式，没有处理到，则直接抛出异常
throw new WorkflowException("未知的退回场景，请报告给技术支持人员！");
}
/// <summary>
/// 创建运行用户身份
/// </summary>
/// <param name="runner">运行用户</param>
/// <returns>服务类</returns>
public IWorkflowService CreateRunner(WfAppRunner runner)
{
_wfAppRunner = runner;
return(this);
}
//提交请假信息
protected void btnSave_Click(object sender, EventArgs e)
{
try
{
string processGUID = this.txtProcessGUID.Value.ToString();
decimal days = Helper.ConverToDecimal(this.txtDays.Value);
int leaveType = Helper.ConverToInt32(selectLeaveType.Value);
string strNextActivityPerformers = hiddenNextActivityPerformers.Value.ToString().Trim();
IDictionary <string, PerformerList> nextActivityPerformers = NextActivityPerformers(strNextActivityPerformers);
if (nextActivityPerformers == null)
{
base.RegisterStartupScript("", "<script>alert('请选择办理步骤或办理人员--Please select next step and user');</script>");
return;
}
DateTime now = DateTime.Now;
//请假业务数据
HrsLeaveEntity hrsLeaveEntity = new HrsLeaveEntity();
hrsLeaveEntity.LeaveType = leaveType;
hrsLeaveEntity.Days = days;
try
{
hrsLeaveEntity.FromDate = Helper.ConvertToDateTime(this.txtFromDate.Value, now);
}
catch (Exception ex)
{
hrsLeaveEntity.FromDate = now;
}
try
{
hrsLeaveEntity.ToDate = Helper.ConvertToDateTime(this.txtToDate.Value, now);
}
catch (Exception ex)
{
hrsLeaveEntity.ToDate = now;
}
hrsLeaveEntity.CurrentActivityText = string.Empty;
hrsLeaveEntity.Status = 0;
hrsLeaveEntity.CreatedUserID = LoginUserID;
hrsLeaveEntity.CreatedUserName = this.LoginUserName;
hrsLeaveEntity.CreatedDate = now;
int instanceId = WorkFlows.AddHrsLeave(hrsLeaveEntity);
if (instanceId > 0)
{
//调用流程
IWorkflowService service = new WorkflowService();
WfAppRunner initiator = new WfAppRunner();
initiator.AppName = "请假流程(AskforLeaveProcess)";
initiator.AppInstanceID = instanceId.ToString();
initiator.ProcessGUID = processGUID;
initiator.UserID = LoginUserID.ToString();
initiator.UserName = LoginUserName;
initiator.Conditions = GetCondition(string.Format("days-{0}", days));
WfExecutedResult startedResult = service.StartProcess(initiator);
if (startedResult.Status != WfExecutedStatus.Success)
{
base.RegisterStartupScript("", "<script>alert('" + startedResult.Message + "');</script>");
return;
}
//送往下一步
/*
* PerformerList pList = new PerformerList();
* pList.Add(new Performer(nextUserID.ToString(), nextUserName));
*
* initiator.NextActivityPerformers = new Dictionary<String, PerformerList>();
* initiator.NextActivityPerformers.Add(stepGuid, pList);
*/
initiator.NextActivityPerformers = nextActivityPerformers;
WfExecutedResult runAppResult = service.RunProcessApp(initiator);
if (runAppResult.Status != WfExecutedStatus.Success)
{
base.RegisterStartupScript("", "<script>alert('" + runAppResult.Message + "');</script>");
return;
}
//保存业务数据
//BizAppFlowEntity AppFlowEntity = new Entity.BizAppFlowEntity();
//AppFlowEntity.AppName = "流程发起";
//AppFlowEntity.AppInstanceID = instanceId.ToString();
//AppFlowEntity.ActivityName = "流程发起";
//AppFlowEntity.Remark = string.Format("申请人:{0}-{1}", LoginUserID, LoginUserName);
//AppFlowEntity.ChangedTime = now;
//AppFlowEntity.ChangedUserID = LoginUserID.ToString();
//AppFlowEntity.ChangedUserName = LoginUserName;
//WorkFlows.AddBizAppFlow(AppFlowEntity);
HrsLeaveOpinionEntity hrsleaveOpinionEntity = new HrsLeaveOpinionEntity();
hrsleaveOpinionEntity.AppInstanceID = instanceId.ToString();
hrsleaveOpinionEntity.ActivityID = System.Guid.Empty.ToString();
hrsleaveOpinionEntity.ActivityName = "流程发起(Apply)";
hrsleaveOpinionEntity.Remark = string.Format("申请人(Applicant):{0}-{1}", LoginUserID, LoginUserName);
hrsleaveOpinionEntity.ChangedTime = now;
hrsleaveOpinionEntity.ChangedUserID = LoginUserID.ToString();
hrsleaveOpinionEntity.ChangedUserName = LoginUserName;
WorkFlows.AddHrsLeaveOpinion(hrsleaveOpinionEntity);
base.RegisterStartupScript("", "<script>alert('流程发起成功--Successed');window.location.href='FlowList.aspx';</script>");
}
}
catch (Exception ex)
{
base.RegisterStartupScript("", "<script>alert('流程发起出现异常--EXCEPTION:" + ex.ToString() + "');</script>");
}
}
/// <summary>
/// EOrJoin合并时的节点完成方法
/// 内部执行逻辑
/// </summary>
/// <param name="processInstance">流程实例</param>
/// <param name="transitionGUID">转移GUID</param>
/// <param name="fromActivity">起始活动</param>
/// <param name="fromActivityInstance">起始活动实例</param>
/// <param name="tokensCountRequired">合并要求的Token数目</param>
/// <param name="runner">运行者</param>
/// <param name="session">会话</param>
private NodeAutoExecutedResult CompleteAutomaticallyInternal(ProcessInstanceEntity processInstance,
string transitionGUID,
ActivityEntity fromActivity,
ActivityInstanceEntity fromActivityInstance,
int tokensCountRequired,
WfAppRunner runner,
IDbSession session)
{
NodeAutoExecutedResult result = NodeAutoExecutedResult.CreateGatewayExecutedResult(NodeAutoExecutedStatus.Unknown);
//当前执行的分支就是强制分支
//检查是否有运行中的合并节点实例
ActivityInstanceEntity joinNode = base.ActivityInstanceManager.GetActivityRunning(
processInstance.ID,
base.GatewayActivity.ActivityGUID,
session);;
if (joinNode == null)
{
//第一个分支首次运行
joinNode = base.CreateActivityInstanceObject(base.GatewayActivity,
processInstance, runner);
//计算总需要的Token数目
joinNode.TokensRequired = tokensCountRequired;
joinNode.TokensHad = 1;
//进入运行状态
joinNode.ActivityState = (short)ActivityStateEnum.Running;
joinNode.GatewayDirectionTypeID = (short)GatewayDirectionEnum.OrJoin;
//写入默认第一次的预选步骤用户列表
joinNode.NextStepPerformers = NextStepUtility.SerializeNextStepPerformers(runner.NextActivityPerformers);
base.InsertActivityInstance(joinNode,
session);
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
joinNode,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
runner,
session);
}
else
{
//更新节点的活动实例属性
joinNode.TokensHad += 1;
base.GatewayActivityInstance = joinNode;
//更新Token数目
base.ActivityInstanceManager.IncreaseTokensHad(base.GatewayActivityInstance.ID,
runner,
session);
base.InsertTransitionInstance(processInstance,
transitionGUID,
fromActivityInstance,
joinNode,
TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
runner,
session);
}
//判断是否到达合并节点的通过Token数目要求
if (joinNode.TokensHad == joinNode.TokensRequired)
{
//如果达到完成节点的Token数，则设置该节点状态为完成
base.CompleteActivityInstance(base.GatewayActivityInstance.ID,
runner,
session);
base.GatewayActivityInstance.ActivityState = (short)ActivityStateEnum.Completed;
//更新其它分支上的待办节点为阻止状态(CanRenewInstance = 0)
base.ActivityInstanceManager.UpdateActivityInstanceBlockedBetweenSplitJoin(base.GatewayActivity, base.GatewayActivityInstance,
base.ProcessModel, session);
result = NodeAutoExecutedResult.CreateGatewayExecutedResult(NodeAutoExecutedStatus.Successed);
}
else if (joinNode.TokensHad < joinNode.TokensRequired)
{
result = NodeAutoExecutedResult.CreateGatewayExecutedResult(NodeAutoExecutedStatus.WaitingForOthersJoin);
}
return(result);
}
/// <summary>
/// 活动实例被读取
/// </summary>
/// <param name="activityInstanceID">活动实例ID</param>
/// <param name="runner">执行者</param>
/// <param name="session">会话</param>
internal void SetActivityRead(int activityInstanceID,
WfAppRunner runner,
IDbSession session)
{
SetActivityState(activityInstanceID, ActivityStateEnum.Running, runner, session);
}
internal NodeMediatorOrSplit(ActivityEntity activity, IProcessModel processModel, WfAppRunner runner, IServiceProvider serviceProvider)
: base(activity, processModel, runner, serviceProvider)
{
}
/// <summary>
/// 撤销活动实例
/// </summary>
/// <param name="activityInstanceID"></param>
/// <param name="runner"></param>
/// <param name="session"></param>
internal void Withdraw(int activityInstanceID,
WfAppRunner runner,
IDbSession session)
{
SetActivityState(activityInstanceID, ActivityStateEnum.Withdrawed, runner, session);
}
/// <summary>
/// 取消流程
/// </summary>
/// <param name="canceller">执行操作的用户</param>
/// <returns>执行结果的标志</returns>
public bool CancelProcess(WfAppRunner runner)
{
var pim = new ProcessInstanceManager();
return(pim.Cancel(runner));
}
/// <summary>
/// 退回活动实例
/// </summary>
/// <param name="activityInstanceID"></param>
/// <param name="runner"></param>
/// <param name="session"></param>
internal void SendBack(int activityInstanceID,
WfAppRunner runner,
IDbSession session)
{
SetActivityState(activityInstanceID, ActivityStateEnum.Sendbacked, runner, session);
}
/// <summary>
/// 启动流程
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceStartup(WfAppRunner runner, IServiceProvider serviceProvider,
ref WfExecutedResult result)
{
return(CreateRuntimeInstanceStartup(runner, serviceProvider, null, null, ref result));
}
///// <summary>
///// 流程重置：流程先取消，后重新开始启动流程
///// </summary>
///// <param name="reseter"></param>
///// <returns></returns>
//public WfExecutedResult ResetProcess(WfAppRunner reseter)
//{
// //检查是否有运行中的流程，如果有运行中的流程，则必须先取消
// var pim = new ProcessInstanceManager();
// var entity = pim.GetRunningProcess(reseter.AppName, reseter.AppInstanceID, reseter.ProcessGUID);
// if (entity != null)
// {
// throw new WorkflowException("当前单据有流程实例处于运行状态，必须先取消流程，才可以重置！");
// }
// //当前无运行中的流程，可以再次启动流程
// StartProcess(reseter);
// return _wfExecutedResult;
//}
#endregion
#region 运行流程
/// <summary>
/// 根据应用获取流程下一步节点列表
/// </summary>
/// <param name="runner">应用执行人</param>
/// <param name="condition">条件</param>
/// <returns></returns>
public IList <NodeView> GetNextActivityTree(WfAppRunner runner, IDictionary <string, string> condition = null)
{
var tm = new TaskManager();
return(tm.GetNextActivityTree(runner, condition));
}