tede/gx_api/GxPress/Service/GxPress.Service.Implement/Role/RoleService.cs

using GxPress.Repository.Interface.SystemRoleMenus;
using GxPress.Service.Interface.Role;
using GxPress.Repository.Interface.SystemRole;
using GxPress.Repository.Interface.Menus;
using System.Threading.Tasks;
using GxPress.Request.Role;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using AutoMapper;
using GxPress.Request.Menu;

namespace GxPress.Service.Implement.Role
{
    public class RoleService : IRoleService
    {
        private readonly ISystemRoleMenusRepository systemRoleMenusRepository;
        private readonly IMenusRepository menusRepository;

        private readonly ISystemRoleRepository systemRoleRepository;

        private readonly IMapper _mapper;
        public RoleService(ISystemRoleMenusRepository systemRoleMenusRepository, IMenusRepository menusRepository, ISystemRoleRepository systemRoleRepository, IMapper _mapper)
        {
            this.systemRoleRepository = systemRoleRepository;
            this.systemRoleMenusRepository = systemRoleMenusRepository;
            this.menusRepository = menusRepository;
            this._mapper = _mapper;
        }
        /// <summary>
        /// 添加权限菜单关联
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        public async Task<bool> InsertSystemRoleMenusAsync(SystemRoleMenusInRequest models)
        {
            return await systemRoleMenusRepository.InsertAsync(models);
        }

        /// <summary>
        /// 添加权限
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        public async Task<bool> InsertSystemRoleAsync(Entity.SystemRole.SystemRole model)
        {
            return await systemRoleRepository.InsertAsync(model) > 0;
        }

        public async Task<IEnumerable<Entity.SystemRole.SystemRole>> GetSystemRoleAllAsync()
        {
            return await systemRoleRepository.GetSystemRolesAllAsync();
        }
        /// <summary>
        /// 修改权限
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> UpdateSystemRoleAsync(Entity.SystemRole.SystemRole model)
        {
            return await systemRoleRepository.UpdateAsync(model);
        }
        /// <summary>
        /// 删除权限
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<bool> DeleteSystemRoleAsync(int id)
        {
            return await systemRoleRepository.DeleteAsync(id);
        }
        /// <summary>
        /// 添加菜单
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        public async Task<bool> InsertMenusAsync(Entity.Menus.Menus model)
        {
            return await menusRepository.InsertAsync(model) > 0;
        }

        /// <summary>
        /// 添加菜单
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        public async Task<bool> InsertMenusAsync(List<MenuInRequest> models)
        {
            try
            {
                using (var transactionScope = new TransactionScope())
                {
                    foreach (var item in models)
                    {
                        var menuEntity = new Entity.Menus.Menus()
                        {
                            Icon = item.Icon,
                            Name = item.Name,
                            ParentId = item.ParentId,
                            Path = item.Path,
                            Title = item.Title
                        };
                        var id = await menusRepository.InsertAsync(menuEntity);
                        if (item.Children == null)
                            continue;
                        foreach (var menu in item.Children)
                        {
                            menuEntity = new Entity.Menus.Menus()
                            {
                                Icon = menu.Icon,
                                Name = menu.Name,
                                ParentId = id,
                                Path = menu.Path,
                                Title = menu.Title
                            };
                            await menusRepository.InsertAsync(menuEntity);
                        }
                    }
                    transactionScope.Complete();
                }
            }
            catch (System.Exception ex)
            {
                throw new Common.Exceptions.BusinessException(ex.Message);
            }
            return true;
        }
        /// <summary>
        /// 修改菜单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> UpdateMenusAsync(Entity.Menus.Menus model)
        {
            return await menusRepository.UpdateAsync(model);
        }
        /// <summary>
        /// 删除菜单
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<bool> DeleteMenusAsync(int id)
        {
            return await menusRepository.DeleteAsync(id);
        }
        /// <summary>
        /// 根据权限ID获取菜单
        /// </summary>
        /// <param name="roleId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<Entity.Menus.Menus>> GetMenusAllAsync(int roleId)
        {
            //获取
            var models = await systemRoleMenusRepository.GetAllAsync(roleId);

            return await menusRepository.GetAllAsync(models.Select(n => n.Id).ToList());
        }

        /// <summary>
        /// 获取所有菜单
        /// </summary>
        /// <param name="roleId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<Entity.Menus.Menus>> GetMenusAllAsync()
        {
            return await menusRepository.GetAllAsync();
        }
    }
}