using Edu.Cache.User;
using Edu.Common;
using Edu.Common.Enum.Course;
using Edu.Common.Enum.User;
using Edu.Common.Plugin;
using Edu.Model.CacheModel;
using Edu.Model.Entity.Course;
using Edu.Model.ViewModel.Course;
using Edu.Repository.Course;
using Edu.Repository.Flow;
using Edu.Repository.Log;
using Edu.Repository.User;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using VT.FW.DB;

namespace Edu.Module.Course
{
    /// <summary>
    /// 学员单据处理类
    /// </summary>
    public class StudentBillModule
    {
        /// <summary>
        /// 学员退课单据仓储层对象
        /// </summary>
        private readonly RB_Student_BackClassRepository student_BackClassRepository = new RB_Student_BackClassRepository();

        /// <summary>
        /// 退款单据审核人员信息仓储层对象
        /// </summary>
        private readonly RB_Student_BackRelevanceRepository student_BackRelevanceRepository = new RB_Student_BackRelevanceRepository();

        /// <summary>
        /// 学员退课单据审核记录仓储层对象
        /// </summary>
        private readonly RB_Student_BackRecordRepository student_BackRecordRepository = new RB_Student_BackRecordRepository();

        /// <summary>
        /// 旅客表仓储层对象
        /// </summary>
        private readonly RB_Order_GuestRepository order_GuestRepository = new RB_Order_GuestRepository();

        /// <summary>
        /// 订单仓储层对象
        /// </summary>
        private readonly RB_OrderRepository orderRepository = new RB_OrderRepository();

        /// <summary>
        /// 班级
        /// </summary>
        private readonly RB_ClassRepository classRepository = new RB_ClassRepository();

        /// <summary>
        /// 学校
        /// </summary>
        private readonly RB_SchoolRepository schoolRepository = new RB_SchoolRepository();

        /// <summary>
        /// 流程仓储层对象
        /// </summary>
        private readonly RB_FlowRepository flowRepository = new RB_FlowRepository();

        /// <summary>
        /// 账号
        /// </summary>
        private readonly RB_AccountRepository accountRepository = new RB_AccountRepository();

        /// <summary>
        /// 日志
        /// </summary>
        private readonly RB_User_ChangeLogRepository changeLogRepository = new RB_User_ChangeLogRepository();

        /// <summary>
        /// 获取学员退课单据分页列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowsCount"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<RB_Student_BackClass_ViewModel> GetStudentBackClassPageListModule(int pageIndex, int pageSize, out long rowsCount, RB_Student_BackClass_ViewModel query)
        {
            var list = student_BackClassRepository.GetStudentBackClassPageListRepository(pageIndex, pageSize, out rowsCount, query);
            if (list != null)
            {
                foreach (var item in list)
                {

                }
            }
            return list;
        }

