WorkFlow/WorkFlowApi/WorkFlowApi..../Scheme/WFProcessBus...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WorkFlowApi.Entity;
using WorkFlowApi.Entity.SchemeEntity;
using WorkFlowApi.Entity.SchemeView;
using WorkFlowApi.IBusiness;
using WorkFlowApi.IBusiness.Scheme;
using WorkFlowApi.Utility;
using WorkFlowApi.Utility.WorkFlowEngine;
using WorkFlowApi.Utility.WorkFlowEngine.Scheme.Config;
using WorkFlowApi.Utility.WorkFlowEngine.Scheme.Line;
using WorkFlowApi.Utility.WorkFlowEngine.Scheme.Node;
using WorkFlowApi.ViewModels.View;

namespace WorkFlowApi.Business.Scheme
{
    public class WFProcessBusiness : BaseBusiness<T_WF_Process>, IWFProcessBusiness
    {
        private IWFSchemeBusiness wFSchemeBusiness = new WFSchemeBusiness();
        private IWFSchemeInfoBusiness wFSchemeInfoBusiness = new WFSchemeInfoBusiness();
        private IUserAccountBusiness user = new UserAccountBusiness();
        private IWFTaskBusiness wFTaskBusiness = new WFTaskBusiness();
        private IWFTaskLogBusiness logBusiness = new WFTaskLogBusiness();
        private IWFTaskTaskRelationBusiness wFTaskTaskRelationBusiness = new WFTaskTaskRelationBusiness();
        private IUserRelationBusiness userRelation = new UserRelationBusiness();

        public WFProcessBusiness()
        {
        }
        /// <summary>
        /// 创建流程
        /// </summary>
        /// <param name="schemeCode">流程模板编码</param>
        /// <param name="processId">流程进程主键</param>
        /// <param name="title">标题</param>
        /// <param name="level">流程等级</param>
        /// <param name="auditors">下一节点审核人</param>
        /// <param name="userInfo">当前操作人信息</param>
        public void CreateFlow(string schemeCode, string processId, string title, int level,string branchnodeCode, T_Sys_UserAccount userInfo, out List<T_WF_TaskView>   t_WF_TaskViews, List<WFAuditor> auditors = null )
        {

            // 初始化流程引擎
            WFIEngine nWFIEngine = _Bootstraper(schemeCode, processId, "", userInfo);
            WFEngineParamConfig nWFEngineParamConfig = nWFIEngine.GetConfig();
            nWFEngineParamConfig.Auditers = auditors;

            WFNodeInfo nodeInfo = nWFIEngine.GetStartNode();
            // 获取下一节点信息
            List<WFLineInfo> lineList = new List<WFLineInfo>();
            List<WFNodeInfo> list = nWFIEngine.GetNextTaskNode(nodeInfo, "agree", false, lineList, branchnodeCode);

            string codelist = nWFIEngine.GetButonList(list.FirstOrDefault().id, lineList);
            // 创建任务
            List<T_WF_TaskView> taskList = _CreateTask(list, nodeInfo, nWFEngineParamConfig, codelist);
            List<T_WF_Task> taskListEntity =  taskList.MapToList<T_WF_Task>();
            t_WF_TaskViews = taskList;
            // nextTaskinfos = taskList.MapToList<NextTaskinfo>();
            // 保存流程进程信息
            T_WF_Process nWFProcessEntity = new T_WF_Process()
            {
                F_Id = nWFEngineParamConfig.ProcessId,
                F_SchemeId = nWFEngineParamConfig.SchemeId,
                F_SchemeCode = nWFEngineParamConfig.SchemeCode,
                F_SchemeName = nWFEngineParamConfig.SchemeName,
                F_Level = level,
                F_EnabledMark = 1,
                F_IsAgain = 0,
                F_IsFinished = 0,
                F_IsChild = 0,
                F_IsStart = 0,
                F_CreateUserId = nWFEngineParamConfig.CurrentUser.Id,
                F_CreateUserName = nWFEngineParamConfig.CurrentUser.Name
            };
            if (!string.IsNullOrEmpty(title))
            {
                nWFProcessEntity.F_Title = title;
            }
            else
            {
                nWFProcessEntity.F_Title = nWFEngineParamConfig.SchemeName;
            }
            if (nWFEngineParamConfig.State == 1)
            {
                nWFProcessEntity.F_IsAgain = 1;
            }
            else if (nWFEngineParamConfig.State == 2)
            {
                nWFProcessEntity.F_IsFinished = 1;
            }
            nWFProcessEntity.Create();

            // 创建任务日志信息
            T_WF_TaskLog nWFTaskLogEntity = new T_WF_TaskLog()
            {
                F_ProcessId = processId,
                F_OperationCode = "create",
                F_OperationName = "创建流程",
                F_NodeId = nodeInfo.id,
                F_NodeName = nodeInfo.name,
                F_TaskType = 0,
                F_CreateUserId = userInfo.F_UserId.ToString(),
                F_CreateUserName = userInfo.F_UserName
            };
            nWFTaskLogEntity.Create();
            // 保存信息
            save(nWFProcessEntity, taskList, nWFTaskLogEntity);
         


        }

