< 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: 252
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.Http;
 6using Microsoft.AspNetCore.Mvc;
 7
 8namespace FAU.API.Controllers;
 9
 10/// <summary>
 11/// Gestión de roles del sistema
 12/// </summary>
 13[ApiController]
 14[Route("api/[controller]")]
 15[Produces("application/json")]
 16public class RolesController : ControllerBase
 17{
 18    private readonly IRolService _rolService;
 19    private readonly ILogger<RolesController> _logger;
 20
 1121    public RolesController(
 1122        IRolService rolService,
 1123        ILogger<RolesController> logger)
 24    {
 1125        _rolService = rolService;
 1126        _logger = logger;
 1127    }
 28
 29    /// <summary>
 30    /// Listar todos los roles con sus permisos
 31    /// GET /api/roles
 32    /// </summary>
 33    [HttpGet]
 34    [FAU.API.Security.RequirePermission(PermisoEnum.VerRoles)]
 35    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 36    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 37    public async Task<IActionResult> GetRoles()
 38    {
 39        try
 40        {
 241            var roles = await _rolService.GetAllAsync();
 42
 343            var rolesDto = roles.Select(r => new
 344            {
 345                id = r.Id,
 346                nombre = r.Nombre,
 347                descripcion = r.Descripcion,
 348                permisos = r.Permisos.Select(p => new {
 349                    id = p.Id,
 350                    nombre = p.Nombre,
 351                    descripcion = p.Descripcion
 352                }).ToList()
 353            }).ToList();
 54
 155            var response = rolesDto;
 56
 157            return Ok(ApiResponse<object>.SuccessResult(response));
 58        }
 159        catch (Exception ex)
 60        {
 161            _logger.LogError(ex, "Error al obtener roles");
 162            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 63        }
 264    }
 65
 66    /// <summary>
 67    /// Crear rol con permisos
 68    /// POST /api/roles
 69    /// </summary>
 70    [HttpPost]
 71    [FAU.API.Security.RequirePermission(PermisoEnum.CrearRoles)]
 72    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status201Created)]
 73    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 74    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 75    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 76    public async Task<IActionResult> CreateRol([FromBody] CreateRolRequest request)
 77    {
 78        try
 79        {
 80            // Validaciones
 381            if (string.IsNullOrWhiteSpace(request.Nombre))
 82            {
 183                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del rol es requerido"));
 84            }
 85
 286            var (success, rol, error) = await _rolService.CreateAsync(
 287                request.Nombre,
 288                request.Descripcion);
 89
 290            if (!success)
 91            {
 192                if (error?.Contains("ya existe") == true)
 93                {
 194                    return Conflict(ApiResponse<string>.ErrorResult(error));
 95                }
 096                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear rol"));
 97            }
 98
 99            // Asignar permisos si se especificaron
 1100            if (request.PermisosIds != null && request.PermisosIds.Any())
 101            {
 8102                foreach (var permisoId in request.PermisosIds)
 103                {
 3104                    await _rolService.AsignarPermisoAsync(rol!.Id, permisoId);
 105                }
 106            }
 107
 1108            var response = new
 1109            {
 1110                id = rol!.Id,
 1111                creado = true
 1112            };
 113
 1114            return CreatedAtAction(
 1115                nameof(GetRol),
 1116                new { id = rol.Id },
 1117                ApiResponse<object>.SuccessResult(response, "Rol creado exitosamente"));
 118        }
 0119        catch (Exception ex)
 120        {
 0121            _logger.LogError(ex, "Error al crear rol");
 0122            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 123        }
 3124    }
 125
 126    /// <summary>
 127    /// Obtener rol por ID
 128    /// GET /api/roles/{id}
 129    /// </summary>
 130    [HttpGet("{id}")]
 131    [FAU.API.Security.RequirePermission(PermisoEnum.VerRoles)]
 132    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 133    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 134    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 135    public async Task<IActionResult> GetRol(long id)
 136    {
 137        try
 138        {
 3139            var rol = await _rolService.GetByIdAsync(id);
 140
 2141            if (rol == null)
 142            {
 1143                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 144            }
 145
 1146            var response = new
 1147            {
 1148                id = rol.Id,
 1149                nombre = rol.Nombre,
 1150                descripcion = rol.Descripcion,
 1151                permisos = rol.Permisos.Select(p => new {
 1152                    id = p.Id,
 1153                    nombre = p.Nombre,
 1154                    descripcion = p.Descripcion
 1155                }).ToList()
 1156            };
 157
 1158            return Ok(ApiResponse<object>.SuccessResult(response));
 159        }
 1160        catch (Exception ex)
 161        {
 1162            _logger.LogError(ex, "Error al obtener rol {Id}", id);
 1163            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 164        }
 3165    }
 166
 167    /// <summary>
 168    /// Editar rol (nombre y permisos)
 169    /// PUT /api/roles/{id}
 170    /// </summary>
 171    [HttpPut("{id}")]
 172    [FAU.API.Security.RequirePermission(PermisoEnum.ActualizarRoles)]
 173    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 174    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 175    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 176    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 177    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 178    public async Task<IActionResult> UpdateRol(long id, [FromBody] UpdateRolRequest request)
 179    {
 180        try
 181        {
 3182            if (id != request.Id)
 183            {
 1184                return BadRequest(ApiResponse<string>.ErrorResult("El ID del rol no coincide"));
 185            }
 186
 187            // Verificar que el rol existe
 2188            var rolExistente = await _rolService.GetByIdAsync(id);
 2189            if (rolExistente == null)
 190            {
 1191                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 192            }
 193
 194            // Actualizar nombre si se proporciona
 1195            if (!string.IsNullOrWhiteSpace(request.Nombre))
 196            {
 1197                var (success, rol, error) = await _rolService.UpdateAsync(
 1198                    request.Id,
 1199                    request.Nombre,
 1200                    request.Descripcion);
 201
 1202                if (!success)
 203                {
 0204                    if (error?.Contains("ya existe") == true)
 205                    {
 0206                        return Conflict(ApiResponse<string>.ErrorResult(error));
 207                    }
 0208                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar rol"));
 209                }
 210            }
 211
 212            // Actualizar permisos si se especifican
 1213            if (request.PermisosIds != null)
 214            {
 3215                var permisosActuales = rolExistente.Permisos.Select(p => p.Id).ToList();
 1216                var permisosNuevos = request.PermisosIds;
 217
 218                // Remover permisos que ya no están en la lista
 6219                foreach (var permisoId in permisosActuales)
 220                {
 2221                    if (!permisosNuevos.Contains(permisoId))
 222                    {
 1223                        await _rolService.RemoverPermisoAsync(request.Id, permisoId);
 224                    }
 225                }
 226
 227                // Agregar permisos nuevos
 6228                foreach (var permisoId in permisosNuevos)
 229                {
 2230                    if (!permisosActuales.Contains(permisoId))
 231                    {
 1232                        await _rolService.AsignarPermisoAsync(request.Id, permisoId);
 233                    }
 234                }
 1235            }
 236
 1237            var response = new
 1238            {
 1239                actualizado = true
 1240            };
 241
 1242            return Ok(ApiResponse<object>.SuccessResult(response, "Rol actualizado exitosamente"));
 243        }
 0244        catch (Exception ex)
 245        {
 0246            _logger.LogError(ex, "Error al actualizar rol {Id}", id);
 0247            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 248        }
 3249    }
 250}
 251
 252
Generated by: ReportGenerator 5.5.10.0
06/18/2026 - 03:39:18
GitHub | reportgenerator.io

Methods/Properties

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