using IStation.Untity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Service
{
    /// <summary>
    /// 用户权限
    /// </summary>
    public partial class UserAuthority
    {
        #region 私有方法

        //获取菜单权限项列表
        private List<Model.MenuAuthItem> GetMenuAuthItemList(long userId)
        {
            var vmList = new List<Model.MenuAuthItem>();

            //角色授权
            var roleList = new Role().GetRelationByUserID(userId);
            if (roleList == null || roleList.Count < 1)
                return vmList;
            var roleAuthList = new RoleMenuMapping().GetByRoleIds(roleList.Select(x => x.ID).ToList());
            if (roleAuthList != null && roleAuthList.Count > 0)
            {
                foreach (var roleAuth in roleAuthList)
                {
                    var vm = vmList.Find(x =>x.MenuID==roleAuth.MenuID);
                    if (vm == null)
                    {
                        vm = new Model.MenuAuthItem();
                        vm.MenuID = roleAuth.MenuID;
                        vm.AuthLevel = roleAuth.AuthLevel;
                        vmList.Add(vm);
                    }
                    else
                    {
                        if (roleAuth.AuthLevel < vm.AuthLevel)
                        {
                            vm.AuthLevel = roleAuth.AuthLevel;
                        }
                    }
                }
            }

            return vmList;
        }

        //获取菜单权限项列表
        private List<Model.MenuAuthItem> GetMenuAuthItemList(long userId, Role roleService, RoleMenuMapping roleAuthService)
        {
            var vmList = new List<Model.MenuAuthItem>();

            //角色授权
            var roleList = roleService.GetRelationByUserID(userId);
            var roleAuthList = roleAuthService.GetByRoleIds(roleList.Select(x => x.ID).ToList());
            if (roleAuthList != null && roleAuthList.Count > 0)
            {
                foreach (var roleAuth in roleAuthList)
                {
                    var vm = vmList.Find(x => x.MenuID == roleAuth.MenuID );
                    if (vm == null)
                    {
                        vm = new Model.MenuAuthItem();
                        vm.MenuID = roleAuth.MenuID;
                        vm.AuthLevel = roleAuth.AuthLevel;
                        vmList.Add(vm);
                    }
                    else
                    {
                        if (roleAuth.AuthLevel < vm.AuthLevel)
                        {
                            vm.AuthLevel = roleAuth.AuthLevel;
                        }
                    }
                }
            }

            return vmList;
        }

        //通过 Soft 获取可下发的菜单权限树项列表
        private List<Model.AuthorizeMenuAuthTreeItem> GetAuthorizeMenuAuthTreeItemListBySoft(string SoftType, string SoftTag)
        {
            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
                return default;

            //遍历菜单生成
            var vmList = new List<Model.AuthorizeMenuAuthTreeItem>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.AuthorizeMenuAuthTreeItem(menu);
                vmMenu.Id = GuidCreater.CreateN();
                vmMenu.ParentId = string.Empty;
                vmList.Add(vmMenu);
            }

            //维护树形结构
            foreach (var menu in menuList)
            {
                if (menu.ParentIds != null && menu.ParentIds.Count > 0)
                {
                    var vmMenu = vmList.Find(x => x.MenuID == menu.ID);
                    var vmParentMenu = vmList.Find(x => x.MenuID == menu.ParentIds.Last());
                    vmMenu.ParentId = vmParentMenu.Id;
                }
            }

            return vmList;
        }

        //通过 Soft 获取菜单权限树项列表
        private List<Model.MenuAuthTreeItem> GetMenuAuthTreeItemListBySoft(string SoftType, string SoftTag)
        {
            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
                return default;

            //遍历菜单生成
            var vmList = new List<Model.MenuAuthTreeItem>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.MenuAuthTreeItem(menu);
                vmMenu.Id = GuidCreater.CreateN();
                vmMenu.ParentId = string.Empty;
                vmList.Add(vmMenu);
            }

            //维护树形结构
            foreach (var menu in menuList)
            {
                if (menu.ParentIds != null && menu.ParentIds.Count > 0)
                {
                    var vmMenu = vmList.Find(x => x.MenuID == menu.ID);
                    var vmParentMenu = vmList.Find(x => x.MenuID == menu.ParentIds.Last());
                    vmMenu.ParentId = vmParentMenu.Id;
                }
            }

            return vmList;
        }

        //通过 Soft 获取可下发的菜单权限树列表（2022-6-28 lxj修正）
        private List<Model.AuthorizeMenuAuthTree> GetAuthorizeMenuAuthTreeListBySoft(string SoftType, string SoftTag)
        {
            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
                return default;

            //遍历菜单生成
            var vmMenuList = new List<Model.AuthorizeMenuAuthTree>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.AuthorizeMenuAuthTree(menu);
                vmMenuList.Add(vmMenu);
            }

            var vmList = new List<Model.AuthorizeMenuAuthTree>();
            foreach (var menu in menuList)
            {
                var vmMenu = vmMenuList.Find(x => x.MenuID == menu.ID);
                if (menu.ParentIds.Count > 0)
                {               
                    var vmParentMenu = vmMenuList.Find(x => x.MenuID == menu.ParentIds.Last());
                    if(vmParentMenu!=null)
                        vmParentMenu.Children.Add(vmMenu);
                }
                else
                {
                    vmList.Add(vmMenu);
                }
            }

            return vmList;
        }

        //通过 Soft 获取权限树列表（2022-6-28 lxj修正）
        private List<Model.MenuAuthTree> GetMenuAuthTreeListBySoft(string SoftType, string SoftTag)
        {
            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
                return default;

            //遍历菜单生成
            var vmMenuList = new List<Model.MenuAuthTree>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.MenuAuthTree(menu);
                vmMenuList.Add(vmMenu);
            }

            //构建树形结构
            var vmList = new List<Model.MenuAuthTree>();
            foreach (var menu in menuList)
            {
                var vmMenu= vmMenuList.Find(x => x.MenuID == menu.ID);
                if (menu.ParentIds.Count > 0)
                {
                    var vmParentMenu = vmMenuList.Find(x=>x.MenuID==menu.ParentIds.Last());
                    if (vmParentMenu != null)
                    {
                        vmParentMenu.Children.Add(vmMenu);
                    }
                }
                else
                {
                    vmList.Add(vmMenu);
                }
            }

            return vmList;
        }

        #endregion

        #region 可下发的权限

        /// <summary>
        ///  通过 UserID 获取可下发的权限树项列表（2022-6-28 lxj修正）
        /// </summary>
        public List<Model.AuthorizeMenuAuthTreeItem> GetAuthorizeMenuAuthTreeItemList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
            {
                return default;
            }

            //超级管理员通道
            if (user.IsAdmin)
            {
                return GetAuthorizeMenuAuthTreeItemListBySoft(SoftType, SoftTag);
            }

            //获取权限项集合
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems == null || authItems.Count < 1)
            {
                return default;
            }

            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
            {
                return default;
            }

            //遍历菜单生成
            var vmMenuList = new List<Model.AuthorizeMenuAuthTreeItem>();
            foreach (var menu in menuList)
            {
                var menuAuth = authItems.Find(x => x.AuthLevel == Model.eAuthLevel.All && x.MenuID == menu.ID);
                if (menuAuth != null)
                {
                    var vm_menu = new Model.AuthorizeMenuAuthTreeItem(menu);
                    vm_menu.Id = GuidCreater.CreateN();
                    vm_menu.ParentId = string.Empty;
                    vmMenuList.Add(vm_menu);
                }
            }

            //维护树形结构并检查可下发的可靠性
            var menuAuthIds = vmMenuList.Select(x => x.MenuID).ToList();
            var menuAuthList = menuList.Where(x => menuAuthIds.Contains(x.ID)).OrderBy(x =>x.ParentIds.Count).ThenBy(x => x.SortCode).ToList();

            foreach (var menuAuth in menuAuthList)
            {
                var vmMenu = vmMenuList.Find(x => x.MenuID == menuAuth.ID);
                if (menuAuth.ParentIds.Count > 0)
                {
                    var menuAuthParent = menuAuthList.Find(x => x.ID == menuAuth.ParentIds.Last());
                    if (menuAuthParent == null)
                    {
                        vmMenuList.Remove(vmMenu);
                    }
                    else
                    {
                        var vmParentMenu = vmMenuList.Find(x => x.MenuID == menuAuthParent.ID);
                        vmMenu.ParentId = vmParentMenu.Id;
                    }
                }
            }

            return vmMenuList;
        }

        /// <summary>
        /// 通过 UserID 获取可下发的权限树列表
        /// </summary>
        public List<Model.AuthorizeMenuAuthTree> GetAuthorizeMenuAuthTreeList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
            {
                return default;
            }

            //超级管理员通道
            if (user.IsAdmin)
            {
                return GetAuthorizeMenuAuthTreeListBySoft(SoftType, SoftTag);
            }

            //获取权限项集合
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems == null || authItems.Count < 1)
            {
                return default;
            }

            //获取所有菜单
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
            {
                return default;
            }

            //遍历生成
            var vmMenuList = new List<Model.AuthorizeMenuAuthTree>();
            foreach (var menu in menuList)
            {
                var authMenu = authItems.Find(x => x.AuthLevel == Model.eAuthLevel.All && x.MenuID == menu.ID);
                if (authMenu != null)
                {
                    var vm_menu = new Model.AuthorizeMenuAuthTree(menu);
                    vmMenuList.Add(vm_menu);
                }
            }

            //建立菜单树形结构并检查权限等级
            var vmList = new List<Model.AuthorizeMenuAuthTree>();
            var menuAuthIds = vmMenuList.Select(x => x.MenuID).ToList();
            var menuAuthList = menuList.Where(x => menuAuthIds.Contains(x.ID)).OrderBy(x =>x.ParentIds.Count).ThenBy(x => x.SortCode).ToList();
            foreach (var menuAuth in menuAuthList)
            {
                var vmMenu = vmMenuList.Find(x => x.MenuID == menuAuth.ID);
                if (menuAuth.ParentIds.Count > 0)
                {
                    var vmParentMenu = vmMenuList.Find(x => x.MenuID == menuAuth.ParentIds.Last());
                    if (vmParentMenu != null)
                    {
                        vmParentMenu.Children.Add(vmMenu);
                    }
                }
                else
                {
                    vmList.Add(vmMenu);
                }
            }

            return vmList;
        }

        #endregion

        #region 权限树项

        /// <summary>
        ///  通过 UserID 获取权限树项列表（2022-6-28 lxj修正）
        /// </summary>
        public List<Model.MenuAuthTreeItem> GetMenuAuthTreeItemList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
            {
                return default;
            }

            //超级管理员通道
            if (user.IsAdmin)
            {
                return GetMenuAuthTreeItemListBySoft(SoftType, SoftTag);
            }

            //获取权限项集合
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems == null || authItems.Count < 1)
            {
                return default;
            }

            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
            {
                return default;
            }

            //遍历生成
            var vmList = new List<Model.MenuAuthTreeItem>();
            foreach (var menu in menuList)
            {
                var menuAuth = authItems.Find(x =>  x.MenuID == menu.ID);
                if (menuAuth != null)
                {
                    var vmMenu = new Model.MenuAuthTreeItem(menu);
                    vmMenu.Id = GuidCreater.CreateN();
                    vmMenu.ParentId = string.Empty;
                    vmMenu.AuthLevel = menuAuth.AuthLevel;
                    vmList.Add(vmMenu);
                }
            }

            //维护菜单树形结构并检查权限等级
            var menuAuthIds = vmList.Select(x => x.MenuID).ToList();
            var menuAuthList = menuList.Where(x => menuAuthIds.Contains(x.ID)).OrderBy(x =>x.ParentIds.Count).ThenBy(x => x.SortCode).ToList();

            foreach (var menuAuth in menuAuthList)
            {
                var vmMenu = vmList.Find(x => x.MenuID == menuAuth.ID);
                if (menuAuth.ParentIds.Count > 0)
                {
                    var menuAuthParent = menuAuthList.Find(x => x.ID == menuAuth.ParentIds.Last());
                    if (menuAuthParent == null)//有上级菜单，但未检索到上级菜单，则移除自身及自身下的功能点
                    {
                        vmList.Remove(vmMenu);
                    }
                    else//有上级菜单的情况下，维护树形结构，并根据上级菜单的权限等级，更改自身的权限等级
                    {
                        var vmParentMenu = vmList.Find(x => x.MenuID == menuAuthParent.ID);
                        vmMenu.ParentId = vmParentMenu.Id;
                        if (vmParentMenu.AuthLevel == Model.eAuthLevel.ReadOnly)
                        {
                            vmMenu.AuthLevel = Model.eAuthLevel.ReadOnly;
                        }
                    }
                }
            }

            return vmList;
        }

        /// <summary>
        ///  通过 UserID 获取权限拥有树项列表（2022-6-28 lxj修正）
        /// </summary>
        public List<Model.MenuAuthHaveTreeItem> GetMenuAuthHaveTreeItemList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
            {
                return default;
            }

            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
            {
                return default;
            }

            //遍历菜单生成
            var vmList = new List<Model.MenuAuthHaveTreeItem>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.MenuAuthHaveTreeItem(menu);
                vmMenu.Id = GuidCreater.CreateN();
                vmMenu.ParentId = string.Empty;
                vmMenu.AuthLevel = Model.eAuthLevel.ReadOnly;
                vmMenu.Have = false;
                vmList.Add(vmMenu);
            }

            //维护树形结构
            foreach (var menu in menuList)
            {
                if (menu.ParentIds.Count > 0)
                {
                    var vmMenu = vmList.Find(x => x.MenuID == menu.ID);
                    var vmParentMenu = vmList.Find(x => x.MenuID == menu.ParentIds.Last());
                    vmMenu.ParentId = vmParentMenu.Id;
                }
            }

            //超级管理员通道
            if (user.IsAdmin)
            {
                vmList.ForEach(x =>
                {
                    x.Have = true;
                    x.AuthLevel = Model.eAuthLevel.All;
                });
                return vmList;
            }

            //权限匹配
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems != null && authItems.Count > 0)
            {
                vmList.ForEach(x =>
                {
                    var haveItem = authItems.Find(t => t.MenuID==x.MenuID);
                    if (haveItem != null)
                    {
                        x.Have = true;
                        x.AuthLevel = haveItem.AuthLevel;
                    }
                });
            }

            foreach (var menu in menuList)
            {
                var vmMenu = vmList.Find(x => x.MenuID == menu.ID);
                if (menu.ParentIds.Count > 0)
                {
                    var vmParentMenu = vmList.Find(x => x.MenuID == menu.ParentIds.Last());
                    if (!vmParentMenu.Have)
                    {
                        vmMenu.Have = false;
                    }
                    if (vmParentMenu.AuthLevel == Model.eAuthLevel.ReadOnly)
                    {
                        vmMenu.AuthLevel = Model.eAuthLevel.ReadOnly;
                    }
                }
            }

            return vmList;
        }

        #endregion

        #region 权限树



        /// <summary>
        /// 通过 UserID 获取权限树列表（2022-6-28 lxj修正）
        /// </summary>
        public List<Model.MenuAuthTree> GetMenuAuthTreeList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
            {
                return default;
            }

            //超级管理员通道
            if (user.IsAdmin)
            {
                return GetMenuAuthTreeListBySoft(SoftType, SoftTag);
            }

            //获取权限项集合
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems == null || authItems.Count < 1)
            {
                return default;
            }

            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
            {
                return default;
            }

            //遍历菜单生成
            var vmMenuList = new List<Model.MenuAuthTree>();
            foreach (var menu in menuList)
            {
                var authMenu = authItems.Find(x =>  x.MenuID == menu.ID);
                if (authMenu != null)
                {
                    var vmMenu = new Model.MenuAuthTree(menu);
                    vmMenuList.Add(vmMenu);
                }
            }

            //建立菜单树形结构并检查权限等级
            var vmList = new List<Model.MenuAuthTree>();
            var menuAuthIds = vmMenuList.Select(x => x.MenuID).ToList();
            var menuAuthList = menuList.Where(x => menuAuthIds.Contains(x.ID)).OrderBy(x =>x.ParentIds.Count).ThenBy(x => x.SortCode).ToList();

            foreach (var menuAuth in menuAuthList)
            {
                var vmMenu = vmMenuList.Find(x => x.MenuID == menuAuth.ID);
                if (menuAuth.ParentIds != null && menuAuth.ParentIds.Count > 0)
                {
                    var vmParentMenu = vmMenuList.Find(x => x.MenuID == menuAuth.ParentIds.Last());
                    if (vmParentMenu != null)
                    {
                        vmParentMenu.Children.Add(vmMenu);
                        if (vmParentMenu.AuthLevel == Model.eAuthLevel.ReadOnly)
                        {
                            vmMenu.AuthLevel = Model.eAuthLevel.ReadOnly;
                        }
                    }
                }
                else
                {
                    vmList.Add(vmMenu);
                }
            }

            return vmList;
        }

        /// <summary>
        /// 通过 UserID 获取权限拥有树列表（2022-6-28 lxj修正）
        /// </summary>
        public List<Model.MenuAuthHaveTree> GetMenuAuthHaveTreeList(long UserID, string SoftType, string SoftTag)
        {
            //获取用户
            var user = new User().GetByID(UserID);
            if (user == null)
                return default;

            //加载菜单列表
            var menuList = new Menu().GetBySoft(SoftType, SoftTag);
            if (menuList == null || menuList.Count < 1)
                return default;

            //遍历菜单
            var vmMenuList = new List<Model.MenuAuthHaveTree>();
            foreach (var menu in menuList)
            {
                var vmMenu = new Model.MenuAuthHaveTree(menu);
                vmMenu.AuthLevel =Model.eAuthLevel.ReadOnly;
                vmMenu.Have = false;
                vmMenu.Children = new List<Model.MenuAuthHaveTree>();
                vmMenuList.Add(vmMenu);
            }

            var vmList = new List<Model.MenuAuthHaveTree>();

            //超级管理员通道
            if (user.IsAdmin)
            {
                vmMenuList.ForEach(x =>
                {
                    x.AuthLevel = Model.eAuthLevel.All;
                    x.Have = true;
                });

                foreach (var menu in menuList)
                {
                    var vmMenu = vmMenuList.Find(x => x.MenuID == menu.ID);
                    if ( menu.ParentIds.Count > 0)
                    {
                        var vmParentMenu = vmMenuList.Find(x => x.MenuID == menu.ParentIds.Last());
                        vmParentMenu.Children.Add(vmMenu);
                    }
                    else
                    {
                        vmList.Add(vmMenu);
                    }
                }

                return vmList;
            }

            //获取权限项集合
            var authItems = GetMenuAuthItemList(UserID);
            if (authItems != null && authItems.Count > 0)
            {
                vmMenuList.ForEach(x =>
                {
                    var menuHaveItem = authItems.Find(t => t.MenuID==x.MenuID);
                    if (menuHaveItem != null)
                    {
                        x.Have = true;
                        x.AuthLevel = menuHaveItem.AuthLevel;
                    }
                });
            }

            //建立菜单树形结构并检查权限等级
            foreach (var menu in menuList)
            {
                var vmMenu = vmMenuList.Find(x => x.MenuID == menu.ID);
                if (menu.ParentIds.Count > 0)
                {
                    var vmParentMenu = vmMenuList.Find(x => x.MenuID == menu.ParentIds.Last());
                    vmParentMenu.Children.Add(vmMenu);
                    if (!vmParentMenu.Have)
                    {
                        vmMenu.Have = false;
                    }
                    if (vmParentMenu.AuthLevel == Model.eAuthLevel.ReadOnly)
                    {
                        vmMenu.AuthLevel = Model.eAuthLevel.ReadOnly;
                    }
                }
                else
                {
                    vmList.Add(vmMenu);
                }
            }

            return vmList;
        }

        #endregion

        #region 下发权限

        /// <summary>
        /// 下发角色权限
        /// </summary>
        public Model.eAuthorizeStatus Authorize(long userId, IEnumerable<Model.RoleMenuSelected> authItems)
        {
            #region 验证数据

            if (authItems == null || authItems.Count() < 1)
            {
                return Model.eAuthorizeStatus.Error;
            }

            var roleAuthItems = authItems.ToList();
            var roleAuthItems_none = roleAuthItems.Where(x => !x.Selected).ToList();
            var roleAuthItems_selected = roleAuthItems.Where(x => x.Selected).ToList();

            #endregion

            #region 验证用户

            var service_user = new User();
            var currentUser = service_user.GetByID(userId);
            if (currentUser == null)
            {
                return Model.eAuthorizeStatus.UserIsNotExist;
            }
            if (currentUser.UseStatus == Model.eUseStatus.Disable)
            {
                return Model.eAuthorizeStatus.UserIsStopped;
            }
            if (!service_user.VerifyCreateUseStatus(userId))
            {
                return Model.eAuthorizeStatus.ParentUserIsStopped;
            }

            #endregion

            #region 验证角色

            var service_role = new Role();
            var roleIds_input = roleAuthItems.Select(x => x.RoleID).Distinct().ToList();
            var roles_input = service_role.GetByIds(roleIds_input);
            if (roles_input == null || roles_input.Count < 1)
            {
                return Model.eAuthorizeStatus.Error;
            }
            var createUserIds_input = roles_input.Select(x => x.CreateUserID).Distinct().ToList();
            if (createUserIds_input.Count != 1)
            {
                return Model.eAuthorizeStatus.Error;
            }
            if (createUserIds_input[0] != userId)
            {
                return Model.eAuthorizeStatus.Error;
            }

            #endregion

            #region 验证权限变动

            //当前用户创建的角色拥有的权限
            var roleAuth_current_list = new List<Model.RoleMenuPure>();

            //当前用户创建的角色
            var role_current_list = service_role.GetByCreateUserID(userId);
            if (role_current_list == null || role_current_list.Count < 1)
            {
                return Model.eAuthorizeStatus.Error;
            }

            //当前用户创建的角色已经拥有的权限
            var service_role_auth = new RoleMenuMapping();
            var role_auth_current_list = service_role_auth.GetByRoleIds(role_current_list.Select(x => x.ID).ToList());

            //当前用户创建的角色不拥有权限
            if (role_auth_current_list == null || role_auth_current_list.Count < 1)
            {
                if (roleAuthItems_selected.Count < 1)
                {
                    return Model.eAuthorizeStatus.Success;
                }
                roleAuth_current_list.AddRange(roleAuthItems_selected.Select(x => new Model.RoleMenuPure(x)));
            }
            //当前用户创建的角色拥有部分权限
            else
            {
                //存在取消角色权限
                if (roleAuthItems_none.Count > 0)
                {
                    //取消的角色权限都不在已有权限中
                    if (!roleAuthItems_none.Exists(x => role_auth_current_list.Exists(t => t.RoleID == x.RoleID && t.MenuID == x.MenuID )))
                    {
                        if (roleAuthItems_selected.Count < 1)
                        {
                            return Model.eAuthorizeStatus.Success;
                        }
                        else
                        {
                            //新增的权限都在已有的权限中
                            if (!roleAuthItems_selected.Exists(x => !role_auth_current_list.Exists(t => t.RoleID == x.RoleID && t.MenuID == x.MenuID && t.AuthLevel == x.AuthLevel)))
                            {
                                return Model.eAuthorizeStatus.Success;
                            }
                        }
                    }
                }
                //不存在取消角色权限
                else
                {
                    //新增的权限都在已有的角色权限中
                    if (!roleAuthItems_selected.Exists(x => !role_auth_current_list.Exists(t => t.RoleID == x.RoleID && t.MenuID == x.MenuID && t.AuthLevel == x.AuthLevel)))
                    {
                        return Model.eAuthorizeStatus.Success;
                    }
                }

                //初始化当前用户创建的角色所拥有的权限      
                roleAuth_current_list.AddRange(role_auth_current_list.Select(x => new Model.RoleMenuPure(x.RoleID, x.MenuID, x.AuthLevel)));
                if (roleAuthItems_none.Count > 0)
                {
                    roleAuth_current_list.RemoveAll(x => roleAuthItems_none.Exists(t => t.RoleID == x.RoleID && t.MenuID == x.MenuID ));
                }
                if (roleAuthItems_selected.Count > 0)
                {
                    foreach (var roleAuthItem_selected in roleAuthItems_selected)
                    {
                        var roleAuth_current = roleAuth_current_list.Find(x => x.RoleID == roleAuthItem_selected.RoleID && x.MenuID == roleAuthItem_selected.MenuID );
                        if (roleAuth_current == null)
                        {
                            roleAuth_current = new Model.RoleMenuPure(roleAuthItem_selected);
                            roleAuth_current_list.Add(roleAuth_current);
                        }
                        else
                        {
                            if (roleAuth_current.AuthLevel > roleAuthItem_selected.AuthLevel)
                            {
                                roleAuth_current.AuthLevel = roleAuthItem_selected.AuthLevel;
                            }
                        }
                    }
                }
            }


            #endregion

            #region 验证自身权限

            if (!currentUser.IsAdmin)
            {
                var selfAuthItems = GetMenuAuthItemList(userId);
                if (selfAuthItems == null || selfAuthItems.Count < 1)
                {
                    if (roleAuthItems.Exists(x => x.Selected))
                    {
                        return Model.eAuthorizeStatus.MissingPremission;
                    }
                }
                var selfAllAuthItems = selfAuthItems.Where(x => x.AuthLevel == Model.eAuthLevel.All).ToList();
                if (selfAllAuthItems.Count < 1)
                {
                    if (roleAuthItems.Exists(x => x.Selected))
                    {
                        return Model.eAuthorizeStatus.MissingPremission;
                    }
                }
                if (roleAuthItems.Exists(x => (x.Selected) && (!selfAllAuthItems.Exists(t => t.MenuID == x.MenuID))))
                {
                    return Model.eAuthorizeStatus.MissingPremission;
                }
            }

            #endregion

            #region 权限回收

            var roleAuth_expire_list = GetInvalidRoleAuth(userId, roleAuth_current_list, service_user, service_role, service_role_auth);
            if (roleAuth_expire_list != null && roleAuth_expire_list.Count > 0)
            {
                roleAuthItems.AddRange(roleAuth_expire_list.Select(x => new Model.RoleMenuSelected(x,false) ));
            }

            #endregion

            #region 权限下发

            var bol = service_role_auth.Set(roleAuthItems);
            if (!bol)
            {
                return Model.eAuthorizeStatus.Error;
            }

            #endregion

            return Model.eAuthorizeStatus.Success;
        }

        //获取失效角色权限
        private List<Model.RoleMenuPure> GetInvalidRoleAuth
            (
                long currentUserId,//当前用户标识
                List<Model.RoleMenuPure> currentRoleAuthList,//当前用户创建的角色所拥有的权限
                User service_user,//用户服务
                Role service_role,//角色服务
                RoleMenuMapping service_role_auth//角色授权服务
            )
        {
            //初始化
            if (currentRoleAuthList == null)
                currentRoleAuthList = new List<Model.RoleMenuPure>();
            var roleAuth_expire_list = new List<Model.RoleMenuPure>();

            //获取创建的用户列表
            var user_list = service_user.GetByCreateUserID(currentUserId);
            if (user_list == null || user_list.Count < 1)
            {
                return roleAuth_expire_list;
            }

            //遍历创建的用户列表
            foreach (var user in user_list)
            {
                var role_create_list = service_role.GetByCreateUserID(user.ID);
                if (role_create_list != null && role_create_list.Count > 0)
                {
                    var role_auth_create_list = service_role_auth.GetByRoleIds(role_create_list.Select(x => x.ID).ToList());
                    if (role_auth_create_list != null && role_auth_create_list.Count > 0)
                    {
                        //获取角色权限列表
                        var roleAuth_list = new List<Model.RoleMenuPure>();
                        var role_relation_list = service_role.GetRelationByUserID(user.ID);
                        if (role_relation_list != null && role_relation_list.Count > 0)
                        {
                            var roleId_relation_list = role_relation_list.Select(x => x.ID).Distinct().ToList();
                            roleAuth_list = currentRoleAuthList.Where(x => roleId_relation_list.Contains(x.RoleID)).ToList();
                        }

                        //创建角色拥有的角色权限
                        var roleAuth_create_list = new List<Model.RoleMenuPure>();
                        foreach (var role_auth_create in role_auth_create_list)
                        {
                            var roleAuth = new Model.RoleMenuPure() { 
                                RoleID=role_auth_create.RoleID,
                                MenuID=role_auth_create.MenuID,
                                AuthLevel=role_auth_create.AuthLevel
                            };
                            if (!roleAuth_list.Exists(x => x.AuthLevel == Model.eAuthLevel.All && x.MenuID == roleAuth.MenuID))
                            {
                                roleAuth_expire_list.Add(roleAuth);
                                continue;
                            }
                            roleAuth_create_list.Add(roleAuth);
                        }
                        roleAuth_expire_list.AddRange(GetInvalidRoleAuth(user.ID, roleAuth_create_list, service_user, service_role, service_role_auth));
                    }
                }
            }
            return roleAuth_expire_list;
        }

        #endregion







    }
}