public static WorkflowInfo ProcessAdapter(IWfProcess procInstance, bool isMainStream)
{
WorkflowInfo result = new WorkflowInfo();
if (procInstance == null)
return result;
AdaptProcessProperties(procInstance, result, isMainStream);
if (isMainStream == false || procInstance.MainStream == null)
{
foreach (IWfActivity instanceAct in procInstance.Activities)
{
result.Activities.Add(AdaptActivityProperties(instanceAct.Descriptor, isMainStream));
result.Transitions.AddRange(AdaptTransitionProperties(procInstance, instanceAct));
}
}
else
{
foreach (IWfActivityDescriptor instanceActDesc in procInstance.MainStream.Activities)
{
result.Activities.Add(AdaptActivityProperties(instanceActDesc, isMainStream));
result.Transitions.AddRange(AdaptMainStreamTransitionProperties(instanceActDesc));
}
}
return result;
}
/// <summary>
///
/// </summary>
/// <param name="process"></param>
/// <param name="descriptor"></param>
/// <returns></returns>
public IWfAnchorActivity CreateAnchorActivity(IWfProcess process, IWfAnchorActivityDescriptor descriptor)
{
WfAnchorActivity activity = new WfAnchorActivity(descriptor);
activity.Process = process;
return activity;
}
protected static void AfterStartupBranchProcess(IWfProcess process)
{
StringBuilder strB = new StringBuilder();
foreach (WfAssignee assignee in process.BranchStartupParams.Assignees)
{
if (strB.Length > 0)
strB.Append(",");
strB.Append(assignee.User.DisplayName);
}
if (strB.Length > 0)
{
string opName = string.Empty;
switch (process.Descriptor.Key)
{
case WfProcessDescriptorManager.DefaultConsignProcessKey:
opName = EnumItemDescriptionAttribute.GetDescription(WfControlOperationType.Consign);
break;
case WfProcessDescriptorManager.DefaultCirculationProcessKey:
opName = EnumItemDescriptionAttribute.GetDescription(WfControlOperationType.Circulate);
break;
}
if (opName.IsNotEmpty())
opName = opName + ": " + strB.ToString();
else
opName = strB.ToString();
((WfProcessDescriptor)process.Descriptor).Name = opName;
}
}
public WfActivity(Actinst actins)
: base(actins)
{
this.actinst = actins;
this.process = WfFactory.GetWfProcess(this.actinst.Proinst);
this.executor = WfActivityAbstractImplFact.GetConcretImpl(this);
}
public WfTransferParams ClientToServer(WfClientTransferParams client, IWfProcess process, ref WfTransferParams server)
{
client.NullCheck("client");
if (server == null)
server = new WfTransferParams();
server.Context["NextActivityDescriptorKey"] = client.NextActivityDescriptorKey;
server.Context["FromTransitionDescriptorKey"] = client.FromTransitionDescriptorKey;
if (process != null)
{
if (client.NextActivityDescriptorKey.IsNotEmpty())
{
IWfActivity nextActivity = process.Activities.FindActivityByDescriptorKey(client.NextActivityDescriptorKey);
if (nextActivity != null)
server.NextActivityDescriptor = nextActivity.Descriptor;
}
if (client.FromTransitionDescriptorKey.IsNotEmpty())
{
IWfTransitionDescriptor fromTransition = process.Descriptor.FindTransitionByKey(client.FromTransitionDescriptorKey);
server.FromTransitionDescriptor = fromTransition;
}
}
server.Operator = (IUser)client.Operator.ToOguObject();
WfClientBranchProcessTransferParamsCollectionConverter.Instance.ClientToServer(client.BranchTransferParams, server.BranchTransferParams);
WfClientAssigneeCollectionConverter.Instance.ClientToServer(client.Assignees, server.Assignees);
return server;
}
private CommandStateBase Controller_PrepareCommandState(IWfProcess process)
{
DynamicFormCommandState state = null;
//从流程上下文中获取数据。在这里通过流程上下文保存表单数据，省去了单独建表存储的工作
//var data = DynamicFormDataAdapter.Instance.Load(process.ResourceID, false); //(string)process.RootProcess.Context["appData"];;
string strData = (string)process.RootProcess.Context["appData"];
if (strData.IsNullOrEmpty())
{
DynamicFormData data = new DynamicFormData();
//data.Properties = null;
state = new DynamicFormCommandState() { Data = data };
process.GenerateCandidatesFromResources();
}
else
{
var data = SerializationHelper.DeserializeStringToObject(strData, SerializationFormatterType.Binary) as DynamicFormData;
return new DynamicFormCommandState() { Data = data };
}
return state;
}
public WfClientAuthorizationInfo GetAuthorizationInfo(IWfProcess process, IWfActivity originalActivity, WfClientUser user)
{
string userID = user.IsNotNullOrEmpty() ? user.ID : string.Empty;
string originalActivityID = originalActivity != null ? originalActivity.ID : string.Empty;
return GetAuthorizationInfo(process, originalActivityID, userID);
}
/// <summary>
/// 根据流程和角色创建SOARoleContext
/// </summary>
/// <param name="role"></param>
/// <param name="process"></param>
/// <returns></returns>
public static SOARoleContext CreateContext(IRole role, IWfProcess process)
{
role.NullCheck("role");
SOARole soaRole = (SOARole)SOARole.CreateWrapperObject(role);
return CreateContext(soaRole.PropertyDefinitions, process);
}
/// <summary>
///
/// </summary>
/// <param name="process"></param>
/// <param name="transParams"></param>
/// <returns></returns>
public IWfActivity CreateActivity(IWfProcess process, WfTransferParams transParams)
{
WfActivity activity = new WfActivity(transParams.NextActivityDescriptor);
activity.Operator = transParams.Operator;
activity.Process = process;
return activity;
}
private void OutputProcessInfo(IWfProcess process, TextWriter writer)
{
writer.WriteLine("ProcessID: {0}, Key: {1}, Name: {2}", process.ID, process.Descriptor.Key, process.Descriptor.Name);
writer.WriteLine("Activities Begin");
process.Activities.ForEach(a => OutputActivityInfo(a, writer));
writer.WriteLine("Activities End");
}
protected virtual void OnProcessReady(IWfProcess process)
{
if (ProcessReady != null)
{
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("ProcessReady",
() => ProcessReady(process));
}
}
public void CheckUserInAcl(IUser user, IWfProcess process, ref bool continueCheck)
{
user.NullCheck("user");
continueCheck = WfClientContext.IsProcessAdmin(user, process) == false;
if (continueCheck)
continueCheck = WfClientContext.IsProcessViewer(user, process) == false;
}
public DeleteObjectHelper(IWfProcess process, IWfProcessDescriptor processDesp, bool syncMSObject)
{
process.NullCheck("process");
processDesp.NullCheck("processDesp");
this._Process = process;
this._ProcessDescriptor = processDesp;
this._SyncMainStream = syncMSObject;
}
public WfAsyncCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess process)
: base(operatorActivity, WfControlOperationType.AsyncCancelProcess)
{
process.NullCheck("process");
this.Process = process;
if (this.OperatorActivity == null)
this.OperatorActivity = process.CurrentActivity;
}
public WfPauseProcessExecutor(IWfActivity operatorActivity, IWfProcess pauseProcess)
: base(operatorActivity, WfControlOperationType.PauseProcess)
{
pauseProcess.NullCheck("pauseProcess");
this.PauseProcess = pauseProcess;
if (OperatorActivity == null)
OperatorActivity = PauseProcess.CurrentActivity;
}
/// <summary>
///
/// </summary>
/// <param name="process"></param>
/// <param name="transParams"></param>
/// <returns></returns>
public IWfAnchorActivity CreateAnchorActivity(IWfProcess process, WfBranchesTransferParams transParams)
{
WfAnchorActivity activity = new WfAnchorActivity((IWfAnchorActivityDescriptor)transParams.NextActivityDescriptor);
activity.Process = process;
activity.Operations.Add(CreateOperation(activity, transParams));
return activity;
}
public WfResumeProcessExecutor(IWfActivity operatorActivity, IWfProcess resumeProcess)
: base(operatorActivity, WfControlOperationType.ResumeProcess)
{
resumeProcess.NullCheck("resumeProcess");
this.ResumeProcess = resumeProcess;
if (OperatorActivity == null)
OperatorActivity = ResumeProcess.CurrentActivity;
}
public WfExitMaintainingStatusExecutor(IWfActivity operatorActivity, IWfProcess process, bool autoProcessPendingActivity)
: base(operatorActivity, WfControlOperationType.ExitMaintainingStatus)
{
process.NullCheck("process");
this.Process = process;
this.AutoProcessPendingActivity = autoProcessPendingActivity;
if (this.OperatorActivity == null)
this.OperatorActivity = process.CurrentActivity;
}
public void UpdateProcessActivities(IWfProcess process)
{
process.NullCheck("process");
WfProcessCurrentActivityCollection pcas = new WfProcessCurrentActivityCollection();
foreach (IWfActivity activity in process.Activities)
pcas.Add(WfProcessCurrentActivity.FromActivity(activity));
Update(process.ID, pcas);
}
public EditProcessPropertiesHelper(IWfProcess process, IWfProcessDescriptor processDesp, PropertyValueCollection properties, bool syncMSObject)
{
process.NullCheck("process");
processDesp.NullCheck("processDesp");
properties.NullCheck("properties");
this._Process = process;
this._ProcessDescriptor = processDesp;
this._Properties = properties;
this._SyncMainStream = syncMSObject;
}
private static IWfTransitionDescriptor GetNextMoveToTransition(IWfProcess process)
{
IWfTransitionDescriptor result = null;
if (process.CurrentActivity != null)
{
result = process.CurrentActivity.Descriptor.ToTransitions.GetAllCanTransitTransitions().FindDefaultSelectTransition();
}
return result;
}
private static void ServerActivitiesToClient(IWfProcess server, WfClientProcess client)
{
foreach (IWfActivity activity in server.Activities)
{
WfClientActivity clientActivity = null;
WfClientActivityConverter.WithoutDescriptorInstance.ServerToClient(activity, ref clientActivity);
client.Activities.Add(clientActivity);
}
}
public WfCancelProcessExecutor(IWfActivity operatorActivity, IWfProcess cancelProcess, bool cancelAllBranchProcesses)
: base(operatorActivity, WfControlOperationType.CancelProcess)
{
cancelProcess.NullCheck("cancelProcess");
this.CancelProcess = cancelProcess;
this.CancelAllBranchProcesses = cancelAllBranchProcesses;
if (OperatorActivity == null)
OperatorActivity = CancelProcess.CurrentActivity;
}
public void Write(IWfProcess process, WfSimulationOperationType operationType, WfSimulationContext context)
{
switch (operationType)
{
case WfSimulationOperationType.Startup:
WriteStartupProcessInfo(process, context);
break;
case WfSimulationOperationType.MoveTo:
WriteMoveToInfo(process, context);
break;
}
}
public static SOARoleContext CreateContext(SOARolePropertyDefinitionCollection propertyDefines, IWfProcess process)
{
propertyDefines.NullCheck("propertyDefines");
SOARolePropertiesQueryParamCollection queryParams = CreateQueryParams(propertyDefines, process);
SOARoleContext context = SOARoleContext.CreateContext(queryParams, process);
context.PropertyDefinitions = propertyDefines;
return context;
}
public static IWfActivity GetWfActivity(Actdef actdef, IWfProcess process)
{
if (actdef == null)
{
throw new WfException("Actdef cannot be null");
}
if (process == null)
{
throw new WfException("WfProcess cannot be null");
}
return new WfActivity(actdef, process);
}
public WfSimulationResult(IWfProcess process)
{
process.NullCheck("process");
this.ProcessID = process.ID;
if (process.CurrentActivity != null)
this.ActivityID = process.CurrentActivity.ID;
this.MoveToCount = WfRuntime.ProcessContext.SimulationContext.MoveToCount;
this.ProcessStatus = process.Status;
}
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;
}
protected virtual void OnPrepareCommandState(IWfProcess process)
{
if (PrepareCommandState != null)
{
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("PrepareCommandState", () =>
{
CommandStateBase state = PrepareCommandState(process);
if (state != null)
CommandStateHelper.RegisterState(state);
});
}
}
private static void MultiSerializeTest(IWfProcess process, int count, Stopwatch sw)
{
for (int i = 0; i < count; i++)
{
XElement data = SerializeProcess(process);
IWfProcess deserializedProcess = DeserializeProcess(data);
Trace.Assert(process.Descriptor.Name == deserializedProcess.Descriptor.Name);
Trace.Assert(process.Activities.Count == deserializedProcess.Activities.Count);
Console.WriteLine("Count: {0}, Elapsed time: {1:#,##0.00}", i, sw.ElapsedMilliseconds);
}
}
private void GetProcessParameters(IWfProcess process, List <RuntimeParameterInfo> source)
{
string processName = string.IsNullOrEmpty(process.Descriptor.Name) ? process.Descriptor.Name : process.Descriptor.Key;
foreach (KeyValuePair <string, object> item in process.ApplicationRuntimeParameters)
{
RuntimeParameterInfo currentInfo = new RuntimeParameterInfo(item);
//currentInfo.ProcessName = processName;
source.Add(currentInfo);
}
/*if (process.Descriptor.Properties.GetValue("ProbeParentProcessParams", false) == true)
* GetProcessParameters(process.EntryInfo.OwnerActivity.Process, source); */
}
public void UpdatePersistQueue(IWfProcess process)
{
process.NullCheck("process");
WfPersistQueue pq = WfPersistQueue.FromProcess(process);
string sql = GetUpdatePersistQueueSql(pq);
using (TransactionScope scope = TransactionScopeFactory.Create())
{
DbHelper.RunSql(sql, GetConnectionName());
scope.Complete();
}
}
private bool ProcessOpenProcessRequest()
{
string processID = WebUtility.GetRequestQueryValue <string>("relProcCtlProcessID", "");
HttpContext.Current.Response.Clear();
bool result = processID.IsNotEmpty();
if (result)
{
IWfProcess proc = WfRuntime.GetProcessByProcessID(processID);
string url = string.Format("{0}?resourceID={1}&activityID={2}", proc.Descriptor.Url, proc.ResourceID, proc.CurrentActivity.ID);
Page.Response.Redirect(url);
}
return(result);
}
/// <summary>
/// 执行退回线，然后再流转一步
/// </summary>
/// <param name="process"></param>
/// <param name="count"></param>
private static void MoveAgreeProcessAndValidate(IWfProcess process, int count)
{
Console.WriteLine("第{0}次退件之前，退件发起点为{1}({2})", count, process.CurrentActivity.Descriptor.Key, process.CurrentActivity.Descriptor.AssociatedActivityKey);
IWfActivity returnedActivityA = process.MoveToDefaultActivityByExecutor(false).CurrentActivity; //Move To A
Console.WriteLine("第{0}次退件之后，退件当前点为{1}({2})", count, process.CurrentActivity.Descriptor.Key, process.CurrentActivity.Descriptor.AssociatedActivityKey);
Assert.AreEqual("A", returnedActivityA.Descriptor.AssociatedActivityKey);
IWfActivity returnedActivityB = process.MoveToDefaultActivityByExecutor(false).CurrentActivity; //Move To B again
Assert.AreEqual("B", returnedActivityB.Descriptor.AssociatedActivityKey);
ValidateAggressProcessBTransitions(returnedActivityB, count);
}
protected WfBranchProcessInfo(SerializationInfo info, StreamingContext context)
{
this._Process = (IWfProcess)info.GetValue("Process", typeof(IWfProcess));
this._OwnerOperation = (IWfOperation)info.GetValue("OwnerOperation", typeof(IWfOperation));
this._OperationID = info.GetString("OperationID");
this._Sequence = info.GetInt32("Sequence");
this._IsSpecificProcess = info.GetBoolean("IsSpecificProcess");
this._ProcessDescriptorKey = info.GetString("ProcessDescriptorKey");
this._BranchInfoState = (State)info.GetValue("BranchInfoState", typeof(State));
this._Context = (WfBranchProcessInfoContext)info.GetValue("Context", typeof(WfBranchProcessInfoContext));
this._LoadingType = (DataLoadingType)info.GetValue("LoadingType", typeof(DataLoadingType));
}
public static WfClientProcessInfo ToClientProcessInfo(this IWfProcess process, IWfActivity originalActivity, WfClientUser clientUser)
{
process.NullCheck("process");
WfClientProcessInfo clientProcessInfo = null;
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("ToClientProcessInfo", () =>
{
WfClientProcessInfoConverter.Instance.ServerToClient(process, ref clientProcessInfo);
clientProcessInfo.AuthorizationInfo = WfClientProcessInfoBaseConverter.Instance.GetAuthorizationInfo(process, originalActivity, clientUser);
});
return(clientProcessInfo);
}
public static IWfProcess LoadProcessDescriptor(string processid)
{
WfRuntime.ClearCache();
IWfProcess process = WfRuntime.GetProcessByProcessID(processid);
//string xml = File.ReadAllText(@"C:\Documents and Settings\issuser\Desktop\111.txt");
//Type descType = process.Descriptor.GetType();
//PropertyInfo graphProp = descType.GetProperty("GraphDescription");
//graphProp.SetValue(process.Descriptor, xml, null);
//WorkflowSettings.GetConfig().GetPersistManager().SaveProcess(process);
//WfRuntime.PersistWorkflows();
return(process);
}
/// <summary>
/// 根据默认的下一环节生成流转参数
/// </summary>
/// <param name="process"></param>
/// <returns></returns>
public static WfTransferParams FromNextDefaultActivity(IWfProcess process)
{
process.NullCheck("process");
WfTransferParams transferParams = null;
if (process.CurrentActivity != null)
{
transferParams = FromNextDefaultActivity(process.CurrentActivity.Descriptor);
}
(transferParams != null).FalseThrow(Translator.Translate(Define.DefaultCulture, "不能根据流程当前活动找到默认的下一步环节"));
return(transferParams);
}
private static string GetDefaultExtData(IWfProcess process)
{
XElement result = XElement.Parse("<ExtData />");
string encodingName = "gb2312";
if (process.LoadingType == DataLoadingType.Memory)
{
encodingName = "utf-8";
}
result.SetAttributeValue("encoding", encodingName);
return(result.ToString());
}
public void InitialActivityAutoMoveTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptor();
processDesp.InitialActivity.Properties.SetValue("AutoMoveTo", true);
processDesp.Activities["NormalActivity"].Properties.SetValue("AutoMoveTo", true);
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
IWfActivity currentActivity = process.MoveToNextDefaultActivity();
Console.WriteLine(currentActivity.Descriptor.ActivityType);
Assert.AreEqual(WfActivityType.CompletedActivity, currentActivity.Descriptor.ActivityType);
}
public void MoveToWithBranchProcessesExecutorTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptorWithBranchTemplate();
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
IWfActivityDescriptor normalActivity = processDesp.InitialActivity.ToTransitions[0].ToActivity;
WfTransferParams transferParams0 = new WfTransferParams(normalActivity);
//初始化后，流转到有分支流程的活动
process.MoveTo(transferParams0);
Assert.AreEqual(normalActivity.BranchProcessTemplates.Count, process.CurrentActivity.BranchProcessGroups.Count);
}
public void EnterMaintainingStatusTest()
{
IWfProcessDescriptor processDesp = CreateProcessWithAutoMaintainProperty();
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
MoveToExecutor(process);
process = WfRuntime.GetProcessByProcessID(process.ID);
Assert.AreEqual(WfProcessStatus.Maintaining, process.Status);
Assert.AreEqual(WfActivityStatus.Pending, process.CurrentActivity.Status);
Assert.AreEqual(0, process.CurrentActivity.BranchProcessGroups.Count);
}
public void AddActivityWithTwoOutTransitionsExecutorTest()
{
IWfProcess process = WfProcessTestCommon.StartupSimpleProcess();
int originalActCount = process.Activities.Count;
IWfActivity targetActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
targetActivity.Descriptor.ToTransitions.FirstOrDefault().Properties.SetValue("Name", "同意");
//增加一条出线
IWfTransitionDescriptor tReturn = targetActivity.Descriptor.ToTransitions.AddBackwardTransition(process.InitialActivity.Descriptor);
tReturn.Properties.SetValue("Name", "不同意");
WfActivityDescriptorCreateParams createParams = new WfActivityDescriptorCreateParams();
createParams.AllAgreeWhenConsign = false;
createParams.Users = new OguDataCollection <IUser>();
createParams.Users.Add((IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object);
WfAddActivityExecutor executor = new WfAddActivityExecutor(process.CurrentActivity, targetActivity, createParams);
executor.Execute();
process = WfRuntime.GetProcessByProcessID(process.ID);
IWfActivity addedActivity = process.Activities[executor.AddedActivity.ID];
targetActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
Assert.AreEqual(originalActCount + 1, process.Activities.Count);
Assert.AreEqual(1, targetActivity.Descriptor.ToTransitions.Count);
Assert.IsFalse(targetActivity.Descriptor.ToTransitions[0].IsBackward);
Assert.AreEqual(2, addedActivity.Descriptor.ToTransitions.Count, "新加的活动应该也有两条出线");
Assert.AreEqual("同意", addedActivity.Descriptor.ToTransitions[0].Name);
Assert.AreEqual("不同意", addedActivity.Descriptor.ToTransitions[1].Name);
WfMainStreamActivityDescriptorCollection processDespMSA = process.Descriptor.GetMainStreamActivities();
WfMainStreamActivityDescriptorCollection processMSA = process.GetMainStreamActivities(true);
processDespMSA.Output("流程描述中的主线活动");
processMSA.Output("主线流程中的主线活动");
Assert.AreEqual(process.Descriptor.Activities.Count, process.MainStream.Activities.Count);
Assert.AreEqual(processDespMSA.Count, processMSA.Count);
}
public void AddApproverExecutorTest()
{
//Initial NormalActivity NormalActivity1 NormalActivity2 NormalActivity3 Completed
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object;
IWfProcessDescriptor procDesp = WfProcessTestCommon.CreateProcessDescriptor();
WfUserResourceDescriptor userDesp = new WfUserResourceDescriptor(user);
procDesp.InitialActivity.Resources.Add(userDesp);
WfProcessStartupParams startParams = WfProcessTestCommon.GetInstanceOfWfProcessStartupParams(procDesp);
WfStartWorkflowExecutor exec = new WfStartWorkflowExecutor(null, startParams);
IWfProcess proc = exec.Execute(); //启动流程
IWfProcess wfp = WfRuntime.GetProcessByProcessID(proc.ID);
MoveToExecutor(wfp); //流转一步 ,即第2个节点
IWfProcess p = WfRuntime.GetProcessByProcessID(proc.ID);
WfAssigneeCollection assignees = new WfAssigneeCollection();
assignees.Add((IUser)OguObjectSettings.GetConfig().Objects[OguObject.approver1.ToString()].Object);
WfAddApproverExecutor addExec = new WfAddApproverExecutor(p.CurrentActivity, p.CurrentActivity, assignees);
addExec.Execute(); //加签,即流转到加签点上
IWfProcess process = WfRuntime.GetProcessByProcessID(p.ID);
Assert.AreEqual(process.Descriptor.GetMainStreamActivities().Count, process.Activities.Count - 2, "动态添加两个活动,因被加签人要回到加签人");
Assert.AreEqual(2, process.ElapsedActivities.Count);
Assert.IsTrue(ProcessTestHelper.ExistsActivityUserTasks(process.CurrentActivity.ID, TaskStatus.Ban));
Assert.IsTrue(process.CurrentActivity.Descriptor.ToTransitions.Count == 1);
Assert.IsNotNull(process.CurrentActivity.Descriptor.ToTransitions[0].ToActivity);
IWfProcess wfProcess9 = WfRuntime.GetProcessByProcessID(process.ID);
WfWithdrawExecutor withdrawExec = new WfWithdrawExecutor(wfProcess9.CurrentActivity, wfProcess9.CurrentActivity);
withdrawExec.Execute();
IWfProcess wfProcess1 = WfRuntime.GetProcessByProcessID(wfProcess9.ID);
Assert.AreEqual(wfProcess1.Activities.Count, wfProcess1.Descriptor.GetMainStreamActivities().Count, "此处应该撤回到加签的活动点上,同时被加签的两个点都应该移除");
Assert.AreEqual(1, wfProcess1.ElapsedActivities.Count);
Assert.IsTrue(ProcessTestHelper.ExistsActivityUserTasks(wfProcess1.CurrentActivity.ID, TaskStatus.Ban));
Assert.IsTrue(wfProcess1.CurrentActivity.Descriptor.ToTransitions.Count == 1);
}
public void BranchProcessContainsSecretaryWithAgreeLineTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateBranchProcessWithSecretaryAndAgreeLine();
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
WfProcessTestCommon.MoveToNextDefaultActivityWithExecutor(process);
process = WfRuntime.GetProcessByProcessID(process.ID);
process.CurrentActivity.BranchProcessGroups[0].Branches.ForEach(subProcess =>
{
Console.WriteLine("分支流程ID={0}", subProcess.ID);
OutputProcessCandidatesAndOutTransitions(subProcess);
});
}
public void ClearSecretaryTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptorWithSecretary();
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
ChangeActivityResource(process.Descriptor.Activities["NormalActivity"], (IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object);
WfRuntime.DecorateProcess(process);
OutputProcessCandidates(process);
ReturnExecutorTestHelper.OutputMainStream(process);
Assert.AreEqual(3, processDesp.Activities.Count);
Assert.AreEqual(3, process.MainStream.Activities.Count);
}
public void TransitionNameTest()
{
IWfProcessDescriptor processDesp = PrepareProcessDescriptor(true);
IWfProcess process = processDesp.StartupProcess();
process = process.MoveToDefaultActivityByExecutor();
process = process.MoveToDefaultActivityByExecutor();
Console.WriteLine(process.ApplicationRuntimeParameters["CurrentTransitionName"]);
IWfActivityDescriptor normalActivity = processDesp.Activities["NormalActivity"];
Assert.AreEqual(normalActivity.ToTransitions[0].Name, process.ApplicationRuntimeParameters["CurrentTransitionName"]);
}
private static bool GetInMoveToStatus(IWfProcess process, string originalActivityID)
{
bool result = false;
IWfActivity currentActivity = process.Activities[originalActivityID];
if (currentActivity != null)
{
//锁判断
//result = this.LockResult == null || this.LockResult.Succeed;
result = process.Status == WfProcessStatus.Running &&
currentActivity.Status == WfActivityStatus.Running;
}
return(result);
}
public void BasicDynamicActivityWithoutResourceTest()
{
IWfProcessDescriptor processDesp = ProcessHelper.CreateSimpleProcessDescriptor();
IWfActivityDescriptor templateActDesp = processDesp.Activities["NormalActivity"];
FillDynamicActivitySimpleResource(templateActDesp);
IWfProcess process = processDesp.StartupProcess();
IWfActivityDescriptor firstDynamicActDesp = ValidateDynamicActivities(process.InitialActivity.Descriptor, templateActDesp);
ValidateNoResourceTransitionsProperties(processDesp.InitialActivity.ToTransitions.FindAll(t => t.Properties.GetValue("DynamicSource", string.Empty) == templateActDesp.Key), templateActDesp);
Assert.AreEqual(processDesp.CompletedActivity.Key, firstDynamicActDesp.Key, "起始点和终止点连接在一起");
}
public void EnterActivityServiceTest()
{
IWfProcessDescriptor processDesp = ProcessHelper.CreateSimpleProcessDescriptor();
((WfActivityDescriptor)processDesp.InitialActivity).EnterEventExecuteServiceKeys = "PCGetVersion";
IWfProcess process = processDesp.StartupProcessByExecutor(new Dictionary <string, object>()
{
{ "callerID", "EnterActivity" }
});
string result = process.ApplicationRuntimeParameters.GetValue("Version", string.Empty);
Console.WriteLine(result);
Assert.IsTrue(result.IndexOf("EnterActivity") >= 0);
}
private void OnProcessReadyHandler(IWfProcess process)
{
if (process.LoadingType == DataLoadingType.Cloned)
{
string sourceResourceID = WebUtility.GetRequestQueryString("sourceResourceID", string.Empty);
ICommandStatePersist originalState = LoadStateByResourceID(sourceResourceID);
ExceptionHelper.FalseThrow(originalState != null, "CopyForm时，必须实现LoadStateByResourceID方法");
ICommandStatePersist persistedState = (ICommandStatePersist)originalState;
CommandStateBase newState = (CommandStateBase)persistedState.CloneBusinessObject();
CommandStateHelper.RegisterState(newState);
}
}
public void CancelProcessAndBranchProcessCompleted()
{
IWfProcess process = GetProcessInstanceWithBranchProcessRunning(WfBranchProcessExecuteSequence.Parallel, WfBranchProcessBlockingType.WaitAnyoneBranchProcessComplete);
ProcessTestHelper.CompleteActivityBranchProcessesByBlockingType(process.CurrentActivity, WfBranchProcessBlockingType.WaitAnyoneBranchProcessComplete);
ProcessTestHelper.ProcessPendingActivity(process.CurrentActivity.ID);
Assert.AreEqual(WfProcessStatus.Completed, process.CurrentActivity.BranchProcessGroups[0].Branches[0].Status);
Assert.AreEqual(WfProcessStatus.Running, process.CurrentActivity.BranchProcessGroups[0].Branches[1].Status);
CancelProcess(process, true);
process = WfRuntime.GetProcessByProcessID(process.ID);
CheckOperationAndStatusAfterCancelProcess(process.Activities[1].BranchProcessGroups[0].Branches[0]);
CheckOperationAndStatusAfterCancelProcess(process.Activities[1].BranchProcessGroups[0].Branches[1]);
}
public void CancelSubProcessTest()
{
IWfProcess process = GetProcessInstanceWithBranchProcessRunning(WfBranchProcessExecuteSequence.Parallel, WfBranchProcessBlockingType.WaitAllBranchProcessesComplete);
IWfProcess branchProcess = process.CurrentActivity.BranchProcessGroups[0].Branches[0];
CancelProcess(branchProcess, false);
IWfProcess branchProcess2 = process.CurrentActivity.BranchProcessGroups[0].Branches[1];
CancelProcess(branchProcess2, false);
process = WfRuntime.GetProcessByProcessID(process.ID);
process.MoveTo(new WfTransferParams(process.CurrentActivity.Descriptor.ToTransitions[0].ToActivity));
Assert.AreEqual(WfActivityStatus.Completed, process.Activities[1].Status);
}
public static WfProcessDimension FromProcess(IWfProcess process)
{
process.NullCheck("process");
WfProcessDimension result = new WfProcessDimension();
result.ProcessID = process.ID;
XElement xml = XElement.Parse("<Process/>");
((ISimpleXmlSerializer)process).ToXElement(xml, string.Empty);
result.Data = xml.ToString();
return(result);
}
internal WfProcessActionContextState SaveDifferentProcessInfo(IWfProcess process)
{
WfProcessActionContextState state = new WfProcessActionContextState();
IWfProcess originalProcess = null;
if (OriginalActivity != null)
{
originalProcess = OriginalActivity.Process;
}
state.SavedOriginalActivity = OriginalActivity;
state.NeedToRestore = (originalProcess != process);
return(state);
}
public IWfProcess Execute()
{
IWfProcess result = null;
try
{
ExecutionWrapper(EnumItemDescriptionAttribute.GetDescription(OperationType),
() => result = InternalExecute(true));
return(result);
}
finally
{
WfExecutorLogContextInfo.CommitInfoToLogger();
}
}
public static List <IWfProcess> StartupMultiProcesses(IWfProcessDescriptor processDesp, int totalProcesses)
{
List <IWfProcess> processes = new List <IWfProcess>();
//准备流程实例
for (int i = 0; i < totalProcesses; i++)
{
WfProcessStartupParams startupParams = new WfProcessStartupParams();
startupParams.ProcessDescriptor = processDesp;
IWfProcess process = WfRuntime.StartWorkflow(startupParams);
processes.Add(process);
}
return(processes);
}
private void InitOriginalActivityByActivityID(string resourceID, string activityID)
{
if (activityID.IsNotEmpty())
{
IWfProcess process = WfRuntime.GetProcessByActivityID(activityID);
//取得OriginalActivity
this._OriginalCurrentActivity = process.CurrentActivity;
this.OriginalActivity = process.Activities[activityID];
if (this.OriginalActivity == null)
{
this.OriginalActivity = process.CurrentActivity;
}
}
}
private void NormalizeOneTaskInfo(UserTask task)
{
if (task.ProcessID.IsNotEmpty())
{
try
{
IWfProcess process = WfRuntime.GetProcessByProcessID(task.ProcessID);
task.TaskTitle = process.ApplicationRuntimeParameters.GetMatchedString(task.TaskTitle);
task.Url = process.ApplicationRuntimeParameters.GetMatchedString(task.Url);
}
catch (WfRuntimeException)
{
}
}
}
private static bool GetInMoveToMode(IWfProcess process, string originalActivityID, string userID)
{
bool result = GetInMoveToStatus(process, originalActivityID);
if (result)
{
IWfActivity currentActivity = process.Activities[originalActivityID];
if (result)
{
result = IsUserInAssignees(userID, currentActivity.Assignees);
}
}
return(result);
}
