Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected virtual bool CheckNodeCondition(NodeEntity node)
        {
            if (node == null || node.Conditions == null || node.Conditions.Count == 0)
            {
                return(true);
            }
            if (node.ConditionDelegate != null)
            {
                return(node.ConditionDelegate(this));
            }
            var infos = new List <object> {
                Task.Consumer as object
            };

            foreach (var condition in node.Conditions)
            {
                if (string.IsNullOrEmpty(condition.InspectExp))
                {
                    continue;
                }
                if (!infos.AsQueryable().Where(condition.InspectExp, condition.ArgumentArray).Any())
                {
                    return(false);
                }
            }
            return(true);
        }
Example #2
0
        /// <summary>
        /// 得到下一个节点
        /// </summary>
        /// <returns></returns>
        protected virtual IList <NodeEntity> GetNextNodes(NodeEntity currentNode, bool isPass)
        {
            if (currentNode == null)
            {
                return(null);
            }
            var nodes = new List <NodeEntity>();
            var name  = isPass ? currentNode.PassName : currentNode.RejectName;

            foreach (var node in Flow.Nodes.Where(it => it.Name == name))
            {
                if (CheckNodeCondition(node))
                {
                    switch (node.ConditionType)
                    {
                    case ConditionType.Create:
                        nodes.Add(node);
                        break;

                    case ConditionType.UnCreate:
                        break;

                    case ConditionType.Skip:
                        return(GetNextNodes(Flow.Nodes.FirstOrDefault(it => it.PassName == currentNode.PassName), isPass));
                    }
                }
            }
            return(nodes);
        }
Example #3
0
        /// <summary>
        /// 得到任务用户编号
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected virtual long GetTaskAccountId(NodeEntity node)
        {
            if (node.Auditor == null || node.Auditor.AuditorAccounts == null || node.Auditor.AuditorAccounts.Count == 0)
            {
                return(0);
            }
            var userIds = GetTaskAccountIds(node);

            if (userIds == null)
            {
                return(0);
            }
            if (node.AssignType == NodeAssignType.Average)
            {
                int index = (int)(Entity.UpdateTime.Ticks % node.Auditor.AuditorAccounts.Count);
                return(node.Auditor.AuditorAccounts[index].Account == null ? 0 : node.Auditor.AuditorAccounts[index].Account.Id);
            }
            if (node.AssignType == NodeAssignType.Random)
            {
                Random rd    = new Random(Guid.NewGuid().GetHashCode());
                var    index = rd.Next(0, node.Auditor.AuditorAccounts.Count - 1);
                return(node.Auditor.AuditorAccounts[index].Account == null ? 0 : node.Auditor.AuditorAccounts[index].Account.Id);
            }
            return(0);
        }
Example #4
0
        /// <summary>
        /// 确定是否生成
        /// </summary>
        /// <returns></returns>
        protected virtual bool CheckCreateTask(NodeEntity node, IList <TaskEntity> tasks)
        {
            if (node == null || tasks == null)
            {
                return(false);
            }
            var nextName = IsPass ? node.PassName:  node.RejectName;
            var nextNode = Flow.Nodes.FirstOrDefault(it => it.Name == nextName);

            if (nextNode == null || nextNode.NodeType == NodeType.End)
            {
                return(false);
            }
            switch (node.NodeType)
            {
            case NodeType.Single:
            {
                return(true);
            }

            case NodeType.Any:
            {
                if (IsPass)
                {
                    return(tasks.Count(it => it.Status == TaskStatusType.Passed) == 0);
                }
                return(tasks.All(it => it.Status == TaskStatusType.Rejected && it.Id != Task.Id));
            }

            case NodeType.All:
            {
                if (IsPass)
                {
                    return(tasks.All(it => it.Status == TaskStatusType.Passed && it.Id == Task.Id));
                }
                return(tasks.Count(it => it.Status == TaskStatusType.Rejected) == 0);
            }
            }
            return(false);
        }
Example #5
0
        /// <summary>
        /// 得到用户编号
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected virtual IList <long> GetTaskAccountIds(NodeEntity node)
        {
            var groupIds = Engine.GetGroups(AccountId)?.ToDictionary(it => it);
            var accounts = new Dictionary <long, long>();

            foreach (var id in node.Auditor.AuditorAccounts.Where(it => it.Account != null && it.Account.IsUsed).Select(it => it.Account.Id))
            {
                if (accounts.ContainsKey(id))
                {
                    continue;
                }
                if (node.IsGroup)
                {
                    var auditorGroupIds = Engine.GetGroups(id);
                    if (groupIds == null || auditorGroupIds == null || auditorGroupIds.Count(it => groupIds.ContainsKey(it)) == 0)
                    {
                        continue;
                    }
                }
                accounts.Add(id, id);
            }
            return(accounts.Values.ToList());
        }
Example #6
0
        /// <summary>
        /// 创建消息
        /// </summary>
        /// <param name="node"></param>
        /// <param name="task"></param>
        protected virtual void CreateMessage(NodeEntity node, TaskEntity task)
        {
            if (node.NodeMessages == null || node.NodeMessages.Count == 0)
            {
                return;
            }

            task.Messages = task.Messages ?? new List <MessageEntity> ();
            foreach (var nodeMessage in node.NodeMessages)
            {
                var url = ConfigurationManager.GetSetting <string>(nodeMessage.Url);
                url = string.IsNullOrWhiteSpace(url) ? nodeMessage.Url : url;
                var message = new MessageEntity
                {
                    Task     = task,
                    Type     = MessageType.Default,
                    Title    = nodeMessage.Title,
                    Detail   = nodeMessage.Detail,
                    Url      = url,
                    SaveType = SaveType.Add
                };
                task.Messages.Add(message);
            }
        }