< Summary

Information
Class: FAU.API.Controllers.EscalafonesController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/EscalafonesController.cs
Line coverage
78%
Covered lines: 25
Uncovered lines: 7
Coverable lines: 32
Total lines: 111
Line coverage: 78.1%
Branch coverage
40%
Covered branches: 8
Total branches: 20
Branch coverage: 40%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
ObtenerEscalafones()100%11100%
CrearEscalafonAsync()50%8890%
ActualizarEscalafonAsync()33.33%301250%

File(s)

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

#LineLine coverage
 1using FAU.Logica.DTOs;
 2using FAU.Logica.Services;
 3using Microsoft.AspNetCore.Authorization;
 4using Microsoft.AspNetCore.Http;
 5using Microsoft.AspNetCore.Mvc;
 6
 7namespace FAU.API.Controllers;
 8
 9[ApiController]
 10[Route("api/[controller]")]
 11[Authorize]
 12[Produces("application/json")]
 13public class EscalafonesController : ControllerBase
 14{
 15    private readonly IEscalafonService _escalafonService;
 16    private readonly ILogger<EscalafonesController> _logger;
 17
 818    public EscalafonesController(IEscalafonService escalafonService, ILogger<EscalafonesController> logger)
 19    {
 820        _escalafonService = escalafonService;
 821        _logger = logger;
 822    }
 23
 24    /// <summary>
 25    /// Listar todos los escalafones vigentes
 26    /// GET /api/escalafones
 27    /// </summary>
 28    [HttpGet]
 29    [ProducesResponseType(typeof(ApiResponse<IEnumerable<EscalafonDto>>), StatusCodes.Status200OK)]
 30    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 31    public async Task<IActionResult> ObtenerEscalafones()
 32    {
 33        try
 34        {
 335            var escalafones = await _escalafonService.ObtenerTodosAsync();
 236            return Ok(ApiResponse<IEnumerable<EscalafonDto>>.SuccessResult(escalafones));
 37        }
 138        catch (Exception ex)
 39        {
 140            _logger.LogError(ex, "Error al obtener escalafones");
 141            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 42        }
 343    }
 44
 45    /// <summary>
 46    /// Crear un nuevo escalafón
 47    /// POST /api/escalafones
 48    /// </summary>
 49    [HttpPost]
 50    [Authorize(Roles = "Administrador")]
 51    [ProducesResponseType(typeof(ApiResponse<EscalafonDto>), StatusCodes.Status201Created)]
 52    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 53    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 54    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 55    public async Task<IActionResult> CrearEscalafonAsync([FromBody] CrearEscalafonRequest request)
 56    {
 57        try
 58        {
 359            var (exito, resultado, error) = await _escalafonService.CrearAsync(request.Codigo, request.Denominacion, req
 60
 261            if (!exito)
 62            {
 163                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 164                    return Conflict(ApiResponse<string>.ErrorResult(error));
 065                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear escalafón"));
 66            }
 67
 168            return CreatedAtAction(nameof(ObtenerEscalafones), ApiResponse<EscalafonDto>.SuccessResult(resultado!, "Esca
 69        }
 170        catch (Exception ex)
 71        {
 172            _logger.LogError(ex, "Error al crear escalafón");
 173            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 74        }
 375    }
 76
 77    /// <summary>
 78    /// Actualizar un escalafón existente
 79    /// PUT /api/escalafones/{id}
 80    /// </summary>
 81    [HttpPut("{id}")]
 82    [Authorize(Roles = "Administrador")]
 83    [ProducesResponseType(typeof(ApiResponse<EscalafonDto>), StatusCodes.Status200OK)]
 84    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 85    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 86    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 87    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 88    public async Task<IActionResult> ActualizarEscalafonAsync(long id, [FromBody] ActualizarEscalafonRequest request)
 89    {
 90        try
 91        {
 292            var (exito, resultado, error) = await _escalafonService.ActualizarAsync(id, request.Codigo, request.Denomina
 93
 294            if (!exito)
 95            {
 196                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 197                    return NotFound(ApiResponse<string>.ErrorResult(error));
 098                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 099                    return Conflict(ApiResponse<string>.ErrorResult(error));
 0100                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar escalafón"));
 101            }
 102
 1103            return Ok(ApiResponse<EscalafonDto>.SuccessResult(resultado!, "Escalafón actualizado exitosamente"));
 104        }
 0105        catch (Exception ex)
 106        {
 0107            _logger.LogError(ex, "Error al actualizar escalafón {Id}", id);
 0108            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 109        }
 2110    }
 111}