        private void save(T_WF_Process nWFProcessEntity, List<T_WF_TaskView> taskList, T_WF_TaskLog nWFTaskLogEntity)
        {
            var wFProcessEntityTmp = GetEntity(nWFProcessEntity.F_Id);
            if (wFProcessEntityTmp == null)
            {
                InsertExe(nWFProcessEntity);
            }
            else
            {
                UpdateExe(nWFProcessEntity);
            }

            foreach (var task in taskList)
            {
                if (task.nWFUserInfoList != null && task.nWFUserInfoList.Count > 0 && task.F_Type != null)
                {
                    task.F_ModifyDate = DateTime.Now;
                    wFTaskBusiness.InsertExe(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            T_WF_TaskRelation nWFTaskRelationEntity = new T_WF_TaskRelation();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            wFTaskTaskRelationBusiness.InsertExe(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }

            }
            logBusiness.InsertExe(nWFTaskLogEntity);
        }

        /// <summary>
        /// 重新创建流程
        /// </summary>
        /// <param name="processId"></param>
        /// <param name="userInfo"></param>
        /// <param name=""></param>
        public void AgainCreateFlow(string processId, string branchnodeCode, T_Sys_UserAccount userInfo, out List<T_WF_TaskView> t_WF_TaskViews)
        {

            // 初始化流程引擎
            WFIEngine nWFIEngine = _Bootstraper("", processId, "", userInfo);
            WFEngineParamConfig nWFEngineParamConfig = nWFIEngine.GetConfig();
            // 获取开始节点
            WFNodeInfo nodeInfo = nWFIEngine.GetStartNode();
            // 获取任务实体
            var taskEntiy = wFTaskBusiness.GetList($"F_NodeId='{nodeInfo.id}' and F_ProcessId='{processId}'   AND F_Type != 3","").FirstOrDefault();
            if (taskEntiy == null)
            {
                throw (new Exception("找不到对应流程任务！"));
            }
            if (taskEntiy.F_IsFinished != 0)
            {
                throw (new Exception("该任务已经结束！"));
            }
            taskEntiy.F_ModifyDate = DateTime.Now;
            taskEntiy.F_ModifyUserId = userInfo.F_UserId.ToString();
            taskEntiy.F_ModifyUserName = userInfo.F_UserName;
            taskEntiy.F_IsFinished = 1;

            string taskUserId = userInfo.F_UserId.ToString();
            // 获取当前任务的执行人列表

            List<T_WF_TaskRelation> taskUserList = wFTaskTaskRelationBusiness.GetList($"F_TaskId='{taskEntiy.F_Id}'", "");

            Dictionary<string, string> taskUserMap = new Dictionary<string, string>();
            foreach (var item in taskUserList)
            {

                if (!taskUserMap.ContainsKey(userInfo.F_UserId.ToString()))
                {
                    taskUserMap.Add(userInfo.F_UserId.ToString(), "1");
                }
            }

            // 创建任务日志信息
            T_WF_TaskLog nWFTaskLogEntity = new T_WF_TaskLog()
            {
                F_ProcessId = processId,
                F_OperationCode = "create",
                F_OperationName = "重新发起",
                F_NodeId = nodeInfo.id,
                F_NodeName = nodeInfo.name,
                F_PrevNodeId = taskEntiy.F_PrevNodeId,
                F_PrevNodeName = taskEntiy.F_PrevNodeName,
                F_TaskId = taskEntiy.F_Id,
                F_TaskType = 5,
                F_CreateUserId = userInfo.F_UserId.ToString(),
                F_CreateUserName = userInfo.F_UserName,
                F_TaskUserId = userInfo.F_UserId.ToString(),
                F_TaskUserName = userInfo.F_UserName
            };
            nWFTaskLogEntity.Create();

            T_WF_TaskRelation nWFTaskRelationEntity = taskUserList.Find(t => t.F_UserId == taskUserId);
            nWFTaskRelationEntity.F_Result = 1;

            // 获取下一节点信息
            List<WFLineInfo> lineList = new List<WFLineInfo>();
            List<WFNodeInfo> list = nWFIEngine.GetNextTaskNode(nodeInfo, "agree", false, lineList, branchnodeCode);
            string codelist = nWFIEngine.GetButonList(list.FirstOrDefault().id, lineList);
            // 创建任务
            List<T_WF_TaskView> taskList = _CreateTask(list, nodeInfo, nWFEngineParamConfig,codelist);
            List<T_WF_Task> taskListEntity = taskList.MapToList<T_WF_Task>();
            t_WF_TaskViews = taskList;


            // 保存流程进程信息
            T_WF_Process nWFProcessEntity = new T_WF_Process()
            {
                F_Id = nWFEngineParamConfig.ProcessId
            };
            nWFProcessEntity.F_IsAgain = 0;
            if (nWFEngineParamConfig.State == 1)
            {
                nWFProcessEntity.F_IsAgain = 1;
            }
            else if (nWFEngineParamConfig.State == 2)
            {
                nWFProcessEntity.F_IsFinished = 1;
            }
            // 保存信息 任务日志 任务执行人状态更新 任务状态更新 流程进程状态更新 会签信息更新 新的任务列表 新的任务消息列表
          
            logBusiness.InsertExe(nWFTaskLogEntity);
            if (nWFTaskRelationEntity != null)
            {
                wFTaskTaskRelationBusiness.UpdateExe(nWFTaskRelationEntity);

            }
            wFTaskBusiness.UpdateExe(taskEntiy);

            if (nWFProcessEntity != null)
            {
                UpdateExe(nWFProcessEntity);
            }

            foreach (var task in taskList)
            {
                if (task.nWFUserInfoList != null && task.nWFUserInfoList.Count > 0 && task.F_Type != null)
                {
                    task.F_ModifyDate = DateTime.Now;
                    wFTaskBusiness.InsertExe(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            T_WF_TaskRelation _WF_TaskRelation = new T_WF_TaskRelation();
                            _WF_TaskRelation.Create();
                            _WF_TaskRelation.F_TaskId = task.F_Id;
                            _WF_TaskRelation.F_UserId = taskUser.Id;
                            _WF_TaskRelation.F_Mark = taskUser.Mark;
                            _WF_TaskRelation.F_Result = 0;
                            _WF_TaskRelation.F_Sort = num;
                            wFTaskTaskRelationBusiness.InsertExe(_WF_TaskRelation);
                            num++;
                        }
                    }
                }
                  
            }


        }
        /// <summary>
        /// 审批流程
        /// </summary>
        /// <param name="operationCode"></param>
        /// <param name="operationName"></param>
        /// <param name="processId"></param>
        /// <param name="taskId"></param>
        /// <param name="des"></param>
        /// <param name="auditors"></param>
        /// <param name="stamp"></param>
        /// <param name="signUrl"></param>
        /// <param name="userInfo"></param>
        public void AuditFlow(string operationCode, string operationName, string processId, string taskId, string des , string stamp, string signUrl, string branchnodeCode, T_Sys_UserAccount userInfo, out List<T_WF_TaskView> t_WF_TaskViews, List<WFAuditor> auditors = null)
        {
            // 初始化流程引擎
            WFIEngine nWFIEngine = _Bootstraper("", processId, taskId, userInfo);
            WFEngineParamConfig nWFEngineParamConfig = nWFIEngine.GetConfig();
            nWFEngineParamConfig.Auditers = auditors;

            // 获取任务实体
            var taskEntiy = wFTaskBusiness.GetEntity(taskId);
            if (taskEntiy == null)
            {
                throw (new Exception("找不到对应流程任务！"));
            }
            if (taskEntiy.F_IsFinished != 0)
            {
                throw (new Exception("该任务已经结束！"));
            }

            taskEntiy.F_ModifyDate = DateTime.Now;
            taskEntiy.F_ModifyUserId = userInfo.F_UserId.ToString();
            taskEntiy.F_ModifyUserName = userInfo.F_UserName;
            taskEntiy.F_IsFinished = 1;
            WFNodeInfo nodeInfo = nWFIEngine.GetNode(taskEntiy.F_NodeId);
            string taskUserId = userInfo.F_UserId.ToString();



            // 获取当前任务的执行人列表
            List<T_WF_TaskRelation> taskUserList = wFTaskTaskRelationBusiness.GetList($"F_TaskId='{taskId}'", "");
            Dictionary<string, string> taskUserMap = new Dictionary<string, string>();
            foreach (var item in taskUserList)
            {

                if (!taskUserMap.ContainsKey(userInfo.F_UserId.ToString()))
                {
                    taskUserMap.Add(userInfo.F_UserId.ToString(), "1");
                }
            }

            // 创建任务日志信息
            T_WF_TaskLog nWFTaskLogEntity = new T_WF_TaskLog()
            {
                F_ProcessId = processId,
                F_OperationCode = operationCode,
                F_OperationName = operationName,
                F_NodeId = nodeInfo.id,
                F_NodeName = nodeInfo.name,
                F_PrevNodeId = taskEntiy.F_PrevNodeId,
                F_PrevNodeName = taskEntiy.F_PrevNodeName,
                F_Des = des,
                F_TaskId = taskId,
                F_TaskType = 1,
                F_CreateUserId = userInfo.F_UserId.ToString(),
                F_CreateUserName = userInfo.F_UserName,
                F_TaskUserId = userInfo.F_UserId.ToString(),
                F_TaskUserName = userInfo.F_UserName,
                F_StampImg = stamp
            };

         
    

            T_WF_TaskRelation nWFTaskRelationEntity = taskUserList.Find(t => t.F_UserId == taskUserId);
            if (nWFTaskRelationEntity == null)
            {
                nWFTaskRelationEntity = taskUserList[0];
            }
            nWFTaskRelationEntity.F_Time = DateTime.Now;
            // 如果是一般审核节点
                if (operationCode == "agree")
                {
                    nWFTaskRelationEntity.F_Result = 1;
                }
                else if (operationCode == "refuse")
                {
                    nWFTaskRelationEntity.F_Result = 2;
                }
                else
                {
                    nWFTaskRelationEntity.F_Result = 4;
                }
            

            // 获取下一节点信息
            List<WFLineInfo> lineList = new List<WFLineInfo>();
            List<WFNodeInfo> list = nWFIEngine.GetNextTaskNode(nodeInfo, operationCode, false, lineList, branchnodeCode);
           
            if (list == null && list.Count() == 0)
            {
                throw (new Exception("找不到对应流程任务！"));
               
            }
            var codelist = nWFIEngine.GetButonList(list.FirstOrDefault().id, lineList);


            // 创建任务
            List<T_WF_TaskView> taskList = _CreateTask(list, nodeInfo, nWFEngineParamConfig, codelist);
            List<T_WF_Task> taskListEntity = taskList.MapToList<T_WF_Task>();
            t_WF_TaskViews = taskList;


             // 保存流程进程信息
            T_WF_Process nWFProcessEntity = new T_WF_Process()
            {
                F_Id = nWFEngineParamConfig.ProcessId,
                F_IsStart = 1
            };
            if (nWFEngineParamConfig.State == 1)
            {
                nWFProcessEntity.F_IsAgain = 1;
            }
            else if (nWFEngineParamConfig.State == 2)
            {
                nWFProcessEntity.F_IsFinished = 1;
            }

            List<WFLineInfo> pLineList = new List<WFLineInfo>();
            List<T_WF_Task> pTaskList = new List<T_WF_Task>();


            T_WF_Process pNWFProcessEntity = null;
          


            List<T_WF_Task> nTaskList = new List<T_WF_Task>();
            nTaskList.AddRange(taskListEntity);

            taskListEntity.AddRange(pTaskList);

            // 保存信息
            nWFTaskLogEntity.Create();
            logBusiness.InsertExe(nWFTaskLogEntity);
            if (nWFTaskRelationEntity != null)
            {
                wFTaskTaskRelationBusiness.UpdateExe(nWFTaskRelationEntity);
                
            }
            wFTaskBusiness.UpdateExe(taskEntiy);

            if (nWFProcessEntity != null)
            {
                UpdateExe(nWFProcessEntity);
            }

            if (pNWFProcessEntity != null)
            {
                UpdateExe(pNWFProcessEntity);
            }

            foreach (var task in taskList)
            {
                if(task.nWFUserInfoList!= null&& task.nWFUserInfoList.Count>0&& task.F_Type!=null)
                {
                    task.F_ModifyDate = DateTime.Now;
                    wFTaskBusiness.InsertExe(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            T_WF_TaskRelation _WF_TaskRelation = new T_WF_TaskRelation();
                            _WF_TaskRelation.Create();
                            _WF_TaskRelation.F_TaskId = task.F_Id;
                            _WF_TaskRelation.F_UserId = taskUser.Id;
                            _WF_TaskRelation.F_Mark = taskUser.Mark;
                            _WF_TaskRelation.F_Result = 0;
                            _WF_TaskRelation.F_Sort = num;
                            wFTaskTaskRelationBusiness.InsertExe(_WF_TaskRelation);
                            num++;
                        }
                    }
                }
               
            }
         

        }

