< Summary

Information
Class: FAU.API.Controllers.RolesController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/RolesController.cs
Line coverage
90%
Covered lines: 91
Uncovered lines: 10
Coverable lines: 101
Total lines: 232
Line coverage: 90%
Branch coverage
73%
Covered branches: 31
Total branches: 42
Branch coverage: 73.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetRoles()100%11100%
CreateRol()75%171684%
GetRol()100%22100%
UpdateRol()70.83%282481.25%

File(s)

/home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/RolesController.cs

#LineLine coverage
 1using FAU.Logica.DTOs;
 2using FAU.Logica.Services;
 3using Microsoft.AspNetCore.Authorization;
 4using Microsoft.AspNetCore.Mvc;
 5
 6namespace FAU.API.Controllers;
 7
 8/// <summary>
 9/// Gestión de roles del sistema
 10/// </summary>
 11[ApiController]
 12[Route("api/[controller]")]
 13[Authorize(Roles = "Administrador")]
 14public class RolesController : ControllerBase
 15{
 16    private readonly IRolService _rolService;
 17    private readonly ILogger<RolesController> _logger;
 18
 1119    public RolesController(
 1120        IRolService rolService,
 1121        ILogger<RolesController> logger)
 22    {
 1123        _rolService = rolService;
 1124        _logger = logger;
 1125    }
 26
 27    /// <summary>
 28    /// Listar todos los roles con sus permisos
 29    /// GET /api/roles
 30    /// </summary>
 31    [HttpGet]
 32    public async Task<IActionResult> GetRoles()
 33    {
 34        try
 35        {
 236            var roles = await _rolService.GetAllAsync();
 37
 338            var rolesDto = roles.Select(r => new
 339            {
 340                id = r.Id,
 341                nombre = r.Nombre,
 342                descripcion = r.Descripcion,
 343                permisos = r.Permisos.Select(p => new {
 344                    id = p.Id,
 345                    nombre = p.Nombre,
 346                    descripcion = p.Descripcion
 347                }).ToList()
 348            }).ToList();
 49
 150            var response = rolesDto;
 51
 152            return Ok(ApiResponse<object>.SuccessResult(response));
 53        }
 154        catch (Exception ex)
 55        {
 156            _logger.LogError(ex, "Error al obtener roles");
 157            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 58        }
 259    }
 60
 61    /// <summary>
 62    /// Crear rol con permisos
 63    /// POST /api/roles
 64    /// </summary>
 65    [HttpPost]
 66    public async Task<IActionResult> CreateRol([FromBody] CreateRolRequest request)
 67    {
 68        try
 69        {
 70            // Validaciones
 371            if (string.IsNullOrWhiteSpace(request.Nombre))
 72            {
 173                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del rol es requerido"));
 74            }
 75
 276            var (success, rol, error) = await _rolService.CreateAsync(
 277                request.Nombre,
 278                request.Descripcion);
 79
 280            if (!success)
 81            {
 182                if (error?.Contains("ya existe") == true)
 83                {
 184                    return Conflict(ApiResponse<string>.ErrorResult(error));
 85                }
 086                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear rol"));
 87            }
 88
 89            // Asignar permisos si se especificaron
 190            if (request.PermisosIds != null && request.PermisosIds.Any())
 91            {
 892                foreach (var permisoId in request.PermisosIds)
 93                {
 394                    await _rolService.AsignarPermisoAsync(rol!.Id, permisoId);
 95                }
 96            }
 97
 198            var response = new
 199            {
 1100                id = rol!.Id,
 1101                creado = true
 1102            };
 103
 1104            return CreatedAtAction(
 1105                nameof(GetRol),
 1106                new { id = rol.Id },
 1107                ApiResponse<object>.SuccessResult(response, "Rol creado exitosamente"));
 108        }
 0109        catch (Exception ex)
 110        {
 0111            _logger.LogError(ex, "Error al crear rol");
 0112            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 113        }
 3114    }
 115
 116    /// <summary>
 117    /// Obtener rol por ID
 118    /// GET /api/roles/{id}
 119    /// </summary>
 120    [HttpGet("{id}")]
 121    public async Task<IActionResult> GetRol(long id)
 122    {
 123        try
 124        {
 3125            var rol = await _rolService.GetByIdAsync(id);
 126
 2127            if (rol == null)
 128            {
 1129                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 130            }
 131
 1132            var response = new
 1133            {
 1134                id = rol.Id,
 1135                nombre = rol.Nombre,
 1136                descripcion = rol.Descripcion,
 1137                permisos = rol.Permisos.Select(p => new {
 1138                    id = p.Id,
 1139                    nombre = p.Nombre,
 1140                    descripcion = p.Descripcion
 1141                }).ToList()
 1142            };
 143
 1144            return Ok(ApiResponse<object>.SuccessResult(response));
 145        }
 1146        catch (Exception ex)
 147        {
 1148            _logger.LogError(ex, "Error al obtener rol {Id}", id);
 1149            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 150        }
 3151    }
 152
 153    /// <summary>
 154    /// Editar rol (nombre y permisos)
 155    /// PUT /api/roles/{id}
 156    /// </summary>
 157    [HttpPut("{id}")]
 158    public async Task<IActionResult> UpdateRol(long id, [FromBody] UpdateRolRequest request)
 159    {
 160        try
 161        {
 3162            if (id != request.Id)
 163            {
 1164                return BadRequest(ApiResponse<string>.ErrorResult("El ID del rol no coincide"));
 165            }
 166
 167            // Verificar que el rol existe
 2168            var rolExistente = await _rolService.GetByIdAsync(id);
 2169            if (rolExistente == null)
 170            {
 1171                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 172            }
 173
 174            // Actualizar nombre si se proporciona
 1175            if (!string.IsNullOrWhiteSpace(request.Nombre))
 176            {
 1177                var (success, rol, error) = await _rolService.UpdateAsync(
 1178                    request.Id,
 1179                    request.Nombre,
 1180                    request.Descripcion);
 181
 1182                if (!success)
 183                {
 0184                    if (error?.Contains("ya existe") == true)
 185                    {
 0186                        return Conflict(ApiResponse<string>.ErrorResult(error));
 187                    }
 0188                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar rol"));
 189                }
 190            }
 191
 192            // Actualizar permisos si se especifican
 1193            if (request.PermisosIds != null)
 194            {
 3195                var permisosActuales = rolExistente.Permisos.Select(p => p.Id).ToList();
 1196                var permisosNuevos = request.PermisosIds;
 197
 198                // Remover permisos que ya no están en la lista
 6199                foreach (var permisoId in permisosActuales)
 200                {
 2201                    if (!permisosNuevos.Contains(permisoId))
 202                    {
 1203                        await _rolService.RemoverPermisoAsync(request.Id, permisoId);
 204                    }
 205                }
 206
 207                // Agregar permisos nuevos
 6208                foreach (var permisoId in permisosNuevos)
 209                {
 2210                    if (!permisosActuales.Contains(permisoId))
 211                    {
 1212                        await _rolService.AsignarPermisoAsync(request.Id, permisoId);
 213                    }
 214                }
 1215            }
 216
 1217            var response = new
 1218            {
 1219                actualizado = true
 1220            };
 221
 1222            return Ok(ApiResponse<object>.SuccessResult(response, "Rol actualizado exitosamente"));
 223        }
 0224        catch (Exception ex)
 225        {
 0226            _logger.LogError(ex, "Error al actualizar rol {Id}", id);
 0227            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 228        }
 3229    }
 230}
 231
 232
Generated by: ReportGenerator 5.5.4.0
03/23/2026 - 23:16:29
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.Logica.Services.IRolService,Microsoft.Extensions.Logging.ILogger`1<FAU.API.Controllers.RolesController>)
GetRoles()
CreateRol()
GetRol()
UpdateRol()