Exemplo n.º 1
0
        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);
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 5
0
        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);
        }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
        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;
            }
        }
Exemplo n.º 11
0
        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);
        }
Exemplo n.º 12
0
		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();
		}
Exemplo n.º 14
0
		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);
				}
			}
		}
Exemplo n.º 15
0
        /// <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;
        }
Exemplo n.º 16
0
        /// <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;
        }
Exemplo n.º 17
0
        /// <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;
        }
Exemplo n.º 18
0
        /// <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;
        }
Exemplo n.º 19
0
        /// <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;
        }