        private WFIEngine _Bootstraper(string code, string processId, string taskId, T_Sys_UserAccount userInfo)
        {
            WFIEngine wfIEngine = null;

            WFEngineConfig nWFEngineConfig = new WFEngineConfig();
            WFEngineParamConfig nWFEngineParamConfig = new WFEngineParamConfig();
            nWFEngineConfig.ParamConfig = nWFEngineParamConfig;

            if (userInfo != null)
            {
                nWFEngineParamConfig.CurrentUser = new WFUserInfo()
                {
                    Id = userInfo.F_UserId.ToString(),
                    Account = userInfo.F_UserCode,
                    Name = userInfo.F_UserName,
                    DepartmentId = userInfo.F_DeptId.ToString()
                };
            }

            if (!string.IsNullOrEmpty(code))
            {
                var schemeInfo = wFSchemeInfoBusiness.GetList($"F_Code='{code}'", "").FirstOrDefault();
                if (schemeInfo != null)
                {
                   
                    var data = wFSchemeBusiness.GetEntity(schemeInfo.F_SchemeId);
                    if (data != null)
                    {
                        nWFEngineParamConfig.Scheme = data.F_Content;
                        nWFEngineParamConfig.SchemeCode = code;
                        nWFEngineParamConfig.SchemeId = schemeInfo.F_SchemeId;
                        nWFEngineParamConfig.SchemeName = schemeInfo.F_Name;
                        nWFEngineParamConfig.ProcessId = processId;
                        nWFEngineParamConfig.HasInstance = false;

                        nWFEngineParamConfig.CreateUser = nWFEngineParamConfig.CurrentUser;
                    }
                }
            }
            else if (!string.IsNullOrEmpty(processId))
            {
                var processEntity = GetEntity(processId);
                if (processEntity != null)
                {
                    if (string.IsNullOrEmpty(processEntity.F_SchemeId))// 这种情况出现在草稿下
                    {
                        var schemeInfo = wFSchemeInfoBusiness.GetList($"F_Code='{processEntity.F_SchemeCode}'", "").FirstOrDefault();

                        if (schemeInfo != null)
                        {
                            var data = wFSchemeBusiness.GetEntity(schemeInfo.F_SchemeId);
                            if (data != null)
                            {
                                nWFEngineParamConfig.Scheme = data.F_Content;
                                nWFEngineParamConfig.SchemeCode = processEntity.F_SchemeCode;
                                nWFEngineParamConfig.SchemeId = schemeInfo.F_SchemeId;
                                nWFEngineParamConfig.SchemeName = schemeInfo.F_Name;
                                nWFEngineParamConfig.ProcessId = processId;
                                nWFEngineParamConfig.HasInstance = true;

                                nWFEngineParamConfig.CreateUser = nWFEngineParamConfig.CurrentUser;
                            }
                        }
                    }
                    else
                    {
                        var data = wFSchemeBusiness.GetEntity(processEntity.F_SchemeId);
                        if (data != null)
                        {
                            nWFEngineParamConfig.Scheme = data.F_Content;
                            nWFEngineParamConfig.SchemeCode = processEntity.F_SchemeCode;
                            nWFEngineParamConfig.SchemeId = processEntity.F_SchemeId;
                            nWFEngineParamConfig.SchemeName = processEntity.F_SchemeName;
                            nWFEngineParamConfig.IsChild = (int)processEntity.F_IsChild;
                            nWFEngineParamConfig.ParentProcessId = processEntity.F_ParentProcessId;
                            nWFEngineParamConfig.ParentTaskId = processEntity.F_ParentTaskId;
                            nWFEngineParamConfig.ProcessId = processId;
                            nWFEngineParamConfig.HasInstance = true;
                         
                            var userEntity = user.GetEntity(processEntity.F_CreateUserId);

                            nWFEngineParamConfig.CreateUser = new WFUserInfo()
                            {
                                Id = processEntity.F_CreateUserId,
                                Account = userEntity.F_UserCode,
                                Name = userEntity.F_UserName,
    
                                DepartmentId = userEntity.F_DeptId.ToString()
                            };
                        }
                    }
                }
            }
            else if (!string.IsNullOrEmpty(taskId))
            {
                var taskEntiy = wFTaskBusiness.GetEntity(taskId);
                if (taskEntiy != null)
                {
                    var processEntity = GetEntity(taskEntiy.F_ProcessId);
                    if (processEntity != null)
                    {
                        var data = wFSchemeBusiness.GetEntity(processEntity.F_SchemeId);
                        if (data != null)
                        {
                            nWFEngineParamConfig.Scheme = data.F_Content;
                            nWFEngineParamConfig.SchemeCode = processEntity.F_SchemeCode;
                            nWFEngineParamConfig.SchemeId = processEntity.F_SchemeId;
                            nWFEngineParamConfig.SchemeName = processEntity.F_SchemeName;
                            nWFEngineParamConfig.IsChild = (int)processEntity.F_IsChild;
                            nWFEngineParamConfig.ParentProcessId = processEntity.F_ParentProcessId;
                            nWFEngineParamConfig.ParentTaskId = processEntity.F_ParentTaskId;
                            nWFEngineParamConfig.ProcessId = processEntity.F_Id;
                            nWFEngineParamConfig.HasInstance = true;

                            var userEntity = user.GetEntity(processEntity.F_CreateUserId);

                            nWFEngineParamConfig.CreateUser = new WFUserInfo()
                            {
                                Id = processEntity.F_CreateUserId,
                                Account = userEntity.F_UserCode,
                                Name = userEntity.F_UserName,

                                DepartmentId = userEntity.F_DeptId.ToString()
                            };
                        }
                    }
                }
            }
            wfIEngine = new WFEngine(nWFEngineConfig);
            return wfIEngine;
        }

