< 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
85%
Covered lines: 78
Uncovered lines: 13
Coverable lines: 91
Total lines: 222
Line coverage: 85.7%
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%2276.92%
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
 1019    public RolesController(
 1020        IRolService rolService,
 1021        ILogger<RolesController> logger)
 22    {
 1023        _rolService = rolService;
 1024        _logger = logger;
 1025    }
 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                permisos = r.Permisos.Select(p => p.Nombre).ToList()
 343            }).ToList();
 44
 145            var response = rolesDto;
 46
 147            return Ok(ApiResponse<object>.SuccessResult(response));
 48        }
 149        catch (Exception ex)
 50        {
 151            _logger.LogError(ex, "Error al obtener roles");
 152            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 53        }
 254    }
 55
 56    /// <summary>
 57    /// Crear rol con permisos
 58    /// POST /api/roles
 59    /// </summary>
 60    [HttpPost]
 61    public async Task<IActionResult> CreateRol([FromBody] CreateRolRequest request)
 62    {
 63        try
 64        {
 65            // Validaciones
 366            if (string.IsNullOrWhiteSpace(request.Nombre))
 67            {
 168                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del rol es requerido"));
 69            }
 70
 271            var (success, rol, error) = await _rolService.CreateAsync(
 272                request.Nombre,
 273                request.Descripcion);
 74
 275            if (!success)
 76            {
 177                if (error?.Contains("ya existe") == true)
 78                {
 179                    return Conflict(ApiResponse<string>.ErrorResult(error));
 80                }
 081                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear rol"));
 82            }
 83
 84            // Asignar permisos si se especificaron
 185            if (request.PermisosIds != null && request.PermisosIds.Any())
 86            {
 887                foreach (var permisoId in request.PermisosIds)
 88                {
 389                    await _rolService.AsignarPermisoAsync(rol!.Id, permisoId);
 90                }
 91            }
 92
 193            var response = new
 194            {
 195                id = rol!.Id,
 196                creado = true
 197            };
 98
 199            return CreatedAtAction(
 1100                nameof(GetRol),
 1101                new { id = rol.Id },
 1102                ApiResponse<object>.SuccessResult(response, "Rol creado exitosamente"));
 103        }
 0104        catch (Exception ex)
 105        {
 0106            _logger.LogError(ex, "Error al crear rol");
 0107            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 108        }
 3109    }
 110
 111    /// <summary>
 112    /// Obtener rol por ID
 113    /// GET /api/roles/{id}
 114    /// </summary>
 115    [HttpGet("{id}")]
 116    public async Task<IActionResult> GetRol(long id)
 117    {
 118        try
 119        {
 2120            var rol = await _rolService.GetByIdAsync(id);
 121
 2122            if (rol == null)
 123            {
 1124                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 125            }
 126
 1127            var response = new
 1128            {
 1129                id = rol.Id,
 1130                nombre = rol.Nombre,
 1131                permisos = rol.Permisos.Select(p => p.Nombre).ToList()
 1132            };
 133
 1134            return Ok(ApiResponse<object>.SuccessResult(response));
 135        }
 0136        catch (Exception ex)
 137        {
 0138            _logger.LogError(ex, "Error al obtener rol {Id}", id);
 0139            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 140        }
 2141    }
 142
 143    /// <summary>
 144    /// Editar rol (nombre y permisos)
 145    /// PUT /api/roles/{id}
 146    /// </summary>
 147    [HttpPut("{id}")]
 148    public async Task<IActionResult> UpdateRol(long id, [FromBody] UpdateRolRequest request)
 149    {
 150        try
 151        {
 3152            if (id != request.Id)
 153            {
 1154                return BadRequest(ApiResponse<string>.ErrorResult("El ID del rol no coincide"));
 155            }
 156
 157            // Verificar que el rol existe
 2158            var rolExistente = await _rolService.GetByIdAsync(id);
 2159            if (rolExistente == null)
 160            {
 1161                return NotFound(ApiResponse<string>.ErrorResult("Rol no encontrado"));
 162            }
 163
 164            // Actualizar nombre si se proporciona
 1165            if (!string.IsNullOrWhiteSpace(request.Nombre))
 166            {
 1167                var (success, rol, error) = await _rolService.UpdateAsync(
 1168                    request.Id,
 1169                    request.Nombre,
 1170                    request.Descripcion);
 171
 1172                if (!success)
 173                {
 0174                    if (error?.Contains("ya existe") == true)
 175                    {
 0176                        return Conflict(ApiResponse<string>.ErrorResult(error));
 177                    }
 0178                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar rol"));
 179                }
 180            }
 181
 182            // Actualizar permisos si se especifican
 1183            if (request.PermisosIds != null)
 184            {
 3185                var permisosActuales = rolExistente.Permisos.Select(p => p.Id).ToList();
 1186                var permisosNuevos = request.PermisosIds;
 187
 188                // Remover permisos que ya no están en la lista
 6189                foreach (var permisoId in permisosActuales)
 190                {
 2191                    if (!permisosNuevos.Contains(permisoId))
 192                    {
 1193                        await _rolService.RemoverPermisoAsync(request.Id, permisoId);
 194                    }
 195                }
 196
 197                // Agregar permisos nuevos
 6198                foreach (var permisoId in permisosNuevos)
 199                {
 2200                    if (!permisosActuales.Contains(permisoId))
 201                    {
 1202                        await _rolService.AsignarPermisoAsync(request.Id, permisoId);
 203                    }
 204                }
 1205            }
 206
 1207            var response = new
 1208            {
 1209                actualizado = true
 1210            };
 211
 1212            return Ok(ApiResponse<object>.SuccessResult(response, "Rol actualizado exitosamente"));
 213        }
 0214        catch (Exception ex)
 215        {
 0216            _logger.LogError(ex, "Error al actualizar rol {Id}", id);
 0217            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 218        }
 3219    }
 220}
 221
 222
Generated by: ReportGenerator 5.5.0.0
11/22/2025 - 23:32:45
GitHub | reportgenerator.io

Methods/Properties

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