Esempio n. 1
0
        //public ProcessEngine()
        //{
        //    this._ProcessInstances = new Dictionary<string, ProcessInstance>();
        //    this.modelInstanceIDMaps = new Dictionary<string, string>();
        //}

        public string CreateProcessInstance(string Identity, int User, Dictionary <string, object> InputData = null)
        {
            // 获取流程模板
            var def = ProcessModelCache.Instance[Identity];

            // 获取流程的监听者
            var _Ob = UnityContainerHelper.GetServer <IObservation>(def.ProcessOb.Name);

            var pID = Guid.NewGuid().ToString();

            // 生成流程实例
            var pi = new ProcessInstance()
            {
                ID   = pID,
                Name = def.ID,
            };

            pi.StartDate  = DateTime.Now;
            pi.Version    = 1;
            pi.CreateUser = User;
            pi.InputData  = InputData;

            // 流程资源
            def.Resources.ForEach(r =>
            {
                var prs = new ProcessResouce()
                {
                    Key   = r.ID,
                    Users = new Dictionary <string, string>()
                };

                r.Users.ForEach(u =>
                {
                    prs.Users.Add(u.ID, u.Name);
                });

                pi.ProcessResouces.Add(r.ID, prs);
            });

            // 编译脚本代码
            if (!string.IsNullOrEmpty(def.ConditionCode))
            {
                pi.Compiled = ConditionExpression.Evaluator(def.ConditionCode, def.ID);
            }

            // 生成流程脚本实例
            pi.GeneratTasks(def, InputData, _Ob);

            // 缓存流程实例
            _ProcessInstances.Add(pID, pi);

            // 保存生成的流程实例
            BPMDBService.Create(pi);

            return(pID);
        }
Esempio n. 2
0
        public override async Task <string> Excute(ProcessInstance pi)
        {
            return(await Task <string> .Factory.StartNew(() =>
            {
                BPMDBService.TaskDone(this.ID, pi.CreateUser);

                pi.Status = ProcessStatus.Finish;

                //Console.WriteLine(this.Name);

                return null;
            }));
        }
Esempio n. 3
0
        /// <summary>
        /// 删除流程实例
        /// </summary>
        /// <param name="Pid"></param>
        public bool DeleteProcess(string Pid)
        {
            // 删除流程实例的存储数据
            if (BPMDBService.DeleteProcess(Pid))
            {
                if (_ProcessInstances.ContainsKey(Pid))
                {
                    _ProcessInstances.Remove(Pid);
                }

                return(true);
            }


            return(false);
        }
Esempio n. 4
0
        public async Task <bool> Start(string DefinitionID, Dictionary <string, object> InputData = null)
        {
            var token = new TaskToken();
            var pi    = _ProcessInstances[DefinitionID];

            pi.StartTask.Token = token;
            pi.Tokens.Add(token);
            pi.Status = ProcessStatus.Running;

            if (InputData != null)
            {
                pi.InputData = InputData;
            }
            if (pi.InputData == null)
            {
                pi.InputData = new Dictionary <string, object>();
            }

            while (pi.Status == ProcessStatus.Running)
            {
                foreach (var t in pi.Tokens)
                {
                    if (await t.Excute(pi))
                    {
                        //  令牌数量发生变化,集合更改,重新循环
                        break;
                    }
                }
            }

            if (pi.Status == ProcessStatus.Finish)
            {
                // 异步更新状态
                BPMDBService.ProcessDone(pi.ID);

                // 从缓存中移除已完成的流程实例
                _ProcessInstances.Remove(pi.ID);

                // 通知业务系统流程完成
                pi.OB.ProcessFinish(pi);
            }

            return(true);
        }
Esempio n. 5
0
        /// <summary>
        /// 设置流程任务的用户
        /// </summary>
        /// <param name="Pid"></param>
        /// <param name="Data"></param>
        public void SetProceeTaskUsers(Guid Pid, List <TaskInfo> TaskUsers)
        {
            var strPid = Pid.ToString("N");

            // 更新内存中的流程实例用户
            if (_ProcessInstances.ContainsKey(strPid))
            {
                var process = _ProcessInstances[strPid];

                foreach (var task in TaskUsers)
                {
                    var taskInstanceID = process.ModelInstanceIDMaps[task.ID];

                    process.Tasks[taskInstanceID].UserID = task.User;
                }
            }

            // 更新存储中的用户ID
            BPMDBService.UpdateTaskUsers(Pid, TaskUsers);
        }