        /// <summary>
        /// 创建流程任务
        /// </summary>
        /// <param name="nodeList">节点信息</param>
        /// <param name="paramConfig">流程配置信息</param>
        /// <returns></returns>
        private List<T_WF_TaskView> _CreateTask(List<WFNodeInfo> nodeList, WFNodeInfo currentNodeInfo, WFEngineParamConfig paramConfig,string codelist)
        {
            List<T_WF_TaskView> list = new List<T_WF_TaskView>();
            foreach (var node in nodeList)
            {
                T_WF_TaskView nWFTaskEntity = new T_WF_TaskView();
                nWFTaskEntity.Create();
                nWFTaskEntity.F_ProcessId = paramConfig.ProcessId;
                nWFTaskEntity.F_NodeId = node.id;
                nWFTaskEntity.F_NodeName = node.name;
                nWFTaskEntity.F_PrevNodeId = currentNodeInfo.id;
                nWFTaskEntity.F_PrevNodeName = currentNodeInfo.name;

                nWFTaskEntity.F_CreateUserId = paramConfig.CurrentUser.Id;
                nWFTaskEntity.F_CreateUserName = paramConfig.CurrentUser.Name;

                if (!string.IsNullOrEmpty(node.timeoutAction))
                {
                    nWFTaskEntity.F_TimeoutAction = Convert.ToInt32(node.timeoutAction);
                }
                if (!string.IsNullOrEmpty(node.timeoutInterval))
                {
                    nWFTaskEntity.F_TimeoutInterval = Convert.ToInt32(node.timeoutInterval);
                }
                if (!string.IsNullOrEmpty(node.timeoutNotice))
                {
                    nWFTaskEntity.F_TimeoutNotice = Convert.ToInt32(node.timeoutNotice);
                }
                if (!string.IsNullOrEmpty(node.timeoutStrategy))
                {
                    nWFTaskEntity.F_TimeoutStrategy = node.timeoutStrategy;
                }
                nWFTaskEntity.nWFUserInfoList = _GetNodeAuditors(node.auditors, node, paramConfig);
                nWFTaskEntity.auditors = _GetNodeAuditors3(node.auditors, node, paramConfig);
                nWFTaskEntity.btnList = codelist;




                nWFTaskEntity.nodeType = node.type;

                switch (node.type)
                {
                    case "stepnode":// 审核节点
                        nWFTaskEntity.F_Type = 1;
                        nWFTaskEntity.F_IsBatchAudit = node.isBatchAudit;
                        if (node.isAllAuditor == "2" && node.auditorType == "2")
                        {// 当前节点人员需要都审核
                            foreach (var item in nWFTaskEntity.nWFUserInfoList)
                            {
                                item.Mark = 1;
                            }
                            nWFTaskEntity.nWFUserInfoList[0].Mark = 0;
                        }
                        break;
                    case "startround":// 开始节点

                       nWFTaskEntity.F_Type = 5;
                     
                        break;
                }
                list.Add(nWFTaskEntity);
                //if (nWFTaskEntity.nWFUserInfoList.Count > 0 && nWFTaskEntity.F_Type != null)
                //{
                //    list.Add(nWFTaskEntity);
                //}
            }
            return list;
        }

