public void SingleStepWithdrawByDynamicAddReplay()
{
//会签都是针对同样的两个人操作，且串行
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["approver2"].Object;
string procResourceId = GetStartWorkflowResourceID(user);
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(procResourceId);
string processID = processes[0].ID;
MoveToExecutor(processes[0]);
Assert.AreEqual(1, processes[0].ElapsedActivities.Count); //initial
IWfProcess proc = WfRuntime.GetProcessByProcessID(processID);
List <IUser> users;
ConsignExecutorWithCondition(proc, out users);
proc = WfRuntime.GetProcessByProcessID(processID);
WfWithdrawExecutor withdrawExec = new WfWithdrawExecutor(proc.CurrentActivity, proc.CurrentActivity);
withdrawExec.Execute();
proc = WfRuntime.GetProcessByProcessID(processID);
Assert.AreEqual(1, proc.ElapsedActivities.Count);
}
public List <WfClientProcess> GetProcessesByResourceID(string resourceID, WfClientUser user, WfClientProcessInfoFilter filter)
{
resourceID.CheckStringIsNullOrEmpty("resourceID");
OperationContext.Current.FillContextToOguServiceContext();
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(resourceID).SortByUserRelativity((IUser)user.ToOguObject());
WfClientProcessConverter converter = new WfClientProcessConverter(filter);
List <WfClientProcess> result = new List <WfClientProcess>();
foreach (IWfProcess process in processes)
{
WfClientProcess client = null;
converter.ServerToClient(process, ref client);
client.AuthorizationInfo = WfClientProcessInfoBaseConverter.Instance.GetAuthorizationInfo(process, process.CurrentActivity, user);
if ((filter & WfClientProcessInfoFilter.CurrentOpinion) == WfClientProcessInfoFilter.CurrentOpinion)
{
client.FillCurrentOpinion(process.CurrentActivity, user);
}
result.Add(client);
}
return(result);
}
public void StartBranchProcessExecutorTest()
{
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptorWithBranchTemplate();
IWfActivityDescriptor normalActivityDesp = processDesp.Activities["NormalActivity"];
//不自动启动分支流程
normalActivityDesp.Properties.SetValue("AutoStartBranchProcesses", false);
IWfProcess process = WfProcessTestCommon.StartupProcess(processDesp);
//前进一步，但是没有启动流程
MoveToExecutor(process);
process = WfRuntime.GetProcessByProcessID(process.ID);
IWfActivity normalActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
Assert.AreEqual(0, normalActivity.BranchProcessGroups.Count);
WfProcessCollection processes = new WfProcessCollection();
for (int i = 0; i < normalActivity.Descriptor.BranchProcessTemplates.Count; i++)
{
process = WfRuntime.GetProcessByProcessID(process.ID);
normalActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
WfStartBranchProcessExecutor executor = new WfStartBranchProcessExecutor(normalActivity, normalActivity, normalActivity.Descriptor.BranchProcessTemplates[i]);
executor.Execute();
processes.CopyFrom(executor.StartedProcesses);
}
process = WfRuntime.GetProcessByProcessID(process.ID);
normalActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");
Console.WriteLine(processes.Count);
Assert.AreEqual(2, normalActivity.BranchProcessGroups.Count);
//Assert.AreEqual(1, normalActivity.BranchProcessGroups[0].BranchProcessStatistics.Total);
//Assert.AreEqual(0, normalActivity.BranchProcessGroups[0].BranchProcessStatistics.Completed);
//Assert.AreEqual(0, normalActivity.BranchProcessGroups[0].BranchProcessStatistics.Aborted);
Assert.IsTrue(normalActivity.BranchProcessGroups[0].IsBlocking());
//Assert.AreEqual(1, normalActivity.BranchProcessGroups[1].BranchProcessStatistics.Total);
//Assert.AreEqual(0, normalActivity.BranchProcessGroups[1].BranchProcessStatistics.Completed);
//Assert.AreEqual(0, normalActivity.BranchProcessGroups[1].BranchProcessStatistics.Aborted);
Assert.IsTrue(normalActivity.BranchProcessGroups[1].IsBlocking());
Assert.AreEqual(1, normalActivity.BranchProcessGroups[0].Branches.Count);
Assert.AreEqual(1, normalActivity.BranchProcessGroups[1].Branches.Count);
}
public List <WfClientProcessInfo> GetProcessesInfoByResourceID(string resourceID, WfClientUser user)
{
resourceID.CheckStringIsNullOrEmpty("resourceID");
OperationContext.Current.FillContextToOguServiceContext();
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(resourceID).SortByUserRelativity((IUser)user.ToOguObject());
List <WfClientProcessInfo> result = new List <WfClientProcessInfo>();
processes.ForEach(process => result.Add(process.ToClientProcessInfo(user).FillCurrentOpinion(process.CurrentActivity, user)));
return(result);
}
public void MoveToExecutorTest()
{
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object;
string procResourceId = GetStartWorkflowResourceID(user);
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(procResourceId);
IWfProcess process = processes[0];
string nextActivityDespKey = process.CurrentActivity.Descriptor.ToTransitions[0].ToActivity.Key;
MoveToExecutor(process);
IWfProcess proc = WfRuntime.GetProcessByProcessID(process.ID);
Assert.AreEqual(nextActivityDespKey, proc.CurrentActivity.Descriptor.Key);
}
public void StartWorkflowExecutorTest()
{
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object;
string procResourceId = GetStartWorkflowResourceID(user);
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(procResourceId);
Assert.AreEqual(1, processes.Count);
Assert.AreEqual(0, processes[0].ElapsedActivities.Count);
WfUserResourceDescriptor uDesp = (WfUserResourceDescriptor)processes[0].InitialActivity.Descriptor.Resources[0];
Assert.AreEqual(user.ID, uDesp.User.ID);
}
protected virtual void CopyWorkflow(string processDescKey, string appName, string programName, string sourceResourceID, string sourceProcessID, string relativeID, string relativeURL)
{
IWfProcess originalProcess = null;
if (sourceProcessID.IsNotEmpty())
{
originalProcess = WfRuntime.GetProcessByProcessID(sourceProcessID);
}
else
{
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(sourceResourceID);
(processes.Count > 0).FalseThrow("不能根据{0}找到对应的流程", sourceResourceID);
originalProcess = processes[0];
}
InnerStartWorkflow(processDescKey, appName, programName, relativeID, relativeURL, true, originalProcess.ApprovalRootProcess.RelativeParams);
}
public void ConsignExecutorTest()
{
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["approver2"].Object;
string procResourceID = GetStartWorkflowResourceID(user);
string processID = string.Empty;
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(procResourceID);
processID = processes[0].ID;
MoveToExecutor(processes[0]);
Assert.AreEqual(1, processes[0].ElapsedActivities.Count);
processes = WfRuntime.GetProcessByResourceID(procResourceID);
List <IUser> users;
ConsignExecutor(processes[0], out users);
processes = WfRuntime.GetProcessByResourceID(procResourceID);
Assert.AreEqual(3, processes.Count, "共3个流程，主流程与两个子流程");
IWfProcess proc = WfRuntime.GetProcessByProcessID(processID);
Assert.AreEqual(7, proc.Activities.Count);
string k = proc.CurrentActivity.Descriptor.FromTransitions[0].FromActivity.Key;
Assert.IsNotNull(proc.Activities.FindActivityByDescriptorKey(k).CreatorInstanceID, "添加会签点的活动确实没值");
Assert.AreEqual(WfActivityStatus.Pending, proc.CurrentActivity.Status); //NO
Assert.AreEqual(users.Count, proc.CurrentActivity.BranchProcessGroups[0].Branches.Count);
//使子流程完成
proc = WfRuntime.GetProcessByProcessID(processID);
ProcessTestHelper.CompleteActivityBranchProcessesByBlockingType(proc.CurrentActivity, WfBranchProcessBlockingType.WaitAllBranchProcessesComplete);
WfRuntime.PersistWorkflows();
ProcessTestHelper.ProcessPendingActivity(proc.CurrentActivity.ID);
proc = WfRuntime.GetProcessByProcessID(processID);
Assert.AreEqual(WfActivityStatus.Running, proc.CurrentActivity.Status, "此为添加的会签点");
Assert.AreEqual(2, proc.CurrentActivity.BranchProcessGroups[0].Branches.Count, "存在两个子流程");
Assert.AreEqual(2, proc.ElapsedActivities.Count);
MoveToExecutor(proc);
Assert.AreEqual(3, proc.ElapsedActivities.Count);
}
private bool OriginalDataExists(string resourceID)
{
bool result = false;
try
{
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(resourceID);
result = processes.Count > 0;
if (result == false)
{
result = AppCommonInfoAdapter.Instance.ExistsAndNotArchived(resourceID);
}
}
catch (System.Exception)
{
}
return(result);
}
private void InitOriginalActivityByResourceID(string resourceID)
{
if (resourceID.IsNotEmpty())
{
WfProcessCollection procCollection = WfRuntime.GetProcessByResourceID(resourceID);
(procCollection.Count > 0).FalseThrow <WfRuntimeException>("不能根据'{0}'找到ResourceID对应的流程", resourceID);
IWfProcess process = procCollection.Find(p =>
{
return(p.HasParentProcess == false);
});
if (process == null)
{
process = procCollection[0].SameResourceRootProcess;
}
OriginalActivity = process.CurrentActivity;
this._OriginalCurrentActivity = OriginalActivity;
}
}
public void SingleStepWithDrawByDynamicAdd()
{
//Initial NormalActivity NormalActivity1 NormalActivity2 NormalActivity3 Completed
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["approver2"].Object;
string procResourceId = GetStartWorkflowResourceID(user);
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(procResourceId);
string processId = processes[0].ID;
MoveToExecutor(processes[0]);
Assert.AreEqual(1, processes[0].ElapsedActivities.Count); //initial
processes = WfRuntime.GetProcessByResourceID(procResourceId);
List <IUser> users;
ConsignExecutor(processes[0], out users);
IWfProcess proc = WfRuntime.GetProcessByProcessID(processId);
Assert.AreEqual(2, proc.ElapsedActivities.Count); //NormalActivity
ProcessTestHelper.CompleteActivityBranchProcessesByBlockingType(proc.CurrentActivity, WfBranchProcessBlockingType.WaitAllBranchProcessesComplete);
WfRuntime.PersistWorkflows();
ProcessTestHelper.ProcessPendingActivity(proc.CurrentActivity.ID);
proc = WfRuntime.GetProcessByProcessID(processId);
WfWithdrawExecutor withdrawExec = new WfWithdrawExecutor(proc.CurrentActivity, proc.CurrentActivity); //"NO"
withdrawExec.Execute();
proc = WfRuntime.GetProcessByProcessID(processId);
Assert.AreEqual(1, proc.ElapsedActivities.Count);
Assert.AreEqual(proc.Descriptor.GetMainStreamActivities().Count, proc.Activities.Count);
Assert.AreEqual(proc.ElapsedActivities[0].Descriptor.ToTransitions[0].ToActivity.Key, proc.CurrentActivity.Descriptor.Key);
Assert.IsTrue(ProcessTestHelper.ExistsActivityUserTasks(proc.CurrentActivity.ID, TaskStatus.Ban));
Assert.IsTrue(proc.CurrentActivity.Descriptor.ToTransitions.Count == 1);
}
private WfProcessCollection GetDeletedProcesses(WfActivityCollection deletedActivities)
{
WfProcessCollection deletedProcesses = new WfProcessCollection();
foreach (IWfActivity activity in deletedActivities)
{
if (activity is IWfAnchorActivity)
{
foreach (IWfOperation operation in ((IWfAnchorActivity)activity).Operations)
{
foreach (WfBranchProcessInfo branchProcessInfo in operation.Branches)
{
deletedProcesses.Add(branchProcessInfo.Process);
WfProcessCollection deletedSubProcesses =
GetDeletedProcesses(branchProcessInfo.Process.Activities);
foreach (IWfProcess subProcess in deletedSubProcesses)
deletedProcesses.Add(subProcess);
}
}
}
}
return deletedProcesses;
}
/// <summary>
/// 根据流程实例，初始化统计值。主要用于分支流程的初始化
/// </summary>
/// <param name="processes"></param>
internal void SyncProcessesStatus(WfProcessCollection processes)
{
this.Total += processes.Count;
foreach (IWfProcess process in processes)
{
IncreaseByStatus(process.Status);
}
this.MaxSequence = processes.GetMaxSequence();
}
private static void FillProcessesFromPersistence(WfProcessCollection processes, List<string> notInCacheIDs)
{
if (notInCacheIDs.Count > 0)
{
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
WfProcessCollection tempCollection = persistProcess.LoadProcesses(notInCacheIDs.ToArray());
foreach (IWfProcess tempProcess in tempCollection)
{
processes.Add(tempProcess);
AddProcessToCache(tempProcess.ID, tempProcess);
}
}
}
/// <summary>
/// 根据ResourceID得到流程
/// </summary>
/// <param name="resourceID"></param>
/// <returns></returns>
public static WfProcessCollection GetProcessByResourceID(string resourceID)
{
resourceID.NullCheck<WfRuntimeException>("resourceID");
WfProcessCollection processes = new WfProcessCollection();
foreach (KeyValuePair<string, IWfProcess> kp in WfProcessContextCache.Instance)
{
if (string.Compare(kp.Value.ResourceID, resourceID, true) == 0)
{
processes.Add(kp.Value);
break;
}
}
WfProcessCollection persistedProcesses = null;
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("LoadProcessByResourceID({0})", resourceID), () =>
persistedProcesses = WorkflowSettings.GetConfig().GetPersistManager().LoadProcessByResourceID(resourceID)
);
persistedProcesses.ForEach(p =>
{
if (processes.ContainsKey(p.ID) == false)
processes.Add(p);
WfProcessContextCache.Instance[p.ID] = p;
});
return processes;
}
/// <summary>
/// 得到某个活动的子流程。如果缓存中存在，则使用缓存中的流程
/// </summary>
/// <param name="activityID"></param>
/// <param name="templateKey"></param>
/// <returns></returns>
public static WfProcessCollection GetProcessByOwnerActivityID(string activityID, string templateKey)
{
activityID.CheckStringIsNullOrEmpty("activityID");
templateKey.CheckStringIsNullOrEmpty("templateKey");
WfProcessCollection queryResult = null;
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("LoadProcessByOwnerActivityID({0}-{1})", activityID, templateKey), () =>
queryResult = WorkflowSettings.GetConfig().GetPersistManager().LoadProcessByOwnerActivityID(activityID, templateKey)
);
WfProcessCollection result = new WfProcessCollection();
foreach (IWfProcess process in queryResult)
{
//如果缓存中存在，则使用缓存的数据，如果缓存中不存在，则使用查询到的结果
IWfProcess processNeedToAdd = WfProcessContextCache.Instance.GetOrAddNewValue(process.ID, (cache, key) =>
{
cache.Add(key, process);
return process;
});
result.Add(processNeedToAdd);
}
return result;
}
/// <summary>
/// 调用外部服务。对方会返回一个或一组流程ID。本函数返回这组ID对应的流程。
/// </summary>
/// <param name="startupParams"></param>
/// <param name="template"></param>
/// <returns></returns>
private WfProcessCollection InvokeBranchProcess(WfServiceStartupProcessParams startupParams, IWfBranchProcessTemplateDescriptor template)
{
this.Process.ApplicationRuntimeParameters["serviceOP_Paramas"] = startupParams;
WfServiceInvoker svcInvoker = new WfServiceInvoker(template.OperationDefinition);
object obj = svcInvoker.Invoke();
WfProcessCollection processes = new WfProcessCollection();
WfBranchProcessTemplateDescriptor temp = template as WfBranchProcessTemplateDescriptor;
IList array = obj as IList;
if (array != null)
{
IWfProcess process = null;
foreach (string processID in array)
{
process = WfRuntime.GetProcessByProcessID(processID);
processes.Add(process);
}
temp.BranchProcessKey = process.Descriptor.Key;
}
else
{
IWfProcess process = WfRuntime.GetProcessByProcessID(obj.ToString());
processes.Add(process);
temp.BranchProcessKey = process.Descriptor.Key;
}
return processes;
}
/// <summary>
/// 启动一个模版（组）下的一组分支流程，在服务模式下，可能返回多个流程。其它情况返回单个流程
/// </summary>
/// <param name="branchTransferParams"></param>
/// <param name="group"></param>
/// <param name="index"></param>
/// <returns></returns>
private WfProcessCollection StartupBranchProcess(WfBranchProcessTransferParams branchTransferParams, IWfBranchProcessGroup group, int index)
{
WfProcessCollection processes = null;
if (branchTransferParams.Template.OperationDefinition == null)
{
WfProcessStartupParams startupParams = PrepareOneBranchProcessStartupParams(branchTransferParams, group, index);
startupParams.CheckStartProcessUserPermission = false;
processes = new WfProcessCollection();
processes.Add(WfRuntime.StartWorkflow(startupParams));
}
else
{
if (WfRuntime.ProcessContext.EnableServiceCall)
{
WfServiceStartupProcessParams startupParams = PrepareOneServiceStartupProcessParams(branchTransferParams, group, index);
processes = InvokeBranchProcess(startupParams, branchTransferParams.Template);
}
else
processes = new WfProcessCollection();
}
return processes;
}
/// <summary>
/// 内部启动分支流程
/// </summary>
/// <param name="branchTransferParams">分支流程启动参数</param>
/// <param name="addToOwnerBranches"></param>
/// <returns></returns>
internal WfProcessCollection InternalStartupBranchProcesses(WfBranchProcessTransferParams branchTransferParams, bool addToOwnerBranches)
{
WfProcessCollection processes = null;
if (CanStartBranchProcessFromTemplate(branchTransferParams.Template))
{
IWfBranchProcessGroup group = this.BranchProcessGroups[branchTransferParams.Template.Key];
//以模版Key为分支流程实例的分组标准
if (group == null)
{
group = new WfBranchProcessGroup(this, branchTransferParams.Template);
this.BranchProcessGroups.Add(group);
}
WfRuntime.ProcessContext.FirePrepareBranchProcessParams(group, branchTransferParams.BranchParams);
ProcessProgress.Current.MaxStep += branchTransferParams.BranchParams.Count;
ProcessProgress.Current.Response();
//根据模板内的分支流程参数，逐一启动具体流程
for (int i = 0; i < branchTransferParams.BranchParams.Count; i++)
{
//processes = StartupBranchProcess(branchTransferParams, group, group.BranchProcessStatistics.MaxSequence++);
processes = StartupBranchProcess(branchTransferParams, group, i);
processes.ForEach(p =>
{
if (addToOwnerBranches)
{
if (group.Branches.Contains(p) == false)
{
group.Branches.Add(p);
}
}
WfRuntime.ProcessContext.FireAfterStartupBranchProcess(p);
});
ProcessProgress.Current.MaxStep = Math.Max(ProcessProgress.Current.MaxStep, ProcessProgress.Current.CurrentStep + processes.Count);
ProcessProgress.Current.IncrementBy(processes.Count);
ProcessProgress.Current.Response();
}
WfRuntime.ProcessContext.AffectedProcesses.AddOrReplace(this.Process);
}
if (processes == null)
processes = new WfProcessCollection();
return processes;
}
protected override void OnModifyWorkflow(WfExecutorDataContext dataContext)
{
this.StartedProcesses = ((WfActivityBase)this.OwnerActivity).InternalStartupBranchProcesses(this.BranchTransferParams, false);
}
private static WfProcessCollection DataTableToProcessCollection(DataTable table)
{
WfProcessCollection result = new WfProcessCollection();
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = WorkflowSettings.GetConfig().OutputShortType;
foreach (DataRow row in table.Rows)
{
WfProcessInstanceData instanceData = new WfProcessInstanceData();
ORMapping.DataRowToObject(row, instanceData);
XElement extData = GetExtData(instanceData.ExtData);
Encoding originalEncoding = GetEncodingFromExtData(extData);
Encoding preferedEncoding = originalEncoding;
byte[] decompressedData = null;
if (null != instanceData.BinaryData)
{
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("Extra Process Data:{0}", instanceData.InstanceID),
() => decompressedData = CompressManager.ExtractBytes(instanceData.BinaryData));
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("EncodeProcessString", () =>
{
preferedEncoding = GetPreferedEncoding(decompressedData, originalEncoding);
instanceData.Data = BytesToProcessData(decompressedData, preferedEncoding);
}
);
}
else
{
(instanceData.Data != null).FalseThrow<ArgumentException>(Translator.Translate(Define.DefaultCulture, "流程实例表的Data和BinaryData都为空"));
}
XElement root = null;
try
{
root = XElement.Parse(instanceData.Data);
}
catch (System.Xml.XmlException)
{
if (decompressedData != null)
{
instanceData.Data = ChangeEncoding(decompressedData, preferedEncoding);
root = XElement.Parse(instanceData.Data);
}
else
throw;
}
extData.SetAttributeValue("encoding", originalEncoding.BodyName);
WfProcess process = null;
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("Deserialize Process:{0}", instanceData.InstanceID),
() => process = (WfProcess)formatter.Deserialize(root));
process.LoadingType = DataLoadingType.External;
process.Activities.ForEach(a =>
{
((WfActivityBase)a).LoadingType = DataLoadingType.External;
WfActivityBuilderBase.LoadActions(a);
});
process.UpdateTag = instanceData.UpdateTag;
process.Context["SerilizationExtData"] = extData.ToString();
result.Add(process);
}
return result;
}