        /// <summary>
        /// 退课单据审核
        /// </summary>
        /// <param name="BackId">退课单据号</param>
        /// <param name="AuditStatus">审核状态(1-待审核，2-审核通过，3-驳回)</param>
        /// <param name="Description">审核备注</param>
        /// <param name="user">登录用户信息</param>
        /// <param name="message">返回提示信息</param>
        /// <param name="BackMoney"></param>
        /// <returns></returns>
        public virtual bool SetBackBillAduitModule(int BackId, int AuditStatus, string Description, UserInfo user, out string message, decimal BackMoney = 0)
        {
            message = "";
            bool flag = false;
            //获取单据实体类
            var backModel = student_BackClassRepository.GetEntity(BackId);
            if (backModel == null)
            {
                message = "单据不存在,请核实!";
                return flag;
            }

            //获取审核记录
            var aurList = student_BackRecordRepository.GetStudentBackRecordListRepository(new RB_Student_BackRecord_ViewModel()
            {
                ConditionId = backModel.BackId,
            });
            //审核关联列表
            var arList = student_BackRelevanceRepository.GetStudentBackRelevanceListRepository(new RB_Student_BackRelevance_ViewModel()
            {
                ConditionId = backModel.BackId
            });

            //驳回处理
            if (AuditStatus == 3)
            {
                //找出当前审核
                int Notcount = arList.Where(x => x.Stauts == WFRrocessStatus.AuditNotThrough).Count();
                if (Notcount > 0)
                {
                    message = "该申请单已被拒绝!";
                    return false;
                }
                var ToAuditFlow = arList.Where(x => x.Stauts == WFRrocessStatus.NotAudit).OrderBy(x => x.Sort).ToList();
                if (ToAuditFlow.Count <= 0)
                {
                    message = "该申请单审核已经完结!";
                    return false;
                }
                if (ToAuditFlow.Count > 0)
                {
                    var model = ToAuditFlow[0];
                    var RecordList = aurList.Where(x => x.AuditId == model.Id).ToList();
                    var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                    if (amodel == null)
                    {
                        message = "尚未匹配到审核相关信息，请联系管理员!";
                        return false;
                    }
                    //同时  修改  审核记录状态 审核流程 
                    model.Stauts = WFRrocessStatus.AuditNotThrough;
                    if (!string.IsNullOrWhiteSpace(model.AuditedId))
                    {
                        model.AuditedId += "," + user.Id;
                    }
                    else
                    {
                        model.AuditedId = user.Id.ToString();
                    }
                    #region 更新审核记录表状态
                    flag = UpdateStuRecordModule(WFRrocessStatus.AuditNotThrough, Description, user.Id, amodel.Id);
                    #endregion
                    #region 更新审核关联表状态
                    flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                    #endregion

                    var list = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).ToList();
                    int AuditCount = list.Count();
                    if (AuditCount > 0)//表示最后一个人就是子集审核   申请单 通过
                    {
                        foreach (var item in list)
                        {
                            flag = UpdateStuRecordModule(WFRrocessStatus.OtherHaveAudit, Description, user.Id, item.Id);
                        }
                    }
                }

                #region  更新订单旅客表未驳回状态
                Dictionary<string, object> guestFileds = new Dictionary<string, object>()
                {
                    {nameof(RB_Order_Guest_ViewModel.GuestState),4 }
                };
                flag = order_GuestRepository.Update(guestFileds, new WhereHelper(nameof(RB_Order_Guest_ViewModel.Id), backModel.StudentId));
                #endregion

                #region 更新退课单据为驳回状态
                Dictionary<string, object> backFileds = new Dictionary<string, object>()
                {
                     {nameof(RB_Student_BackClass_ViewModel.AuditStatus), (int)BackClassAuditStatusEnum.Rejected }
                };
                flag = student_BackClassRepository.Update(backFileds, new WhereHelper(nameof(RB_Student_BackClass_ViewModel.BackId), backModel.BackId));
                #endregion
            }
            //审核通过
            else
            {
                //找出当前审核
                int Notcount = arList.Where(x => x.Stauts == WFRrocessStatus.AuditNotThrough).Count();
                if (Notcount > 0)
                {
                    message = "该退课申请单已被拒绝";
                    return false;
                }

                var ToAuditFlow = arList.Where(x => x.Stauts == WFRrocessStatus.NotAudit).OrderBy(x => x.Sort).ToList();
                if (ToAuditFlow.Count <= 0)
                {
                    message = "该申请单审核已经完结";
                    return false;
                }
                //审核关联表字段
                var relevanceFileds = new Dictionary<string, object>();
                ///目前审核为最后一步
                if (ToAuditFlow.Count == 1)
                {
                    var model = ToAuditFlow[0];
                    var RecordList = aurList.Where(x => x.AuditId == model.Id).ToList();
                    if (model.AuditWay == WFTAuditWayEnum.Countersign)
                    {
                        //会签  所有人必须审核完该流程才算完成
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        #region 更新审核记录表状态
                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion

                        int AuditCount = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).Count();
                        if (AuditCount <= 0)//表示最后一个人就是子集审核   申请单 通过
                        {
                            //同时  修改  审核记录状态 审核流程 
                            model.Stauts = WFRrocessStatus.AuditThrough;
                            if (!string.IsNullOrWhiteSpace(model.AuditedId))
                            {
                                model.AuditedId += "," + user.Id;
                            }
                            else
                            {
                                model.AuditedId = user.Id.ToString();
                            }
                            #region 更新审核关联表状态
                            flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                            #endregion

                            //更新主表状态
                            Dictionary<string, object> backFileds = new Dictionary<string, object>()
                            {
                                 {nameof(RB_Student_BackClass_ViewModel.AuditStatus), (int)BackClassAuditStatusEnum.Pass }
                            };
                            flag = student_BackClassRepository.Update(backFileds, new WhereHelper(nameof(RB_Student_BackClass_ViewModel.BackId), backModel.BackId));
                        }
                        else
                        {
                            //同时  修改  审核记录状态 审核流程 
                            model.Stauts = WFRrocessStatus.AuditThrough;
                            if (!string.IsNullOrWhiteSpace(model.AuditedId))
                            {
                                model.AuditedId += "," + user.Id;
                            }
                            else
                            {
                                model.AuditedId = user.Id.ToString();
                            }
                            #region 更新审核关联表状态
                            flag = UpdateStuRelevanceModule(model.Id, null, model.AuditedId);
                            #endregion
                        }
                    }
                    else if (model.AuditWay == WFTAuditWayEnum.OrSign)
                    {
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        //同时  修改  审核记录状态 审核流程 
                        model.Stauts = WFRrocessStatus.AuditThrough;
                        if (!string.IsNullOrWhiteSpace(model.AuditedId))
                        {
                            model.AuditedId += "," + user.Id;
                        }
                        else
                        {
                            model.AuditedId = user.Id.ToString();
                        }
                        #region 更新审核记录表状态
                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion

                        #region 更新审核关联表状态
                        flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                        #endregion

                        var list = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).ToList();
                        int AuditCount = list.Count();
                        if (AuditCount > 0)//表示最后一个人就是子集审核   申请单 通过
                        {
                            foreach (var item in list)
                            {
                                flag = UpdateStuRecordModule(WFRrocessStatus.OtherHaveAudit, Description, user.Id, item.Id);
                            }
                        }
                        Dictionary<string, object> backFileds = new Dictionary<string, object>()
                        {
                             {nameof(RB_Student_BackClass_ViewModel.AuditStatus), (int)BackClassAuditStatusEnum.Pass }
                        };
                        flag = student_BackClassRepository.Update(backFileds, new WhereHelper(nameof(RB_Student_BackClass_ViewModel.BackId), backModel.BackId));

                    }
                    else
                    {
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        var list = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).ToList();
                        int AuditCount = list.Count();
                        if (AuditCount > 0)
                        {
                            message = "流程配置出错啦！非会签，或签 都只能有一个审核人!";
                            return false;
                        }
                        //同时  修改  审核记录状态 审核流程 
                        model.Stauts = WFRrocessStatus.AuditThrough;
                        if (!string.IsNullOrWhiteSpace(model.AuditedId))
                        {
                            model.AuditedId += "," + user.Id;
                        }
                        else
                        {
                            model.AuditedId = user.Id.ToString();
                        }
                        #region 更新审核记录表状态
                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion
                        #region 更新审核关联表状态
                        flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                        #endregion
                        Dictionary<string, object> backFileds = new Dictionary<string, object>()
                        {
                             {nameof(RB_Student_BackClass_ViewModel.AuditStatus), (int)BackClassAuditStatusEnum.Pass }
                        };
                        flag = student_BackClassRepository.Update(backFileds, new WhereHelper(nameof(RB_Student_BackClass_ViewModel.BackId), backModel.BackId));
                    }