        /// <summary>
        /// 获取节点处理人列表
        /// </summary>
        /// <param name="nodeAuditorList">节点审核人设置信息</param>
        /// <param name="nodeId">流程id</param>
        /// <param name="paramConfig">流程配置信息</param>
        private List<WFUserInfo> _GetNodeAuditors(List<WFAuditor> nodeAuditorList, WFNodeInfo nodeInfo, WFEngineParamConfig paramConfig)
        {
            List<WFUserInfo> list = new List<WFUserInfo>();

            List<WFUserInfo> list2 = _GetNodeAuditors2(nodeAuditorList, nodeInfo, paramConfig);

            // 判断当前节点之前是否有过审核，如果有就用之前的审核人
            T_WF_Task taskEntiy = null;

            if (!string.IsNullOrEmpty(paramConfig.ProcessId))
            {
                taskEntiy = wFTaskBusiness.GetList($"F_NodeId='{nodeInfo.id}' and F_ProcessId='{paramConfig.ProcessId}'","").FirstOrDefault();


                if (taskEntiy != null)
                {
                    if (taskEntiy.F_IsFinished == 0)
                    {
                        return list;
                    }

                    List<T_WF_TaskRelation> taskUserList = wFTaskTaskRelationBusiness.GetList($"F_TaskId='{taskEntiy.F_Id}'", "");
     
                        T_WF_TaskRelation taskUser = taskUserList.Find(t => t.F_Result != 0 && t.F_Result != 3);
                        if (taskUser != null)
                        {

                            var  taskUserEntity = user.GetEntity(taskUser.F_UserId);
                            if (taskUserEntity != null)
                            {
                                list.Add(new WFUserInfo()
                                {
                                    Id = taskUserEntity.F_UserId.ToString(),
                                    Account = taskUserEntity.F_UserCode,
                                    Name = taskUserEntity.F_UserName
                                });
                                string _userId = taskUserEntity.F_UserId.ToString();

                                if (list2.Find(t => t.Id == _userId) == null)
                                {
                                    if (list2.Count == 0)
                                    {
                                    // 找不到审核人无法提交
                                       // if (nodeInfo.noPeopleGz == 3)
                                       // {
                                            throw (new Exception("下一节点没有审核人,无法提交！"));
                                       // }
                                        // 如果找不到审核人就默认超级管理员才能审核
                                        //var adminEntityList = user.GetList("F_RoleId=4", "");
                                        //foreach (var item in adminEntityList)
                                        //{
                                        //    list2.Add(new WFUserInfo()
                                        //    {
                                        //        Id = item.F_UserId.ToString(),
                                        //        Account = item.F_UserCode,
                                        //        Name = item.F_UserName,
                                        //        noPeople = true
                                        //    });
                                        //}
                                    }
                                    return list2;
                                }
                                return list;
                            }
                        }
                    
                }
            }

            list.AddRange(list2);

            if (list.Count == 0)
            {
                    throw (new Exception("下一节点没有审核人,无法提交！"));              
            }

            return list;
        }

