public static void SureMinPassNum(this SysActivity activity)
{
if (!activity.MinPassNum.HasValue)
{
activity.MinPassNum = 1;
}
}
public static void SureMinPassRatio(this SysActivity activity)
{
if (!activity.MinPassRatio.HasValue)
{
activity.MinPassRatio = 100.0;
}
}
public static void SurePassType(this SysActivity activity)
{
if (!activity.PassType.HasValue)
{
activity.PassType = 0;
}
}
public List <SysActivity> GetNextActivityList(string processName)
{
List <SysActivity> list2;
try
{
List <SysActivity> list = new List <SysActivity>();
SysProcess processCache = this._processCache.GetProcessCache(processName);
if (processCache == null)
{
throw new ApplicationException(string.Format("流程名称[{0}]不正确", processName));
}
SysActivity activity = processCache.Activities.FirstOrDefault <SysActivity>(p => p.ActivityType == 1);
if (activity != null)
{
list = (from p in activity.FromTransitions select p.PostActivity).ToList <SysActivity>();
}
list2 = list;
}
catch (Exception exception)
{
AppLogHelper.Error(string.Format("GetNextActivityList,processName=[{0}]失败", processName), exception);
throw exception;
}
return(list2);
}
public override void Execute(Queue <WorkflowMessage> queue)
{
this.JustCompleteCurrentAI();
SysActivity activity = this.AI.Activity;
SysProcess process = activity.Process;
if (activity.ActivityType == 3)
{
this.CompleteNormalActivity(queue, process, activity);
}
else if (activity.ActivityType == 1)
{
this.CompleteStartActivity(queue, process, activity);
}
else if (activity.ActivityType == 2)
{
this.CompleteDecisionActivity(queue, process, activity);
}
else if (activity.ActivityType == 4)
{
this.CompleteEndActivity(queue, process, activity);
}
else
{
if (activity.ActivityType != 6)
{
throw new ApplicationException("未知的活动类型");
}
this.CompleteApproveActivity(queue, process, activity);
}
}
public string GetWorkItemCompletePageUrl(SysWorkItem wi, SysProcessInstance pi, SysActivityInstance ai, bool isRelative = true)
{
string str3;
try
{
SysActivity activity = ai.Activity;
if (activity == null)
{
throw new ApplicationException(string.Format("活动实例:{0}找不到对应活动", ai.ActivityInstanceId));
}
if (pi.Process.ProcessCategory == 2)
{
return(string.Format("../FormWorkflow/FormInstanceApprove.aspx?id={0}", wi.WorkItemId));
}
long? pageid = activity.PageId;
SysPage page = pi.Process.ProcessEntity.Pages.FirstOrDefault <SysPage>(p => p.ControlId == pageid);
if (page == null)
{
throw new ApplicationException(string.Format("活动:{0}找不到对应页面", activity.ActivityId));
}
if (!isRelative)
{
return(string.Format("{0}_{1}/{2}.aspx?id={3}", new object[] { page.OwnerEntity.OwnerModule.EntityCategory.CategoryName, page.OwnerEntity.OwnerModule.ModuleName, page.PageName, wi.WorkItemId }));
}
str3 = string.Format("../{0}_{1}/{2}.aspx?id={3}", new object[] { page.OwnerEntity.OwnerModule.EntityCategory.CategoryName, page.OwnerEntity.OwnerModule.ModuleName, page.PageName, wi.WorkItemId });
}
catch (Exception exception)
{
throw exception;
}
return(str3);
}
private bool CanCancel()
{
if (base.PI.InstanceStatus == 10)
{
return(false);
}
foreach (SysActivityInstance instance in base.PI.ActivityInstances)
{
SysActivity activity = instance.Activity;
if (activity == null)
{
throw new ApplicationException("活动为空");
}
if ((activity.ActivityType != 2) && (instance.InstanceStatus == 10))
{
if (activity.ExecType == 1)
{
if (!string.IsNullOrEmpty(activity.JScriptText))
{
return(false);
}
}
else
{
return(false);
}
}
}
return(true);
}
public string GetWorkItemDisplayText(SysWorkItem wi, SysProcessInstance pi, SysActivityInstance ai)
{
string str6;
try
{
SysActivity activity = ai.Activity;
if (activity == null)
{
throw new ApplicationException(string.Format("活动实例:{0}找不到对应活动", ai.ActivityInstanceId));
}
SysProcess process = pi.Process;
if (process == null)
{
throw new ApplicationException(string.Format("活动:{0}找不到对应流程", activity.ActivityId));
}
string activityName = activity.ActivityName;
string processName = process.ProcessName;
if (process.ProcessCategory == 2)
{
return(string.Format("[{0}][{1}]{2}", processName, activityName, pi.FormInstance.FormTitle));
}
EntityCache cache = new EntityCache(this._manager);
SysEntity processEntity = process.ProcessEntity;
string objectDisplayName = cache.GetObjectDisplayName(processEntity, wi.RelativeObjectId.Value);
str6 = string.Format("[{0}][{1}]{2}", processName, activityName, objectDisplayName);
}
catch (Exception exception)
{
throw exception;
}
return(str6);
}
public override void Execute(Queue <WorkflowMessage> queue)
{
base.JustCompleteCurrentAI();
SysActivity postActivity = base.PI.Process.Activities.FirstOrDefault <SysActivity>(p => p.ActivityId == this._nextActivityId);
SysActivityInstance ai = base.CreatePostActivityInstance(base.PI, postActivity);
WorkflowMessage item = base.Engine.NewActivityInstanceCreatedMessage(ai);
queue.Enqueue(item);
}
private void LoadActivityOperation(SysActivityOperation ao, SysActivity a)
{
ao.Activity = a;
string condition = string.Format("OperationId = {0}", ao.OperationId);
ao.ActivitySteps = this._context.Where <SysActivityStep>(condition, new DbParameter[0]);
foreach (SysActivityStep step in ao.ActivitySteps)
{
step.ActivityOperation = ao;
}
}
private string GetActivityParticipant(SysActivity a)
{
var source = from ap in this.DataHelper.Set <SysActivityParticipant>()
join pp in this.DataHelper.Set <SysProcessParticipant>()
on ap.ParticipantId equals pp.ParticipantId
where ap.ActivityId == a.ActivityId
select pp.ParticipantName;
string result = string.Join("、", source.ToList());
return(result);
}
private SysActivityInstance CreatePostAcitivtyInstance(SysProcessInstance pi, SysTransition tran)
{
if (!tran.PostActivityId.HasValue)
{
throw new ApplicationException("后续活动为空");
}
SysActivity postActivity = pi.Process.Activities.FirstOrDefault <SysActivity>(p => p.ActivityId == tran.PostActivityId.Value);
SysActivityInstance postAi = this.CreatePostActivityInstance(pi, postActivity);
this.CreateTransitionInstance(postAi, tran);
return(postAi);
}
private void LoadActivityParticipant(SysActivityParticipant ap, SysActivity a, SysProcess p)
{
ap.Activity = a;
ap.ActivityApproveGroup = this._context.FindById <SysActivityApproveGroup>(new object[] { ap.ActivityApproveGroupId });
if (ap.ActivityApproveGroup != null)
{
string condition = string.Format("ActivityApproveGroupId = {0}", ap.ActivityApproveGroup.ActivityApproveGroupId);
ap.ActivityApproveGroup.Activity = a;
ap.ActivityApproveGroup.ActivityParticipants = this._context.Where <SysActivityParticipant>(condition, new DbParameter[0]);
}
ap.ProcessParticipant = p.ProcessParticipants.FirstOrDefault <SysProcessParticipant>(i => i.ParticipantId == ap.ParticipantId);
}
/// <summary>
/// 绑定活动列表（只显示审核活动）
/// </summary>
private void BindActivityList()
{
var source = from a in this.DataHelper.Set <SysActivity>()
where a.ProcessId == this.ProcessId &&
a.ActivityType == (int)ActivityType.Approve
orderby a.DisplayOrder
select new
{
a.DisplayOrder,
a.ActivityId,
a.ActivityName,
SelectClass = a.ActivityId == this.SelectedActivityId ? "selected" : "unselected",
};
this.rActivity.DataSource = source.ToList();
this.rActivity.DataBind();
//驳回方式
this.ccRejectType.DataSource = typeof(FormProcessActivityRejectType);
this.ccRejectType.DataBind();
//驳回目标活动（只能选当前活动上面的的审核活动）
this.ccRejectTargetActivity.DataSource = source.Where(p => p.DisplayOrder < this.SelectedActivity.DisplayOrder).ToList();
this.ccRejectTargetActivity.DataBind();
//找到当前活动驳回指向的活动
this.divRejectTargetActivity.Visible = false;
SysTransition t = this.DataHelper.Set <SysTransition>()
.Where(p => p.PreActivityId == this.SelectedActivityId && p.Direction == (int)FlowStepDirection.False).FirstOrDefault();
if (t == null)
{
this.ccRejectType.SelectedValue = ((int)FormProcessActivityRejectType.SelectActivityWhenRunning).ToString();
}
else
{
SysActivity target = this.DataHelper.FindById <SysActivity>(t.PostActivityId);
if (target.ActivityType == (int)ActivityType.End)
{
this.ccRejectType.SelectedValue = ((int)FormProcessActivityRejectType.EndActivity).ToString();
}
else
{
this.ccRejectType.SelectedValue = ((int)FormProcessActivityRejectType.SelectActivity).ToString();
this.ccRejectTargetActivity.SelectedValue = target.ActivityId.ToString();
this.divRejectTargetActivity.Visible = true;
}
}
}
/// <summary>
/// 选中某个活动
/// </summary>
/// <param name="activity"></param>
private void SelectActivity(SysActivity activity)
{
if (activity == null)
{
throw new Exception("选择的活动不存在");
}
this.SelectedActivity = activity;
this.hc.Value = activity.ActivityId.ToString();
//重新绑定活动列表（更新选中状态）
BindActivityList();
//重新绑定表单字段
BindFormField();
}
private SysActivityInstance CreateActivityInstance(SysProcessInstance pi, SysActivity act)
{
SysActivityInstance ai = new SysActivityInstance {
ActivityId = new long?(act.ActivityId),
ActivityInstanceId = base.Manager.GetNextIdentity(),
EndTime = null,
ExpressionValue = null,
InstanceStatus = 0,
ProcessInstanceId = new int?(pi.ProcessInstanceId),
StartTime = new DateTime?(DateTime.Now),
WwfActivityInstanceId = null
};
base.PICacheFactory.AddActivityInstance(pi, ai);
return(ai);
}
private void CalDecisionValue()
{
SysActivity activity = this.AI.Activity;
if ((activity.Expressions == null) || (activity.Expressions.Count == 0))
{
throw new ApplicationException("活动没有表达式");
}
if (!activity.ExpressionId.HasValue)
{
throw new ApplicationException("未指定活动的表达式");
}
SysExpression expr = activity.Expressions.FirstOrDefault <SysExpression>(e => e.ExpressionId == activity.ExpressionId.Value);
if (expr == null)
{
throw new ApplicationException("指定的表达式不在活动的表达式中");
}
Queue <SysExpression> calOrder = ExpressionHelper.GetCalOrder(activity.Expressions.ToList <SysExpression>());
if (calOrder.Count <SysExpression>(p => (p.ExpressionId == expr.ExpressionId)) <= 0)
{
throw new ApplicationException("无法计算表达式的值");
}
EntityCache cache = new EntityCache(base.Manager);
ExpressionCache cache2 = new ExpressionCache();
while (calOrder.Count > 0)
{
SysExpression expression = calOrder.Dequeue();
object obj2 = ExpressionHelper.GetHelper(expression).GetValue(expression, cache, cache2, base.PI, this.AI);
if (expression.ExpressionId == expr.ExpressionId)
{
if (obj2 == null)
{
throw new ApplicationException("决策活动的值返回null");
}
if (obj2.GetType() != typeof(bool))
{
throw new ApplicationException("决策活动的值不是布尔类型");
}
this.AI.ExpressionValue = new int?(Convert.ToInt32(obj2));
return;
}
}
}
/// <summary>
/// 选中某个活动
/// </summary>
/// <param name="activity"></param>
private void SelectActivity(SysActivity activity)
{
if (activity == null)
{
throw new Exception("选择的活动不存在");
}
this.SelectedActivity = activity;
this.hc.Value = activity.ActivityId.ToString();
this.txtActivityName.Text = activity.ActivityName;
//绑定活动参与人列表
BindActivityParticipant();
//重新绑定活动列表（更新选中状态）
BindActivityList();
}
public SysProcess GetProcessCacheByActivity(long activityId, out SysActivity activity)
{
Func <SysActivity, bool> predicate = null;
SysActivity activity2 = this._context.FindById <SysActivity>(new object[] { activityId });
if ((activity2 == null) || !activity2.ProcessId.HasValue)
{
throw new ApplicationException("活动ID不正确");
}
SysProcess processCache = this.GetProcessCache(activity2.ProcessId.Value);
if (predicate == null)
{
predicate = p => p.ActivityId == activityId;
}
activity = processCache.Activities.FirstOrDefault <SysActivity>(predicate);
return(processCache);
}
private void ExecuteForAuto(SysActivity activity, SysProcess process)
{
foreach (SysActivityOperation operation in
(from a in activity.ActivityOperations.Where <SysActivityOperation>(delegate(SysActivityOperation p)
{
long?activityId = p.ActivityId;
long num = activity.ActivityId;
return((activityId.GetValueOrDefault() == num) && activityId.HasValue);
})
orderby a.OperationId
select a).ToList <SysActivityOperation>())
{
if (operation.OperationType != 2)
{
throw new ApplicationException("目前只支持Python脚本");
}
base.Manager.ExecutePython(base.PI, operation.JScriptText);
}
}
public override void Execute(Queue <WorkflowMessage> queue)
{
SysActivity activity = this.AI.Activity;
SysProcess process = activity.Process;
if (((activity.ActivityType == 3) || (activity.ActivityType == 1)) || (activity.ActivityType == 6))
{
if (activity.ExecType == 0)
{
new ActivityRemindHandler(base.PICacheFactory, base.PI, this.AI, ActivityRemindUseTimeType.ActivityStart, null, null).Execute();
this.ExecuteForManual(activity, process, queue);
}
else
{
if (activity.ExecType != 1)
{
throw new ApplicationException("未知的活动执行类型");
}
base.Manager.ExecutePython(base.PI, activity.JScriptText);
this.ExecuteForAuto(activity, process);
WorkflowMessage item = base.Engine.NewCompleteActivityMessage(this.AI);
queue.Enqueue(item);
}
}
else if (activity.ActivityType == 2)
{
this.CopyActivityInstanceData();
this.CalDecisionValue();
WorkflowMessage message2 = base.Engine.NewCompleteActivityMessage(this.AI);
queue.Enqueue(message2);
}
else
{
if (activity.ActivityType != 4)
{
throw new ApplicationException("未知活动类型");
}
base.Manager.ExecutePython(base.PI, activity.JScriptText);
this.ExecuteForAuto(activity, process);
WorkflowMessage message3 = base.Engine.NewCompleteActivityMessage(this.AI);
queue.Enqueue(message3);
}
}
/// <summary>
/// 连接两个活动
/// </summary>
private void ConnectActivity(BizDataContext db, SysActivity prev, SysActivity post, FlowStepDirection direction)
{
SysTransition t = new SysTransition()
{
TransitionId = db.GetNextIdentity(),
PreActivityId = prev.ActivityId,
PostActivityId = post.ActivityId,
ProcessId = this.ProcessId,
Direction = (int)direction,
};
switch (direction)
{
case FlowStepDirection.False: t.DisplayText = "驳回"; break;
case FlowStepDirection.True: t.DisplayText = "通过"; break;
default: break;
}
db.Insert(t);
}
public override void Execute(Queue <WorkflowMessage> queue)
{
SysProcess process = base.PI.Process;
if ((process.Activities == null) || (process.Activities.Count == 0))
{
throw new ApplicationException("没有任何活动");
}
SysActivity act = process.Activities.FirstOrDefault <SysActivity>(a => a.ActivityType == 1);
if (act == null)
{
throw new ApplicationException("没有开始活动");
}
SysActivityInstance ai = this.CreateActivityInstance(base.PI, act);
new ProcessRemindHandler(base.PICacheFactory, base.PI, ai, ProcessRemindUseTimeType.ProcessStart).Execute();
WorkflowMessage item = base.Engine.NewActivityInstanceCreatedMessage(ai);
queue.Enqueue(item);
}
private void LoadActivityRemind(SysActivityRemind ar, SysActivity a, SysProcess p)
{
ar.Activity = a;
string condition = string.Format("RemindId = {0}", ar.RemindId);
ar.RemindParticipants = this._context.Where <SysActivityRemindParticipant>(condition, new DbParameter[0]);
using (IEnumerator <SysActivityRemindParticipant> enumerator = ar.RemindParticipants.GetEnumerator())
{
while (enumerator.MoveNext())
{
Func <SysProcessParticipant, bool> predicate = null;
SysActivityRemindParticipant arp = enumerator.Current;
arp.Remind = ar;
if (predicate == null)
{
predicate = i => i.ParticipantId == arp.ParticipantId;
}
arp.Participant = p.ProcessParticipants.FirstOrDefault <SysProcessParticipant>(predicate);
arp.RemindTemplate = this._context.FindById <SysProcessRemindTemplate>(new object[] { arp.TemplateId });
}
}
}
/// <summary>
/// 初始化
/// </summary>
private void Initialize()
{
int? id = QueryString <int?>("id");
SysWorkItem wi = this.DataHelper.FindById <SysWorkItem>(id);
if (wi == null)
{
throw new Exception("工作项不存在");
}
SysActivityInstance ai = this.DataHelper.FindById <SysActivityInstance>(wi.ActivityInstanceId);
if (ai == null)
{
throw new Exception("活动实例不存在");
}
SysActivity activity = this.DataHelper.FindById <SysActivity>(ai.ActivityId);
if (activity == null)
{
throw new Exception("活动不存在");
}
SysProcessInstance pi = this.DataHelper.FindById <SysProcessInstance>(ai.ProcessInstanceId);
if (pi == null)
{
throw new Exception("流程实例不存在");
}
this.WorkItemId = id.Value;
this.ProcessInstanceId = pi.ProcessInstanceId;
this.ActivityId = activity.ActivityId;
this.ActivityDispalyOrder = activity.DisplayOrder ?? 0;
this.FormInstanceId = pi.FormInstanceId ?? 0;
this.ProcessId = pi.ProcessId.Value;
CheckRejectButton();
}
public List <SysActivity> GetNextActivityList(int workItemId)
{
List <SysActivity> list2;
try
{
SysWorkItem item;
List <SysActivity> list = new List <SysActivity>();
new ProcessInstanceCacheFactory(this._context).GetProcessInstanceCacheByWorkItem(workItemId, out item);
SysActivity activity = item.ActivityInstance.Activity;
if (activity != null)
{
list = (from p in activity.FromTransitions select p.PostActivity).ToList <SysActivity>();
}
list2 = list;
}
catch (Exception exception)
{
AppLogHelper.Error(string.Format("GetNextActivityList,workItemId=[{0}]失败", workItemId), exception);
throw exception;
}
return(list2);
}
private void LoadActivity(SysActivity a, SysProcess p)
{
string condition = string.Format("activityId = {0}", a.ActivityId);
a.Process = p;
a.Expression = p.Expressions.FirstOrDefault <SysExpression>(i => i.ExpressionId == a.ExpressionId);
a.ActivityParticipants = this._context.Where <SysActivityParticipant>(condition, new DbParameter[0]);
a.ActivityReminds = this._context.Where <SysActivityRemind>(condition, new DbParameter[0]);
a.ActivityOperations = this._context.Where <SysActivityOperation>(condition, new DbParameter[0]);
a.Expressions = p.Expressions.Where <SysExpression>(delegate(SysExpression i) {
long?activityId = i.ActivityId;
long num = a.ActivityId;
return((activityId.GetValueOrDefault() == num) && activityId.HasValue);
}).ToList <SysExpression>();
a.FromTransitions = p.Transitions.Where <SysTransition>(delegate(SysTransition i) {
long?preActivityId = i.PreActivityId;
long activityId = a.ActivityId;
return((preActivityId.GetValueOrDefault() == activityId) && preActivityId.HasValue);
}).ToList <SysTransition>();
a.ToTransitions = p.Transitions.Where <SysTransition>(delegate(SysTransition i) {
long?postActivityId = i.PostActivityId;
long activityId = a.ActivityId;
return((postActivityId.GetValueOrDefault() == activityId) && postActivityId.HasValue);
}).ToList <SysTransition>();
foreach (SysActivityParticipant participant in a.ActivityParticipants)
{
this.LoadActivityParticipant(participant, a, p);
}
foreach (SysActivityRemind remind in a.ActivityReminds)
{
this.LoadActivityRemind(remind, a, p);
}
foreach (SysActivityOperation operation in a.ActivityOperations)
{
this.LoadActivityOperation(operation, a);
}
}
/// <summary>
/// 验证流程的完整性，绑定流程详情和验证错误信息
/// </summary>
private void BindAndValidateData(SysProcess process)
{
this.lblProcessName.Text = process.ProcessName;
this.lblProcessVersion.Text = process.ProcessVersion;
//表单相关
SysForm form = this.DataHelper.FindById <SysForm>(process.FormId);
if (form != null)
{
this.lblFormName.Text = form.FormName;
SysEntity entity = GetEntity(form.EntityId);
if (entity != null)
{
this.lblProcessEntity.Text = entity.DisplayText;
}
else
{
AddError(new Exception("流程实体为空，请至表单配置页面设置"));
}
}
else
{
AddError(new Exception("流程关联表单为空，请返回至第一步配置"));
}
//流程参与人
var ppCount = this.DataHelper.Set <SysProcessParticipant>()
.Where(p => p.ProcessId == this.ProcessId).Count();
if (ppCount == 0)
{
AddError(new Exception("流程参与人未配置，请返回至第一步配置"));
}
//活动相关
var activityList = this.DataHelper.Set <SysActivity>()
.Where(p => p.ProcessId == this.ProcessId).OrderBy(p => p.DisplayOrder ?? 0).ToList();
this.gcActivity.DataSource = activityList.Select(p => new
{
p.ActivityName,
ActivityType = EnumHelper.GetDescription((ActivityType)p.ActivityType),
ExecuteType = EnumHelper.GetDescription((ActivityExecType)p.ExecType),
ActivityParticipant = GetActivityParticipant(p),
}).ToList();
this.gcActivity.DataBind();
if (activityList.Count(p => p.ActivityType == (int)ActivityType.Start) != 1)
{
AddError(new Exception("流程开始活动内部错误，请重建流程"));
return;
}
if (activityList.Count(p => p.ActivityType == (int)ActivityType.End) != 2)
{
AddError(new Exception("流程结束活动内部错误，请重建流程"));
return;
}
if (activityList.Count(p => p.ActivityType == (int)ActivityType.Approve) == 0)
{
AddError(new Exception("流程审核活动内部错误，请重建流程"));
return;
}
foreach (var a in activityList)
{
if (string.IsNullOrEmpty(a.ActivityName))
{
AddError(new Exception("活动名称为空，请返回至第二步配置"));
}
if (a.ActivityType == (int)ActivityType.Approve)
{
var apCount = this.DataHelper.Set <SysActivityParticipant>()
.Where(p => p.ActivityId == a.ActivityId).Count();
if (apCount == 0)
{
AddError(new Exception(string.Format("活动【{0}】参与人未配置，请返回至第二步配置", a.ActivityName)));
}
}
}
//连接线完整性验证
List <SysTransition> tList = this.DataHelper.Set <SysTransition>()
.Where(p => p.ProcessId == this.ProcessId).ToList();
Queue <SysActivity> queue = new Queue <SysActivity>();
SysActivity start = activityList.FirstOrDefault(p => p.ActivityType == (int)ActivityType.Start);
SysActivity temp = start;
queue.Enqueue(start);
while (queue.Count > 0)
{
temp = queue.Dequeue();
SysTransition t = tList.FirstOrDefault(p => p.PreActivityId == temp.ActivityId &&
p.Direction == (int)FlowStepDirection.True);
if (t != null)
{
temp = activityList.FirstOrDefault(p => p.ActivityId == t.PostActivityId);
queue.Enqueue(temp);
}
else
{
break;
}
}
if (!(temp.ActivityType == (int)ActivityType.End && temp.ActivityName == "通过"))
{
AddError(new Exception(string.Format("流程在活动【{0}】处断开，内部错误，请重建流程", temp.ActivityName)));
}
}
/// <summary>
/// 复制流程，从“已启用”或“已升级”的流程进入设计，需要先复制一份流程供设计
/// 状态为“新增”，版本为当前最高版本 + 1
/// </summary>
public SysProcess CopyProcess()
{
SysProcess result;
using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope())
{
using (BizDataContext db = new BizDataContext())
{
//新流程
SysProcess newP = _process.ConvertTo <SysProcess>();
newP.ProcessId = db.GetNextIdentity();
//版本处理
newP.ProcessStatus = (int)ProcessState.Created;
string maxVersion = db.Set <SysProcess>().Where(p => p.ProcessType == _process.ProcessType).OrderByDescending(p => p.ProcessVersion).First().ProcessVersion;
newP.ProcessVersion = (maxVersion.ToInt() + 1).ToString();
result = newP;
db.Insert(newP);
//新流程参与人
var ppList = db.Set <SysProcessParticipant>().Where(p => p.ProcessId == _process.ProcessId).ToList();
Dictionary <long?, SysProcessParticipant> tempPpDict = new Dictionary <long?, SysProcessParticipant>();
foreach (var pp in ppList)
{
SysProcessParticipant newPp = pp.ConvertTo <SysProcessParticipant>();
newPp.ParticipantId = db.GetNextIdentity();
newPp.ProcessId = newP.ProcessId;
tempPpDict[pp.ParticipantId] = newPp; //记录原始ID和新对象的关系
}
foreach (var newPp in tempPpDict.Values)
{
if (newPp.Param_ParticipantId != null) //通过刚才记录的关系找到实际的值
{
newPp.Param_ParticipantId = tempPpDict[newPp.Param_ParticipantId].ParticipantId;
}
db.Insert(newPp);
}
//新活动
var aList = db.Set <SysActivity>().Where(p => p.ProcessId == _process.ProcessId).ToList();
Dictionary <long?, SysActivity> tempADict = new Dictionary <long?, SysActivity>();
foreach (var a in aList)
{
SysActivity newA = a.ConvertTo <SysActivity>();
newA.ActivityId = db.GetNextIdentity();
newA.ProcessId = newP.ProcessId;
tempADict[a.ActivityId] = newA;//记录原始ID和新对象的关系
db.Insert(newA);
//新活动参与人
var apList = db.Set <SysActivityParticipant>().Where(p => p.ActivityId == a.ActivityId).ToList();
foreach (var ap in apList)
{
SysActivityParticipant newAp = ap.ConvertTo <SysActivityParticipant>();
newAp.ActivityParticipantId = db.GetNextIdentity();
newAp.ActivityId = newA.ActivityId;
newAp.ParticipantId = tempPpDict[newAp.ParticipantId].ParticipantId; //通过刚才记录的关系找到实际的值
db.Insert(newAp);
}
}
//连接线
var tList = db.Set <SysTransition>().Where(p => p.ProcessId == _process.ProcessId).ToList();
foreach (var t in tList)
{
SysTransition newT = t.ConvertTo <SysTransition>();
newT.TransitionId = db.GetNextIdentity();
newT.ProcessId = newP.ProcessId;
//通过刚才记录的关系找到实际的值
newT.PreActivityId = tempADict[newT.PreActivityId].ActivityId;
newT.PostActivityId = tempADict[newT.PostActivityId].ActivityId;
db.Insert(newT);
}
//表单活动权限
var fpList = db.Set <SysFormPrivilege>().Where(p => p.ProcessId == _process.ProcessId).ToList();
foreach (var fp in fpList)
{
SysFormPrivilege newFp = fp.ConvertTo <SysFormPrivilege>();
newFp.PrivilegeId = db.GetNextIdentity();
newFp.ProcessId = newP.ProcessId;
newFp.ActivityId = tempADict[newFp.ActivityId].ActivityId;//通过刚才记录的关系找到实际的值
db.Insert(newFp);
}
}
ts.Complete();
}
return(result);
}
private void ExecuteForManual(SysActivity activity, SysProcess process, Queue <WorkflowMessage> queue)
{
if ((activity.ActivityParticipants == null) || (activity.ActivityParticipants.Count == 0))
{
throw new ApplicationException("未指定参与人");
}
Dictionary <SysWorkItemApproveGroup, List <IUser> > dictionary = new Dictionary <SysWorkItemApproveGroup, List <IUser> >(20);
List <IUser> list = new List <IUser>();
if (this.AI.UserDefinedApproveUsers.Count > 0)
{
SysWorkItemApproveGroup key = this.CreateWorkItemGroup();
IOrgProxy orgProxy = OrgProxyFactory.GetProxy(base.Context);
List <IUser> users = (from p in this.AI.UserDefinedApproveUsers select orgProxy.GetUserById(p.UserId.Value)).ToList <IUser>();
this.RemoveRepeatedUsers(users);
list.AddRange(users);
dictionary.Add(key, users);
}
else
{
using (IEnumerator <SysActivityParticipant> enumerator = activity.ActivityParticipants.GetEnumerator())
{
while (enumerator.MoveNext())
{
Func <SysProcessParticipant, bool> predicate = null;
SysActivityParticipant activity_part = enumerator.Current;
SysWorkItemApproveGroup group = this.CreateWorkItemGroup(activity_part);
if (predicate == null)
{
predicate = p => p.ParticipantId == activity_part.ParticipantId.Value;
}
SysProcessParticipant part = process.ProcessParticipants.FirstOrDefault <SysProcessParticipant>(predicate);
if (part == null)
{
throw new ApplicationException("参与人为空");
}
int? wiOwnerId = null;
var users = ParticipantHelper.GetUsers(base.Context, part, base.PI, this.AI, wiOwnerId);
List <IUser> targetUsers = users;
this.AssertGroupHasUsers(activity_part, group, targetUsers);
this.RemoveRepeatedUsers(targetUsers);
list.AddRange(targetUsers);
dictionary.Add(group, targetUsers);
}
}
}
if (list.Count == 0)
{
bool?isPassedWithNoParticipants = this.AI.Activity.IsPassedWithNoParticipants;
if (!(isPassedWithNoParticipants.HasValue ? isPassedWithNoParticipants.GetValueOrDefault() : false))
{
throw new ApplicationException("未计算出任何参与人");
}
SysActivityInstance aI = this.AI;
aI.InstanceStatus = 10;
aI.EndTime = new DateTime?(DateTime.Now);
aI.ApproveResult = 1;
aI.ExpressionValue = 1;
aI.Remark = "无人审核,自动通过";
base.PICacheFactory.UpdateActiviyInstance(this.AI);
WorkflowMessage item = base.Engine.NewCompleteActivityMessage(this.AI);
queue.Enqueue(item);
}
else
{
SysActivity activity3 = this.AI.Activity;
if (!activity3.PassType.HasValue)
{
activity3.PassType = 1;
if (!activity3.MinPassNum.HasValue)
{
activity3.MinPassNum = 1;
}
}
foreach (KeyValuePair <SysWorkItemApproveGroup, List <IUser> > pair in dictionary)
{
SysWorkItemApproveGroup group3 = pair.Key;
foreach (IUser user in pair.Value)
{
this.CreateWorkItem(user, group3);
}
}
}
if (this.AI.UserDefinedApproveUsers.Count > 0)
{
base.PICacheFactory.ClearApproveUsers(this.AI);
}
}
