using APT.Infrastructure.Core;
using APT.BaseData.Domain.Entities.FM;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using APT.BaseData.Domain.IServices.FM;

using APT.Utility;
using APT.BaseData.Domain.Entities.BD;
using System.Linq;
using APT.BaseData.Domain.Enums;
using System;
using System.Linq.Expressions;
using APT.BaseData.Services.Services.FM;
using APT.BaseData.Domain.IServices;
using APT.BaseData.Services.DomainServices;
using NPOI.Util;
using Google.Protobuf.WellKnownTypes;
using APT.BaseData.Domain.ApiModel;
using NPOI.SS.Formula.Functions;
using APT.MS.Domain.Entities.PF;
using APT.BaseData.Domain.Enums.PF;

namespace APT.FM.WebApi.Controllers.Api.FM
{
    [Route("api/FM/Department")]
    public class DepartmentController : AuthorizeTreeApiController<T_FM_DEPARTMENT>
    {
        IFMDepartmentService DepartmentService { get; set; }
        public DepartmentController(IFMDepartmentService departmentService)
        {
            DepartmentService = departmentService;
        }
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_FM_DEPARTMENT>> Entities([FromBody] KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        /// 

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_FM_DEPARTMENT>> OrderEntities([FromBody] KeywordFilter filter)
        {
            filter.FilterGroup.Rules.Add(new FilterRule() { Field = "ENABLE_STATUS", Operate = FilterOperate.Equal, Value = 0 });
            filter.FilterGroup.Rules.Add(new FilterRule() { Field = "CATEGORY", Operate = FilterOperate.Equal, Value = 5 });
            var result = WitOrderEntities(null, filter);
            if (result.Data.Count() > 0)
            {
                var users = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用, new BaseFilter(filter.OrgId)).ToList();
                foreach (var item in result.Data)
                {
                    List<Guid> outPartmentIds = new List<Guid>();
                    List<Guid> inputIds = new List<Guid>() { item.ID };
                    GetDepartmentIds(filter.OrgId.Value, inputIds, ref outPartmentIds);
                    outPartmentIds.Add(item.ID);
                    var userCount = users.Count(t => t.DEPARTMENT_ID != null && outPartmentIds.Contains((Guid)t.DEPARTMENT_ID));
                    item.NAME = item.NAME + "(" + userCount + ")";
                }
            }
            return result;
        }
        /// <summary>
        /// 返回所有下级部门节点
        /// </summary>
        /// <param name="orgId"></param>
        /// <param name="listDepIDInt"></param>
        /// <param name="departmentIdPs"></param>
        public void GetDepartmentIds(Guid orgId, List<Guid> listDepIDInt, ref List<Guid> departmentIdPs)
        {
            var listDep = GetEntities<T_FM_DEPARTMENT>(e => !e.IS_DELETED && e.PARENT_ID.HasValue && listDepIDInt.Contains(e.PARENT_ID.Value), new BaseFilter(orgId));

            if (listDep != null && listDep.Any())
            {
                listDepIDInt = listDep.Select(e => e.ID).ToList();
                departmentIdPs.AddRange(listDepIDInt);
                GetDepartmentIds(orgId, listDepIDInt, ref departmentIdPs);
            }
        }
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="pageFilter"></param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_FM_DEPARTMENT> Paged([FromBody] KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="pageFilter"></param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_FM_DEPARTMENT> OrderPaged([FromBody] KeywordPageFilter pageFilter)
        {
            bool isAdd = false;
            if (pageFilter.FilterGroup.Rules == null)
                isAdd = true;
            if (!isAdd)
            {
                var c = pageFilter.FilterGroup.Rules.FirstOrDefault(e => e.Field == "CATEGORY");
                if (c == null)
                    isAdd = true;
            }
            if (isAdd)
            {
                if (pageFilter.FilterGroup.Rules == null)
                    pageFilter.FilterGroup.Rules = new List<FilterRule>();
                //默认非外包
                FilterRule filterRule = new FilterRule();
                filterRule.Field = "CATEGORY";
                filterRule.Value = FMCATEGORY.ACTURE;
                filterRule.IsSysParamRule = false;
                filterRule.Operate = FilterOperate.Equal;
                pageFilter.FilterGroup.Rules.Add(filterRule);
            }

            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost, Route("Update")]
        public JsonActionResult<bool> Update([FromBody] T_FM_DEPARTMENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        [HttpGet, Route("BatchDelete")]
        public JsonActionResult<bool> BatchDelete(string ids)
        {
            return WitRealBatchDelete(ids);
        }


        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_FM_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }


        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost, Route("FullUpdate")]
        public JsonActionResult<bool> FullUpdate([FromBody] T_FM_DEPARTMENT entity)
        {
            return SafeExecute<bool>(() =>
            {
                var deptUser = entity.Nav_UserDeparts;
                entity.Nav_UserDeparts = null;
                this.UnifiedCommit(() =>
                {
                    this.UpdateEntityNoCommit(entity);
                    if (deptUser != null)
                    {
                        this.BantchSaveEntityNoCommit(deptUser);
                    }
                });
                return true;
            });
        }