        private List<WFUserInfo> _GetNodeAuditors2(List<WFAuditor> nodeAuditorList, WFNodeInfo nodeInfo, WFEngineParamConfig paramConfig)
        {
            List<WFUserInfo> list = new List<WFUserInfo>();

            if (nodeAuditorList == null)
            {
                // 开始节点的情况
                list.Add(new WFUserInfo()
                {
                    Id = paramConfig.CreateUser.Id,
                    Account = paramConfig.CreateUser.Account,
                    Name = paramConfig.CreateUser.Name
                });

                return list;
            }

            //if (nodeAuditorList.Count == 0)
            //{
            //    // 如果找不到审核人就默认超级管理员才能审核           
            //    var adminEntityList = user.GetList("F_RoleId=4", "");
            //    foreach (var item in adminEntityList)
            //    {
            //        list.Add(new WFUserInfo()
            //        {
            //            Id = item.F_UserId.ToString(),
            //            Account = item.F_UserCode,
            //            Name = item.F_UserName
            //        });
            //    }
            //}
           // else
            //{
                foreach (var item in nodeAuditorList)
                {
                    switch (item.type)//1.部门2.角色3.用户
                    {
                        case 1:// 部门

                           // var userRelationList = userRelation.GetList($"F_ObjectId='{item.auditorId}'", "");
                            var userList1 = user.GetList($"F_DeptId='{item.auditorId}'","");
                            foreach (var userEntity in userList1)
                            {
                                                   
                                        list.Add(new WFUserInfo()
                                        {
                                            Id = userEntity.F_UserId.ToString(),
                                            Account = userEntity.F_UserCode,
                                            Name = userEntity.F_UserName
                                        });
                                    
                                
                            }
                            break;
                        case 2:// 角色
                            //var userRelationList2 = userRelation.GetList($"where F_ObjectId='{item.auditorId}'", "");
                            var userList2 = user.GetList($"F_RoleId='{item.auditorId}'", "");
                            foreach (var userEntity in userList2)
                            {
                                        list.Add(new WFUserInfo()
                                        {
                                            Id = userEntity.F_UserId.ToString(),
                                            Account = userEntity.F_UserCode,
                                            Name = userEntity.F_UserName
                                        });                           
                            }
                            break;
                        case 3:// 用户
                            if (!string.IsNullOrEmpty(item.auditorId))
                            {
                                string[] userList = item.auditorId.Split(',');
                                foreach (var userItem in userList)
                                {
                                    var userEntity3 = user.GetEntity(userItem);
                                    if (userEntity3 != null)
                                    {
                                        list.Add(new WFUserInfo()
                                        {
                                            Id = userEntity3.F_UserId.ToString(),
                                            Account = userEntity3.F_UserCode,
                                            Name = userEntity3.F_UserName
                                        });
                                    }
                                }
                            }

                            break;
                        case 4:// 某一个节点执行人
                            var task = logBusiness.GetList($"F_NodeId='{item.auditorId}' and F_ProcessId='{paramConfig.ProcessId}' and F_TaskType<>3 and F_TaskType<>6","" ).FirstOrDefault();
                            if (task != null && !string.IsNullOrEmpty(task.F_CreateUserId))
                            {
                                var userEntity6 = user.GetEntity(task.F_CreateUserId);
                                if (userEntity6 != null)
                                {
                                    list.Add(new WFUserInfo()
                                    {
                                        Id = userEntity6.F_UserId.ToString(),
                                        Account = userEntity6.F_UserCode,
                                        Name = userEntity6.F_UserName
                                    });
                                }
                               
                            }
                            break;
                    }
                }
           // }
            return list;
        }

