QRAPI/API/Wood.Service/SystemManage/RoleService.cs

using Mapster;
using SqlSugar;
using Wood.Data.Repository;
using Wood.Entity;
using Wood.Entity.SystemManage;
using Wood.Service.BaseService;
using Wood.Service.SystemManage.Dto;
using Wood.Service.SystemManage.Param;
using Wood.Util;

namespace Wood.Service.SystemManage
{
	/// <summary>
	/// 角色管理
	/// </summary>
	public class RoleService : ApiService
	{
		private readonly SqlSugarRepository<RoleEntity> _roleRepository;
		private readonly SqlSugarRepository<MenuAuthorizeEntity> _menuAuthorizeRepository;
		private readonly SqlSugarRepository<RoleDataScopeEntity> _roleDataScopeRepository;
		private readonly SqlSugarRepository<UserBelongRoleEntity> _userBelongRoleRepository;
		public RoleService(SqlSugarRepository<RoleEntity> roleRepository, SqlSugarRepository<MenuAuthorizeEntity> menuAuthorizeRepository, SqlSugarRepository<RoleDataScopeEntity> roleDataScopeRepository, SqlSugarRepository<UserBelongRoleEntity> userBelongRoleRepository)
		{
			_roleRepository = roleRepository;
			_menuAuthorizeRepository = menuAuthorizeRepository;
			_roleDataScopeRepository = roleDataScopeRepository;
			_userBelongRoleRepository = userBelongRoleRepository;
		}

		public async Task<TDataPaged<RolePagedDto>> Paged(RolePagedParam param)
		{
			return await _roleRepository.AsQueryable()
				.WhereIF(!string.IsNullOrEmpty(param.Name), it => it.RoleName.Contains(param.Name!) || it.FormCode.Contains(param.Name!))
				.Select(it => new RolePagedDto()
				{
					Id = it.Id.SelectAll()
				})
				.ToPagedListAsync(param);
		}

		/// <summary>
		/// 获取角色信息列表用于选择
		/// </summary>
		/// <returns></returns>
		public async Task<List<ElSelectDto>> SelectList()
		{
			return await _roleRepository.AsQueryable()
				.Where(it => it.Status == 1)
				.Select(it => new ElSelectDto()
				{
					Label = it.RoleName,
					Disabled = false,
					Value = it.Id.ToString()
				}).ToListAsync();
		}

		public async Task<RoleDetailDto> GetDetail(BaseIdParam param)
		{
			var entity = await _roleRepository.GetByIdAsync(param.Id);
			var dto = entity.Adapt<RoleDetailDto>();

			dto.Menus = await _menuAuthorizeRepository.AsQueryable()
				.LeftJoin<MenuEntity>((it,me)=>it.MenuId==me.Id)
				.Where((it,me) => it.RoleId == param.Id&&me.MenuType!=MenuTypeEnum.Button).Select(it => it.MenuId).ToListAsync();

			dto.Btns = await _menuAuthorizeRepository.AsQueryable()
				.LeftJoin<MenuEntity>((it, me) => it.MenuId == me.Id)
				.Where((it, me) => it.RoleId == param.Id && me.MenuType == MenuTypeEnum.Button).Select(it => it.MenuId).ToListAsync();

			dto.Orgs = await _roleDataScopeRepository.AsQueryable().Where(it => it.RoleId == param.Id).Select(it => it.OrgId).ToListAsync();
			return dto;
		}

		public async Task<int> GetMaxSort()
		{
			var result = await _roleRepository.AsQueryable().MaxAsync(it => it.Sort);
			return result + 10;
		}

		[UnitOfWork]
		public async Task Add(RoleAddParam entity)
		{
			await _roleRepository.InsertAsync(entity.Adapt<RoleEntity>());

			await _menuAuthorizeRepository.InsertRangeAsync(
				entity.Menus.Select(it => new MenuAuthorizeEntity() { RoleId = entity.Id, MenuId = it }).ToList()
				);
		}

		[UnitOfWork]
		public async Task Update(RoleUpdateParam entity)
		{
			await _roleRepository.UpdateAsync(entity.Adapt<RoleEntity>());
			await _menuAuthorizeRepository.DeleteAsync(it => it.RoleId == entity.Id);
			await _menuAuthorizeRepository.InsertRangeAsync(
				entity.Menus.Select(it => new MenuAuthorizeEntity() { RoleId = entity.Id, MenuId = it }).ToList()
				);
		}
		/// <summary>
		/// 更新数据权限
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		[UnitOfWork]
		public async Task UpdateRoleDataType(RoleUpdateDataTypeParam param)
		{
			var role = await _roleRepository.GetByIdAsync(param.Id);
			role.DataScopeType = param.DataScopeType;
			await _roleRepository.UpdateAsync(role);
			await _roleDataScopeRepository.DeleteAsync(it => it.RoleId == param.Id);
			if (role.DataScopeType == DataScopeTypeEnum.Custom)
			{
				var scopeList = param.Orgs.Select(it => new RoleDataScopeEntity() { OrgId = it, RoleId = param.Id }).ToList();

				await _roleDataScopeRepository.InsertRangeAsync(scopeList);
			}
		}

		/// <summary>
		/// 删除角色
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		[UnitOfWork]
		public async Task Delete(BaseIdListParam param)
		{
			//删除角色信息
			await _roleRepository.DeleteAsync(it => param.Ids.Contains(it.Id));
			//删除角色授权菜单信息
			await _menuAuthorizeRepository.DeleteAsync(it => param.Ids.Contains(it.RoleId));
			//删除角色数据范围信息
			await _roleDataScopeRepository.DeleteAsync(it => param.Ids.Contains(it.RoleId));
			//删除用户角色信息
			await _userBelongRoleRepository.DeleteAsync(it => param.Ids.Contains(it.RoleId));
		}

		#region 私有方法

		#endregion
	}
}