王明 / Food-Labeling-Management-Platform

  using FoodLabeling.Application.Contracts.Dtos.RbacRole;

  using FoodLabeling.Application.Helpers;

  using FoodLabeling.Application.Contracts.Dtos.Common;
  using FoodLabeling.Application.Contracts.IServices;

  using FoodLabeling.Application.Services.DbModels;

  using Microsoft.AspNetCore.Mvc;
  using SqlSugar;
  using Volo.Abp;
  using Volo.Abp.Application.Services;
  using Volo.Abp.Domain.Entities;
  using Volo.Abp.Uow;
  using Yi.Framework.Rbac.Domain.Entities;
  using Yi.Framework.SqlSugarCore.Abstractions;
  
  namespace FoodLabeling.Application.Services;
  
  /// <summary>
  /// 角色管理（食品标签-美国版对外）
  /// </summary>
  public class RbacRoleAppService : ApplicationService, IRbacRoleAppService
  {

      private readonly ISqlSugarDbContext _dbContext;

      private readonly ISqlSugarRepository<RoleAggregateRoot, Guid> _roleRepository;
      private readonly ISqlSugarRepository<RoleMenuEntity> _roleMenuRepository;
      private readonly ISqlSugarRepository<RoleDeptEntity> _roleDeptRepository;
      private readonly ISqlSugarRepository<UserRoleEntity> _userRoleRepository;
  
      public RbacRoleAppService(

          ISqlSugarDbContext dbContext,

          ISqlSugarRepository<RoleAggregateRoot, Guid> roleRepository,
          ISqlSugarRepository<RoleMenuEntity> roleMenuRepository,
          ISqlSugarRepository<RoleDeptEntity> roleDeptRepository,
          ISqlSugarRepository<UserRoleEntity> userRoleRepository)
      {

          _dbContext = dbContext;

          _roleRepository = roleRepository;
          _roleMenuRepository = roleMenuRepository;
          _roleDeptRepository = roleDeptRepository;
          _userRoleRepository = userRoleRepository;
      }
  
      /// <inheritdoc />
      public async Task<PagedResultWithPageDto<RbacRoleGetListOutputDto>> GetListAsync([FromQuery] RbacRoleGetListInputVo input)
      {
          RefAsync<int> total = 0;
  
          var query = _roleRepository._DbQueryable
              .Where(x => x.IsDeleted == false)
              .WhereIF(!string.IsNullOrWhiteSpace(input.RoleCode), x => x.RoleCode.Contains(input.RoleCode!.Trim()))
              .WhereIF(!string.IsNullOrWhiteSpace(input.RoleName), x => x.RoleName.Contains(input.RoleName!.Trim()))
              .WhereIF(input.State is not null, x => x.State == input.State);
  
          if (!string.IsNullOrWhiteSpace(input.Sorting))
          {
              query = query.OrderBy(input.Sorting);
          }
          else
          {
              query = query.OrderBy(x => x.OrderNum, OrderByType.Desc);
          }
  
          var entities = await query.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
  
          var items = entities.Select(x => new RbacRoleGetListOutputDto
          {
              Id = x.Id,
              RoleName = x.RoleName ?? string.Empty,
              RoleCode = x.RoleCode ?? string.Empty,
              Remark = x.Remark,
              DataScope = (int)x.DataScope,
              State = x.State,
              OrderNum = x.OrderNum
          }).ToList();
  
          var pageSize = input.MaxResultCount <= 0 ? items.Count : input.MaxResultCount;

          var pageIndex = pageSize <= 0 ? 1 : PagedQueryConvention.PageIndexFromSkipCount(input.SkipCount);

          var totalPages = pageSize <= 0 ? 0 : (int)Math.Ceiling(total / (double)pageSize);
  
          return new PagedResultWithPageDto<RbacRoleGetListOutputDto>
          {
              PageIndex = pageIndex,
              PageSize = pageSize,
              TotalCount = total,
              TotalPages = totalPages,
              Items = items
          };
      }
  
      /// <inheritdoc />
      public async Task<RbacRoleGetOutputDto> GetAsync(Guid id)
      {
          var entity = await _roleRepository.GetSingleAsync(x => x.Id == id && x.IsDeleted == false);
          if (entity is null)
          {
              throw new UserFriendlyException("角色不存在");
          }
  

          var menuIds = await _dbContext.SqlSugarClient.Queryable<RoleMenuDbEntity>()
              .Where(x => x.RoleId == id.ToString())
              .Select(x => x.MenuId)
              .ToListAsync();
  

          return new RbacRoleGetOutputDto
          {
              Id = entity.Id,
              RoleName = entity.RoleName ?? string.Empty,
              RoleCode = entity.RoleCode ?? string.Empty,
              Remark = entity.Remark,
              DataScope = (int)entity.DataScope,
              State = entity.State,

              OrderNum = entity.OrderNum,
              MenuIds = menuIds

          };
      }
  
      /// <inheritdoc />
      public async Task<RbacRoleGetOutputDto> CreateAsync([FromBody] RbacRoleCreateInputVo input)
      {
          var roleName = input.RoleName?.Trim();
          var roleCode = input.RoleCode?.Trim();
          if (string.IsNullOrWhiteSpace(roleName))
          {
              throw new UserFriendlyException("角色名称不能为空");
          }
  
          if (string.IsNullOrWhiteSpace(roleCode))
          {
              throw new UserFriendlyException("角色编码不能为空");
          }
  
          var isExist = await _roleRepository.IsAnyAsync(x => x.RoleCode == roleCode || x.RoleName == roleName);
          if (isExist)
          {
              throw new UserFriendlyException("角色名称或编码已存在");
          }
  
          var entity = new RoleAggregateRoot
          {
              RoleName = roleName,
              RoleCode = roleCode,
              Remark = input.Remark?.Trim(),
              DataScope = (Yi.Framework.Rbac.Domain.Shared.Enums.DataScopeEnum)input.DataScope,
              State = input.State,
              OrderNum = input.OrderNum
          };
          EntityHelper.TrySetId(entity, () => GuidGenerator.Create());
  
          await _roleRepository.InsertAsync(entity);
  
          return await GetAsync(entity.Id);
      }
  
      /// <inheritdoc />
      public async Task<RbacRoleGetOutputDto> UpdateAsync(Guid id, [FromBody] RbacRoleUpdateInputVo input)
      {
          var entity = await _roleRepository.GetSingleAsync(x => x.Id == id && x.IsDeleted == false);
          if (entity is null)
          {
              throw new UserFriendlyException("角色不存在");
          }
  
          var roleName = input.RoleName?.Trim();
          var roleCode = input.RoleCode?.Trim();
          if (string.IsNullOrWhiteSpace(roleName))
          {
              throw new UserFriendlyException("角色名称不能为空");
          }
  
          if (string.IsNullOrWhiteSpace(roleCode))
          {
              throw new UserFriendlyException("角色编码不能为空");
          }
  
          var isExist = await _roleRepository._DbQueryable
              .Where(x => x.Id != entity.Id && x.IsDeleted == false)
              .AnyAsync(x => x.RoleCode == roleCode || x.RoleName == roleName);
          if (isExist)
          {
              throw new UserFriendlyException("角色名称或编码已存在");
          }
  
          entity.RoleName = roleName;
          entity.RoleCode = roleCode;
          entity.Remark = input.Remark?.Trim();
          entity.DataScope = (Yi.Framework.Rbac.Domain.Shared.Enums.DataScopeEnum)input.DataScope;
          entity.State = input.State;
          entity.OrderNum = input.OrderNum;
  
          await _roleRepository.UpdateAsync(entity);
  
          return await GetAsync(entity.Id);
      }
  
      /// <inheritdoc />
      [UnitOfWork]
      public async Task DeleteAsync([FromBody] List<Guid> ids)
      {
          var idList = ids?.Distinct().ToList() ?? new List<Guid>();
          if (idList.Count == 0)
          {
              return;
          }
  
          await _roleMenuRepository.DeleteAsync(x => idList.Contains(x.RoleId));
          await _roleDeptRepository.DeleteAsync(x => idList.Contains(x.RoleId));
          await _userRoleRepository.DeleteAsync(x => idList.Contains(x.RoleId));
  
          // 角色表为软删（ISoftDelete）
          await _roleRepository.DeleteAsync(x => idList.Contains(x.Id));
      }
  }