        /// <summary>
        /// 部门列表
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        [HttpPost, Route("WorkShopTreeData")]
        public JsonActionResult<IEnumerable<TreeNode<T_FM_DEPARTMENT>>> WorkShopTreeData([FromBody] KeywordFilter filter)
        {
            return WitTreeOrderEntities(i => i.DEPARTMENT_TYPE == (int)FMDepartmentType.车间, filter);
        }


        /// <summary>
        /// 保存生产日历配置信息
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("CalendarUpdate")]
        public JsonActionResult<bool> CalendarUpdate([FromBody] T_FM_DEPARTMENT entity)
        {
            return SafeExecute<bool>(() =>
            {
                if (entity != null && entity.Nav_DepartmentScheduling != null && entity.ORG_ID != null)
                {
                    //var shiftList = this.GetEntities<T_FM_DEPARTMENT_SCHEDULING>(s => s.ORG_ID == entity.ORG_ID && s.DEPARTMENT_ID == entity.ID && s.DATE_TIME == entity
                    //.Nav_DepartmentScheduling.FirstOrDefault().DATE_TIME, filter);
                    //var sIds = shiftList.Select(s => s.ID);

                    //排除不存在数据库中并且是删除状态的数据
                    List<T_FM_DEPARTMENT_SCHEDULING> nodeSchedulingList = entity.Nav_DepartmentScheduling.Where(i => !i.IS_DELETED).Select(e => new T_FM_DEPARTMENT_SCHEDULING
                    {
                        ORG_ID = entity.ORG_ID,
                        ID = Guid.NewGuid(),
                        DEPARTMENT_ID = entity.ID,
                        //DEPARTMENT_CALENDAR_CONFIG_ID = e.DEPARTMENT_CALENDAR_CONFIG_ID,
                        DATE_TIME = e.DATE_TIME,
                        CLASS_ID = e.CLASS_ID,
                        TEAM_ID = e.TEAM_ID,
                        ENABLE_STATUS = e.ENABLE_STATUS
                    }).ToList();
                    //删除原本的人员排班计划
                    var teamIds = entity.Nav_DepartmentScheduling.Select(i => i.TEAM_ID).ToList();
                    var filter = new BaseFilter(entity.ORG_ID);
                    filter.SelectField = new string[] { "ID", "TEAM_ID", "PERSON_ID" };
                    var classPersons = this.GetEntities<T_FM_TEAM_PERSON>(i => teamIds.Contains(i.TEAM_ID), filter);
                    List<T_FM_DEPARTMENT_SCHEDULING_DETAIL> departmentSchedulingDetails = new List<T_FM_DEPARTMENT_SCHEDULING_DETAIL>();
                    foreach (var e in nodeSchedulingList)
                    {
                        var classPerson = classPersons.Where(i => i.TEAM_ID == e.TEAM_ID).ToList();
                        foreach (var t in classPerson)
                        {
                            T_FM_DEPARTMENT_SCHEDULING_DETAIL sd = new T_FM_DEPARTMENT_SCHEDULING_DETAIL()
                            {
                                ID = Guid.NewGuid(),
                                ORG_ID = e.ORG_ID,
                                PERSON_ID = t.PERSON_ID,
                                DEPARTMENT_SCHEDULING_ID = e.ID,
                            };
                            departmentSchedulingDetails.Add(sd);
                        }
                    }
                    this.UnifiedCommit(() =>
                    {
                        this.DeleteEntityNoCommit<T_FM_DEPARTMENT_SCHEDULING_DETAIL>(i => i.Nav_DepartmentScheduling.DEPARTMENT_ID == entity.ID
                      && i.Nav_DepartmentScheduling.DATE_TIME == entity.Nav_DepartmentScheduling.FirstOrDefault().DATE_TIME);
                        this.DeleteEntityNoCommit<T_FM_DEPARTMENT_SCHEDULING>(i => i.DEPARTMENT_ID == entity.ID
                        && i.DATE_TIME == entity.Nav_DepartmentScheduling.FirstOrDefault().DATE_TIME);
                        if (nodeSchedulingList.Count > 0)
                            this.BantchAddEntityNoCommit(nodeSchedulingList);
                        if (departmentSchedulingDetails.Count > 0)
                            this.BantchAddEntityNoCommit(departmentSchedulingDetails);
                    });
                }
                else
                    this.ThrowError("040001");
                return true;
            });
        }