        private List<WFAuditor> _GetNodeAuditors3(List<WFAuditor> nodeAuditorList, WFNodeInfo nodeInfo, WFEngineParamConfig paramConfig)
        {
            List<WFAuditor> list = new List<WFAuditor>();
            if (nodeAuditorList != null)
            {
                foreach (var item in nodeAuditorList)
                {
                    switch (item.type)//1.部门2.角色3.用户
                    {
                        case 1:// 部门

                            list.Add(item);
                            break;
                        case 2:// 角色
                               //var userRelationList2 = userRelation.GetList($"where F_ObjectId='{item.auditorId}'", "");
                            list.Add(item);
                            break;
                        case 3:// 用户
                            list.Add(item);

                            break;
                        case 4:// 某一个节点执行人
                            var task = logBusiness.GetList($"F_NodeId='{item.auditorId}' and F_ProcessId='{paramConfig.ProcessId}' and F_TaskType<>3 and F_TaskType<>6", "").FirstOrDefault();
                            if (task != null && !string.IsNullOrEmpty(task.F_CreateUserId))
                            {
                                var userEntity6 = user.GetEntity(task.F_CreateUserId);
                                if (userEntity6 != null)
                                {
                                    list.Add(new WFAuditor()
                                    {
                                        id = userEntity6.F_UserId.ToString(),
                                        auditorId = userEntity6.F_UserId.ToString(),
                                        auditorAccount = userEntity6.F_UserCode,
                                        auditorName = userEntity6.F_UserName,
                                        type = 2

                                    });
                                }

                            }
                            break;
                    }
                }
            }
               
            
            return list;
        }

    }
}