/// <summary>
/// 调整同意和不同意的线
/// </summary>
/// <param name="result"></param>
private void AutoAdjustAgreeTransitions(IWfProcessDescriptor processDesp)
{
IWfActivityDescriptor currentActDesp = processDesp.InitialActivity;
IWfTransitionDescriptor transition = currentActDesp.ToTransitions.GetAllCanTransitForwardTransitions().FindDefaultSelectTransition();
while (transition != null && currentActDesp.ActivityType != WfActivityType.CompletedActivity)
{
IWfActivityDescriptor nextActDesp = transition.ToActivity;
if (currentActDesp.Variables.GetValue(WfProcessBuilderBase.AutoBuiltActivityVariableName, false))
{
if (this.SubProcessApprovalMode == WfSubProcessApprovalMode.AnyActivityDecide ||
(this.SubProcessApprovalMode == WfSubProcessApprovalMode.LastActivityDecide && nextActDesp.ActivityType == WfActivityType.CompletedActivity))
{
currentActDesp.ToTransitions.RemoveByToActivity(nextActDesp);
//这句可以不要，RemoveByToActivity清除了相关的线
//nextActDesp.FromTransitions.Remove(t => string.Compare(t.Key, transition.Key) == 0);
AddAgreeAndDisagreeLine(currentActDesp, nextActDesp, this);
}
}
currentActDesp = nextActDesp;
transition = currentActDesp.ToTransitions.GetAllCanTransitForwardTransitions().FindDefaultSelectTransition();
}
}
/// <summary>
/// 根据流程和上下文
/// </summary>
/// <param name="process"></param>
internal void FillActivityAndTransitionInfoFromContext(IWfProcess process)
{
process.NullCheck("process");
if (this._NextActivityDescriptor == null)
{
string nextActivityDescriptorKey = this.Context.GetValue("NextActivityDescriptorKey", string.Empty);
if (nextActivityDescriptorKey.IsNotEmpty())
{
IWfActivity nextActivity = process.Activities.FindActivityByDescriptorKey(nextActivityDescriptorKey);
if (nextActivity != null)
{
this.NextActivityDescriptor = nextActivity.Descriptor;
}
}
}
if (this._FromTransitionDescriptor == null)
{
string fromTransitionDescriptorKey = this.Context.GetValue("FromTransitionDescriptorKey", string.Empty);
if (fromTransitionDescriptorKey.IsNotEmpty())
{
IWfTransitionDescriptor fromTransition = process.Descriptor.FindTransitionByKey(fromTransitionDescriptorKey);
this.FromTransitionDescriptor = fromTransition;
}
}
}
private static IWfActivityDescriptor InnerFindLastAssociateActivity(IWfTransitionDescriptor transition, string actKey, Dictionary <string, IWfTransitionDescriptor> elapsedTransitions)
{
IWfActivityDescriptor result = null;
if (elapsedTransitions.ContainsKey(transition.Key) || transition.IsBackward == true)
{
return(result);
}
elapsedTransitions.Add(transition.Key, transition);
if (transition.FromActivity.GetAssociatedActivity().Key == actKey)
{
result = transition.FromActivity;
}
foreach (IWfTransitionDescriptor fromTransition in transition.FromActivity.FromTransitions)
{
result = InnerFindLastAssociateActivity(fromTransition, actKey, elapsedTransitions);
if (result != null)
{
break;
}
}
return(result);
}
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);
}
}
public void CreateTransitionByTransitionParamsTest()
{
WfCreateTransitionParamCollection transitionParams = new WfCreateTransitionParamCollection();
WfCreateTransitionParam tp = new WfCreateTransitionParam();
tp.Parameters["Key"] = "T1";
tp.Parameters["Name"] = "Transition1";
tp.Parameters["Condition"] = "Amount > 4000";
Dictionary <string, object>[] variableDicts = new Dictionary <string, object> [1];
variableDicts[0] = new Dictionary <string, object>();
variableDicts[0]["Key"] = "V1";
variableDicts[0]["OriginalType"] = DataType.Int;
variableDicts[0]["OriginalValue"] = 10;
tp.Parameters["Variables"] = variableDicts;
IWfTransitionDescriptor transition = tp.CreateTransition();
Assert.AreEqual(tp.Parameters["Key"], transition.Key);
Assert.AreEqual(tp.Parameters["Name"], transition.Name);
Assert.AreEqual(tp.Parameters["Condition"], transition.Condition.Expression);
Assert.AreEqual(10, transition.Variables.GetValue("V1", 0));
}
public void AddElapsedTransition(IWfTransitionDescriptor transition)
{
if (this._ElapsedTransitions.ContainsKey(transition) == false)
{
this._ElapsedTransitions.Add(transition, transition);
}
}
public WfCreateTransitionParam(IWfTransitionDescriptor transition)
{
transition.NullCheck("transition");
this._Parameters = transition.Properties.ToDictionary();
if (transition.Condition.IsEmpty == false)
{
this.Parameters.Add("Condition", transition.Condition.Expression);
}
if (transition.Variables.Count > 0)
{
Dictionary <string, object>[] variables = new Dictionary <string, object> [transition.Variables.Count];
for (int i = 0; i < variables.Length; i++)
{
WfVariableDescriptor variable = transition.Variables[i];
variables[i] = variable.Properties.ToDictionary();
variables[i]["OriginalType"] = variable.OriginalType;
variables[i]["OriginalValue"] = variable.OriginalValue;
}
this.Parameters.Add("Variables", variables);
}
}
/// <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));
}
}
/// <summary>
/// 根据FromActivity(线的发出点)得到线
/// </summary>
/// <param name="actKey">FromActivity Key值</param>
/// <returns>result</returns>
/// <remarks>根据FromActivity(线的发出点)得到线</remarks>
/// <scholiast>徐照雨</scholiast>
public IWfTransitionDescriptor GetTransitionByFromActivity(string actKey)
{
ExceptionHelper.CheckStringIsNullOrEmpty(actKey, "actKey");
IWfTransitionDescriptor result = null;
this.RWLock.AcquireReaderLock(lockTimeout);
try
{
foreach (IWfTransitionDescriptor transition in base.List)
{
if (transition.FromActivity.Key == actKey)
{
result = transition;
break;
}
}
return(result);
}
finally
{
this.RWLock.ReleaseReaderLock();
}
}
private static void OutputActivityInfoRecursively(IWfActivityDescriptor actDesp, Dictionary <string, IWfTransitionDescriptor> elapsedTransitions, StringBuilder strB)
{
if (strB.Length > 0)
{
strB.Append("->");
}
strB.Append(actDesp.Key);
if (actDesp.AssociatedActivityKey.IsNotEmpty())
{
strB.AppendFormat("[{0}]", actDesp.AssociatedActivityKey);
}
OutputCandidates(actDesp, strB);
IWfTransitionDescriptor transition = actDesp.ToTransitions.FindElapsedTransition();
if (transition == null)
{
transition = actDesp.ToTransitions.GetAllEnabledTransitions().GetAllCanTransitTransitions().FirstOrDefault();
}
if (transition != null)
{
if (elapsedTransitions.ContainsKey(transition.Key) == false)
{
elapsedTransitions.Add(transition.Key, transition);
OutputActivityInfoRecursively(transition.ToActivity, elapsedTransitions, strB);
}
}
}
protected void descriptorEditor_SaveButtonClicked(object sender, EventArgs e)
{
IWfTransitionDescriptor transition = GetNextMoveToTransition(this.operationEditor.CurrentProcess);
(transition != null).FalseThrow("不能找到下一步能够流转的连线");
//如果下一步不允许为人员为空，则校验。
if (transition.ToActivity.Properties.GetValue("AllowEmptyCandidates", true) == false)
{
(this.userSelector.SelectedOuUserData.Count > 0).FalseThrow("必须指定下一步的流转人员");
}
WfTransferParams transferParams = new WfTransferParams(transition.ToActivity);
transferParams.FromTransitionDescriptor = transition;
transferParams.Operator = DeluxeIdentity.CurrentUser;
foreach (IUser candidate in this.userSelector.SelectedOuUserData)
{
transferParams.Assignees.Add(candidate);
}
WfMoveToExecutor executor = new WfMoveToExecutor(
this.operationEditor.CurrentProcess.CurrentActivity,
this.operationEditor.CurrentProcess.CurrentActivity,
transferParams);
executor.Execute();
}
private static IWfTransitionDescriptor CreateMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
bool useOriginal = true;
IWfTransitionDescriptor resultTransition = null;
if (activityToAppend.Process.MainStream != null)
{
IWfActivityDescriptor startActDesp = startActivity.GetMainStreamActivityDescriptor();
IWfActivityDescriptor endActDesp = endActivity.GetMainStreamActivityDescriptor();
if (startActDesp != null && endActDesp != null)
{
WfCopyMainStreamContext context = new WfCopyMainStreamContext(startActDesp, endActivity.Descriptor, entryTransition, true);
FillCopyContext(context.StartActivityDescriptor, endActDesp, context, operationType);
resultTransition = context.StartActivityDescriptor.GenerateCopiedActivitiesDescriptors(activityToAppend.Process, activityToAppend.Descriptor, context, operationType);
useOriginal = false;
}
}
if (useOriginal)
{
OriginalCreateMainStreamActivities(activityToAppend, startActivity, endActivity, entryTransition, operationType);
}
return(resultTransition);
}
protected void EditTransitionPropertiesPreRender(string processID, string transitionKey)
{
if (this.CurrentProcessDescriptor != null)
{
IWfTransitionDescriptor matchedTransition = null;
foreach (IWfActivityDescriptor actDesp in this.CurrentProcessDescriptor.Activities)
{
matchedTransition = actDesp.ToTransitions.Find(t => t.Key == transitionKey);
if (matchedTransition != null)
{
break;
}
}
(matchedTransition != null).FalseThrow("不能在流程中找到Key为{0}的连线", transitionKey);
this.descriptorEditor.RegisterAfterProcessDeserializedFunction(
string.Format("WFWeb.BindPropertyGrid(process.Key, findTransitionByKey(process, \"{0}\"));", transitionKey));
}
diagLogoText.Text = Translator.Translate(Define.DefaultCulture, "编辑连线属性");
documentTitle.Text = diagLogoText.Text;
}
public void BasicAdminAddTransitionWithMainStreamExecutorTest()
{
IWfProcess process = WfProcessTestCommon.StartupSimpleProcess();
const string targetName = "修改后的名称";
IWfActivity fromActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
IWfTransitionDescriptor targetDesp = fromActivity.Descriptor.ToTransitions.AddBackwardTransition(process.Descriptor.InitialActivity);
targetDesp.Properties.SetValue("Name", targetName);
WfAdminAddTransitionExecutor executor = new WfAdminAddTransitionExecutor(process.CurrentActivity, process, targetDesp, true);
executor.Execute();
process = WfRuntime.GetProcessByProcessID(process.ID);
fromActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
targetDesp = fromActivity.Descriptor.ToTransitions.GetTransitionByToActivity(process.Descriptor.InitialActivity);
Assert.IsNotNull(targetDesp);
Assert.AreEqual(targetName, targetDesp.Properties.GetValue("Name", string.Empty));
IWfActivityDescriptor msFromActDesp = process.MainStream.Activities["NormalActivity"];
IWfActivityDescriptor msToActDesp = process.MainStream.InitialActivity;
targetDesp = msFromActDesp.ToTransitions.GetTransitionByToActivity(msToActDesp);
Assert.IsNotNull(targetDesp);
Assert.AreEqual(targetName, targetDesp.Properties.GetValue("Name", string.Empty));
}
public void BasicAdminDeleteTransitionWithMainStreamExecutorTest()
{
IWfProcess process = WfProcessTestCommon.StartupSimpleProcess();
IWfActivityDescriptor targetDesp = process.Descriptor.Activities["NormalActivity"];
IWfTransitionDescriptor transitionDesp = targetDesp.ToTransitions.FirstOrDefault();
IWfActivityDescriptor nextActDesp = transitionDesp.ToActivity;
WfAdminDeleteTransitionExecutor executor = new WfAdminDeleteTransitionExecutor(process.CurrentActivity, process.Descriptor, transitionDesp, true);
executor.Execute();
process = WfRuntime.GetProcessByProcessID(process.ID);
IWfProcessDescriptor processDesp = process.Descriptor;
targetDesp = processDesp.Activities[targetDesp.Key];
nextActDesp = processDesp.CompletedActivity;
Assert.IsNull(targetDesp.ToTransitions.FirstOrDefault());
Assert.IsNull(nextActDesp.FromTransitions.FirstOrDefault());
processDesp = process.MainStream;
targetDesp = processDesp.Activities[targetDesp.Key];
nextActDesp = processDesp.CompletedActivity;
Assert.IsNull(targetDesp.ToTransitions.FirstOrDefault());
Assert.IsNull(nextActDesp.FromTransitions.FirstOrDefault());
}
public static void IsValid(this IWfTransitionDescriptor st)
{
Assert.IsNotNull(st);
Assert.IsNotNull(st.FromActivity);
Assert.IsNotNull(st.ToActivity);
}
private static void FindAllNextStepActivityDescriptor(
IWfActivityDescriptor currentAct,
bool autoCalcaulatePath,
IWfProcess process,
List <IWfActivityDescriptor> alreadyScanedActivities)
{
try
{
foreach (IWfTransitionDescriptor transition in currentAct.ToTransitions)
{
if (autoCalcaulatePath == false || transition.CanTransit())
{
AddTransitionToScanedActivities(transition, autoCalcaulatePath, process, alreadyScanedActivities);
}
}
}
catch (WfTransitionEvaluationException ex)
{
IWfTransitionDescriptor transition = FindNearestPassedTransitionDescriptor(process, currentAct.ToTransitions);
if (transition != null)
{
AddTransitionToScanedActivities(transition, autoCalcaulatePath, process, alreadyScanedActivities);
}
else
{
throw ex;
}
}
}
public void DeleteActivityDescriptorWithComplexTransitionsTest()
{
IWfProcessDescriptor processDesp = PrepareComplexProcessForDelete();
IWfActivityDescriptor normalActDesp = processDesp.Activities["NormalActivity1"];
IWfActivityDescriptor normalActivity = processDesp.Activities["NormalActivity"];
IWfActivityDescriptor normalActivity2 = processDesp.Activities["NormalActivity2"];
IWfTransitionDescriptor transitionNN2 = normalActivity.ToTransitions.GetTransitionByToActivity(normalActivity2);
int originalActCount = processDesp.Activities.Count;
normalActDesp.Delete();
processDesp.Output();
Assert.AreEqual(originalActCount - 1, processDesp.Activities.Count);
Assert.AreEqual(1, normalActivity.ToTransitions.Count);
Assert.AreEqual(2, normalActivity2.FromTransitions.Count);
Assert.AreEqual(2, normalActivity2.ToTransitions.Count);
IWfTransitionDescriptor newTransitionNN2 = normalActivity.ToTransitions.GetTransitionByToActivity(normalActivity2);
Assert.AreEqual(transitionNN2.Key, newTransitionNN2.Key, "原有的线保留");
}
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);
}
}
public WfCopyMainStreamContext(IWfActivityDescriptor startActDesp, IWfActivityDescriptor endActDesp, IWfTransitionDescriptor entryTransition, bool isMainStream)
{
this._IsMainStream = isMainStream;
this._StartActivityDescriptor = new WfCopyMainStreamActivityNode(startActDesp, startActDesp, true, false);
this._EndActivityDescriptor = endActDesp;
this._EntryTransition = entryTransition;
}
/// <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);
}
private static IWfTransitionDescriptor CreateMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
bool useOriginal = true;
IWfTransitionDescriptor resultTransition = null;
if (activityToAppend.Process.MainStream != null)
{
IWfActivityDescriptor startActDesp = startActivity.GetMainStreamActivityDescriptor();
IWfActivityDescriptor endActDesp = endActivity.GetMainStreamActivityDescriptor();
if (startActDesp != null && endActDesp != null)
{
WfCopyMainStreamContext context = new WfCopyMainStreamContext(startActDesp, endActivity.Descriptor, entryTransition, true);
FillCopyContext(context.StartActivityDescriptor, endActDesp, context, operationType);
resultTransition = context.StartActivityDescriptor.GenerateCopiedActivitiesDescriptors(activityToAppend.Process, activityToAppend.Descriptor, context, operationType);
useOriginal = false;
}
}
if (useOriginal)
OriginalCreateMainStreamActivities(activityToAppend, startActivity, endActivity, entryTransition, operationType);
return resultTransition;
}
public void ExpenseProcessSerializationTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.LoadProcessDescriptorFromFile("Expense.xml");
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
process.ApplicationRuntimeParameters["Amount"] = 500;
WfRuntime.PersistWorkflows();
process = WfRuntime.GetProcessByProcessID(process.ID);
WfProcessTestCommon.MoveToNextDefaultActivityWithExecutor(process);
process = WfRuntime.GetProcessByProcessID(process.ID);
IWfActivityDescriptor currentActDesp = process.CurrentActivity.Descriptor;
ToTransitionsDescriptorCollection transitions = currentActDesp.ToTransitions;
foreach (string key in transitions.GetAllKeys())
{
Assert.IsTrue(key.IsNotEmpty());
IWfTransitionDescriptor transition = transitions[key];
Assert.AreEqual(key, transition.Key);
}
}
public static WfTransferParams FromNextActivity(IWfActivityDescriptor currentActDesp, Func <WfTransitionDescriptorCollection, IWfTransitionDescriptor> predicate)
{
currentActDesp.NullCheck("actDesp");
predicate.NullCheck("predicate");
WfTransferParams transferParams = null;
WfTransitionDescriptorCollection toTransitions =
currentActDesp.ToTransitions.GetAllCanTransitTransitions();
//找到匹配的线
IWfTransitionDescriptor transition = predicate(toTransitions);
if (transition != null)
{
transferParams = new WfTransferParams(transition.ToActivity);
transferParams.FromTransitionDescriptor = transition;
if (transition.ToActivity.Instance != null)
{
transferParams.Assignees.CopyFrom(transition.ToActivity.Instance.Candidates);
}
if (DeluxePrincipal.IsAuthenticated)
{
transferParams.Operator = DeluxeIdentity.CurrentUser;
}
}
(transferParams != null).FalseThrow(Translator.Translate(Define.DefaultCulture, "不能根据活动定义{0}找到符合条件的下一步环节", currentActDesp.Key));
return(transferParams);
}
private static IWfActivityDescriptor InnerFindFirstAssociateActivity(IWfTransitionDescriptor transition, string actKey, Dictionary <string, IWfTransitionDescriptor> elapsedTransitions)
{
IWfActivityDescriptor result = null;
if (elapsedTransitions.ContainsKey(transition.Key) || transition.IsBackward == true)
{
return(result);
}
elapsedTransitions.Add(transition.Key, transition);
if (transition.ToActivity.GetAssociatedActivity().Key == actKey)
{
if (transition.ToActivity.Instance != null && transition.ToActivity.Instance.Status == WfActivityStatus.NotRunning)
{
result = transition.ToActivity;
}
}
if (result == null)
{
foreach (IWfTransitionDescriptor toTransition in transition.ToActivity.ToTransitions)
{
result = InnerFindFirstAssociateActivity(toTransition, actKey, elapsedTransitions);
if (result != null)
{
break;
}
}
}
return(result);
}
private void SetTransitionCondition(IWfTransitionDescriptor transitionDesp, bool isDefSelect, int priority)
{
WfTransitionDescriptor transDesp = (WfTransitionDescriptor)transitionDesp;
transDesp.DefaultSelect = isDefSelect;
transDesp.Priority = priority;
}
/// <summary>
/// 在线中，查找最接近的经过的线
/// </summary>
/// <param name="process"></param>
/// <param name="transitionDesps"></param>
/// <returns></returns>
private static IWfTransitionDescriptor FindNearestPassedTransitionDescriptor(IWfProcess process, WfTransitionDescriptorCollection transitionDesps)
{
IWfTransitionDescriptor result = null;
if (process != null)
{
IWfActivity currentActivity = process.LastActivity;
while (currentActivity != null)
{
IWfTransitionDescriptor fromTransitionDescriptor = currentActivity.FromTransitionDescriptor;
if (fromTransitionDescriptor != null)
{
if (transitionDesps.Exists(t => t.Key == fromTransitionDescriptor.Key))
{
result = fromTransitionDescriptor;
break;
}
}
if (currentActivity.FromTransition != null)
{
currentActivity = currentActivity.FromTransition.FromActivity;
}
else
{
currentActivity = null;
}
}
}
return(result);
}
/// <summary>
/// 历史实现规则。当流程不存在MainStream属性时，采用从当前流程活动中爬出来
/// </summary>
/// <param name="activityToAppend"></param>
/// <param name="startActivity"></param>
/// <param name="endActivity"></param>
/// <param name="operationType"></param>
private static void OriginalCreateMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
WfCopyMainStreamContext context = new WfCopyMainStreamContext(startActivity.Descriptor, endActivity.Descriptor, entryTransition, false);
FillCopyContext(context.StartActivityDescriptor, endActivity.Descriptor, context, operationType);
context.StartActivityDescriptor.GenerateCopiedActivitiesDescriptors(activityToAppend.Process, activityToAppend.Descriptor, context, operationType);
}
protected void descriptorEditor_PreRenderControl(object sender, EventArgs e)
{
IWfTransitionDescriptor transition = GetNextMoveToTransition(this.operationEditor.CurrentProcess);
if (transition != null)
{
this.userSelector.SelectedOuUserData.CopyFrom(transition.ToActivity.Instance.Candidates.ToUsers());
}
}
public WfControlNextStep(IWfTransitionDescriptor transition, IWfActivity toActivity)
{
transition.NullCheck("transition");
toActivity.NullCheck("toActivity");
this.ActivityDescriptor = toActivity.Descriptor;
this._Candidates = toActivity.Candidates.GetSelectedAssignees();;
this.TransitionDescriptor = transition;
}
/// <summary>
/// 设置原来的出线和最后一个动态活动点之间的关系和属性
/// </summary>
/// <param name="lastDynamicActivity"></param>
/// <param name="toTransitions"></param>
private static void SetExitTransitionsProperties(IWfActivityDescriptor lastDynamicActivity, WfTransitionDescriptorCollection toTransitions)
{
foreach (IWfTransitionDescriptor transition in toTransitions)
{
IWfTransitionDescriptor dynTransition = transition.ToActivity.FromTransitions.AddForwardTransition(lastDynamicActivity);
SetDynamicTransitionProperties(transition, dynTransition, transition.FromActivity, false);
}
}
private static WfClientTransitionDescriptor ConvertServerTransitionToClient(IWfTransitionDescriptor server)
{
WfClientTransitionDescriptor clientTransition = null;
if (server != null)
WfClientTransitionDescriptorConverter.Instance.ServerToClient((WfTransitionDescriptor)server, ref clientTransition);
return clientTransition;
}
/// <summary>
/// 设置原来的进线和第一个动态活动点之间的关系和属性
/// </summary>
/// <param name="firstDynamicActivity"></param>
/// <param name="fromTransitions"></param>
private static void SetEntryTransitionsProperties(IWfActivityDescriptor firstDynamicActivity, WfTransitionDescriptorCollection fromTransitions)
{
foreach (IWfTransitionDescriptor transition in fromTransitions)
{
IWfTransitionDescriptor dynTransition = transition.FromActivity.ToTransitions.AddForwardTransition(firstDynamicActivity);
SetDynamicTransitionProperties(transition, dynTransition, transition.ToActivity, true);
}
}
public WfControlNextStep(IWfTransitionDescriptor transition, IWfActivity toActivity)
{
transition.NullCheck("transition");
toActivity.NullCheck("toActivity");
this.ActivityDescriptor = toActivity.Descriptor;
this._Candidates = toActivity.Candidates.GetSelectedAssignees();;
this.TransitionDescriptor = transition;
}
/// <summary>
/// 在指定的活动点之后，添加从startActivity与endActivity之间复制出来的
/// </summary>
/// <param name="activityToAppend">复制的活动需要添加到哪一个活动之后</param>
/// <param name="startActivity">需要复制的活动的起始点</param>
/// <param name="endActivity">需要复制的活动的终止点</param>
/// <param name="entryTransition"></param>
/// <param name="operationType">操作类型</param>
/// <returns>返回的第一个Clone活动的出线</returns>
public IWfTransitionDescriptor CopyMainStreamActivities(IWfActivity activityToAppend, IWfActivity startActivity, IWfActivity endActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
activityToAppend.NullCheck("activityToAppend");
//沈峥注释，和WfMoveToExecutor中，是否按退回线进行的判断进行匹配
ExceptionHelper.TrueThrow(startActivity.Status == WfActivityStatus.NotRunning, "退件时所指定活动必须是已执行过的活动");
//沈峥重构后的实现
return CreateMainStreamActivities(activityToAppend, startActivity, endActivity, entryTransition, operationType);
}
public WfAdminDeleteTransitionExecutor(IWfActivity operatorActivity, IWfProcessDescriptor processDescriptor, IWfTransitionDescriptor targetTransitionDescriptor, bool syncMSObject) :
base(operatorActivity, WfControlOperationType.AdminDeleteTransition)
{
processDescriptor.NullCheck("processDescriptor");
targetTransitionDescriptor.NullCheck("targetTransitionDescriptor");
this._TargetTransitionDescriptor = targetTransitionDescriptor;
this._ProcessDescriptor = processDescriptor;
this._SyncMainStreamObject = syncMSObject;
}
private static WfClientTransitionDescriptor ConvertServerTransitionToClient(IWfTransitionDescriptor server)
{
WfClientTransitionDescriptor clientTransition = null;
if (server != null)
{
WfClientTransitionDescriptorConverter.Instance.ServerToClient((WfTransitionDescriptor)server, ref clientTransition);
}
return(clientTransition);
}
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);
}
protected static IWfTransitionDescriptor FindMainStreamTransition(IWfTransitionDescriptor templateTransition)
{
IWfActivityDescriptor fromActDesp = templateTransition.FromActivity;
IWfActivityDescriptor toActDesp = templateTransition.ToActivity;
IWfTransitionDescriptor result = null;
if (fromActDesp != null && toActDesp != null && fromActDesp.IsMainStreamActivity == false && toActDesp.IsMainStreamActivity == false)
{
IWfActivityDescriptor msFromActDesp = fromActDesp.Instance.GetMainStreamActivityDescriptor();
IWfActivityDescriptor msToActDesp = toActDesp.Instance.GetMainStreamActivityDescriptor();
if (msFromActDesp != null && msToActDesp != null)
{
result = msFromActDesp.ToTransitions.GetTransitionByToActivity(msToActDesp);
}
}
return result;
}
private static void AddTransitionToScanedActivities(IWfTransitionDescriptor transition, bool autoCalcaulatePath, IWfProcess process, List<IWfActivityDescriptor> alreadyScanedActivities)
{
IWfActivityDescriptor target = transition.ToActivity;
if ((target is IWfInitialActivityDescriptor == false) && (target is IWfCompletedActivityDescriptor == false))
{
if (alreadyScanedActivities.Exists(a => a.Key == target.Key) == false)
{
if (string.IsNullOrEmpty(target.LevelName) == false)
{
alreadyScanedActivities.Add(target);
FindAllNextStepActivityDescriptor(target, autoCalcaulatePath, process, alreadyScanedActivities);
}
}
}
}
/// <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);
}
/// <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));
}
}
private static string GetTransitionName(IWfTransitionDescriptor transition)
{
string result = transition.Name;
if (result.IsNullOrEmpty())
result = transition.Description;
return result;
}
private static bool TransitionCanTransit(IWfTransitionDescriptor transition)
{
bool result = false;
try
{
result = transition.CanTransit();
}
catch (WfTransitionEvaluationException ex)
{
ex.WriteToLog();
}
return result;
}
private static IWfActivityDescriptor InnerFindFirstAssociateActivity(IWfTransitionDescriptor transition, string actKey, Dictionary<string, IWfTransitionDescriptor> elapsedTransitions)
{
IWfActivityDescriptor result = null;
if (elapsedTransitions.ContainsKey(transition.Key) || transition.IsBackward == true)
return result;
elapsedTransitions.Add(transition.Key, transition);
if (transition.ToActivity.GetAssociatedActivity().Key == actKey)
{
if (transition.ToActivity.Instance != null && transition.ToActivity.Instance.Status == WfActivityStatus.NotRunning)
result = transition.ToActivity;
}
if (result == null)
{
foreach (IWfTransitionDescriptor toTransition in transition.ToActivity.ToTransitions)
{
result = InnerFindFirstAssociateActivity(toTransition, actKey, elapsedTransitions);
if (result != null)
break;
}
}
return result;
}
private static IWfTransitionDescriptor JoinOriginalActivityToClonedActivity(IWfActivityDescriptor originalActDesp, IWfActivityDescriptor clonedActDesp, IWfTransitionDescriptor transitionTemplate)
{
WfTransitionDescriptor newTransition = (WfTransitionDescriptor)originalActDesp.ToTransitions.AddForwardTransition(clonedActDesp);
//将新添加的线的属性设置为原来线的属性
//string newKey = newTransition.Key;
newTransition.Properties.ReplaceExistedPropertyValues(transitionTemplate.Properties);
//newTransition.Key = newKey;
newTransition.IsBackward = false;
newTransition.DefaultSelect = true;
return newTransition;
}
/// <summary>
/// 设置动态活动产生的线属性
/// </summary>
/// <param name="targetActDesp"></param>
/// <param name="newTransition"></param>
private static void SetDynamicTransitionProperties(IWfActivityDescriptor targetActDesp, IWfTransitionDescriptor newTransition)
{
((WfTransitionDescriptor)newTransition).GeneratedByTemplate = targetActDesp.GeneratedByTemplate;
((WfTransitionDescriptor)newTransition).TemplateKey = targetActDesp.TemplateKey;
}
private static IWfActivityDescriptor InnerFindLastAssociateActivity(IWfTransitionDescriptor transition, string actKey, Dictionary<string, IWfTransitionDescriptor> elapsedTransitions)
{
IWfActivityDescriptor result = null;
if (elapsedTransitions.ContainsKey(transition.Key) || transition.IsBackward == true)
return result;
elapsedTransitions.Add(transition.Key, transition);
if (transition.FromActivity.GetAssociatedActivity().Key == actKey)
result = transition.FromActivity;
foreach (IWfTransitionDescriptor fromTransition in transition.FromActivity.FromTransitions)
{
result = InnerFindLastAssociateActivity(fromTransition, actKey, elapsedTransitions);
if (result != null)
break;
}
return result;
}
private static IWfActivityDescriptor GetTransitionValidTarget(IWfTransitionDescriptor transition)
{
IWfActivityDescriptor actDesp = null;
if (transition != null)
{
actDesp = transition.ToActivity;
//if ((actDesp is IWfInitialActivityDescriptor) || (actDesp is IWfCompletedActivityDescriptor))
// actDesp = null;
if ((actDesp is IWfInitialActivityDescriptor))
actDesp = null;
}
return actDesp;
}
private void SetTransitionCondition(IWfTransitionDescriptor transitionDesp, bool isDefSelect, int priority)
{
WfTransitionDescriptor transDesp = (WfTransitionDescriptor)transitionDesp;
transDesp.DefaultSelect = isDefSelect;
transDesp.Priority = priority;
}
public WfAdminAddTransitionExecutor(IWfActivity operatorActivity, IWfProcess process, IWfTransitionDescriptor transitionDesp, bool syncMSObject)
: base(operatorActivity, process, transitionDesp, syncMSObject, WfControlOperationType.AdminAddTransition)
{
}
/// <summary>
/// 在当前活动实例后，添加一些被克隆的活动。
/// </summary>
/// <param name="startActivity">需要复制的活动的起始点</param>
/// <param name="entryTransition"></param>
/// <param name="operationType"></param>
/// <returns>返回的第一个Clone活动的出线</returns>
public IWfTransitionDescriptor CopyMainStreamActivities(IWfActivity startActivity, IWfTransitionDescriptor entryTransition, WfControlOperationType operationType)
{
return CopyMainStreamActivities(this, startActivity, this, entryTransition, operationType);
}
public WfTransition(IWfTransitionDescriptor descriptor)
{
this._StartTime = DateTime.Now;
}