        /// <summary>
        /// 应用当日所有节点
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("ApplyAll")]
        public JsonActionResult<bool> ApplyAll([FromBody] T_FM_DEPARTMENT entity)
        {
            return SafeExecute<bool>(() =>
            {
                KeywordFilter filter = new KeywordFilter();
                if (entity != null && entity.ID != null && entity.ORG_ID != null && entity.Nav_DepartmentScheduling != null)
                {
                    var shiftList = this.GetEntities<T_FM_DEPARTMENT_SCHEDULING>(s => s.ORG_ID == entity.ORG_ID
                    && s.DATE_TIME == entity.Nav_DepartmentScheduling.FirstOrDefault().DATE_TIME, filter);

                    //获取当前排班单元排班配置
                    var sIds = shiftList.Where(s => s.DEPARTMENT_ID == entity.ID).Select(s => s.ID);

                    //排除不存在数据库中并且是删除状态的数据
                    List<T_FM_DEPARTMENT_SCHEDULING> nodeSchedulingList = entity.Nav_DepartmentScheduling.Select(e => new T_FM_DEPARTMENT_SCHEDULING
                    {
                        ORG_ID = entity.ORG_ID,
                        ID = e.ID,
                        DEPARTMENT_ID = e.DEPARTMENT_ID,
                        DEPARTMENT_CALENDAR_CONFIG_ID = e.DEPARTMENT_CALENDAR_CONFIG_ID,
                        DATE_TIME = e.DATE_TIME,
                        CLASS_ID = e.CLASS_ID,
                        TEAM_ID = e.TEAM_ID,
                        IS_DELETED = e.IS_DELETED,
                        ENABLE_STATUS = e.ENABLE_STATUS
                    }).Where(n => !(!sIds.Contains(n.ID) && n.IS_DELETED == true)).ToList();

                    //获取所有排班单元（排除当前配置项）
                    var spanList = this.GetEntities<T_FM_DEPARTMENT>(n => n.DEPARTMENT_TYPE == (int)FMDepartmentType.车间 && n.ID != entity.ID, filter);
                    //获取要删除的排班信息（排除当前排班单元）
                    var delIds = shiftList.Where(s => s.DEPARTMENT_ID != entity.ID).Select(d => d.ID).ToList();
                    //获取要删除排班明细表的数据
                    var delDetailIds = this.GetEntities<T_FM_DEPARTMENT_SCHEDULING_DETAIL>(x => delIds.Contains(x.DEPARTMENT_SCHEDULING_ID), filter).Select(x => x.ID).ToList();

                    var batchData = nodeSchedulingList.Where(b => b.IS_DELETED == false);
                    List<T_FM_DEPARTMENT_SCHEDULING> batchDataList = new List<T_FM_DEPARTMENT_SCHEDULING>();
                    foreach (var item in spanList)
                    {
                        var shiftSpanList = batchData.Select(b => new T_FM_DEPARTMENT_SCHEDULING
                        {
                            ORG_ID = entity.ORG_ID,
                            ID = new Guid(),
                            DEPARTMENT_ID = item.ID,
                            DEPARTMENT_CALENDAR_CONFIG_ID = b.DEPARTMENT_CALENDAR_CONFIG_ID,
                            DATE_TIME = b.DATE_TIME,
                            CLASS_ID = b.CLASS_ID,
                            TEAM_ID = b.TEAM_ID,
                            CREATE_TIME = DateTime.Now,
                            MODIFY_TIME = DateTime.Now,
                            IS_DELETED = b.IS_DELETED,
                            ENABLE_STATUS = b.ENABLE_STATUS
                        });
                        batchDataList.AddRange(shiftSpanList);
                    }


                    //保存当前配置
                    this.UnifiedCommit(() =>
                    {
                        //保存当前配置
                        this.BantchSaveEntityNoCommit(nodeSchedulingList);
                        //先清空明细表数据
                        this.BantchDeleteEntityNoCommit<T_FM_DEPARTMENT_SCHEDULING_DETAIL>(delDetailIds);
                        //清空其它排班
                        this.BantchDeleteEntityNoCommit<T_FM_DEPARTMENT_SCHEDULING>(delIds);
                        //重新创建新的排班
                        this.BantchAddEntityNoCommit(batchDataList);
                    });

                }
                else
                    this.ThrowError("040001");
                return true;
            });
        }

        /// <summary>
        /// 部门保存(新增安全员子表)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost, Route("UpdateAll")]
        public JsonActionResult<bool> UpdateAll([FromBody] T_FM_DEPARTMENT entity)
        {
            return SafeExecute<bool>(() =>
            {
                //var safeUser = entity==null?null:entity.Nav_SafeUser;
                //entity.Nav_SafeUser = null;
                T_FM_TEAM teamInfo = null;
                if (entity.DEPARTMENT_TYPE == (int)FMDepartmentType.班组)
                {
                    teamInfo = this.GetEntity<T_FM_TEAM>(t => t.DEPARTMENT_ID == entity.ID);
                    if (teamInfo == null)
                    {
                        teamInfo = new T_FM_TEAM()
                        {
                            NAME = entity.NAME,
                            DEPARTMENT_ID = entity.ID,
                            //CHARGE_PERSON_ID = user.PERSON_ID,
                            ORG_ID = entity.ORG_ID,
                            ID = Guid.NewGuid(),
                        };
                    }
                    else
                    {
                        teamInfo.NAME = entity.NAME;
                        teamInfo.DEPARTMENT_ID = entity.ID;
                        //teamInfo.CHARGE_PERSON_ID = entity.USER_ID;
                    }
                }
                if (entity.USER_ID != null)
                {
                    var user = this.GetEntity<T_FM_USER>(t => t.ID == entity.USER_ID);
                    if (teamInfo != null)
                        teamInfo.CHARGE_PERSON_ID = user.PERSON_ID;
                }
                //List<T_FM_DEPARTMENT_PRODUCTION_UNIT> productionUnit = null;
                entity.Nav_ProdutionUnit = null;
                //if (productionUnit != null && productionUnit.Any())
                //{
                //    productionUnit.ForEach(t =>
                //    {
                //        t.ORG_ID = entity.ORG_ID; t.DEPARTMENT_ID = entity.ID;
                //        t.Nav_Enums = null;
                //    });
                //}
                var unitList = new List<T_FM_DEPARTMENT_PRODUCTION_UNIT>();
                var userUnitList = new List<T_FM_USER_PRODUCTION_UNIT>();
                var departmentList = new List<T_FM_DEPARTMENT>();
                var userList = new List<T_FM_USER>();
                var deleteDepartIds = new List<Guid>();
                var deleteUserIds = new List<Guid>();
                if (entity.MineType != null)
                {
                    //var enumIds = productionUnit.Select(t => t.ENUMS_ID).Distinct().ToList();
                    var enumList = this.GetEntity<T_FM_ENUMS>(t => t.CODE == "BSMineTypeEnum" && t.VALUE == entity.MineType);
                    //查所有下级部门组织
                    List<Guid> departmentId = new List<Guid>();
                    departmentId.Add(entity.ID);
                    List<Guid> departmentIds = new List<Guid>() { entity.ID };
                    var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId.Value;
                    DepartmentService.GetDepartmentIds(orgId, departmentId, ref departmentIds);
                    departmentList = this.GetEntities<T_FM_DEPARTMENT>(t => departmentIds.Contains(t.ID) && t.ENABLE_STATUS == 0, new BaseFilter(orgId), "Nav_ProdutionUnit").ToList();
                    departmentList.ForEach(t =>
                    {
                        t.MineType = entity.MineType;
                        T_FM_DEPARTMENT_PRODUCTION_UNIT unit = new T_FM_DEPARTMENT_PRODUCTION_UNIT();
                        unit.ORG_ID = t.ORG_ID; unit.DEPARTMENT_ID = t.ID; unit.ENUMS_ID = enumList?.ID;
                        unit.Nav_Enums = null;
                        unitList.Add(unit);
                        if (t.Nav_ProdutionUnit != null && t.Nav_ProdutionUnit.Any())
                        {
                            var ids = t.Nav_ProdutionUnit.Select(t => t.ID).ToList();
                            deleteDepartIds.AddRange(ids);
                        }
                    });
                    //departmentList.ForEach(t => t.MineType = entity.MineType);
                    userList = this.GetEntities<T_FM_USER>(t => departmentIds.Contains(t.DEPARTMENT_ID.Value) && t.ENABLE_STATUS == 0, new BaseFilter(orgId), "Nav_ProdutionUnit").ToList();
                    userList.ForEach(t =>
                    {
                        //var enumValues = new List<string>();
                        //productionUnit.ForEach(t1 =>
                        //{
                        //    T_FM_USER_PRODUCTION_UNIT unit = new T_FM_USER_PRODUCTION_UNIT();
                        //    unit.ORG_ID = t.ORG_ID; unit.USER_ID = t.ID; unit.ENUMS_ID = t1.ENUMS_ID;
                        //    unit.Nav_Enums = null;
                        //    userUnitList.Add(unit);
                        //    var value = enumList.FirstOrDefault(m => m.ID == t1.ENUMS_ID)?.VALUE.ToString();
                        //    enumValues.Add(value);
                        //});
                        //t.MineType = string.Join(",", enumValues);
                        t.MineType = entity.MineType.ToString();
                        T_FM_USER_PRODUCTION_UNIT unit = new T_FM_USER_PRODUCTION_UNIT();
                        unit.ORG_ID = t.ORG_ID; unit.USER_ID = t.ID; unit.ENUMS_ID = enumList?.ID;
                        unit.Nav_Enums = null;
                        userUnitList.Add(unit);
                        if (t.Nav_ProdutionUnit != null && t.Nav_ProdutionUnit.Any())
                        {
                            var ids = t.Nav_ProdutionUnit.Select(t => t.ID).ToList();
                            deleteUserIds.AddRange(ids);
                        }
                    });
                }
                this.UnifiedCommit(() =>
                {
                    //if (safeUser != null && safeUser.Any())
                    //    this.BantchSaveEntityNoCommit(safeUser);
                    if (teamInfo != null)
                        this.UpdateEntityNoCommit(teamInfo);
                    //if (productionUnit != null && productionUnit.Any())
                    //    this.BantchSaveEntityNoCommit(productionUnit);
                    if (deleteDepartIds != null && deleteDepartIds.Any())
                        this.BantchDeleteEntityNoCommit<T_FM_DEPARTMENT_PRODUCTION_UNIT>(deleteDepartIds);
                    if (deleteUserIds != null && deleteUserIds.Any())
                        this.BantchDeleteEntityNoCommit<T_FM_USER_PRODUCTION_UNIT>(deleteUserIds);
                    if (departmentList != null && departmentList.Any())
                        this.BantchSaveEntityNoCommit(departmentList);
                    if (userList != null && userList.Any())
                        this.BantchSaveEntityNoCommit(userList);
                    if (unitList != null && unitList.Any())
                        this.BantchSaveEntityNoCommit(unitList);
                    if (userUnitList != null && userUnitList.Any())
                        this.BantchSaveEntityNoCommit(userUnitList);
                    if (entity != null)
                        this.UpdateEntityNoCommit(entity);
                });
                return true;
            });
        }

        /// <summary>
        /// 获得单条实体数据(新增部门人员子表)
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("GetAll")]
        public JsonActionResult<T_FM_DEPARTMENT> GetAll([FromBody] KeywordFilter filter)
        {
            return SafeExecute(() =>
            {
                T_FM_DEPARTMENT main = new T_FM_DEPARTMENT();
                var id = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "ID").Value.ToString();
                if (!string.IsNullOrEmpty(id))
                {
                    var entity = this.GetEntity<T_FM_DEPARTMENT>(id, false, "Nav_SafeUser", "Nav_DepartmentUser", "Nav_Parent", "Nav_ChargeUser",
                        "Nav_SafeUser.Nav_User", "Nav_DepartmentUser.Nav_User", "Nav_DepartmentUser.Nav_User.Nav_ApproveRole", "Nav_User", "Nav_Person", "Nav_Person.Nav_Post", "Nav_ProdutionUnit.Nav_Enums");
                    if (entity != null)
                    {
                        main = entity;
                        if (entity.Nav_DepartmentUser != null && entity.Nav_DepartmentUser.Any())
                        {
                            main.Nav_DepartmentUser = entity.Nav_DepartmentUser.Where(t => !t.Nav_User.CODE.Contains("admin")).ToList();
                        }
                        else
                        {
                            //List<Guid> departmentIds = new List<Guid>();
                            //List<Guid> departmentId = new List<Guid>();
                            //departmentId.Add(main.ID);
                            //GetAllDepartmentId(departmentId, ref departmentIds);
                            var users = this.GetEntities<T_FM_USER>(t => main.ID == t.DEPARTMENT_ID && t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && !t.CODE.Contains("admin"), new BaseFilter(main.ORG_ID), new string[] { "Nav_ApproveRole", "Nav_Person.Nav_Post" }).ToList();
                            if (users.Any() && users != null)
                            {
                                List<T_FM_DEPARTMENT_USER> departmentUser = new List<T_FM_DEPARTMENT_USER>();
                                users.ForEach(u =>
                                {
                                    T_FM_DEPARTMENT_USER us = new T_FM_DEPARTMENT_USER();
                                    us.DEPARTMENT_ID = u.DEPARTMENT_ID;
                                    us.USER_ID = u.ID;
                                    us.Nav_User = u;
                                    departmentUser.Add(us);
                                });
                                //main.Nav_DepartmentUser = departmentUser.OrderByDescending(e => e.Nav_User.APPROVE_ROLE_ID).ToList();//wyw 有审批角色的显示再前面
                                main.Nav_DepartmentUser = departmentUser.OrderByDescending(e => e.Nav_User.Nav_ApproveRole?.CODE).ToList();
                            }
                        }
                    }
                }
                return main;
            });
        }
        /// <summary>
        /// 返回所有部门节点
        /// <returns></returns>
        private void GetAllDepartmentId(List<Guid> departmentId, ref List<Guid> allDepartmentIds)
        {
            var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
            allDepartmentIds.AddRange(departmentId);
            var department = GetEntities<T_FM_DEPARTMENT>(t => departmentId.Contains((Guid)t.PARENT_ID), new BaseFilter(orgId));
            if (department != null && department.Any())
            {
                var departmentIds = department.Select(u => u.ID).ToList();
                GetAllDepartmentId(departmentIds, ref allDepartmentIds);
            }
        }

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="pageFilter"></param>
        /// <returns></returns>
        [HttpPost, Route("OrderPagedPost")]
        public PagedActionResult<T_FM_USER_POST> OrderPagedPost([FromBody] KeywordPageFilter pageFilter)
        {
            return SafeGetPagedData(delegate (PagedActionResult<T_FM_USER_POST> result)
            {
                Guid DEPARTMENT_ID = Guid.Empty;
                if (pageFilter.FilterGroup.Rules != null && pageFilter.FilterGroup.Rules.Any())
                {
                    var rules = pageFilter.FilterGroup.Rules;
                    foreach (var rule in rules)
                    {
                        if (rule.Field == "DEPARTMENT_ID")
                        {
                            DEPARTMENT_ID = new Guid(rule.Value.ToString());
                            rules.Remove(rule);
                            break;
                        }
                    }
                    pageFilter.FilterGroup.Rules = rules;
                }
                else if (pageFilter.FilterGroup.Groups != null && pageFilter.FilterGroup.Groups.Any())
                {
                    var rules = pageFilter.FilterGroup.Groups.ToList()[0].Rules;
                    foreach (var rule in rules)
                    {
                        if (rule.Field == "DEPARTMENT_ID")
                        {
                            DEPARTMENT_ID = new Guid(rule.Value.ToString());
                            rules.Remove(rule);
                            break;
                        }
                    }
                    //pageFilter.FilterGroup.Groups = rules;
                }

                if (DEPARTMENT_ID != Guid.Empty)
                {
                    List<Guid> listPersonID = new List<Guid>();
                    var IListPersons = GetEntities<T_FM_USER>(e => e.DEPARTMENT_ID.HasValue && e.DEPARTMENT_ID == DEPARTMENT_ID && e.PERSON_ID.HasValue && !e.IS_DELETED && e.ENABLE_STATUS == 0, null, null);
                    if (IListPersons != null && IListPersons.Any())
                    {
                        foreach (var item in IListPersons)
                        {
                            listPersonID.Add(item.PERSON_ID.Value);
                        }
                    }
                    //var listPersonID = GetEntities<T_FM_USER>(e => e.DEPARTMENT_ID.HasValue && e.DEPARTMENT_ID == DEPARTMENT_ID && e.PERSON_ID.HasValue, null, null).ToList().Select(e => e.PERSON_ID);

                    if (listPersonID != null && listPersonID.Any())
                    {
                        var IlistPerson = GetEntities<T_FM_PERSON>(e => e.POST_ID.HasValue && listPersonID.Contains(e.ID), null, null);
                        if (IlistPerson != null && IlistPerson.Any())
                        {
                            List<Guid> listPostID = new List<Guid>();
                            foreach (var item in IlistPerson)
                            {
                                listPostID.Add(item.POST_ID.Value);
                            }

                            if (listPostID.Any())
                            {
                                Expression<Func<T_FM_USER_POST, bool>> expression = e => !e.IS_DELETED && e.STATUS == 1 && listPostID.Contains(e.ID);
                                PagedActionResult<T_FM_USER_POST> orderPageEntities = this.GetOrderPageEntities<T_FM_USER_POST>(expression, pageFilter, null);
                                result.Data = orderPageEntities.Data;
                                result.TotalCount = orderPageEntities.TotalCount;
                            }
                        }

                    }
                }
                else
                {
                    result.Data = new List<T_FM_USER_POST>();
                    result.TotalCount = 0;
                }
            });
        }
        /// <summary>
        /// 根据部门和人员返回人员信息
        /// </summary>
        /// <param name="userModel"></param>
        /// <returns></returns>
        [HttpPost, Route("GetSelectUsers")]
        public JsonActionResult<List<UserModel>> GetSelectUsers([FromBody] SelectUsersModel userModel)
        {
            return SafeExecute<List<UserModel>>(() =>
            {
                Expression<Func<T_FM_USER, bool>> express = t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用;
                Expression<Func<T_FM_USER, bool>> selectExpress = t => false;
                if (userModel == null || (!userModel.UserIds.Any() && !userModel.DepartmentIds.Any()))
                {
                    return new List<UserModel>();
                }
                else
                {

                    if (userModel.UserIds.Any())
                    {
                        var userIds = userModel.UserIds.Select(i => Guid.Parse(i));
                        selectExpress = selectExpress.Or(item => userIds.Contains(item.ID));
                    }
                    if (userModel.DepartmentIds.Any())
                    {
                        var departmentIds = userModel.DepartmentIds.Select(i => Guid.Parse(i));
                        selectExpress = selectExpress.Or(item => departmentIds.Contains(item.DEPARTMENT_ID ?? Guid.Empty));
                    }
                }
                express = express.And(selectExpress);
                var filter = new BaseFilter(Guid.Parse(userModel.OrgId));
                filter.SelectField = new string[] { "ID", "NAME" };
                var deUsers = this.GetEntities<T_FM_USER>(express, filter);
                return deUsers.Select(u => new UserModel { UserId = u.ID.ToString(), UserName = u.NAME }).ToList();
            });
        }

        /// <summary>
        /// 获取部门和安全员信息
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("DepartmentAndUserEntities")]
        public JsonActionResult<IEnumerable<T_FM_DEPARTMENT>> DepartmentAndUserEntities([FromBody] KeywordFilter filter)
        {
            return SafeExecute(() =>
            {
                bool? isMaster = null;
                if (!string.IsNullOrEmpty(filter.Keyword))
                {
                    isMaster = Convert.ToBoolean(filter.Keyword);
                }
                filter.FilterGroup.Rules.Add(new FilterRule() { Field = "ENABLE_STATUS", Operate = FilterOperate.Equal, Value = 0 });
                var result = GetOrderEntities<T_FM_DEPARTMENT>(null, filter, null);
                if (result.Count() > 0 && isMaster.HasValue)
                {
                    IEnumerable<Guid> listUserID = null;
                    T_FM_USER userCheck = null;
                    //Nav_UserList 
                    if (isMaster.Value)
                    {
                        //负责人
                        result = result.Where(e => e.USER_ID.HasValue);
                        listUserID = result.Select(e => e.USER_ID.Value).Distinct();
                        if (listUserID != null && listUserID.Any())
                        {
                            var listUser = GetEntities<T_FM_USER>(e => listUserID.Contains(e.ID), null, null);
                            foreach (var item in result)
                            {
                                //找负责人 
                                userCheck = listUser.FirstOrDefault(e => e.ID == item.USER_ID.Value);
                                if (userCheck != null)
                                {
                                    item.Nav_UserList = new List<T_FM_USER>() { userCheck };
                                }
                            }
                        }
                    }
                    else
                    {
                        //安全员
                        var listDepID = result.Select(e => e.ID);
                        var rows = GetEntities<T_PF_APPROVAL_ROLE>(e => e.NAME.Contains("安全"), null, null);
                        IEnumerable<Guid> listRoleID = null;
                        if (rows != null && rows.Any())
                        {
                            listRoleID = rows.Select(e => e.ID);
                        }
                        if (listRoleID != null && listRoleID.Any())
                        {
                            var listUser = GetEntities<T_FM_USER>(e => e.DEPARTMENT_ID.HasValue && listDepID.Contains(e.DEPARTMENT_ID.Value) && e.APPROVE_ROLE_ID.HasValue && listRoleID.Contains(e.APPROVE_ROLE_ID.Value), null, null);
                            foreach (var item in result)
                            {
                                userCheck = listUser.FirstOrDefault(e => e.DEPARTMENT_ID == item.ID);
                                if (userCheck != null)
                                {
                                    item.Nav_UserList = new List<T_FM_USER>() { userCheck };
                                }
                            }

                        }
                    }
                }
                result = result.Where(e => e.Nav_UserList != null && e.Nav_UserList.Any());
                return result;
            });
        }


        #region      外包单位 组织

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost, Route("FullUpdateWB")]
        public JsonActionResult<bool> FullUpdateWB([FromBody] T_FM_DEPARTMENT entity)
        {
            return SafeExecute<bool>(() =>
            {
                if (!entity.ORG_ID.HasValue)
                {
                    throw new Exception("获取传参失败！");
                }
                T_FM_DEPARTMENT modelP = null;
                if (entity.PARENT_ID == null || entity.PARENT_ID == Guid.Empty)
                {
                    List<EnumsResult> list = APT.Utility.DataHelper.GetEnum("FilePathHead");
                    modelP = GetEntity<T_FM_DEPARTMENT>(e => e.NAME == "外包虚拟组织" && e.CATEGORY == FMCATEGORY.WB);

                    if (modelP == null)
                    {
                        //新增外包初始节点 
                        var root = GetEntity<T_FM_DEPARTMENT>(e => e.DEPARTMENT_TYPE == 3 && e.ENABLE_STATUS == 0);

                        string depID = "1BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        string ORG_ID = entity.ORG_ID.Value.ToString().ToUpper();
                        if (ORG_ID == FilePathHead.XLK.GetDescription())
                        {
                            depID = "1BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }
                        else if (ORG_ID == FilePathHead.LYXT.GetDescription())
                        {
                            depID = "2BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }
                        else if (ORG_ID == FilePathHead.LYYL.GetDescription())
                        {
                            depID = "3BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }
                        else if (ORG_ID == FilePathHead.DCJD.GetDescription())
                        {
                            depID = "4BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }
                        else if (ORG_ID == FilePathHead.GXBB.GetDescription())
                        {
                            depID = "5BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }
                        else if (ORG_ID == FilePathHead.SPSD.GetDescription())
                        {
                            depID = "8BBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB";
                        }

                        modelP = new T_FM_DEPARTMENT();
                        modelP.ID = new Guid(depID);
                        modelP.NAME = "外包虚拟组织";
                        modelP.CODE = "WB";
                        modelP.ORG_ID = entity.ORG_ID;
                        modelP.CATEGORY = FMCATEGORY.WB;
                        modelP.NUM = 1000;
                        modelP.DEPARTMENT_TYPE = 0;//所有的外包定位在一个部门里面

                        modelP.PARENT_ID = root.ID;//绑在公司下级

                    }
                    entity.PARENT_ID = modelP.ID;
                }

                entity.DEPARTMENT_TYPE = 1;//默认到车间级别
                entity.CATEGORY = FMCATEGORY.WB;//操作的都是外包的
                entity.Nav_UserDeparts = null;



                #region    外包管理员 添加 组织权限

                var role = GetEntity<T_FM_ROLE>(e => e.NAME == "外包管理员");
                bool isAddRole = false;
                if (role == null)
                {
                    isAddRole = true;
                    role = new T_FM_ROLE();
                    role.ID = Guid.NewGuid();
                    role.ORG_ID = entity.ORG_ID;
                    role.CODE = "WBGL";
                    role.NAME = "外包管理员";
                    role.NAME_ACRONYM = ";";
                    role.PLATFORM_TYPE = 0;
                    role.REMARK = "系统自动添加外包管理员";
                }
                List<T_FM_ROLE_DEPARTMENT> listRoleDep = new List<T_FM_ROLE_DEPARTMENT>();
                List<Guid> listDepID = new List<Guid>() { entity.ID };
                if (entity.PARENT_ID.HasValue)
                {
                    listDepID.Add(entity.PARENT_ID.Value);
                }
                var lisrRDCheck = GetEntities<T_FM_ROLE_DEPARTMENT>(e => e.ROLE_ID == role.ID && listDepID.Contains(e.DEPARTMENT_ID), null, null);
                T_FM_ROLE_DEPARTMENT check = null;
                foreach (var item in listDepID)
                {
                    check = lisrRDCheck.FirstOrDefault(e => e.DEPARTMENT_ID == item);
                    if (check == null)
                    {
                        listRoleDep.Add(new T_FM_ROLE_DEPARTMENT()
                        {
                            ID = Guid.NewGuid(),
                            ORG_ID = entity.ORG_ID,
                            DEPARTMENT_ID = item,
                            ROLE_ID = role.ID,
                        });
                    }
                }
                #endregion

                this.UnifiedCommit(() =>
                {
                    this.UpdateEntityNoCommit(entity);
                    if (modelP != null)
                        this.UpdateEntityNoCommit(modelP);
                    if (isAddRole)//添加角色
                        this.UpdateEntityNoCommit(role);
                    if (listRoleDep != null && listRoleDep.Any())
                        this.BantchSaveEntityNoCommit(listRoleDep);
                });
                return true;
            });
        }

        #endregion
    }
}