< 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: 236
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 FAU.Entidades;
 4using Microsoft.AspNetCore.Authorization;
 5using Microsoft.AspNetCore.Mvc;
 6
 7namespace FAU.API.Controllers;
 8
 9/// <summary>
 10/// Gestión de roles del sistema
 11/// </summary>
 12[ApiController]
 13[Route("api/[controller]")]
 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    [FAU.API.Security.RequirePermission(PermisoEnum.VerRoles)]
 33    public async Task<IActionResult> GetRoles()
 34    {
 35        try
 36        {
 237            var roles = await _rolService.GetAllAsync();
 38
 339            var rolesDto = roles.Select(r => new
 340            {
 341                id = r.Id,
 342                nombre = r.Nombre,
 343                descripcion = r.Descripcion,
 344                permisos = r.Permisos.Select(p => new {
 345                    id = p.Id,
 346                    nombre = p.Nombre,
 347                    descripcion = p.Descripcion
 348                }).ToList()
 349            }).ToList();
 50
 151            var response = rolesDto;
 52
 153            return Ok(ApiResponse<object>.SuccessResult(response));
 54        }
 155        catch (Exception ex)
 56        {
 157            _logger.LogError(ex, "Error al obtener roles");
 158            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 59        }
 260    }
 61
 62    /// <summary>
 63    /// Crear rol con permisos
 64    /// POST /api/roles
 65    /// </summary>
 66    [HttpPost]
 67    [FAU.API.Security.RequirePermission(PermisoEnum.CrearRoles)]
 68    public async Task<IActionResult> CreateRol([FromBody] CreateRolRequest request)
 69    {
 70        try
 71        {
 72            // Validaciones
 373            if (string.IsNullOrWhiteSpace(request.Nombre))
 74            {
 175                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del rol es requerido"));
 76            }
 77
 278            var (success, rol, error) = await _rolService.CreateAsync(
 279                request.Nombre,
 280                request.Descripcion);
 81
 282            if (!success)
 83            {
 184                if (error?.Contains("ya existe") == true)
 85                {
 186                    return Conflict(ApiResponse<string>.ErrorResult(error));
 87                }
 088                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear rol"));
 89            }
 90
 91            // Asignar permisos si se especificaron
 192            if (request.PermisosIds != null && request.PermisosIds.Any())
 93            {
 894                foreach (var permisoId in request.PermisosIds)
 95                {
 396                    await _rolService.AsignarPermisoAsync(rol!.Id, permisoId);
 97                }
 98            }
 99
 1100            var response = new
 1101            {
 1102                id = rol!.Id,
 1103                creado = true
 1104            };
 105
 1106            return CreatedAtAction(
 1107                nameof(GetRol),
 1108                new { id = rol.Id },
 1109                ApiResponse<object>.SuccessResult(response, "Rol creado exitosamente"));
 110        }
 0111        catch (Exception ex)
 112        {
 0113            _logger.LogError(ex, "Error al crear rol");
 0114            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 115        }
 3116    }
 117
 118    /// <summary>
 119    /// Obtener rol por ID
 120    /// GET /api/roles/{id}
 121    /// </summary>
 122    [HttpGet("{id}")]
 123    [FAU.API.Security.RequirePermission(PermisoEnum.VerRoles)]
 124    public async Task<IActionResult> GetRol(long id)
 125    {
 126        try
 127        {
 3128            var rol = await _rolService.GetByIdAsync(id);
 129
 2130            if (rol == null)
 131            {
 1132                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 133            }
 134
 1135            var response = new
 1136            {
 1137                id = rol.Id,
 1138                nombre = rol.Nombre,
 1139                descripcion = rol.Descripcion,
 1140                permisos = rol.Permisos.Select(p => new {
 1141                    id = p.Id,
 1142                    nombre = p.Nombre,
 1143                    descripcion = p.Descripcion
 1144                }).ToList()
 1145            };
 146
 1147            return Ok(ApiResponse<object>.SuccessResult(response));
 148        }
 1149        catch (Exception ex)
 150        {
 1151            _logger.LogError(ex, "Error al obtener rol {Id}", id);
 1152            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 153        }
 3154    }
 155
 156    /// <summary>
 157    /// Editar rol (nombre y permisos)
 158    /// PUT /api/roles/{id}
 159    /// </summary>
 160    [HttpPut("{id}")]
 161    [FAU.API.Security.RequirePermission(PermisoEnum.ActualizarRoles)]
 162    public async Task<IActionResult> UpdateRol(long id, [FromBody] UpdateRolRequest request)
 163    {
 164        try
 165        {
 3166            if (id != request.Id)
 167            {
 1168                return BadRequest(ApiResponse<string>.ErrorResult("El ID del rol no coincide"));
 169            }
 170
 171            // Verificar que el rol existe
 2172            var rolExistente = await _rolService.GetByIdAsync(id);
 2173            if (rolExistente == null)
 174            {
 1175                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 176            }
 177
 178            // Actualizar nombre si se proporciona
 1179            if (!string.IsNullOrWhiteSpace(request.Nombre))
 180            {
 1181                var (success, rol, error) = await _rolService.UpdateAsync(
 1182                    request.Id,
 1183                    request.Nombre,
 1184                    request.Descripcion);
 185
 1186                if (!success)
 187                {
 0188                    if (error?.Contains("ya existe") == true)
 189                    {
 0190                        return Conflict(ApiResponse<string>.ErrorResult(error));
 191                    }
 0192                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar rol"));
 193                }
 194            }
 195
 196            // Actualizar permisos si se especifican
 1197            if (request.PermisosIds != null)
 198            {
 3199                var permisosActuales = rolExistente.Permisos.Select(p => p.Id).ToList();
 1200                var permisosNuevos = request.PermisosIds;
 201
 202                // Remover permisos que ya no están en la lista
 6203                foreach (var permisoId in permisosActuales)
 204                {
 2205                    if (!permisosNuevos.Contains(permisoId))
 206                    {
 1207                        await _rolService.RemoverPermisoAsync(request.Id, permisoId);
 208                    }
 209                }
 210
 211                // Agregar permisos nuevos
 6212                foreach (var permisoId in permisosNuevos)
 213                {
 2214                    if (!permisosActuales.Contains(permisoId))
 215                    {
 1216                        await _rolService.AsignarPermisoAsync(request.Id, permisoId);
 217                    }
 218                }
 1219            }
 220
 1221            var response = new
 1222            {
 1223                actualizado = true
 1224            };
 225
 1226            return Ok(ApiResponse<object>.SuccessResult(response, "Rol actualizado exitosamente"));
 227        }
 0228        catch (Exception ex)
 229        {
 0230            _logger.LogError(ex, "Error al actualizar rol {Id}", id);
 0231            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 232        }
 3233    }
 234}
 235
 236
Generated by: ReportGenerator 5.5.10.0
06/16/2026 - 02:14:51
GitHub | reportgenerator.io

Methods/Properties

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