示例#1
0
        /// <summary>
        /// 模拟一步流程执行
        /// </summary>
        /// <param name="process"></param>
        /// <param name="simulationContext"></param>
        /// <returns></returns>
        public static WfSimulationResult MoveToSimulation(string processID, WfSimulationParameters simulationParameters)
        {
            bool oldValue = WfRuntime.ProcessContext.EnableSimulation;

            try
            {
                WfRuntime.ProcessContext.EnableSimulation = true;
                InitSimulationContext(simulationParameters);

                IWfProcess process = WfRuntime.GetProcessByProcessID(processID);

                MergeVariablesToApplicationRuntimeParameters(process.ApplicationRuntimeParameters, simulationParameters.Variables);

                InnerMoveToSimulation(process, WfRuntime.ProcessContext.SimulationContext);

                //递归子流程,每个流程执行一步
                return(new WfSimulationResult(process)
                {
                    OutputString = WfRuntime.ProcessContext.SimulationContext.GetOutputString()
                });
            }
            finally
            {
                WfRuntime.ProcessContext.EnableSimulation = oldValue;
            }
        }
示例#2
0
        ///// <summary>
        ///// 取消所有的分支流程
        ///// </summary>
        ///// <param name="recursive">是否递归</param>
        //public void CancelBranchProcesses(bool recursive)
        //{
        //    this.BranchProcessGroups.ForEach(group =>
        //    {
        //        ((WfBranchProcessGroup)group).CheckProcessesStatusInBranches();
        //        ProcessProgress.Current.MaxStep += group.Branches.Count;
        //        ProcessProgress.Current.Response();

        //        group.Branches.ForEach(p =>
        //        {
        //            ((WfProcess)p).InternalCancelProcess(recursive);

        //            ProcessProgress.Current.Increment();
        //            ProcessProgress.Current.Response();
        //        });
        //    });
        //}

        /// <summary>
        /// 取消所有的分支流程
        /// </summary>
        /// <param name="recursive">是否递归</param>
        public void CancelBranchProcesses(bool recursive)
        {
            this.BranchProcessGroups.ForEach(group =>
            {
                ((WfBranchProcessGroup)group).CheckProcessesStatusInBranches();

                IList <string> processIDs = ((WfBranchProcessGroup)group).InternalBranches.FindProcessIDsByStatus(status => status != WfProcessStatus.Aborted);

                ProcessProgress.Current.MaxStep += processIDs.Count;
                ProcessProgress.Current.Response();

                int i = 1;
                processIDs.ForEach(pID =>
                {
                    WfProcess p = (WfProcess)WfRuntime.GetProcessByProcessID(pID);

                    ProcessProgress.Current.StatusText = string.Format("正在作废分支流程{0}/{1}", i, processIDs.Count);
                    ProcessProgress.Current.Response();

                    p.InternalCancelProcess(recursive);

                    i++;
                    ProcessProgress.Current.Increment();
                    ProcessProgress.Current.Response();
                });

                ProcessProgress.Current.StatusText = string.Empty;
                ProcessProgress.Current.Response();
            });
        }
示例#3
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);
        }
        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)
                {
                }
            }
        }
示例#5
0
        /// <summary>
        /// 执行一项队列操作
        /// </summary>
        /// <param name="pq"></param>
        public void DoQueueOperation(WfPersistQueue pq)
        {
            pq.NullCheck("pq");

            Dictionary <object, object> context = new Dictionary <object, object>();

            IWfProcess process = WfRuntime.GetProcessByProcessID(pq.ProcessID);

            try
            {
                WfQueuePersistenceSettings.GetConfig().GetPersisters().SaveData(process, context);
            }
            finally
            {
                WfRuntime.ClearCache();
            }
        }