/// <summary>
///
/// </summary>
/// <param name="process"></param>
/// <param name="descriptor"></param>
/// <returns></returns>
public IWfActivity CreateActivity(IWfProcess process, IWfActivityDescriptor descriptor)
{
WfActivity activity = new WfActivity(descriptor);
activity.Process = process;
return activity;
}
private static void OutputActivity(IWfActivityDescriptor actDesp)
{
Console.Write(actDesp.Key);
if (actDesp.AssociatedActivityKey.IsNotEmpty())
Console.Write("({0})", actDesp.AssociatedActivityKey);
}
private static void OutputActivities(IWfTransitionDescriptor transition, IWfActivityDescriptor targetActDesp, Dictionary<string, IWfTransitionDescriptor> elapsedTransitions)
{
if (transition != null)
{
//防止死循环
if (elapsedTransitions.ContainsKey(transition.Key))
return;
elapsedTransitions.Add(transition.Key, transition);
}
if (transition != null)
{
Console.Write("从 ");
OutputActivity(transition.FromActivity);
Console.Write(" 经过 {0} ", transition.Key);
}
Console.Write("到 ");
OutputActivity(targetActDesp);
Console.WriteLine();
foreach (IWfTransitionDescriptor t in targetActDesp.ToTransitions)
{
OutputActivities(t, t.ToActivity, elapsedTransitions);
}
}
internal OpinionListViewBindEventArgs(GenericOpinion currentOpinion, IWfActivityDescriptor currentWfActDesc, Control container, bool readOnly)
{
_opinion = currentOpinion;
_wfActDesc = currentWfActDesc;
_container = container;
_readOnly = readOnly;
}
public WfCopyMainStreamActivityNode(IWfActivityDescriptor templateActDesp, IWfActivityDescriptor originalActDesp, bool needCopy, bool isEndActivity)
{
this._TemplateActivityDescriptor = templateActDesp;
this._OriginalActivityDescriptor = originalActDesp;
this._NeedCopy = needCopy;
this._IsEndActivity = isEndActivity;
}
protected WfActivityBase(IWfActivityDescriptor descriptor)
{
_Descriptor = descriptor;
this._ProcessDescKey = descriptor.Process.Key;
this._ActivityDescKey = descriptor.Key;
this._StartTime = DateTime.MinValue;
}
public WfActivityBase CreateActivity(IWfActivityDescriptor actDesp)
{
WfActivityBase activity = CreateActivityInstance(actDesp);
LoadActions(activity);
return activity;
}
public WfAdminDeleteActivityExecutor(IWfActivity operatorActivity, IWfActivityDescriptor targetActivityDescriptor, bool syncMSObject) :
base(operatorActivity, WfControlOperationType.AdminDeleteActivity)
{
targetActivityDescriptor.NullCheck("targetActivityDescriptor");
this._TargetActivityDescriptor = targetActivityDescriptor;
this._SyncMainStreamObject = syncMSObject;
}
/// <summary>
/// 活动实例是否运行过或正在运行
/// </summary>
/// <returns></returns>
private static bool InstanceIsRunning(IWfActivityDescriptor actDesp)
{
bool result = false;
if (actDesp.IsMainStreamActivity == false && actDesp.Instance != null)
result = actDesp.Instance.Status != WfActivityStatus.NotRunning;
return result;
}
public WfMoveToSelectedResult(WfControlOperationType opType, WfControlNextStep nextStep)
{
this._OperationType = opType;
IWfProcessDescriptor processDesp = WfClientContext.Current.CurrentActivity.Process.Descriptor;
this._TargetActivityDescriptor = processDesp.Activities[nextStep.ActivityDescriptor.Key];
if (nextStep.TransitionDescriptor != null)
this._FromTransitionDescriptor = processDesp.FindTransitionByKey(nextStep.TransitionDescriptor.Key);
this.Assignees.CopyFrom(nextStep.Candidates);
}
public WfAdminAddActivityExecutor(IWfActivity operatorActivity,
IWfProcess process,
IWfActivityDescriptor fromActivityDesp,
IWfActivityDescriptor newActivityDesp,
bool syncMSObject)
: base(operatorActivity, process, newActivityDesp, syncMSObject, WfControlOperationType.AdminAddActivity)
{
this._FromActivityDescriptor = fromActivityDesp;
newActivityDesp.NullCheck("newActivityDesp");
this._NewActivityDescriptor = newActivityDesp;
}
private static List<TransitionInfo> AdaptMainStreamTransitionProperties(IWfActivityDescriptor instanceActDesc)
{
List<TransitionInfo> result = new List<TransitionInfo>();
foreach (var tran in instanceActDesc.ToTransitions)
{
var link = new TransitionInfo()
{
Key = tran.Key,
Name = tran.Name,
Enabled = tran.Enabled,
FromActivityKey = instanceActDesc.Key,
ToActivityKey = tran.ToActivity.Key,
WfReturnLine = tran.IsBackward,
IsPassed = false
};
result.Add(link);
}
return result;
}
public static void AssertActivityDescriptor(this WfClientActivityDescriptor cad, IWfActivityDescriptor sad)
{
cad.AreSame(sad);
Assert.AreEqual(cad.ActivityType, sad.ActivityType.ToClientActivityType());
cad.Condition.AreSame(sad.Condition);
cad.Variables.AssertCollection(sad.Variables);
cad.Resources.AssertResources(sad.Resources);
cad.EnterEventReceivers.AssertResources(sad.EnterEventReceivers);
cad.LeaveEventReceivers.AssertResources(sad.LeaveEventReceivers);
cad.BranchProcessTemplates.AssertBranchProcessTemplateCollection(sad.BranchProcessTemplates);
cad.ToTransitions.AssertCollection(sad.ToTransitions);
cad.ToTransitions.ForEach(ct => ct.IsValid());
sad.ToTransitions.ForEach(st => st.IsValid());
cad.GetFromTransitions().AssertCollection(sad.FromTransitions);
cad.GetFromTransitions().ForEach(ct => ct.IsValid());
sad.FromTransitions.ForEach(st => st.IsValid());
cad.RelativeLinks.AssertRelativeLinks(sad.RelativeLinks);
}
public WfTransferParamsBase(IWfActivityDescriptor nextActivityDescriptor)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(nextActivityDescriptor != null, "nextActivityDescriptor");
_NextActivityDescriptor = nextActivityDescriptor;
}
/// <summary> /// 创建活动 /// </summary> /// <param name="actDesp"></param> /// <returns></returns> protected abstract WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp);
/// <summary>
///
/// </summary>
/// <param name="nextActivityDescriptor"></param>
public WfTransferParams(IWfActivityDescriptor nextActivityDescriptor)
: base(nextActivityDescriptor)
{
}
protected override WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp)
{
return(new WfCompletedActivity(actDesp));
}
/// <summary>
/// 动态活动生成后整理新生成的动态活动的属性
/// </summary>
/// <param name="firstDynActDesp"></param>
/// <param name="wfActivityBase"></param>
private static void ChangeNewDynActivitiesProperties(WfActivityDescriptorCollection createdActivities, IWfActivityDescriptor templateActDesp)
{
foreach (IWfActivityDescriptor actDesp in createdActivities)
{
((WfActivityDescriptor)actDesp).SetDynamicActivityProperties(templateActDesp.Key);
if (actDesp.IsMainStreamActivity == false && actDesp.Instance != null)
{
actDesp.Instance.GenerateCandidatesFromResources();
}
}
}
/// <summary>
/// 在当前活动实例后，添加一个新的活动
/// </summary>
/// <param name="actDesp"></param>
/// <returns></returns>
public IWfActivity Append(IWfActivityDescriptor newActDesp)
{
return(Append(newActDesp, false));
}
private static void ChangeActivityResources(IWfActivityDescriptor actDesp, IEnumerable <IUser> users)
{
actDesp.Resources.Clear();
users.ForEach(u => actDesp.Resources.Add(new WfUserResourceDescriptor(u)));
}
private WfActivityDescriptorCollection CreateActivities(WfTransitionDescriptorCollection fromTransitions, WfCreateActivityParamCollection capc, WfTransitionDescriptorCollection toTransitions)
{
WfActivityDescriptorCollection result = new WfActivityDescriptorCollection(this.Process);
IWfActivityDescriptor firstDynamicActivity = null;
IWfActivityDescriptor lastDynamicActivity = null;
WfCreateActivityParam lastCreatedActivityParam = null;
foreach (WfCreateActivityParam cap in capc)
{
WfActivityDescriptor actDesp = (WfActivityDescriptor)cap.Template.Clone();
actDesp.Process = this.Process;
string newActKey = "ND" + cap.ActivitySN;
if (this.Process.Activities.ContainsKey(newActKey))
{
newActKey = this.Process.FindNotUsedActivityKey();
}
actDesp.Key = newActKey;
cap.CreatedDescriptor = actDesp;
this.Process.Activities.Add(actDesp);
if (lastCreatedActivityParam != null)
{
lastCreatedActivityParam.DefaultNextDescriptor = actDesp;
}
lastCreatedActivityParam = cap;
if (this.IsMainStreamActivity == false && this.ProcessInstance != null)
{
WfActivityBase.CreateActivityInstance(actDesp, this.ProcessInstance);
}
if (firstDynamicActivity == null)
{
firstDynamicActivity = actDesp;
}
if (lastDynamicActivity != null)
{
WfTransitionDescriptor newTransition = (WfTransitionDescriptor)lastDynamicActivity.ToTransitions.AddForwardTransition(actDesp);
//如果不是第一个生成的活动
if (firstDynamicActivity != actDesp)
{
newTransition.GeneratedByTemplate = true;
newTransition.TemplateKey = this.Key;
}
}
lastDynamicActivity = actDesp;
result.Add(actDesp);
}
if (firstDynamicActivity != null && lastDynamicActivity != null)
{
SetEntryTransitionsProperties(firstDynamicActivity, fromTransitions);
if (lastCreatedActivityParam != null)
{
IWfTransitionDescriptor defaultTransition =
toTransitions.GetAllConditionMatchedTransitions().FindDefaultSelectTransition(true);
if (defaultTransition != null)
{
lastCreatedActivityParam.DefaultNextDescriptor = defaultTransition.ToActivity;
}
}
capc.AdjustTransitionsByTemplate(this.Key);
//如果在活动模板参数的最后一个活动没有配置出线，则使用默认的出线；否则使用配置的出线
if (lastDynamicActivity.ToTransitions.Count == 0)
{
SetExitTransitionsProperties(lastDynamicActivity, toTransitions);
}
else
{
lastDynamicActivity.ToTransitions.ForEach(t => SetDynamicTransitionProperties(null, t, this, false));
}
}
else
{
//当没有动态活动生成时，前后的活动直接串联到一起
JoinOriginalActivitiesAndSetProperties(fromTransitions, toTransitions);
}
//将模版点的进出线的Enabled都设置为False
fromTransitions.ForEach(t => ((WfTransitionDescriptor)t).Enabled = false);
toTransitions.ForEach(t => ((WfTransitionDescriptor)t).Enabled = false);
return(result);
}
private static void ChangeMainStreamSecretaryActivities(WfSecretaryOperation operation, IWfActivityDescriptor msOperationActDesp)
{
IWfTransitionDescriptor prevTransition = msOperationActDesp.FromTransitions.Find(t => t.FromActivity.Variables.GetValue(WfHelper.SecretaryActivity, false));
IWfTransitionDescriptor succeedTransition = msOperationActDesp.ToTransitions.Find(t => t.ToActivity.Variables.GetValue(WfHelper.SecretaryActivity, false));
if (prevTransition != null)
{
ChangeActivityResources(prevTransition.FromActivity, operation.Secretaries);
}
if (succeedTransition != null)
{
ChangeActivityResources(succeedTransition.ToActivity, operation.Secretaries);
}
DecroateTemplateActivity(operation.ActivityDescriptor, operation.Secretaries);
}
private static void ClearMainStreamSecretaryActivities(WfSecretaryOperation operation, IWfActivityDescriptor msOperationActDesp)
{
IWfTransitionDescriptor prevTransition = msOperationActDesp.FromTransitions.Find(t => t.FromActivity.Variables.GetValue(WfHelper.SecretaryActivity, false));
IWfTransitionDescriptor succeedTransition = msOperationActDesp.ToTransitions.Find(t => t.ToActivity.Variables.GetValue(WfHelper.SecretaryActivity, false));
bool needRemoveInitial = false;
if (prevTransition != null)
{
if (prevTransition.FromActivity.ActivityType == WfActivityType.InitialActivity)
{
needRemoveInitial = true;
}
List <IWfTransitionDescriptor> fromTransitions = new List <IWfTransitionDescriptor>();
prevTransition.FromActivity.FromTransitions.CopyTo(fromTransitions);
prevTransition.FromActivity.Remove();
foreach (IWfTransitionDescriptor fromTransition in fromTransitions)
{
fromTransition.ConnectActivities(fromTransition.FromActivity, msOperationActDesp);
}
}
if (succeedTransition != null)
{
List <IWfTransitionDescriptor> toTransitions = new List <IWfTransitionDescriptor>();
succeedTransition.ToActivity.ToTransitions.CopyTo(toTransitions);
succeedTransition.ToActivity.Remove();
foreach (IWfTransitionDescriptor toTransition in toTransitions)
{
toTransition.ConnectActivities(msOperationActDesp, toTransition.ToActivity);
}
}
if (needRemoveInitial)
{
((WfActivityDescriptor)msOperationActDesp).ActivityType = WfActivityType.InitialActivity;
msOperationActDesp.Process.Activities.InitialActivity = msOperationActDesp;
}
DedecroateTemplateActivity(msOperationActDesp, operation.Secretaries);
}
/// <summary>
/// 添加主线活动的秘书环节
/// </summary>
/// <param name="operation"></param>
/// <param name="msOperationActDesp"></param>
private static void AddMainStreamSecretaryActivities(WfSecretaryOperation operation, IWfActivityDescriptor msOperationActDesp, AddSecretaryResult instanceResult)
{
AddSecretaryResult result = new AddSecretaryResult();
//保留住原来领导活动的出线
List <IWfTransitionDescriptor> templateToTransitions = new List <IWfTransitionDescriptor>(msOperationActDesp.ToTransitions);
IWfActivityDescriptor prevSecretaryActDesp = CreateSecretaryActivityDescriptor(msOperationActDesp, operation.Secretaries);
SetActivityPropertiesBooleanValue(prevSecretaryActDesp, false, WfSecretaryDecorator._PrevActForbidProperties);
SetActivityPropertiesBooleanValue(prevSecretaryActDesp, true, WfSecretaryDecorator._PrevActAllowProperties);
msOperationActDesp.InsertBefore(prevSecretaryActDesp);
DecroateTemplateActivity(msOperationActDesp, operation.Secretaries);
IWfActivityDescriptor succeedSecretaryActDesp = CreateSecretaryActivityDescriptor(msOperationActDesp, operation.Secretaries);
SetActivityPropertiesBooleanValue(succeedSecretaryActDesp, false, WfSecretaryDecorator._SucceedActForbidProperties);
msOperationActDesp.Append(succeedSecretaryActDesp, true);
AdjustTemplateActivityToTransitions(msOperationActDesp, succeedSecretaryActDesp, templateToTransitions);
((WfActivityBase)instanceResult.PrevActivity).MainStreamActivityKey = prevSecretaryActDesp.Key;
((WfActivityBase)instanceResult.SucceedActivity).MainStreamActivityKey = succeedSecretaryActDesp.Key;
}
public WfNormalActivity(IWfActivityDescriptor descriptor) : base(descriptor)
{
}
protected override WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp)
{
throw new NotImplementedException();
}
protected override WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp)
{
throw new NotImplementedException();
}
/// <summary>
/// 添加同意和不同意的出线
/// </summary>
/// <param name="currentActDesp"></param>
private static void AddAgreeAndDisagreeLine(IWfActivityDescriptor currentActDesp, IWfActivityDescriptor nextActDesp, IWfBranchProcessTemplateDescriptor template)
{
IWfActivityDescriptor completedActDesp = currentActDesp.Process.CompletedActivity;
WfTransitionDescriptor agreeTransition = (WfTransitionDescriptor)currentActDesp.ToTransitions.AddForwardTransition(nextActDesp);
agreeTransition.Name = template.Properties.GetValue("AgreeLineName", "同意");
agreeTransition.DefaultSelect = true;
agreeTransition.AffectProcessReturnValue = true;
agreeTransition.AffectedProcessReturnValue = true;
agreeTransition.Priority = 0;
WfTransitionDescriptor disagreeTransition = (WfTransitionDescriptor)currentActDesp.ToTransitions.AddForwardTransition(completedActDesp);
disagreeTransition.Name = template.Properties.GetValue("DisagreeLineName", "不同意");
disagreeTransition.Priority = 1;
disagreeTransition.AffectProcessReturnValue = true;
disagreeTransition.AffectedProcessReturnValue = false;
}
/// <summary>
/// 验证模版上没有资源的动态活动的动态线和模版线之间的数量匹配和属性值
/// </summary>
/// <param name="dynamicTransitions"></param>
/// <param name="templateActDesp"></param>
private static void ValidateNoResourceTransitionsProperties(IEnumerable <IWfTransitionDescriptor> dynamicTransitions, IWfActivityDescriptor templateActDesp)
{
Assert.AreEqual(templateActDesp.FromTransitions.Count, dynamicTransitions.Count());
foreach (IWfTransitionDescriptor transition in dynamicTransitions)
{
Assert.IsTrue(transition.Enabled, "动态线应该是Enabled");
Assert.AreEqual(templateActDesp.Key, transition.Properties.GetValue("DynamicSource", string.Empty), "动态线的DynamicSource与模版的Key相同");
}
}
/// <summary>
/// 检查模版的候选人和生成的动态角色候选人是否一样
/// </summary>
/// <param name="firstDynamicActDesp"></param>
/// <param name="templateActDesp"></param>
private static void ValidateTemplateCandidatesAndDynamicActivityCandidates(IWfActivityDescriptor firstDynamicActDesp, IWfActivityDescriptor templateActDesp)
{
IWfActivityDescriptor currentActDesp = firstDynamicActDesp;
foreach (WfAssignee assignee in templateActDesp.Instance.Candidates)
{
Assert.IsTrue(currentActDesp.Instance.Candidates.Contains(assignee.User), "检查模版的候选人和生成的动态角色候选人是否一样");
IWfTransitionDescriptor transition = currentActDesp.ToTransitions.GetAllCanTransitForwardTransitions().FirstOrDefault();
Assert.IsNotNull(transition, "动态活动的数量必须和模版资源匹配");
currentActDesp = transition.ToActivity;
}
}
/// <summary>
/// 设置动态活动进出线的属性
/// </summary>
/// <param name="sourceTransition"></param>
/// <param name="dynTransition"></param>
/// <param name="templateActDesp"></param>
/// <param name="isEntryTransition"></param>
private static void SetDynamicTransitionProperties(IWfTransitionDescriptor sourceTransition, IWfTransitionDescriptor dynTransition, IWfActivityDescriptor templateActDesp, bool isEntryTransition)
{
if (sourceTransition != null)
{
((WfTransitionDescriptor)sourceTransition).CloneProperties((WfTransitionDescriptor)dynTransition);
}
((WfTransitionDescriptor)dynTransition).Enabled = true;
if (isEntryTransition)
{
((WfTransitionDescriptor)dynTransition).IsDynamicActivityTransition = true;
}
dynTransition.Properties.TrySetValue("DynamicSource", templateActDesp.Key);
}
private string GetActivityEmptyOpinionText(IWfActivityDescriptor actDesp)
{
string opText = actDesp != null ? actDesp.Properties.GetValue("EmptyOpinionText", string.Empty) : string.Empty;
if (string.IsNullOrEmpty(opText))
opText = this.EmptyOpinionText;
return opText;
}
//活动矩阵定义的属性优先于活动模板定义的属性，矩阵中没有设置的属性，则使用活动模版的属性
private static void MergeDynamicActivitiesProperties(WfCreateActivityParamCollection createActivityParams, IWfActivityDescriptor templateActDesp)
{
foreach (WfCreateActivityParam cap in createActivityParams)
{
PropertyValueCollection templateProperties = new PropertyValueCollection();
foreach (PropertyValue pv in templateActDesp.Properties)
{
if (cap.RoleDefineActivityPropertyNames.Exists(name => pv.Definition.Name == name))
{
if (cap.Template.Properties.ContainsKey(pv.Definition.Name))
{
templateProperties.Add(cap.Template.Properties[pv.Definition.Name]);
}
}
else
{
templateProperties.Add(pv);
}
}
cap.Template.Properties.ReplaceExistedPropertyValues(templateProperties);
cap.Template.RelativeLinks.Clear();
cap.Template.RelativeLinks.CopyFrom(templateActDesp.RelativeLinks);
cap.Template.Variables.Clear();
cap.Template.Variables.CopyFrom(templateActDesp.Variables);
//cap.Template.EnterEventReceivers.Clear();
cap.Template.EnterEventReceivers.CopyFrom(templateActDesp.EnterEventReceivers);
//cap.Template.LeaveEventReceivers.Clear();
cap.Template.LeaveEventReceivers.CopyFrom(templateActDesp.LeaveEventReceivers);
cap.Template.EnterEventExecuteServices.Clear();
cap.Template.EnterEventExecuteServices.CopyFrom(templateActDesp.EnterEventExecuteServices);
cap.Template.LeaveEventExecuteServices.Clear();
cap.Template.LeaveEventExecuteServices.CopyFrom(templateActDesp.LeaveEventExecuteServices);
cap.Template.WithdrawExecuteServices.Clear();
cap.Template.WithdrawExecuteServices.CopyFrom(templateActDesp.WithdrawExecuteServices);
cap.Template.BeWithdrawnExecuteServices.Clear();
cap.Template.BeWithdrawnExecuteServices.CopyFrom(templateActDesp.BeWithdrawnExecuteServices);
}
}
private void OnRenderOneActivity(IWfActivity currentActivity, IWfActivityDescriptor activityDesctiptor, RenderOneActivityEventArgs eventArgs)
{
if (RenderOneActivityEvent != null)
RenderOneActivityEvent(this, eventArgs);
}
protected override IWfActivityDescriptor PrepareActivityDescriptor(IWfActivityDescriptor targetActDesp)
{
return(targetActDesp);
}
private bool CanActivityInputOpinion(IWfActivityDescriptor actDesp)
{
bool result = false;
IWfActivity originalActivity = OriginalActivity;
IWfActivity rootActivity = originalActivity.OpinionRootActivity;
if (ReadOnly == false && originalActivity != null)
{
string levelName = rootActivity.Descriptor.AssociatedActivityKey != null ? rootActivity.Descriptor.AssociatedActivityKey : rootActivity.Descriptor.Key;
result = WfClientContext.Current.InCirculateMode && string.IsNullOrEmpty(levelName) == false &&
(levelName == actDesp.Key || levelName == actDesp.AssociatedActivityKey);
if (!result)
{
result = originalActivity.Process.Status == WfProcessStatus.Running &&
originalActivity.Status == WfActivityStatus.Running &&
string.IsNullOrEmpty(levelName) == false &&
(levelName == actDesp.Key || levelName == actDesp.Instance.MainStreamActivityKey || levelName == actDesp.AssociatedActivityKey);
if (result)
result = WfClientContext.Current.InMoveToMode;
}
}
return result;
}
/// <summary>
/// 设置线的FromActivity和ToActivity的相关属性，但是不影响fromActivity的ToTransitions以及toActivity的FromTransition的集合
/// </summary>
/// <param name="fromActivity"></param>
/// <param name="toActivity"></param>
internal protected virtual void JoinActivity(IWfActivityDescriptor fromActivity, IWfActivityDescriptor toActivity)
{
this._FromActivity = fromActivity;
this._ToActivity = toActivity;
this._FromActivityKey = fromActivity.Key;
this._ToActivityKey = toActivity.Key;
}
/// <summary> /// 创建活动 /// </summary> /// <param name="actDesp"></param> /// <returns></returns> protected abstract WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp);
private bool IsConsignActivity(IWfActivityDescriptor actDesp)
{
return actDesp.AssociatedActivityKey != null && actDesp.ClonedKey == null;
}
/// <summary>
///
/// </summary>
/// <param name="currentActivityDesp"></param>
/// <returns></returns>
private static IWfActivityDescriptor FindNotReturnSkippedActivity(IWfActivityDescriptor currentActivityDesp)
{
Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor> elapsedTransitions = new Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor>();
return InnerFindNotReturnSkippedActivity(currentActivityDesp, elapsedTransitions);
}
/// <summary>
/// 是否可以编辑环节的，根据AllowModifyActivities变量的值
/// </summary>
/// <param name="actDesp"></param>
/// <returns></returns>
private bool CanEditActivityDescriptor(IWfActivityDescriptor actDesp)
{
bool result = false;
if (CurrentActivity != null)
{
/*
List<IWfActivityDescriptor> activities = actDesp.Process.FindActivitiesByKeys(
CurrentActivity.Descriptor.Variables.GetValue("AllowModifyActivities", string.Empty).Split(',', ';'));
result = activities.Exists(a => a.Key == actDesp.Key);
*/
}
return result;
}
/// <summary>
/// targetActivity是否在currentActivity的后续的线上
/// </summary>
/// <param name="targetActivity"></param>
/// <param name="currentActivity"></param>
/// <returns></returns>
private static bool IsSubsequentActivity(IWfActivityDescriptor targetActivity, IWfActivityDescriptor currentActivity)
{
Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor> elapsedTransitions = new Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor>();
return InnerIsSubsequentActivity(targetActivity, currentActivity, elapsedTransitions);
}
private string GetActivityEditorClientID(IWfActivityDescriptor activityDescriptor)
{
string result = string.Empty;
if (this._activityEditor != null)
result = WfVariableDefine.UseGroupSelector(activityDescriptor) ?
this._groupActivityEditor.ClientID : this._activityEditor.ClientID;
return result;
}
private static void FillCopyContext(WfCopyMainStreamActivityNode currentActivity, IWfActivityDescriptor endActivity, WfCopyMainStreamContext context, WfControlOperationType operationType)
{
foreach (IWfTransitionDescriptor transition in currentActivity.TemplateActivityDescriptor.ToTransitions.GetNotDynamicActivityTransitions())
{
if (context.IsElapsedTransition(transition) == false)
{
IWfActivityDescriptor nextActivityDesp = transition.ToActivity;
if (operationType == WfControlOperationType.Return)
nextActivityDesp = FindNotReturnSkippedActivity(transition.ToActivity);
bool nextIsEndActivity = nextActivityDesp.Key == endActivity.Key;
IWfActivityDescriptor originalActDesp = nextActivityDesp;
if (context.IsMainStream)
{
originalActDesp = context.EndActivityDescriptor.FindSubsequentActivity((t, actDesp) =>
t.IsBackward == false && actDesp.Instance.MainStreamActivityKey == nextActivityDesp.Key);
}
WfCopyMainStreamActivityNode toActivity = new WfCopyMainStreamActivityNode(
nextActivityDesp,
originalActDesp,
IsSubsequentActivity(nextActivityDesp, endActivity) == false,
nextIsEndActivity);
currentActivity.ToActivities.Add(new WfCopyMainStreamSubActivityNode(transition, toActivity));
context.AddElapsedTransition(transition);
if (currentActivity.TemplateActivityDescriptor.Key != endActivity.Key)
FillCopyContext(toActivity, endActivity, context, operationType);
}
}
}
private string GetKeyFromActivity(IWfActivityDescriptor actDesp)
{
return actDesp.AssociatedActivityKey == null ? actDesp.Key : actDesp.AssociatedActivityKey;
}
/// <summary>
/// 根据当前活动定义找到默认的下一环节，生成流转参数
/// </summary>
/// <param name="currentActDesp"></param>
/// <returns></returns>
public static WfTransferParams FromNextDefaultActivity(IWfActivityDescriptor currentActDesp)
{
return(FromNextActivity(currentActDesp, (toTransitions) => toTransitions.FindDefaultSelectTransition()));
}
/// <summary>
///
/// </summary>
/// <param name="opinionCell">表格单元格</param>
/// <param name="msActDesp"></param>
/// <param name="inputActDesp">需要输入的活动描述</param>
/// <param name="nextStepSelectorActDesp"></param>
private void RenderLevelOpinionsPlaceHolders(HtmlTableCell opinionCell, IWfActivityDescriptor msActDesp, IWfActivityDescriptor inputActDesp, IWfActivityDescriptor nextStepSelectorActDesp)
{
HtmlGenericControl opinionContainer = new HtmlGenericControl("div");
opinionCell.Controls.Add(opinionContainer);
this._opinionPlaceHolders.Add(msActDesp, opinionContainer);
PageRenderMode pageMode = WebUtility.GetRequestPageRenderMode();
bool flag = inputActDesp != null || (pageMode.UseNewPage == true && pageMode.RenderControlUniqueID.IndexOf("PredefinedOpinionDialog") >= 0);
//如果当前环节可编辑，则输出意见输入控件
if (flag)
{
GenericOpinion currentOpinion = GetCurrentActivityOpinion();
OnOpinionBind(new OpinionListViewBindEventArgs(currentOpinion, inputActDesp, opinionCell, false));
HtmlGenericControl inputContainer = new HtmlGenericControl("div");
inputContainer.ID = "OpinionInputContainer";
opinionCell.Controls.Add(inputContainer);
inputContainer.Attributes["class"] = "opinionInputCell";
inputContainer.Controls.Add(_OpinionInput);
this._OpinionInput.OpinionContainer.Controls.Add(this.CreateNextStepSelectorControl(nextStepSelectorActDesp, flag));
_OpinionInput.Opinion = currentOpinion;
if (_OpinionInput.Opinion.Content.IsNullOrEmpty())
_OpinionInput.Opinion.Content = GetActivityEmptyOpinionText(inputActDesp);
_ActivateDescriptor = inputActDesp;
_ActivateContainer = opinionCell;
}
}
internal protected virtual void JoinActivity(IWfActivityDescriptor fromActivity, IWfActivityDescriptor toActivity)
{
_FromActivity = fromActivity;
_ToActivity = toActivity;
}
private static IWfActivityDescriptor InnerFindNotReturnSkippedActivity(IWfActivityDescriptor currentActivityDesp, Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor> elapsedTransitions)
{
IWfActivityDescriptor result = null;
if (currentActivityDesp.IsReturnSkipped == false)
result = currentActivityDesp;
else
{
foreach (IWfTransitionDescriptor transition in currentActivityDesp.ToTransitions)
{
if (elapsedTransitions.ContainsKey(transition) == false)
{
elapsedTransitions.Add(transition, transition);
result = InnerFindNotReturnSkippedActivity(transition.ToActivity, elapsedTransitions);
if (result != null)
break;
}
}
}
return result;
}
internal ToTransitionsDescriptorCollection(IWfActivityDescriptor fromActivity)
{
_FromActivity = fromActivity;
}
private static bool InnerIsSubsequentActivity(IWfActivityDescriptor targetActivity, IWfActivityDescriptor currentActivity, Dictionary<IWfTransitionDescriptor, IWfTransitionDescriptor> elapsedTransitions)
{
bool result = false;
if (targetActivity.Key != currentActivity.Key)
{
foreach (IWfTransitionDescriptor transition in currentActivity.ToTransitions)
{
if (elapsedTransitions.ContainsKey(transition) == false)
{
elapsedTransitions.Add(transition, transition);
if (transition.IsBackward == false)
{
if (transition.ToActivity.GetAssociatedActivity().Key == targetActivity.Key)
result = true;
if (result == false)
result = InnerIsSubsequentActivity(targetActivity, transition.ToActivity, elapsedTransitions);
if (result)
break;
}
}
}
}
return result;
}
internal FromTransitionsDescriptorCollection(IWfActivityDescriptor toActivity)
{
_ToActivity = toActivity;
}
/// <summary>
/// 根据FromActivity(线的发出点)得到线
/// </summary>
/// <param name="actDesp">FromActivity</param>
/// <returns>GetTransitionByFromActivity</returns>
/// <remarks>根据FromActivity(线的发出点)得到线</remarks>
/// <scholiast>徐照雨</scholiast>
public IWfTransitionDescriptor GetTransitionByFromActivity(IWfActivityDescriptor actDesp)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(actDesp != null, "actDesp");
return(GetTransitionByFromActivity(actDesp.Key));
}
/// <summary>
/// 创建线，并且连接两个活动。线的起点活动由fromActDesp指定，而终点活动由toActDesp指定
/// </summary>
/// <param name="fromActDesp">线的起点活动</param>
/// <param name="toActDesp">线的终点活动</param>
/// <returns></returns>
public IWfTransitionDescriptor CreateTransitionAndConnectActivities(IWfActivityDescriptor fromActDesp, IWfActivityDescriptor toActDesp)
{
fromActDesp.NullCheck("fromActDesp");
toActDesp.NullCheck("toActDesp");
IWfProcessDescriptor processDesp = fromActDesp.Process;
IWfTransitionDescriptor transition = CreateTransition(processDesp);
transition.ConnectActivities(fromActDesp, toActDesp);
return(transition);
}
protected override WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp)
{
return new WfCompletedActivity(actDesp);
}
/// <summary>
/// 删除已经生成的动态活动
/// </summary>
/// <param name="dynInTransition"></param>
/// <param name="templateActivity"></param>
internal static void DeleteExistedDynamicActivities(IWfTransitionDescriptor dynInTransition, IWfActivityDescriptor templateActivity)
{
IWfActivityDescriptor currentActDesp = dynInTransition.ToActivity;
WfActivityDescriptorCollection endActivities = templateActivity.GetToActivities();
//沈峥修改，2015-1-25，原来删除已经存在的动态活动时没有考虑多条出线的情况，现在改为递归删除
RemoveExistedDynamicActivityRecursively(currentActDesp, endActivities);
////判断当前活动不在结束的活动中
//while (currentActDesp != null && ((WfActivityDescriptor)currentActDesp).GeneratedByTemplate && endActivities.ContainsKey(currentActDesp.Key) == false)
//{
// IWfActivityDescriptor nextActDesp = currentActDesp.GetToActivities().FirstOrDefault();
// if (currentActDesp.IsMainStreamActivity == false && currentActDesp.Instance != null)
// currentActDesp.Instance.Remove();
// else
// currentActDesp.Remove();
// currentActDesp = nextActDesp;
//}
foreach (IWfActivityDescriptor actDesp in templateActivity.GetFromActivities())
{
IList <IWfTransitionDescriptor> transitions = actDesp.ToTransitions.FindAll(t => t.Properties.GetValue("DynamicSource", string.Empty) == templateActivity.Key);
transitions.ForEach(t => actDesp.ToTransitions.Remove(t));
}
}
public WfInitialActivity(IWfActivityDescriptor descriptor)
: base(descriptor)
{
}
/// <summary>
/// 从动态节点的起始点验证动态节点相关属性的正确性
/// </summary>
/// <param name="startActDesp"></param>
/// <param name="templateActDesp">动态活动模版</param>
private static IWfActivityDescriptor ValidateDynamicActivities(IWfActivityDescriptor startActDesp, IWfActivityDescriptor templateActDesp)
{
IWfActivityDescriptor firstDynamicActDesp = null;
Assert.IsTrue(startActDesp.ToTransitions.Count > 1, "起始点不止一条出线");
IWfTransitionDescriptor dynTransition = startActDesp.ToTransitions.Find(t => t.Properties.GetValue("DynamicSource", string.Empty) == templateActDesp.Key);
Assert.IsNotNull(dynTransition, "起始点有一条出线为生成的指向动态路径的线");
foreach (IWfTransitionDescriptor transition in templateActDesp.FromTransitions)
{
Assert.IsFalse(transition.Enabled, "模版活动的进线都是Disabled");
//Assert.IsTrue(transition.IsDynamicActivityTransition, "模版活动的进线的IsDynamicActivityTransition都是True");
}
foreach (IWfTransitionDescriptor transition in templateActDesp.ToTransitions)
{
Assert.IsFalse(transition.Enabled, "模版活动的出线都是Disabled");
//Assert.IsTrue(transition.IsDynamicActivityTransition, "模版活动的出线的IsDynamicActivityTransition都是True");
}
firstDynamicActDesp = dynTransition.ToActivity;
return(firstDynamicActDesp);
}