                    //更新抄送人状态
                    //var CopyToPeopleList = copyToPeopleRepository.GetCopyToPeopleList(WorkFlowId, TemplateType);
                    //foreach (var item in CopyToPeopleList)
                    //{
                    //    item.Stauts = WFRrocessStatus.AuditThrough;
                    //}
                    //CopyAccountList = CopyToPeopleList.Select(x => new EmAccoutIdModel { EmAccount = x.EmLoginMobile, EmployeeId = x.EmployeeId ?? 0 }).Distinct().ToList();
                    //copyToPeopleRepository.UpdateBatch(CopyToPeopleList, trans);

                }
                //同时创建下一步审核  复制审核人到审核关联表   创建审核记录表
                else
                {
                    var model = ToAuditFlow[0];
                    var RecordList = aurList.Where(x => x.AuditId == model.Id).ToList();

                    //会签  所有人必须审核完该流程才算完成
                    if (model.AuditWay == WFTAuditWayEnum.Countersign)
                    {
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        //审核记录状态
                        #region 更新审核记录表状态

                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion

                        int AuditCount = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).Count();
                        if (AuditCount <= 0)//表示最后一个人就是子集审核   申请单 通过
                        {
                            //同时  修改  审核流程 
                            model.Stauts = WFRrocessStatus.AuditThrough;
                            if (!string.IsNullOrWhiteSpace(model.AuditedId))
                            {
                                model.AuditedId += "," + user.Id;
                            }
                            else
                            {
                                model.AuditedId = user.Id.ToString();
                            }
                            #region 更新审核关联表状态
                            flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                            #endregion
                            //赋值下一步到审核记录中  并更新这一步的待审核人
                            var modelNext = ToAuditFlow[1];
                            flag = InsertAuditRelevanceNext(backModel, modelNext);
                            if (flag == false)
                            {
                                message = "审核流程不完整无法审核，请联系相关负责人!";
                                return false;
                            }
                        }
                        else
                        {
                            //同时  修改  审核流程 
                            if (!string.IsNullOrWhiteSpace(model.AuditedId))
                            {
                                model.AuditedId += "," + user.Id;
                            }
                            else
                            {
                                model.AuditedId = user.Id.ToString();
                            }
                            #region 更新审核关联表状态
                            relevanceFileds = new Dictionary<string, object>
                            {
                                { nameof(RB_Student_BackRelevance_ViewModel.AuditedId), model.AuditedId },
                            };
                            flag = student_BackRelevanceRepository.Update(relevanceFileds, new WhereHelper(nameof(RB_Student_BackRelevance_ViewModel.Id), model.Id));
                            #endregion
                        }
                    }
                    else if (model.AuditWay == WFTAuditWayEnum.OrSign)
                    {
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        //同时  修改  审核记录状态 审核流程 
                        model.Stauts = WFRrocessStatus.AuditThrough;
                        if (!string.IsNullOrWhiteSpace(model.AuditedId))
                        {
                            model.AuditedId += "," + user.Id;
                        }
                        else
                        {
                            model.AuditedId = user.Id.ToString();
                        }
                        #region 更新审核记录表状态

                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion

                        #region 更新审核关联表状态
                        flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);
                        #endregion

                        var list = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).ToList();
                        int AuditCount = list.Count();
                        if (AuditCount > 0)//表示最后一个人就是子集审核   申请单 通过
                        {
                            foreach (var item in list)
                            {
                                flag = UpdateStuRecordModule(WFRrocessStatus.OtherHaveAudit, Description, user.Id, item.Id);
                            }
                        }
                        //赋值下一步到审核记录中  并更新这一步的待审核人
                        var modelNext = ToAuditFlow[1];
                        flag = InsertAuditRelevanceNext(backModel, modelNext);
                        if (flag == false)
                        {
                            message = "审核流程不完整无法审核，请联系相关负责人!";
                            return false;
                        }
                    }
                    else
                    {
                        var amodel = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId == user.Id).FirstOrDefault();
                        if (amodel == null)
                        {
                            message = "尚未匹配到审核相关信息，请联系管理员!";
                            return false;
                        }
                        var list = RecordList.Where(x => x.AuditStatus == WFRrocessStatus.NotAudit && x.AuditEmId != user.Id).ToList();
                        int AuditCount = list.Count();
                        if (AuditCount > 0)
                        {
                            message = "流程配置出错啦！非会签、或签 都只能有一个审核人!";
                            return false;
                        }
                        //同时  修改  审核记录状态 审核流程 
                        model.Stauts = WFRrocessStatus.AuditThrough;
                        if (!string.IsNullOrWhiteSpace(model.AuditedId))
                        {
                            model.AuditedId += "," + user.Id;
                        }
                        else
                        {
                            model.AuditedId = user.Id.ToString();
                        }
                        #region 更新审核记录表状态
                        flag = UpdateStuRecordModule(WFRrocessStatus.AuditThrough, Description, user.Id, amodel.Id);
                        #endregion

                        #region 更新审核关联表状态
                        flag = UpdateStuRelevanceModule(model.Id, model.Stauts, model.AuditedId);

                        #endregion
                        //赋值下一步到审核记录中  并更新这一步的待审核人
                        var modelNext = ToAuditFlow[1];
                        flag = InsertAuditRelevanceNext(backModel, modelNext);
                        if (flag == false)
                        {
                            message = "审核流程不完整无法审核，请联系相关负责人!";
                            return false;
                        }
                    }
                }
            }
            return flag;
        }


        /// <summary>
        /// 更新审核记录表信息
        /// </summary>
        /// <param name="wFRrocessStatus">审核状态</param>
        /// <param name="Description">审核意见</param>
        /// <param name="UserId">审核人Id</param>
        /// <param name="Id">审核记录编号</param>
        /// <returns></returns>
        private bool UpdateStuRecordModule(WFRrocessStatus wFRrocessStatus, string Description, int UserId, int Id)
        {
            var recordFileds = new Dictionary<string, object>
            {
                { nameof(RB_Student_BackRecord_ViewModel.AuditStatus), wFRrocessStatus },
                { nameof(RB_Student_BackRecord_ViewModel.Description),Description} ,
                { nameof(RB_Student_BackRecord_ViewModel.UpdateBy),UserId},
                { nameof(RB_Student_BackRecord_ViewModel.UpdateTime),DateTime.Now}
            };
            bool flag = student_BackRecordRepository.Update(recordFileds, new WhereHelper(nameof(RB_Student_BackRecord_ViewModel.Id), Id));
            return flag;
        }

        /// <summary>
        /// 更新审核流程信息
        /// </summary>
        /// <param name="status"></param>
        /// <param name="AuditedId"></param>
        /// <param name="Id"></param>
        /// <returns></returns>
        private bool UpdateStuRelevanceModule(int Id, WFRrocessStatus? status = null, string AuditedId = "")
        {
            var relevanceFileds = new Dictionary<string, object>();
            if (!string.IsNullOrEmpty(AuditedId))
            {
                relevanceFileds.Add(nameof(RB_Student_BackRelevance_ViewModel.AuditedId), AuditedId);
            }
            if (status != null)
            {
                relevanceFileds.Add(nameof(RB_Student_BackRelevance_ViewModel.Stauts), status);
            }
            bool flag = student_BackRelevanceRepository.Update(relevanceFileds, new WhereHelper(nameof(RB_Student_BackRelevance_ViewModel.Id), Id));
            return flag;
        }

        /// <summary>
        /// 添加拷贝审核节点
        /// </summary>
        /// <param name="backModel">退课单据实体</param>
        /// <param name="modelNext">审核关联</param>
        private bool InsertAuditRelevanceNext(RB_Student_BackClass backModel, RB_Student_BackRelevance_ViewModel modelNext)
        {
            if (modelNext != null)
            {
                RB_Student_BackRelevance_ViewModel auditRelevance = modelNext.RefMapperTo<RB_Student_BackRelevance_ViewModel>();
                if (auditRelevance != null)
                {
                    List<int> empList = new List<int>();
                    if (!string.IsNullOrEmpty(auditRelevance.PostIds))
                    {
                        var postList = Common.ConvertHelper.StringToList(auditRelevance.PostIds);
                        if (postList != null&& postList.Count>0)
                        {
                            foreach (var item in postList)
                            {
                                //本班教师审核
                                if (item == 1)
                                {
                                    empList.Add(backModel.TeacherId);
                                }
                                //关联销售审核
                                else if (item == 2)
                                {
                                    var orderModel = orderRepository.GetEntity(backModel.OrderId);
                                    empList.Add(orderModel.EnterID);
                                }
                                //分区校长审核
                                else if (item == 3)
                                {
                                    var headmaster = accountRepository.GetAccountListExtRepository(new Model.ViewModel.User.RB_Account_ViewModel()
                                    {
                                        Post_Id = Common.Config.SchoolPostId,
                                        Group_Id = backModel.Group_Id
                                    })?.FirstOrDefault();
                                    if (headmaster != null && headmaster.Id > 0)
                                    {
                                        empList.Add(headmaster.Id);
                                    }
                                }
                                else if (item == 4)
                                {
                                    var headmaster = accountRepository.GetAccountListExtRepository(new Model.ViewModel.User.RB_Account_ViewModel()
                                    {
                                        Post_Id = Common.Config.JiaoWuZhang,
                                        Group_Id = backModel.Group_Id
                                    })?.FirstOrDefault();
                                    if (headmaster != null && headmaster.Id > 0)
                                    {
                                        empList.Add(headmaster.Id);
                                    }
                                }
                            }
                        }
                    }
                    //以前的存入的数据
                    //empList = Common.ConvertHelper.StringToList(auditRelevance.ToAuditId);
                    InsertBatcheAuditRecord(empList, backModel.BackId, auditRelevance);
                }
            }
            return true;
        }

        /// <summary>
        /// 批量添加审核人
        /// </summary>
        /// <param name="empIds">审核人id集合</param>
        /// <param name="wfId">工作流id</param>
        /// <param name="wFTTemplateTypeEnum">工作流模板</param>
        /// <param name="trans">事务</param>
        /// <param name="auditRelevance">审核节点</param>
        private void InsertBatcheAuditRecord(List<int> empIds, int wfId, RB_Student_BackRelevance_ViewModel auditRelevance)
        {
            List<RB_Student_BackRecord_ViewModel> auditrecordList = new List<RB_Student_BackRecord_ViewModel>();
            foreach (var item in empIds)
            {
                RB_Student_BackRecord_ViewModel auditrecord = new RB_Student_BackRecord_ViewModel
                {
                    AuditEmId = item,
                    AuditId = auditRelevance.Id,
                    AuditStatus = WFRrocessStatus.NotAudit,
                    CreateBy = item,
                    CreateTime = DateTime.Now,
                    UpdateBy = item,
                    UpdateTime = DateTime.Now,
                    ConditionId = wfId,
                    Description = "",
                    BackrelevanceId = auditRelevance.Id
                };
                auditrecordList.Add(auditrecord);
            }
            student_BackRecordRepository.InsertBatch(auditrecordList);
            auditRelevance.ToAuditId = string.Join(",", empIds);
            student_BackRelevanceRepository.Update(auditRelevance);
        }

        /// <summary>
        /// 获取退课单据信息
        /// </summary>
        /// <param name="backId"></param>
        /// <returns></returns>
        public object GetStuBackInfoModule(int backId)
        {
            var obj = new List<object>();
            //获取单据实体类
            var backModel = student_BackClassRepository.GetEntity(backId);
            //获取审核记录
            var aurList = student_BackRecordRepository.GetStudentBackRecordListRepository(new RB_Student_BackRecord_ViewModel()
            {
                ConditionId = backId,
            });
            //审核关联列表
            var arList = student_BackRelevanceRepository.GetStudentBackRelevanceListRepository(new RB_Student_BackRelevance_ViewModel()
            {
                ConditionId = backId
            });

            obj.Add(new
            {
                NodeName = "制单人",
                AduitStatus = 2,
                AuditWayName="",
                AduitStatusName = "发起",
                SubList = new List<object>()
                {
                   new{
                         AduitName= UserReidsCache.GetUserLoginInfo(backModel.CreateBy)?.AccountName ?? "",
                         Description=backModel.ApplyReason,
                         CreateTime=Common.ConvertHelper.FormatTime(backModel.CreateTime),
                         AuditStatus=WFRrocessStatus.AuditThrough,
                         AuditStatusName = WFRrocessStatus.AuditThrough.ToName(),
                      }
                }
            });

            var existsList = arList.Where(qitem => aurList.Any(oldItem => qitem.Id == oldItem.BackrelevanceId));
            foreach (var item in existsList)
            {
                obj.Add(new
                {
                    NodeName = item.AuditDescription,
                    AduitStatus = item.Stauts,
                    AduitStatusName = GetWFRrocessStatusStrModule(item.Stauts),
                    AuditWayName = item.AuditWay != WFTAuditWayEnum.Successively ? item.AuditWay.ToName() : "",
                    SubList = aurList.Where(qitem => qitem.AuditId == item.Id).Select(qitem => new
                    {
                        AduitName = UserReidsCache.GetUserLoginInfo(qitem.AuditEmId)?.AccountName ?? "",
                        Description = !string.IsNullOrEmpty(qitem.Description) ? qitem.Description : "无",
                        CreateTime = Common.ConvertHelper.FormatTime(qitem.UpdateTime),
                        qitem.AuditStatus,
                        AuditStatusName = GetWFRrocessStatusStrModule(qitem.AuditStatus),
                    })
                });
            }
            return obj;
        }

        /// <summary>
        /// 获取审核状态字符串
        /// </summary>
        /// <param name="status"></param>
        /// <returns></returns>
        private string GetWFRrocessStatusStrModule(WFRrocessStatus status)
        {
            var statusName = "待审";
            switch (status)
            {
                case WFRrocessStatus.AuditNotThrough: statusName = "拒绝"; break;
                case WFRrocessStatus.AuditThrough: statusName = "通过"; break;
                case WFRrocessStatus.NotAudit: statusName = "待审"; break;
                case WFRrocessStatus.OtherHaveAudit: statusName = "通过"; break;
                case WFRrocessStatus.Rejected: statusName = "驳回"; break;
            }
            return statusName;
        }

        /// <summary>
        /// 退课一键制单
        /// </summary>
        /// <param name="backClassId"></param>
        /// <param name="isPublic"></param>
        /// <param name="currencyId"></param>
        /// <param name="clientType"></param>
        /// <param name="clientId"></param>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public string SetStudentBackFinance(int backClassId, int IsPublic, int CurrencyId, int clientType, int clientId, UserInfo userInfo)
        {
            var backModel = student_BackClassRepository.GetEntity(backClassId);
            if (backModel == null || backModel.AuditStatus != BackClassAuditStatusEnum.Pass) { return "退课流程未审核通过"; }
            if (backModel.FinanceId > 0) { return "已制单，无法再次生成财务单据"; }
            var guestModel = order_GuestRepository.GetEntity(backModel.GuestId);
            if (guestModel == null || guestModel.GuestState != 2) { return "客人名单状态不正确"; }

            string msg = "";
            #region 新增财务单据
            var detailList = new List<object>
            {
                new
                {
                    CostTypeId = Config.ReadConfigKey("StuBackCostTypeId"),
                    Number = 1,
                    OriginalMoney = backModel.BackMoney,
                    UnitPrice = backModel.BackMoney,
                    Remark = "学员【"+guestModel.GuestName+"】退课"
                }
            };
            var classModel = classRepository.GetEntity(backModel.ClassId);
            string Remark = "【" + (classModel?.ClassName ?? "") + "】下订单" + backModel.OrderId + " 客人退课";
            var financeObj = new
            {
                IsPublic,
                ClientType = clientType,
                ClientID = clientId,
                CurrencyId,
                WBMoney = backModel.BackMoney,
                PayDate = DateTime.Now.ToString("yyyy-MM-dd"),
                TemplateId = Config.ReadConfigKey("StuBackTemplete"),
                OrderSource = 17,
                OrderID = backModel.OrderId,
                TCIDList = new List<int>() { backModel.ClassId },
                OtherType = 28,
                ReFinanceId = backModel.BackId,
                Remark,
                detailList,
                CreateBy = userInfo.Id,
                RB_Branch_Id = classModel.School_Id,
                RB_Depart_Id = userInfo.DeptId,
                RB_Group_Id = userInfo.Group_Id,
                RB_CreateByName = userInfo.AccountName,
                RB_DepartName = userInfo.DeptName,
                RB_BranchName = schoolRepository.GetEntity(classModel.School_Id)?.SName ?? "",
                RB_GroupName = userInfo.GroupName,
                FinanceType = 2
            };
            string sign = EncryptionHelper.AesEncrypt(JsonHelper.Serialize(financeObj), Config.ReadConfigKey("FinanceKey"));
            var resultInfo = new
            {
                msg = sign
            };

            string apiResult = HttpHelper.HttpPost(Config.ReadConfigKey("PaymentFinanceApi"), JsonHelper.Serialize(resultInfo), "");
            JObject parmsJob = JObject.Parse(apiResult);
            string resultCode = parmsJob.GetStringValue("resultCode");
            int frid = parmsJob.GetInt("data", 0);

            if (resultCode == "1" && frid > 0)
            {
                Dictionary<string, object> keyValues = new Dictionary<string, object>() {
                    { nameof(RB_Student_BackClass.FinanceId),frid}
                };
                List<WhereHelper> wheres = new List<WhereHelper>() {
                    new WhereHelper(){
                         FiledName=nameof(RB_Teaching_Perf_ViewModel.Id),
                          FiledValue=backModel.BackId,
                           OperatorEnum=OperatorEnum.Equal
                    }
                };
                bool flag = student_BackClassRepository.Update(keyValues, wheres);
                if (flag)
                {
                    //记录日志
                    changeLogRepository.Insert(new Model.Entity.Log.RB_User_ChangeLog()
                    {
                        Id = 0,
                        Type = 1,
                        CreateBy = userInfo.Id,
                        CreateTime = DateTime.Now,
                        Group_Id = userInfo.Group_Id,
                        LogContent = "生成学员退课财务单据【" + backModel.BackId + "】",
                        School_Id = userInfo.School_Id,
                        SourceId = 0
                    });
                }
            }
            else
            {
                string message = parmsJob.GetStringValue("message");
                LogHelper.Write("SetStudentBackFinance:" + message);
                msg += backModel.BackId + "创建财务单据失败;";
            }
            #endregion

            return msg;
        }
    }
}