/// <summary>
/// 升级流程记录
/// </summary>
/// <param name="processGUID">流程GUID</param>
/// <param name="version">流程版本</param>
/// <param name="newVersion">新版本编号</param>
/// <returns>新流程ID</returns>
public int Upgrade(string processGUID, string version, string newVersion)
{
int newProcessID = 0;
if (string.IsNullOrEmpty(newVersion))
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("processmanager.upgrade.error"));
}
IDbSession session = SessionFactory.CreateSession();
try
{
session.BeginTrans();
var entity = GetByVersion(session.Connection, processGUID, version, true, session.Transaction);
var originProcessID = entity.ID;
entity.Version = newVersion;
entity.CreatedDateTime = System.DateTime.Now;
//升级主流程版本
newProcessID = Repository.Insert <ProcessEntity>(session.Connection, entity, session.Transaction);
if (entity.PackageType == (short)PackageTypeEnum.MainProcess)
{
//升级泳道流程版本
UpgradePoolProcess(session.Connection, originProcessID, newProcessID, newVersion, session.Transaction);
}
session.Commit();
}
catch (System.Exception)
{
session.Rollback();
throw;
}
finally
{
session.Dispose();
}
return(newProcessID);
}
/// <summary>
/// 恢复子流程
/// </summary>
/// <param name="invokedActivityInstanceID">激活活动实例ID</param>
/// <param name="runner">运行者</param>
/// <param name="session">会话</param>
internal void RecallSubProcess(int invokedActivityInstanceID,
WfAppRunner runner,
IDbSession session)
{
//var list = Repository.Query<ProcessInstanceEntity>(
// session.Connection,
// @"SELECT * FROM WfProcessInstance
// WHERE InvokedActivityInstanceID=@invokedActivityInstanceID
// AND ProcessState=5
// ORDER BY CreatedDateTime DESC",
// new
// {
// invokedActivityInstanceID = invokedActivityInstanceID
// },
// session.Transaction).ToList();
var sqlQuery = (from pi in Repository.GetAll <ProcessInstanceEntity>(session.Connection, session.Transaction)
where pi.InvokedActivityInstanceID == invokedActivityInstanceID &&
pi.ProcessState == 5
select pi
);
var list = sqlQuery.OrderByDescending(pi => pi.CreatedDateTime).ToList <ProcessInstanceEntity>();
if (list != null && list.Count() == 1)
{
var bEntity = list[0];
bEntity.ProcessState = (short)ProcessStateEnum.Running;
bEntity.LastUpdatedDateTime = System.DateTime.Now;
bEntity.LastUpdatedByUserID = runner.UserID;
bEntity.LastUpdatedByUserName = runner.UserName;
Update(bEntity, session);
}
else
{
throw new ProcessInstanceException(LocalizeHelper.GetEngineMessage("processinstancemanager.recallsubprocess.error"));
}
}
/// <summary>
/// 流程完成，设置流程的状态为完成
/// </summary>
/// <returns>是否成功</returns>
internal ProcessInstanceEntity Complete(int processInstanceID,
WfAppRunner runner,
IDbSession session)
{
var processInstance = GetById(processInstanceID);
var processState = (ProcessStateEnum)Enum.Parse(typeof(ProcessStateEnum), processInstance.ProcessState.ToString());
if ((processState | ProcessStateEnum.Running) == ProcessStateEnum.Running)
{
processInstance.ProcessState = (short)ProcessStateEnum.Completed;
processInstance.EndedDateTime = System.DateTime.Now;
processInstance.EndedByUserID = runner.UserID;
processInstance.EndedByUserName = runner.UserName;
Update(processInstance, session);
}
else
{
throw new ProcessInstanceException(LocalizeHelper.GetEngineMessage("processinstancemanager.complete.error"));
}
return(processInstance);
}
/// <summary>
/// 流程的取消操作
/// </summary>
/// <param name="runner">运行者</param>
/// <param name="conn">数据库链接</param>
/// <returns>设置成功标识</returns>
internal bool Cancel(WfAppRunner runner, IDbConnection conn = null)
{
bool isCanceled = false;
if (conn == null)
{
conn = SessionFactory.CreateConnection();
}
try
{
var entity = GetProcessInstanceLatest(runner.AppInstanceID,
runner.ProcessGUID);
if (entity == null || entity.ProcessState != (short)ProcessStateEnum.Running)
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("processinstancemanager.cancel.error"));
}
IDbSession session = SessionFactory.CreateSession();
entity.ProcessState = (short)ProcessStateEnum.Canceled;
entity.RecordStatusInvalid = 1;
entity.LastUpdatedByUserID = runner.UserID;
entity.LastUpdatedByUserName = runner.UserName;
entity.LastUpdatedDateTime = System.DateTime.Now;
Update(entity, session);
isCanceled = true;
}
catch (System.Exception e)
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("processinstancemanager.cancel.error", e.Message));
}
finally
{
conn.Close();
}
return(isCanceled);
}
/// <summary>
/// 设置流程过期时间
/// </summary>
/// <param name="processInstanceID">流程实例ID</param>
/// <param name="overdueDateTime">过期时间</param>
/// <param name="runner">当前运行用户</param>
/// <returns>设置成功标识</returns>
internal bool SetOverdue(int processInstanceID, DateTime overdueDateTime, WfAppRunner runner)
{
ProcessInstanceEntity entity = Repository.GetById <ProcessInstanceEntity>(processInstanceID);
if (entity.ProcessState == (int)ProcessStateEnum.Running ||
entity.ProcessState == (int)ProcessStateEnum.Ready ||
entity.ProcessState == (int)ProcessStateEnum.Suspended)
{
entity.OverdueDateTime = overdueDateTime;
entity.LastUpdatedByUserID = runner.UserID;
entity.LastUpdatedByUserName = runner.UserName;
entity.LastUpdatedDateTime = DateTime.Now;
Repository.Update <ProcessInstanceEntity>(entity);
return(true);
}
else
{
throw new ProcessInstanceException(LocalizeHelper.GetEngineMessage("processinstancemanager.setoverdue.error"));
}
}
public ResponseResult <List <TaskViewEntity> > QueryCompletedTasks([FromBody] TaskQuery query)
{
var result = ResponseResult <List <TaskViewEntity> > .Default();
try
{
var taskList = new List <TaskViewEntity>();
var wfService = new WorkflowService();
var itemList = wfService.GetCompletedTasks(query);
if (itemList != null)
{
taskList = itemList.ToList();
}
result = ResponseResult <List <TaskViewEntity> > .Success(taskList);
}
catch (System.Exception ex)
{
result = ResponseResult <List <TaskViewEntity> > .Error(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.querycompletedtasks.error", ex.Message));
}
return(result);
}
/// <summary>
/// 流程终止操作
/// </summary>
/// <param name="runner">执行者</param>
/// <returns>设置成功标识</returns>
internal bool Terminate(WfAppRunner runner)
{
var isTerminated = false;
var session = SessionFactory.CreateSession();
try
{
session.BeginTrans();
var entity = GetProcessInstanceLatest(session.Connection, runner.AppInstanceID, runner.ProcessGUID, session.Transaction);
isTerminated = Terminate(session.Connection, entity, runner.UserID, runner.UserName, session.Transaction);
session.Commit();
}
catch (System.Exception ex)
{
throw new ProcessInstanceException(LocalizeHelper.GetEngineMessage("processinstancemanager.terminate.error", ex.Message));
}
finally
{
session.Dispose();
}
return(isTerminated);
}
/// <summary>
/// 生成活动用户分配信息
/// </summary>
/// <param name="toActivityInstance">下一步活动实例</param>
/// <param name="activityResource">活动资源</param>
/// <returns>下一步活动实例</returns>
protected ActivityInstanceEntity GenerateActivityAssignedUserInfo(ActivityInstanceEntity toActivityInstance,
ActivityResource activityResource)
{
if (activityResource.AppRunner.NextPerformerType == NextPerformerIntTypeEnum.Specific &&
activityResource.NextActivityPerformers != null)
{
//前端显式指定下一步骤的执行用户列表
toActivityInstance.AssignedToUserIDs = PerformerBuilder.GenerateActivityAssignedUserIDs(
activityResource.NextActivityPerformers[toActivityInstance.ActivityGUID]);
toActivityInstance.AssignedToUserNames = PerformerBuilder.GenerateActivityAssignedUserNames(
activityResource.NextActivityPerformers[toActivityInstance.ActivityGUID]);
}
else if (activityResource.AppRunner.NextPerformerType == NextPerformerIntTypeEnum.Definition)
{
//根据节点上的角色定义获取下一步骤的执行用户列表
var performers = ActivityForwardContext.ProcessModel.GetActivityPerformers(toActivityInstance.ActivityGUID);
activityResource.NextActivityPerformers = performers;
toActivityInstance.AssignedToUserIDs = PerformerBuilder.GenerateActivityAssignedUserIDs(
performers[toActivityInstance.ActivityGUID]);
toActivityInstance.AssignedToUserNames = PerformerBuilder.GenerateActivityAssignedUserNames(
performers[toActivityInstance.ActivityGUID]);
}
else if (activityResource.AppRunner.NextPerformerType == NextPerformerIntTypeEnum.Single)
{
//用于测试使用的单一用户列表
activityResource.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(toActivityInstance.ActivityGUID,
activityResource.AppRunner.UserID,
activityResource.AppRunner.UserName);
toActivityInstance.AssignedToUserIDs = activityResource.AppRunner.UserID;
toActivityInstance.AssignedToUserNames = activityResource.AppRunner.UserName;
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("nodemediator.generateactivityassigneduserinfo.warn"));
}
return(toActivityInstance);
}
/// <summary>
/// 使用流程定义资源添加角色用户
/// </summary>
/// <param name="mainActivityInstanceID">主流程节点实例ID</param>
/// <param name="mainActivityGUID">主流程节点GUID</param>
/// <param name="session">数据库会话</param>
/// <returns>执行用户</returns>
private WfAppRunner FillNextActivityPerformersByRoleList(int mainActivityInstanceID,
string mainActivityGUID,
IDbSession session)
{
var pm = new ProcessInstanceManager();
var mainProcessInstance = pm.GetByActivity(session.Connection, mainActivityInstanceID, session.Transaction);
var processModel = ProcessModelFactory.Create(mainProcessInstance.ProcessGUID, mainProcessInstance.Version);
var nextSteps = processModel.GetNextActivityTree(mainActivityGUID);
//获取主流程的任务
var task = (new TaskManager()).GetTaskByActivity(session.Connection, mainProcessInstance.ID, mainActivityInstanceID, session.Transaction);
var runner = new WfAppRunner
{
AppName = mainProcessInstance.AppName,
AppInstanceID = mainProcessInstance.AppInstanceID,
AppInstanceCode = mainProcessInstance.AppInstanceCode,
ProcessGUID = mainProcessInstance.ProcessGUID,
Version = mainProcessInstance.Version,
UserID = task.AssignedToUserID,
UserName = task.AssignedToUserName
};
foreach (var node in nextSteps)
{
Dictionary <string, PerformerList> dict = new Dictionary <string, PerformerList>();
var performerList = PerformerBuilder.CreatePerformerList(node.Roles); //根据节点角色定义，读取执行者列表
if (node.ActivityType != ActivityTypeEnum.EndNode &&
performerList.Count == 0)
{
throw new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediatorend.FillNextActivityPerformersByRoleList.warn", node.ActivityName));
}
else
{
dict.Add(node.ActivityGUID, performerList);
}
runner.NextActivityPerformers = dict;
}
return(runner);
}
public ResponseResult <ProcessEntity> CreateProcess([FromBody] ProcessFileEntity fileEntity)
{
var result = ResponseResult <ProcessEntity> .Default();
try
{
if (string.IsNullOrEmpty(fileEntity.ProcessName.Trim()) ||
string.IsNullOrEmpty(fileEntity.ProcessCode.Trim()) ||
string.IsNullOrEmpty(fileEntity.Version.Trim()))
{
result = ResponseResult <ProcessEntity> .Error(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.crateprocess.warning"));
return(result);
}
ProcessEntity entity = new ProcessEntity
{
ProcessGUID = fileEntity.ProcessGUID,
ProcessName = fileEntity.ProcessName,
ProcessCode = fileEntity.ProcessCode,
Version = fileEntity.Version,
IsUsing = fileEntity.IsUsing,
Description = fileEntity.Description,
};
var wfService = new WorkflowService();
var processID = wfService.CreateProcess(entity);
entity.ID = processID;
result = ResponseResult <ProcessEntity> .Success(entity,
LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.crateprocess.success")
);
}
catch (System.Exception ex)
{
result = ResponseResult <ProcessEntity> .Error(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.crateprocess.error", ex.Message));
}
return(result);
}
/// <summary>
/// 更新任务邮件发送状态
/// </summary>
/// <param name="taskID">任务ID</param>
internal void SetTaskEMailSent(int taskID)
{
var session = SessionFactory.CreateSession();
try
{
var task = GetTask(taskID);
session.BeginTrans();
task.IsEMailSent = (byte)TaskEMailSentStatusEnum.Sent;
Update(task, session);
session.Commit();
}
catch (System.Exception e)
{
session.Rollback();
throw new WorkflowException(LocalizeHelper.GetEngineMessage("taskmanager.settaskemailsent.error", e.Message),
e);
}
finally
{
session.Dispose();
}
}
/// <summary>
/// 根据流程名称和版本标识获取流程
/// </summary>
/// <param name="processCode">流程代码</param>
/// <param name="version">流程版本</param>
/// <returns>流程实体</returns>
public ProcessEntity GetByCode(string processCode, string version = null)
{
ProcessEntity entity = null;
if (string.IsNullOrEmpty(version))
{
version = "1";
}
//var sql = @"SELECT
// *
// FROM WfProcess
// WHERE ProcessCode=@processCode
// AND VERSION=@version";
//var list = Repository.Query<ProcessEntity>(sql, new { processCode = processCode, version = version })
// .ToList<ProcessEntity>();
var sqlQuery = (from p in Repository.GetAll <ProcessEntity>()
where p.ProcessCode == processCode &&
p.Version == version
select p
);
var list = sqlQuery.ToList <ProcessEntity>();
if (list.Count() == 1)
{
entity = list[0];
}
else if (list.Count() == 0)
{
;
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("processmanager.getbycode.error"));
}
return(entity);
}
/// <summary>
/// 执行外部方法
/// </summary>
/// <param name="service">Action实体</param>
/// <param name="delegateService">委托服务</param>
private static void ExecuteSQLMethod(ServiceEntity service, IDelegateService delegateService)
{
try
{
var parameters = CompositeSqlParametersValue(service.Arguments, delegateService);
if (service.CodeInfo != null &&
!string.IsNullOrEmpty(service.CodeInfo.CodeText))
{
//var sqlScript = action.Expression;
var sqlScript = service.CodeInfo.CodeText; //modified by Besley in 12/26/2019, body is nodetext rather than attribute
var session = delegateService.GetSession();
var repository = new Repository();
repository.Execute(session.Connection, sqlScript, parameters, session.Transaction);
}
else
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("actionexecutor.ExecuteSQLMethod.warn"));
}
}
catch (System.Exception ex)
{
throw new WorkflowException(LocalizeHelper.GetEngineMessage("actionexecutor.ExecuteSQLMethod.exception", ex.Message));
}
}
/// <summary>
/// 根据版本选择流程
/// </summary>
/// <param name="conn">数据库链接</param>
/// <param name="processGUID">流程GUID</param>
/// <param name="version">版本</param>
/// <param name="throwException">抛出异常</param>
/// <param name="trans">交易</param>
/// <returns>流程实体</returns>
internal ProcessEntity GetByVersion(IDbConnection conn,
string processGUID,
string version,
bool throwException = true,
IDbTransaction trans = null)
{
ProcessEntity entity = null;
var sql = @"SELECT
*
FROM WfProcess
WHERE ProcessGUID=@processGUID
AND VERSION=@version";
var list = Repository.Query <ProcessEntity>(conn,
sql,
new
{
processGUID = processGUID,
version = version
},
trans).ToList <ProcessEntity>();
if (list.Count() == 1)
{
entity = list[0];
}
else
{
if (throwException == true)
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("processmanager.getbyversion.error",
string.Format("ProcessGUID: {0}, Version: {1}", processGUID, version)
));
}
}
return(entity);
}
/// <summary>
/// 根据流程名称和版本标识获取流程
/// </summary>
/// <param name="processName">流程名称</param>
/// <param name="version">流程版本</param>
/// <returns>流程实体</returns>
public ProcessEntity GetByName(string processName, string version = null)
{
ProcessEntity entity = null;
if (string.IsNullOrEmpty(version))
{
version = "1";
}
var sql = @"SELECT
*
FROM WfProcess
WHERE ProcessName=@processName
AND VERSION=@version";
var list = Repository.Query <ProcessEntity>(sql,
new {
processName = processName,
version = version
})
.ToList <ProcessEntity>();
if (list.Count() == 1)
{
entity = list[0];
}
else if (list.Count() == 0)
{
;
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("processmanager.getbyname.error"));
}
return(entity);
}
/// <summary>
/// 获取当前使用的流程版本
/// </summary>
/// <param name="conn">数据库连接</param>
/// <param name="processGUID">流程GUID</param>
/// <param name="trans">事务</param>
/// <returns>流程实体</returns>
public ProcessEntity GetVersionUsing(IDbConnection conn, string processGUID, IDbTransaction trans)
{
ProcessEntity entity = null;
//var sql = @"SELECT
// *
// FROM WfProcess
// WHERE ProcessGUID=@processGUID
// AND IsUsing=1
// ORDER BY ID DESC"; //current using process definition record
//var list = Repository.Query<ProcessEntity>(conn,
// sql,
// new
// {
// processGUID = processGUID
// },
// trans
// ).ToList<ProcessEntity>();
var sqlQuery = (from p in Repository.GetAll <ProcessEntity>(conn, trans)
where p.ProcessGUID == processGUID &&
p.IsUsing == 1
select p
);
var list = sqlQuery.ToList <ProcessEntity>();
if (list.Count() == 1)
{
entity = list[0];
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("processmanager.getbyversion.error",
string.Format("ProcessGUID: {0}", processGUID)
));
}
return(entity);
}
/// <summary>
/// 创建流程模型实例
/// </summary>
/// <param name="processGUID">流程GUID</param>
/// <param name="version">版本</param>
/// <returns>流程模型</returns>
public static IProcessModel Create(string processGUID, string version)
{
ProcessEntity entity = null;
var pm = new ProcessManager();
if (!string.IsNullOrEmpty(version))
{
entity = pm.GetByVersion(processGUID, version);
}
else
{
//如果版本信息缺省，默认取当前IsUsing=1的流程记录
entity = pm.GetVersionUsing(processGUID);
}
if (entity == null)
{
throw new WfXpdlException(LocalizeHelper.GetEngineMessage("processmodel.factory.processnullexception"));
}
IProcessModel processModel = new ProcessModel(entity);
return(processModel);
}
public ResponseResult UpgradeProcess([FromBody] ProcessEntity entity)
{
var result = ResponseResult.Default();
try
{
var wfService = new WorkflowService();
var process = wfService.GetProcessByID(entity.ID);
int newVersion = 1;
var parsed = int.TryParse(process.Version, out newVersion);
if (parsed == true)
{
newVersion = newVersion + 1;
}
wfService.UpgradeProcess(process.ProcessGUID, process.Version, newVersion.ToString());
result = ResponseResult.Success(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.upgradeprocess.success"));
}
catch (System.Exception ex)
{
result = ResponseResult.Error(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.upgradeprocess.error", ex.Message));
}
return(result);
}
/// <summary>
/// 删除子节点
/// </summary>
/// <param name="nextActivity"></param>
/// <returns></returns>
public virtual bool Remove(NextActivityComponent nextActivity)
{
throw new InvalidOperationException(LocalizeHelper.GetEngineMessage("nextactivitycomponent.Remove.error"));
}
/// <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="session">会话</param>
internal override void ExecuteInstanceImp(IDbSession session)
{
WfExecutedResult result = base.WfExecutedResult;
var runner = this.AppRunner;
var runningNode = this.RunningActivityInstance;
var sendbackOperation = base.SendBackOperation;
if (runningNode.MIHostActivityInstanceID == null)
{
//普通节点
sendbackOperation.CurrentNodeOperationType = SendBackOperationTypeEnum.Normal;
foreach (var step in runner.NextActivityPerformers)
{
var prevActivityGUID = step.Key;
var prevActivity = this.ProcessModel.GetActivity(prevActivityGUID);
sendbackOperation.BackwardToTaskActivity = prevActivity;
if (this.ProcessModel.IsTaskNode(prevActivity))
{
//退回到也是普通节点
sendbackOperation.PreviousNodeOperationType = SendBackOperationTypeEnum.Normal;
}
else if (this.ProcessModel.IsMINode(prevActivity) == true)
{
if (this.ProcessModel.IsMISequence(prevActivity) == true)
{
//退回到会签节点
//模式：串行会签的最后一步
sendbackOperation.PreviousNodeOperationType = SendBackOperationTypeEnum.MISPreviousIsLastOne;
}
else
{
//退回到会签节点
//模式：并行会签节点
sendbackOperation.PreviousNodeOperationType = SendBackOperationTypeEnum.MIPAllIsInCompletedState;
}
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("wfruntimemanagersendback.ExecuteInstanceImp.error"));
}
//执行退回方法
//只要出现多个步骤人员选项，就需要生成同样的多笔退回活动记录和相应的待办任务
var performerList = step.Value;
DistributeEachPerformerTask(sendbackOperation, step.Value, session);
}
}
else
{
//会签节点
sendbackOperation.CurrentNodeOperationType = SendBackOperationTypeEnum.MultipleInstance;
foreach (var step in runner.NextActivityPerformers)
{
var prevActivityGUID = step.Key;
var prevActivity = this.ProcessModel.GetActivity(prevActivityGUID);
sendbackOperation.BackwardToTaskActivity = prevActivity;
//判断会签模式的子类型，然后进行退回处理
if (runningNode.CompleteOrder == 1)
{
//只有串行模式下有CompleteOrder的值为 1
//串行模式多实例的第一个执行节点，此时可退回到上一步
sendbackOperation.CurrentMultipleInstanceDetailType = SendBackOperationTypeEnum.MISFirstOneIsRunning;
}
else if (runningNode.CompleteOrder > 1)
{
//已经是中间节点，只能退回到上一步多实例子节点
sendbackOperation.CurrentMultipleInstanceDetailType = SendBackOperationTypeEnum.MISOneIsRunning;
}
else if (runningNode.CompleteOrder == -1)
{
sendbackOperation.CurrentMultipleInstanceDetailType = SendBackOperationTypeEnum.MIPOneIsRunning;
}
else
{
throw new ApplicationException(LocalizeHelper.GetEngineMessage("wfruntimemanagersendback.ExecuteInstanceImp.error"));
}
//执行退回方法
//只要出现多个步骤人员选项，就需要生成同样的多笔退回活动记录和相应的待办任务
var performerList = step.Value;
DistributeEachPerformerTask(sendbackOperation, step.Value, session);
}
}
//更新运行节点状态
SetRunningNodeSendBack(session);
//构造回调函数需要的数据
result.Status = WfExecutedStatus.Success;
}
public ResponseResult <ProcessValidateResult> ValidateProcess([FromBody] ProcessValidateEntity entity)
{
var result = ResponseResult <ProcessValidateResult> .Default();
try
{
var wfService = new WorkflowService();
var validateResult = wfService.ValidateProcess(entity);
result = ResponseResult <ProcessValidateResult> .Success(validateResult, LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.validateprocess.success"));
}
catch (System.Exception ex)
{
result = ResponseResult <ProcessValidateResult> .Error(LocalizeHelper.GetDesignerMessage("wf2xmlcontroller.validateprocess.error", ex.Message));
}
return(result);
}
/// <summary>
/// 创建运行时实例对象
/// </summary>
/// <param name="runner">执行者</param>
/// <param name="session">数据库会话</param>
/// <param name="result">结果对象</param>
/// <returns>运行时实例对象</returns>
public static WfRuntimeManager CreateRuntimeInstanceAppRunning(WfAppRunner runner,
IDbSession session,
ref WfExecutedResult result)
{
//检查传人参数是否有效
var rmins = new WfRuntimeManagerRun();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (string.IsNullOrEmpty(runner.AppName) ||
String.IsNullOrEmpty(runner.AppInstanceID) ||
runner.ProcessGUID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.missing.error");
return(rmins);
}
//传递runner变量
rmins.AppRunner = runner;
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, session, out taskView);
//判断是否是当前登录用户的任务
if (!string.IsNullOrEmpty(runningNode.AssignedToUserIDs) &&
runningNode.AssignedToUserIDs.Contains(runner.UserID.ToString()) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.RunApp_HasNoTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.nonetask.error");
return(rmins);
}
var isRunning = (new TaskManager()).CheckTaskStateInRunningState(taskView);
if (isRunning == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceAppRunning.notrunning.error");
return(rmins);
}
//用于流程注册事件时的流程实例ID提供
var processInstance = (new ProcessInstanceManager()).GetById(session.Connection, runningNode.ProcessInstanceID, session.Transaction);
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var activityResource = new ActivityResource(runner,
runner.NextActivityPerformers,
runner.Conditions);
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessModel = processModel;
rmins.ActivityResource = activityResource;
return(rmins);
}
/// <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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.missing.error");
return(rmins);
}
//流程跳转时，只能跳转到一个节点
if (runner.NextActivityPerformers.Count() > 1)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_OverOneStep;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.jump.error",
runner.NextActivityPerformers.Count().ToString());
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;
//用于流程注册时间调用时候的流程实例ID提供
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
var processModel = ProcessModelFactory.Create(taskView.ProcessGUID, taskView.Version);
rmins.ProcessModel = processModel;
#region 考虑回跳方式
//获取跳转节点信息
var jumpBackActivityGUID = runner.NextActivityPerformers.First().Key;
var jumpBackActivityInstance = aim.GetActivityInstanceLatest(runningNode.ProcessInstanceID, jumpBackActivityGUID);
if (jumpBackActivityInstance != null)
{
//跳转到曾经执行过的节点上,可以作为跳回方式处理
rmins.IsBackward = true;
rmins.BackwardContext.ProcessInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
rmins.BackwardContext.BackwardToTaskActivity = processModel.GetActivity(jumpBackActivityGUID);
//获取当前运行节点的上一步节点
bool hasGatewayNode = false;
var tim = new TransitionInstanceManager();
var lastTaskTransitionInstance = tim.GetLastTaskTransition(runner.AppName,
runner.AppInstanceID, runner.ProcessGUID);
var npc = new PreviousStepChecker();
var previousActivityInstance = npc.GetPreviousActivityInstanceList(runningNode, true,
out hasGatewayNode).ToList()[0];
//仅仅是回跳到上一步节点，即按SendBack方式处理
if (previousActivityInstance.ActivityGUID == jumpBackActivityGUID)
{
rmins.BackwardContext.BackwardToTaskActivityInstance = previousActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == 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);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
previousActivityInstance.ActivityGUID,
previousActivityInstance.EndedByUserID,
previousActivityInstance.EndedByUserName);
}
else
{
//回跳到早前节点
if (jumpBackActivityInstance.ActivityState != (short)ActivityStateEnum.Completed)
{
//回跳节点不在完成状态
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Jump_NotActivityBackCompleted;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceJump.back.error");
return(rmins);
}
rmins.BackwardContext.BackwardToTaskActivityInstance = jumpBackActivityInstance;
//判断两个节点是否有Transition的定义存在
var transition = processModel.GetForwardTransition(runningNode.ActivityGUID, jumpBackActivityGUID);
rmins.BackwardContext.BackwardToTargetTransitionGUID = transition != null ? transition.TransitionGUID : WfDefine.WF_XPDL_GATEWAY_BYPASS_GUID;
rmins.BackwardContext.BackwardFromActivity = processModel.GetActivity(runningNode.ActivityGUID);
rmins.BackwardContext.BackwardFromActivityInstance = runningNode;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(
jumpBackActivityInstance.ActivityName,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.EndedByUserName);
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(
jumpBackActivityInstance.ActivityGUID,
jumpBackActivityInstance.EndedByUserID,
jumpBackActivityInstance.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
return(rmins);
}
/// <summary>
/// 删除不正常的流程实例（流程在取消状态，才可以进行删除！）
/// </summary>
/// <param name="processInstanceID">流程实例ID</param>
/// <param name="isForced">不取消，直接删除</param>
/// <returns>是否删除标识</returns>
internal bool Delete(int processInstanceID, bool isForced = false)
{
bool isDeleted = false;
IDbSession session = SessionFactory.CreateSession();
try
{
session.BeginTrans();
var entity = Repository.GetById <ProcessInstanceEntity>(processInstanceID);
if (entity.ProcessState == (int)ProcessStateEnum.Canceled ||
isForced == true)
{
//delete tasks
var sqlTasks = @"DELETE
FROM WfTasks
WHERE ProcessInstanceID=@processInstanceID";
Repository.Execute(session.Connection, sqlTasks,
new { processInstanceID = processInstanceID },
session.Transaction);
//delete transitioninstance
var sqlTransitionInstance = @"DELETE
FROM WfTransitionInstance
WHERE ProcessInstanceID=@processInstanceID";
Repository.Execute(session.Connection, sqlTransitionInstance,
new { processInstanceID = processInstanceID },
session.Transaction);
//delete activityinstance
var sqlActivityInstance = @"DELETE
FROM WfActivityInstance
WHERE ProcessInstanceID=@processInstanceID";
Repository.Execute(session.Connection, sqlActivityInstance,
new { processInstanceID = processInstanceID },
session.Transaction);
//delete process variable
var sqlProcessVariable = @"DELETE
FROM WfProcessVariable
WHERE ProcessInstanceID=@processInstanceID";
Repository.Execute(session.Connection, sqlProcessVariable,
new { processInstanceID = processInstanceID },
session.Transaction);
//delete processinstance
Repository.Delete <ProcessInstanceEntity>(session.Connection, processInstanceID, session.Transaction);
session.Commit();
isDeleted = true;
}
else
{
throw new ProcessInstanceException(LocalizeHelper.GetEngineMessage("processinstancemanager.delete.error"));
}
}
catch (System.Exception)
{
session.Rollback();
throw;
}
finally
{
session.Dispose();
}
return(isDeleted);
}
/// <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();
//没有指定退回节点信息
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced &&
(runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0))
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.null.error");
return(rmins);
}
//先查找当前用户正在办理的运行节点
var aim = new ActivityInstanceManager();
TaskViewEntity taskView = null;
var runningNode = aim.GetRunningNode(runner, out taskView);
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonerun.error");
return(rmins);
}
if (aim.IsMineTask(runningNode, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nonetask.error");
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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.nottask.error");
return(rmins);
}
//获取上一步节点信息
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var processModel = ProcessModelFactory.Create(processInstance.ProcessGUID, processInstance.Version);
var previousStepChecker = new PreviousStepChecker();
var previousActivityList = previousStepChecker.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//判断退回是否有效
if (previousActivityList == null || previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.empty.error");
return(rmins);
}
//前端用户指定退回步骤的模式
if (runner.NextPerformerType != NextPerformerIntTypeEnum.Traced)
{
if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.noneperformer.error");
return(rmins);
}
//检查节点是否一致
if (previousActivityList.Count == 1)
{
var onlyActivityGUID = previousActivityList[0].ActivityGUID;
var isOnly = true;
foreach (var step in runner.NextActivityPerformers)
{
if (step.Key != onlyActivityGUID)
{
isOnly = false;
break;
}
}
//存在不一致的退回节点
if (isOnly == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceSendBack.notunique.error");
return(rmins);
}
}
}
else
{
//Traced 用于直接返回上一步使用，测试模式
var prevActivity = previousActivityList[0];
var performerList = PerformerBuilder.CreatePerformerList(runningNode.CreatedByUserID, runningNode.CreatedByUserName);
runner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(prevActivity.ActivityGUID, performerList);
}
//创建运行时
rmins.TaskView = taskView;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
rmins.ProcessInstance = processInstance;
rmins.ProcessModel = processModel;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = runner.NextActivityPerformers;
//设置退回选项类
var sendbackOperation = new SendBackOperation();
sendbackOperation.BackwardType = BackwardTypeEnum.Sendback;
sendbackOperation.ProcessInstance = processInstance;
sendbackOperation.BackwardFromActivityInstance = runningNode;
sendbackOperation.HasGatewayPassed = hasGatewayPassed;
sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
sendbackOperation.ProcessModel = processModel;
sendbackOperation.IsCancellingBrothersNode = (runner.ControlParameterSheet != null &&
runner.ControlParameterSheet.IsCancellingBrothersNode == 1) ? true : false;
rmins.SendBackOperation = sendbackOperation;
return(rmins);
}
/// <summary>
/// 创建撤销处理运行时
/// </summary>
/// <param name="runner">撤销人</param>
/// <param name="result">创建结果</param>
/// <returns>运行时管理器</returns>
internal static WfRuntimeManager CreateRuntimeInstanceWithdraw(WfAppRunner runner,
ref WfExecutedResult result)
{
var rmins = new WfRuntimeManagerSendBack();
rmins.WfExecutedResult = result = new WfExecutedResult();
if (runner.TaskID == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Withdraw_ErrorArguments;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.missingtaskid.error");
return(rmins);
}
//获取已经完成任务的信息
var tm = new TaskManager();
var taskDone = tm.GetTaskView(runner.TaskID.Value);
if (tm.IsMine(taskDone, runner.UserID) == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotMineTask;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonetask.error");
return(rmins);
}
//赋值下一步办理列表
runner.NextActivityPerformers = NextStepUtility.CreateNextStepPerformerList(taskDone.ActivityGUID,
taskDone.AssignedToUserID, taskDone.AssignedToUserName);
//没有指定退回节点信息
if (runner.NextActivityPerformers == null || runner.NextActivityPerformers.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.noneperformer.error");
return(rmins);
}
//获取待办任务
var tim = new TransitionInstanceManager();
var nextStepList = tim.GetTargetActivityInstanceList(taskDone.ActivityInstanceID).ToList();
ActivityInstanceEntity runningNode = nextStepList.Count > 0 ? nextStepList[0] : null;
if (runningNode == null)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_NotInRunning;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nonerun.error");
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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.nottask.error");
return(rmins);
}
//获取待办任务(模拟待办任务用户做退回处理)
var taskToDo = tm.GetTaskViewByActivity(runningNode.ProcessInstanceID, runningNode.ID);
runner.UserID = taskToDo.AssignedToUserID;
runner.UserName = taskToDo.AssignedToUserName;
//获取上一步节点信息
var hasGatewayPassed = false;
var processInstance = (new ProcessInstanceManager()).GetById(runningNode.ProcessInstanceID);
var previousStepChecker = new PreviousStepChecker();
var processModel = ProcessModelFactory.Create(taskToDo.ProcessGUID, taskToDo.Version);
var previousActivityList = previousStepChecker.GetPreviousActivityList(runningNode, processModel, out hasGatewayPassed);
//判断退回是否有效
if (previousActivityList == null || previousActivityList.Count == 0)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsNull;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.empty.error");
return(rmins);
}
//检查节点是否一致
if (previousActivityList.Count == 1)
{
var onlyActivityGUID = previousActivityList[0].ActivityGUID;
var isOnly = true;
foreach (var step in runner.NextActivityPerformers)
{
if (step.Key != onlyActivityGUID)
{
isOnly = false;
break;
}
}
//存在不一致的退回节点
if (isOnly == false)
{
result.Status = WfExecutedStatus.Exception;
result.ExceptionType = WfExceptionType.Sendback_IsTooManyPrevious;
result.Message = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceWithdraw.notunique.error");
return(rmins);
}
}
//创建运行时
rmins.TaskView = taskToDo;
rmins.RunningActivityInstance = runningNode;
rmins.ProcessInstanceID = runningNode.ProcessInstanceID;
rmins.ProcessInstance = processInstance;
rmins.ProcessModel = processModel;
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.AppRunner.NextActivityPerformers = runner.NextActivityPerformers;
//设置退回选项类
var sendbackOperation = new SendBackOperation();
sendbackOperation.BackwardType = BackwardTypeEnum.Withdrawed;
sendbackOperation.ProcessInstance = processInstance;
sendbackOperation.BackwardFromActivityInstance = runningNode;
sendbackOperation.HasGatewayPassed = hasGatewayPassed;
sendbackOperation.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
sendbackOperation.ProcessModel = processModel;
sendbackOperation.IsCancellingBrothersNode = true; //撤销时默认撤销各个并行分支
rmins.SendBackOperation = sendbackOperation;
return(rmins);
}
/// <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 = LocalizeHelper.GetEngineMessage("wfruntimemanagerfactory.CreateRuntimeInstanceReverse.error");
return(rmins);
}
//用于注册事件时候的流程ID
rmins.ProcessInstanceID = processInstance.ID;
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 npc = new PreviousStepChecker();
var lastTaskActivityInstance = npc.GetPreviousActivityInstanceList(endActivityInstance, false,
out hasGatewayNode).ToList()[0];
var lastTaskActivity = processModel.GetActivity(lastTaskActivityInstance.ActivityGUID);
//封装返签结束点之前办理节点的任务接收人
rmins.AppRunner.NextActivityPerformers = ActivityResource.CreateNextActivityPerformers(lastTaskActivityInstance.ActivityGUID,
lastTaskActivityInstance.EndedByUserID,
lastTaskActivityInstance.EndedByUserName);
rmins.ActivityResource = new ActivityResource(runner, rmins.AppRunner.NextActivityPerformers);
rmins.AppRunner.AppName = runner.AppName;
rmins.AppRunner.AppInstanceID = runner.AppInstanceID;
rmins.AppRunner.ProcessGUID = runner.ProcessGUID;
rmins.AppRunner.UserID = runner.UserID;
rmins.AppRunner.UserName = runner.UserName;
rmins.BackwardContext.ProcessInstance = processInstance;
rmins.BackwardContext.BackwardToTaskActivity = lastTaskActivity;
rmins.BackwardContext.BackwardToTaskActivityInstance = lastTaskActivityInstance;
rmins.BackwardContext.BackwardToTargetTransitionGUID =
hasGatewayNode == false ? endTransitionInstance.TransitionGUID : String.Empty;
rmins.BackwardContext.BackwardFromActivity = endActivity;
rmins.BackwardContext.BackwardFromActivityInstance = endActivityInstance;
rmins.BackwardContext.BackwardTaskReceiver = WfBackwardTaskReceiver.Instance(lastTaskActivityInstance.ActivityName,
lastTaskActivityInstance.EndedByUserID,
lastTaskActivityInstance.EndedByUserName);
return(rmins);
}
/// <summary>
/// 创建下一步活动的节点
/// </summary>
/// <param name="transition">转移</param>
/// <param name="activity">活动</param>
/// <returns>下一步节点封装</returns>
internal static NextActivityComponent CreateNextActivityComponent(TransitionEntity transition,
ActivityEntity activity)
{
string name = string.Empty;
NextActivityComponent component = null;
if (XPDLHelper.IsSimpleComponentNode(activity.ActivityType) == true) //可流转简单类型节点
{
//单一节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.singlenode");
component = new NextActivityItem(name, transition, activity);
}
else if (XPDLHelper.IsIntermediateEventComponentNode(activity.ActivityType) == true)
{
//跨事件节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.intermediatenode");
component = new NextActivityIntermediate(name, transition, activity);
}
else if (XPDLHelper.IsGatewayComponentNode(activity.ActivityType) == true)
{
if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.AndJoin)
{
//必全选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.mandatorycheckall");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.AndSplitMI ||
activity.GatewayDirectionType == GatewayDirectionEnum.AndJoinMI)
{
//并行多实例节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.parallelmultipleinstance");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.OrSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.OrJoin)
{
//或多选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.orsplitorjoin");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.XOrSplit ||
activity.GatewayDirectionType == GatewayDirectionEnum.XOrJoin)
{
//异或节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.xor");
}
else if (activity.GatewayDirectionType == GatewayDirectionEnum.EOrJoin)
{
//增强合并多选节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.eorjoin");
}
else
{
throw new WfXpdlException(LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.CreateNextActivityComponent.gateway.error",
activity.GatewayDirectionType.ToString()));
}
component = new NextActivityGateway(name, transition, activity);
}
else if (activity.ActivityType == ActivityTypeEnum.SubProcessNode)
{
//子流程节点
name = LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.subprocess");
component = new NextActivityItem(name, transition, activity);
}
else
{
throw new WfXpdlException(LocalizeHelper.GetEngineMessage("nextactivitycomponentfactory.CreateNextActivityComponent.error",
activity.ActivityType.ToString()));
}
return(component);
}
/// <summary>
/// 递归执行节点
/// 1)创建普通节点的任务
/// 2)创建会签节点的任务
/// </summary>
/// <param name="fromActivity">起始活动</param>
/// <param name="fromActivityInstance">起始活动实例</param>
/// <param name="isNotParsedForward">是否跳跃</param>
/// <param name="root">根节点</param>
/// <param name="conditionKeyValuePair">条件key-value</param>
/// <param name="mediatorResult">执行结果的返回列表</param>
protected void ContinueForwardCurrentNodeRecurisivly(ActivityEntity fromActivity,
ActivityInstanceEntity fromActivityInstance,
NextActivityComponent root,
IDictionary <string, string> conditionKeyValuePair,
Boolean isNotParsedForward,
ref List <WfNodeMediatedResult> mediatorResult)
{
foreach (NextActivityComponent comp in root)
{
if (comp.HasChildren)
{
NodeAutoExecutedResult nodeExecutedResult = null;
if (XPDLHelper.IsGatewayComponentNode(comp.Activity.ActivityType) == true)
{
//此节点类型为任务节点：根据fromActivityInstance的类型判断是否可以创建任务
if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
{
//此节点类型为分支或合并节点类型：首先需要实例化当前节点(自动完成)
NodeMediatorGateway gatewayNodeMediator = NodeMediatorFactory.CreateNodeMediatorGateway(comp.Activity,
this.ActivityForwardContext.ProcessModel,
Session);
ICompleteGatewayAutomaticlly autoGateway = (ICompleteGatewayAutomaticlly)gatewayNodeMediator;
nodeExecutedResult = autoGateway.CompleteAutomaticlly(ActivityForwardContext.ProcessInstance,
comp.Transition.TransitionGUID,
fromActivity,
fromActivityInstance,
ActivityForwardContext.ActivityResource.AppRunner,
Session);
if (nodeExecutedResult.Status == NodeAutoExecutedStatus.Successed)
{
//遍历后续子节点
ContinueForwardCurrentNodeRecurisivly(gatewayNodeMediator.GatewayActivity,
gatewayNodeMediator.GatewayActivityInstance,
comp,
conditionKeyValuePair,
isNotParsedForward,
ref mediatorResult);
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.OrJoinOneBranchHasBeenFinishedWaittingOthers));
LogManager.RecordLog("ContinueForwardCurrentNodeRecurisivlyExeception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(
LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.warn"))
);
}
}
else
{
//下一步的任务节点没有创建，需给出提示信息
if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
LogManager.RecordLog("NodeMediator.ContinueForwardCurrentNodeRecurisivly.IsWaintingOneOfJoin.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
);
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
LogManager.RecordLog("NodeMediator.ContinueForwardCurrentNodeRecurisivly.IsWaintingOneOfJoin.OtherUnknownReason.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
);
}
}
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
LogManager.RecordLog("NodeMediator.UnknownType.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.unknowntype.warn",
comp.Activity.ActivityType.ToString()))
);
}
}
else if (comp.Activity.ActivityType == ActivityTypeEnum.TaskNode) //普通任务节点
{
//此节点类型为任务节点：根据fromActivityInstance的类型判断是否可以创建任务
if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
{
//创建新任务节点
NodeMediator taskNodeMediator = new NodeMediatorTask(Session);
taskNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
ActivityForwardContext.ProcessInstance,
fromActivityInstance,
comp.Transition.TransitionGUID,
comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
TransitionTypeEnum.Loop : TransitionTypeEnum.Forward, //根据Direction方向确定是否是自身循环
isNotParsedForward == true ?
TransitionFlyingTypeEnum.ForwardFlying : TransitionFlyingTypeEnum.NotFlying,
ActivityForwardContext.ActivityResource,
Session);
}
else
{
//下一步的任务节点没有创建，需给出提示信息
if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
LogManager.RecordLog("NodeMediator.TaskNode.NeedOtherGatewayBranchesToJoin.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
);
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
LogManager.RecordLog("NodeMediator.TaskNode.NeedOtherGatewayBranchesToJoin.OtherUnkownReaseon.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
);
}
}
}
else if (comp.Activity.ActivityType == ActivityTypeEnum.SubProcessNode) //子流程节点
{
//节点类型为subprocessnode
if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
{
//实例化subprocess节点数据
NodeMediator subNodeMediator = new NodeMediatorSubProcess(Session);
subNodeMediator.CreateActivityTaskTransitionInstance(comp.Activity,
ActivityForwardContext.ProcessInstance,
fromActivityInstance,
comp.Transition.TransitionGUID,
comp.Transition.DirectionType == TransitionDirectionTypeEnum.Loop ?
TransitionTypeEnum.Loop : TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
ActivityForwardContext.ActivityResource,
Session);
}
}
else if (comp.Activity.ActivityType == ActivityTypeEnum.EndNode) //结束节点
{
if (fromActivityInstance.ActivityState == (short)ActivityStateEnum.Completed)
{
//此节点为完成结束节点，结束流程
var endMediator = NodeMediatorFactory.CreateNodeMediatorEnd(ActivityForwardContext, comp.Activity, Session);
endMediator.Linker.ToActivity = comp.Activity;
//创建结束节点实例及转移数据
endMediator.CreateActivityTaskTransitionInstance(comp.Activity, ActivityForwardContext.ProcessInstance,
fromActivityInstance, comp.Transition.TransitionGUID, TransitionTypeEnum.Forward,
TransitionFlyingTypeEnum.NotFlying,
ActivityForwardContext.ActivityResource,
Session);
//执行结束节点中的业务逻辑
endMediator.ExecuteWorkItem();
}
else
{
//结束节点没有创建，需给出提示信息
if (IsWaitingOneOfJoin(fromActivity.GatewayDirectionType) == true)
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.NeedOtherGatewayBranchesToJoin));
LogManager.RecordLog("NodeMediator.EndNode.NeedOtherGatewayBranchesToJoin.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.waitingothers.warn"))
);
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.OtherUnknownReasonToDebug));
LogManager.RecordLog("NodeMediator.EndNode.NeedOtherGatewayBranchesToJoin.OtherUnkownReaseon.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.otherreason.warn"))
);
}
}
}
else
{
mediatorResult.Add(WfNodeMediatedResult.CreateNodeMediatedResultWithException(
WfNodeMediatedFeedback.UnknownNodeTypeToWatch));
LogManager.RecordLog("NodeMediator.UnkonwNodeType.Exception",
LogEventType.Exception,
LogPriority.Normal,
null,
new WfRuntimeException(LocalizeHelper.GetEngineMessage("nodemediator.ContinueForwardCurrentNodeRecurisivly.unknowntype.warn",
comp.Activity.ActivityType.ToString()))
);
}
}
}
