Puedes utilizar la clase de .NET OperationAuthorizationRequirement la cual nos facilita registrar todos los posibles permisos que maneja tu aplicación. Creamos una clase Operaciones en nuestra carpeta Core y agregamos los tipos de permisos que manejará nuestra aplicación.
Operaciones.cs
public static class Operaciones
{
public static OperationAuthorizationRequirement Crear = new
OperationAuthorizationRequirement
{ Name = "Crear" };
public static OperationAuthorizationRequirement Modificar = new
OperationAuthorizationRequirement
{ Name = "Modificar" };
public static OperationAuthorizationRequirement Borrar = new
OperationAuthorizationRequirement
{ Name = "Borrar" };
public static OperationAuthorizationRequirement Consultar = new
OperationAuthorizationRequirement
{ Name = "Consultar" };
}
Creamos una clase PermisoDTO el cual nos indica que tabla deseamos validar, y también indicamos una variable SoloAdministradores en el cual si esta en true esta tabla sólo es accesible a los usuarios con el rol de Administrador.
PermisoDTO.cs
namespace CaducaRest.DTO;
/// <summary>
/// Permite validar los permisos de cada servicio
/// </summary>
public class PermisoDTO
{
/// <summary>
/// Nombre de la tabla a validar
/// </summary>
public string Tabla { get; set; }
/// <summary>
/// Si esta en true se requiere permiso de Administrador
/// </summary>
public bool EsAdministrador { get; set; } = false;
}
Creamos nuestra clase RolTablaPermisoDAO la cual nos va a ayudar a validar que el usuario tenga acceso a la tabla de acuerdo a su rol, para la operación a realizar
RolTablaPermisoDAO.cs
using System.Linq;
using CaducaRest.Models;
using CaducaRest.Resources;
namespace CaducaRest.DAO;
public class TablaRolPermisoDAO
{
private readonly CaducaContext contexto;
private readonly LocService localizacion;
public TablaRolPermisoDAO(CaducaContext context, LocService localize)
{
this.contexto = context;
this.localizacion = localize;
}
public bool TienePermiso(int usuarioId, string tabla,
string operacion)
{
var test= from Tabla in contexto.Tabla select Tabla.Nombre;
var permiso = (from Tabla in contexto.Tabla
join TablaPermiso in contexto.TablaPermiso
on Tabla.Id equals TablaPermiso.TablaId
join Permiso in contexto.Permiso
on TablaPermiso.PermisoId equals Permiso.Id
join RolTablaPermiso in contexto.RolTablaPermiso
on TablaPermiso.Id equals RolTablaPermiso.TablaPermisoId
join UsuarioRol in contexto.UsuarioRol
on RolTablaPermiso.RolId equals UsuarioRol.RolId
where Tabla.Nombre == tabla
&& Permiso.Nombre == operacion
&& UsuarioRol.UsuarioId == usuarioId
&& RolTablaPermiso.TienePermiso
select RolTablaPermiso.Id).FirstOrDefault();
return permiso>0;
}
}
Para nuestras reglas personalizadas es necesario crear una clase que herede de AuthorizationHandler, la cual recibe como objetos genéricos un objeto de la clase OperationAuthorizationRequirement y cualquier otro dato adicional en nuestro caso es nuestra clase PermisoDTO. Agregamos una clase llamada PermisoEditHandler en nuestra carpeta Core
PermisoEditHandler.cs
using System;
using System.Security.Claims;
using System.Threading.Tasks;
using CaducaRest.DTO;
using CaducaRest.Models;
using CaducaRest.DAO;
using CaducaRest.Resources;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization.Infrastructure;
namespace CaducaRest.Core
{
public class PermisoEditHandler : AuthorizationHandler
<OperationAuthorizationRequirement, PermisoDTO>
{
private readonly CaducaContext contexto;
private readonly LocService _localizer;
public PermisoEditHandler(CaducaContext context,
LocService localizer)
{
contexto = context;
_localizer = localizer;
}
protected override Task HandleRequirementAsync(
AuthorizationHandlerContext context,
OperationAuthorizationRequirement operacion,
PermisoDTO recurso)
{
var usuarioId = Convert.ToInt32(context.User
.FindFirst(c => c.Type == ClaimTypes.Sid).Value);
//Se revisa si en el token se incluye el claim con el
// id del usuario
if (!context.User.HasClaim(c => c.Type == ClaimTypes.Sid))
context.Fail();
RolDAO rolDAO = new RolDAO(contexto, _localizer);
bool esAdministrador = rolDAO.EsAdministrador(usuarioId);
//Si el recurso requiere un usuario administrador
// se valida que el usuario sea de tipo administrador
// si no es asi, mandar error
if (recurso.RequiereAdministrador && !esAdministrador)
context.Fail();
else
{
if (!esAdministrador)
{
//Se revisa si el usuario tiene autorización para realizar la acción
RolTablaPermisoDAO rolTablaPermisoDAO = new RolTablaPermisoDAO(contexto, _localizer);
if (!rolTablaPermisoDAO.TienePermiso(usuarioId, recurso.Tabla, operacion.Name))
context.Fail();
else
context.Succeed(operacion);
}
context.Succeed(operacion);
}
return Task.CompletedTask;
}
}
}
En nuestro archivo CategoriasController agregamos un objeto de la clase PermisoDTO indicando la tabla Categoria, y le indicamos que este servicio no requiere de un usuario Administrador.
Agregamos al archivo de recursos los siguientes mensajes de error:
Clave
Valor
ForbiddenUpdate
No tienes permiso para actualizar {0}. Por favor solicita el acceso.
ForbiddenAdd
No tienes permiso para agregar {0}. Por favor solicita el acceso.
ForbiddenDelete
No tienes permiso para borrar {0}. Por favor solicita el acceso.
En nuestro servicio get, agregamos la validación
CategoriasController.cs
public class CategoriasController : ControllerBase
{
public CategoriasController(CaducaContext context,
LocService localizer,
IAuthorizationService authorizationService)
{
//Código
permisoDTO = new PermisoDTO
{
Tabla = "Categoria",
RequiereAdministrador = false
};
}
[HttpGet]
[Authorize(Roles = "Administrador, Vendedor")]
public async Task<List<Categoria>> GetCategoriaAsync()
{
//Agregamos nuestra validación personalizada
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, permisoDTO, Operaciones.Consultar);
//Si el resultado no fue exitoso regresamos una lista vacia
if (!authorizationResult.Succeeded)
return new List<Categoria>();
return await categoriaDAO.ObtenerTodoAsync();
}
[HttpPut("{id}")]
[Authorize(Roles = "Administrador")]
public async Task<IActionResult> PutCategoria([FromRoute] int id,
[FromBody] Categoria categoria)
{
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, permisoDTO, Operaciones.Modificar);
//Si el resultado no fue exitoso regresamos error
if (!authorizationResult.Succeeded)
return StatusCode(403, String.Format(
this.localizacion.GetLocalizedHtmlString("ForbiddenUpdate"),
"La categoría"));
//Código
}
[HttpPost]
[Authorize(Roles = "Administrador")]
public async Task<IActionResult> PostCategoria(
[FromBody] Categoria categoria)
{
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, permisoDTO, Operaciones.Crear);
//Si el resultado no fue exitoso regresamos una lista vacia
if (!authorizationResult.Succeeded)
return StatusCode(403, String.Format(this.localizacion.
GetLocalizedHtmlString("ForbiddenAdd"), "La categoría"));
//Código
}
[HttpDelete("{id}")]
[Authorize(Roles = "Administrador")]
public async Task<IActionResult> DeleteCategoria([FromRoute] int id)
{
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, permisoDTO, Operaciones.Borrar);
//Si el resultado no fue exitoso regresamos una lista vacia
if (!authorizationResult.Succeeded)
return StatusCode(403, String.Format(this.localizacion.
GetLocalizedHtmlString("ForbiddenDelete"),
"La categoría"));
//Código
}
Puedes ver la documentación oficial aquí
Esta es la recomendación en la página oficial de microsoft, puedes realizar la validación con filtros como explicaré en el siguiente capítulo
