EasyFramework/modules/Easy.AuthorityManagement.Api/Clean/Application/IdentityRoleAppService.cs

using Easy.AuthorityManagement.Clean.Contracts.Inputs;
using Easy.AuthorityManagement.Clean.Contracts.Models;
using Easy.AuthorityManagement.Clean.Domain.Entities;
using Easy.AuthorityManagement.Clean.Shared.IServices;
using Easy.AuthorityManagement.Clean.Shared.Modles;

namespace Easy.AuthorityManagement.Clean.Application;

public class IdentityRoleAppService : ApiService
{
    protected IRepository<IdentityRole> IdentityRoleRepository => LazyServiceProvider.LazyGetService<IRepository<IdentityRole>>();
    protected IRepository<PermissionGrant> PermissionGrantRepository => LazyServiceProvider.LazyGetService<IRepository<PermissionGrant>>();
    protected IPermissionGrantManager PermissionGrantManager => LazyServiceProvider.LazyGetService<IPermissionGrantManager>();
    protected IMapper Mapper => LazyServiceProvider.LazyGetService<IMapper>();
    protected IIdentityRoleManager IdentityRoleManager => LazyServiceProvider.LazyGetService<IIdentityRoleManager>();


    public virtual async Task<ApiResultValue<IdentityRoleModel>> CreateAsync(IdentityRoleCreateInput input)
    {
        var identityRole = await IdentityRoleManager.CreateAsync(input.RoleName, input.TenantId);

        Mapper.Map(input, identityRole);

        await IdentityRoleRepository.Set.AddAsync(identityRole);
        await IdentityRoleRepository.SaveChangesAsync();
        var value = Mapper.Map<IdentityRoleModel>(identityRole);

        return ApiResult.ValueSuccess(value);
    }
    public virtual async Task<ApiResult> DeleteAsync(long id)
    {
        var tenant = await IdentityRoleRepository.Set.FirstOrDefaultAsync(o => o.Id == id);
        if (tenant != null)
        {
            IdentityRoleRepository.Set.Remove(tenant);
            await IdentityRoleRepository.SaveChangesAsync();
        }

        return ApiResult.Success();
    }
    public virtual async Task<ApiResultValue<IdentityRoleModel>> UpdateAsync(long id, IdentityRoleUpdateInput input)
    {
        var tenant = await IdentityRoleRepository.Set.FirstOrDefaultAsync(o => o.Id == id);

        When.Is(tenant == null, "此租户不存在");

        await IdentityRoleManager.ChangeNameAsync(tenant, input.RoleName);

        Mapper.Map(input, tenant);

        IdentityRoleRepository.Set.Update(tenant);
        await IdentityRoleRepository.SaveChangesAsync();

        var value = Mapper.Map<IdentityRoleModel>(tenant);

        return ApiResult.ValueSuccess(value);
    }

    /// <summary>
    /// 获得角色
    /// </summary>
    public virtual async Task<ApiResultValue<IdentityRoleModel>> GetAsync(long id)
    {
        var tenant = await IdentityRoleRepository.Set.FirstOrDefaultAsync(o => o.Id == id);

        var value = Mapper.Map<IdentityRoleModel>(tenant);

        return ApiResult.ValueSuccess(value);
    }
    public async Task<ApiResultPaged<IdentityRoleModel>> GetListAsync(GetIdentityRolesInput input)
    {
        var tenants = await IdentityRoleRepository.Set.ApplyPaging(input.PageIndex, input.PageSize).ToListAsync();

        var paged = Paged.Create(await IdentityRoleRepository.Set.CountAsync(), input);

        var valuePaged = Mapper.Map<List<IdentityRoleModel>>(tenants);

        return ApiResult.ValuesPagedSuccess(paged, valuePaged);
    }

    /// <summary>
    /// 获得许可信息 
    /// </summary>
    public virtual async Task<ApiResultValues<PermissionGroupModel>> GetPermissionGrantsAsync(long id)
    {
        return ApiResult.Values(await PermissionGrantManager.GetPermissionGrantsAsync("R", id));
    }
}