Esempio n. 6
0
        public override async Task <string> Excute(ProcessInstance pi)
        {
            // 第一次轮到
            var arg = getArg(pi);

            if (this.Status == TaskStatus.Waiting)
            {
                // 用户提交了任务,
                this.Status = TaskStatus.Done;
                this.IsDone = true;

                BPMDBService.TaskDone(this.ID, this.UserID);

                // 通知任务完成
                _Observation.TaskDone(arg);

                return(await base.Excute(pi));
            }
            else
            {
                this.Status   = TaskStatus.Waiting;
                this.TurnDate = DateTime.Now;
                this.UserID   = int.Parse(arg.TaskUser);

                // 异步更新任务状态
                BPMDBService.TaskTurn(this.ID, this.UserID);

                if (!await _Observation.TaskTurnCall(arg))
                {
                    // 发起一个用户通知
                    // 中断等待用户回应

                    return(string.Empty);
                }
                else
                {
                    // 继续任务
                    return(await base.Excute(pi));
                }
            }
        }
Esempio n. 7
0
        public override async Task <string> Excute(ProcessInstance pi)
        {
            var arg = getArg(pi);

            // 第一次轮到会签
            if (!BPMDBService.ExistsJoinSignTask(this.ID))
            {
                // 中断等待用户回应
                this.Status   = TaskStatus.Waiting;
                this.TurnDate = DateTime.Now;

                // 异步更新任务状态
                BPMDBService.TaskTurn(this.ID, 0, arg.TaskUser);

                // 创建会签人员列表 // TODO  arg.TaskUser == 0
                arg.JoinSigns = BPMDBService.CreateJoinSignTasks(this.ID, arg.TaskUser);

                // 发起一个用户通知
                if (!await _Observation.TaskTurnCall(arg))
                {
                    return(string.Empty);
                }
                else
                {
                    // 任务完成
                    BPMDBService.TaskDone(this.ID, int.Parse(arg.TaskUser));

                    // 通知任务完成
                    _Observation.TaskDone(arg);

                    // 继续任务
                    return(await base.Excute(pi));
                }
            }
            else
            {
                // 会签任务完成
                BPMDBService.JoinSignTaskDone(int.Parse(pi.InputData["SignID"].ToString()), bool.Parse(pi.InputData["SignIDResult"].ToString()));

                // 通知任务完成
                _Observation.TaskDone(arg);

                // 第二次,检查所有的会签任务是否完成
                if (BPMDBService.CheckAllJoinSignTaskDone(this.ID))
                {
                    // 任务完成
                    BPMDBService.TaskDone(this.ID, 0);

                    // 如果会签的下一个节点是唯一网关,只要有一个会签失败,这个网关的参数设置为false
                    if (BPMDBService.CheckFailureSign(this.ID) &&
                        !string.IsNullOrEmpty(arg.ArgName) &&
                        arg.ArgName.StartsWith("bool_"))
                    {
                        pi.InputData[arg.ArgName] = false;
                    }

                    // 继续任务
                    return(await base.Excute(pi));
                }
                else
                {
                    // 没有全部完成 继续等待
                    return(string.Empty);
                }
            }
        }
Esempio n. 8
0
        public async Task Continu(string TaskID, int User, Dictionary <string, object> InputData = null)
        {
            TaskID = TaskID.ToUpper();

            var pid = getProcessInstance(TaskID);

            ProcessInstance pi = null;

            if (string.IsNullOrEmpty(pid))
            {
                // back from db
                pi = BPMDBService.BackUpInstance(TaskID);

                // 缓存流程实例
                if (!_ProcessInstances.ContainsKey(pi.ID))
                {
                    _ProcessInstances.Add(pi.ID, pi);
                }
            }
            else
            {
                pi = _ProcessInstances[pid];
            }

            pi.Status = ProcessStatus.Running;

            pi.InputData = InputData;

            // 这里不自动跳过此任务,由任务自己来执行下一步(因为会签的话需要所有的会签任务完成才执行下一步)

            //var token = pi.Tasks[TaskID].Token;

            //token.CurrentTask = null;
            //token.CurrentGateway = null;

            //var to = pi.Sequences[pi.Tasks[TaskID].To].To;

            //if (pi.Tasks.ContainsKey(to))
            //{
            //    pi.Tasks[to].Token = token;
            //}
            //else if (pi.Gateways.ContainsKey(to))
            //{
            //    pi.Gateways[to].Token = token;
            //}

            pi.Tasks[TaskID].IsDone = true;

            while (pi.Status == ProcessStatus.Running)
            {
                foreach (var t in pi.Tokens)
                {
                    if (await t.Excute(pi))
                    {
                        //  令牌数量发生变化,集合更改,重新循环
                        break;
                    }
                }
            }

            if (pi.Status == ProcessStatus.Finish)
            {
                // 更新状态
                BPMDBService.ProcessDone(pi.ID);

                // 从缓存中移除已完成的流程实例
                _ProcessInstances.Remove(pi.ID);

                // 通知业务系统流程完成
                pi.OB.ProcessFinish(pi);
            }
        }