< Summary

Information
Class: FAU.API.Controllers.NovedadesPeriodoController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/NovedadesPeriodoController.cs
Line coverage
22%
Covered lines: 22
Uncovered lines: 74
Coverable lines: 96
Total lines: 253
Line coverage: 22.9%
Branch coverage
13%
Covered branches: 10
Total branches: 72
Branch coverage: 13.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%
GetNovedades()100%210%
GetNovedad()0%156120%
CreateNovedad()25%481650%
UpdateNovedad()0%420200%
DeleteNovedad()0%7280%
ConfirmarNovedad()12.5%22840%
AnularNovedad()62.5%16850%

File(s)

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

#LineLine coverage
 1using FAU.Entidades;
 2using FAU.Logica.DTOs;
 3using FAU.Logica.Services;
 4using Microsoft.AspNetCore.Authorization;
 5using Microsoft.AspNetCore.Http;
 6using Microsoft.AspNetCore.Mvc;
 7
 8namespace FAU.API.Controllers;
 9
 10[ApiController]
 11[Route("api/novedades-periodo")]
 12[Authorize(Roles = "Administrador,Supervisor,Usuario")]
 13[Produces("application/json")]
 14public class NovedadesPeriodoController : ControllerBase
 15{
 16    private readonly INovedadPeriodoService _novedadPeriodoService;
 17    private readonly ILogger<NovedadesPeriodoController> _logger;
 18
 419    public NovedadesPeriodoController(
 420        INovedadPeriodoService novedadPeriodoService,
 421        ILogger<NovedadesPeriodoController> logger)
 22    {
 423        _novedadPeriodoService = novedadPeriodoService;
 424        _logger = logger;
 425    }
 26
 27    [HttpGet]
 28    [ProducesResponseType(typeof(ApiResponse<PagedResult<NovedadPeriodoDto>>), StatusCodes.Status200OK)]
 29    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 30    public async Task<IActionResult> GetNovedades(
 31        [FromQuery] int page = 1,
 32        [FromQuery] int pageSize = 10,
 33        [FromQuery] long? periodoId = null,
 34        [FromQuery] long? personaId = null,
 35        [FromQuery] string? tipo = null,
 36        [FromQuery] string? estado = null)
 37    {
 38        try
 39        {
 040            var resultado = await _novedadPeriodoService.GetPaginatedAsync(page, pageSize, periodoId, personaId, tipo, e
 41
 042            return Ok(ApiResponse<PagedResult<NovedadPeriodoDto>>.SuccessResult(resultado));
 43        }
 044        catch (Exception ex)
 45        {
 046            _logger.LogError(ex, "Error al obtener novedades de período");
 047            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 48        }
 049    }
 50
 51    [HttpGet("{id}")]
 52    [ProducesResponseType(typeof(ApiResponse<NovedadPeriodoDto>), StatusCodes.Status200OK)]
 53    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 54    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 55    public async Task<IActionResult> GetNovedad(long id)
 56    {
 57        try
 58        {
 059            var novedad = await _novedadPeriodoService.GetByIdAsync(id);
 060            if (novedad == null)
 61            {
 062                return NotFound(ApiResponse<string>.ErrorResult("Novedad de período no encontrada"));
 63            }
 64
 065            var response = new NovedadPeriodoDto
 066            {
 067                Id = novedad.Id,
 068                PeriodoId = novedad.PeriodoId,
 069                PersonaId = novedad.PersonaId,
 070                Cedula = novedad.Persona?.Cedula ?? string.Empty,
 071                NombreCompleto = novedad.Persona?.NombreCompleto ?? string.Empty,
 072                Tipo = novedad.Tipo,
 073                DiasAfectados = novedad.DiasAfectados,
 074                PorcentajeSubsidio = novedad.PorcentajeSubsidio,
 075                FechaDesde = novedad.FechaDesde ?? DateTime.MinValue,
 076                FechaHasta = novedad.FechaHasta,
 077                Observaciones = novedad.Observaciones,
 078                Estado = novedad.Estado,
 079                CreadoPor = novedad.CreadoPor,
 080                CreadoEn = novedad.CreadoEn,
 081                ConfirmadoPor = novedad.ConfirmadoPor,
 082                ConfirmadoEn = novedad.ConfirmadoEn
 083            };
 84
 085            return Ok(ApiResponse<NovedadPeriodoDto>.SuccessResult(response));
 86        }
 087        catch (Exception ex)
 88        {
 089            _logger.LogError(ex, "Error al obtener novedad de período {Id}", id);
 090            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 91        }
 092    }
 93
 94    [HttpPost]
 95    [Authorize(Roles = "Administrador,Usuario")]
 96    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status201Created)]
 97    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 98    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 99    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 100    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 101    public async Task<IActionResult> CreateNovedad([FromBody] CrearNovedadPeriodoRequest request)
 102    {
 103        try
 104        {
 2105            var (success, novedad, error) = await _novedadPeriodoService.CreateAsync(request);
 2106            if (!success)
 107            {
 1108                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 109                {
 1110                    return Conflict(ApiResponse<string>.ErrorResult(error));
 111                }
 0112                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true ||
 0113                    error?.Contains("no existe", StringComparison.OrdinalIgnoreCase) == true)
 114                {
 0115                    return NotFound(ApiResponse<string>.ErrorResult(error));
 116                }
 117
 0118                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear la novedad de período"));
 119            }
 120
 1121            var response = new { id = novedad!.Id, creado = true };
 1122            return CreatedAtAction(nameof(GetNovedad), new { id = novedad.Id }, ApiResponse<object>.SuccessResult(respon
 123        }
 0124        catch (Exception ex)
 125        {
 0126            _logger.LogError(ex, "Error al crear novedad de período");
 0127            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 128        }
 2129    }
 130
 131    [HttpPut("{id}")]
 132    [Authorize(Roles = "Administrador,Usuario")]
 133    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 134    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 135    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 136    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 137    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 138    public async Task<IActionResult> UpdateNovedad(long id, [FromBody] ActualizarNovedadPeriodoRequest request)
 139    {
 140        try
 141        {
 0142            var (success, novedad, error) = await _novedadPeriodoService.UpdateAsync(id, request);
 0143            if (!success)
 144            {
 0145                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 146                {
 0147                    return NotFound(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 148                }
 0149                if (error?.Contains("solo se pueden", StringComparison.OrdinalIgnoreCase) == true ||
 0150                    error?.Contains("debe proporcionar", StringComparison.OrdinalIgnoreCase) == true)
 151                {
 0152                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 153                }
 154
 0155                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 156            }
 157
 0158            return Ok(ApiResponse<object>.SuccessResult(new { actualizado = true }, "Novedad de período actualizada exit
 159        }
 0160        catch (Exception ex)
 161        {
 0162            _logger.LogError(ex, "Error al actualizar novedad de período {Id}", id);
 0163            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 164        }
 0165    }
 166
 167    [HttpDelete("{id}")]
 168    [Authorize(Roles = "Administrador,Usuario")]
 169    [ProducesResponseType(StatusCodes.Status204NoContent)]
 170    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 171    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 172    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 173    public async Task<IActionResult> DeleteNovedad(long id)
 174    {
 175        try
 176        {
 0177            var (success, novedad, error) = await _novedadPeriodoService.DeleteAsync(id);
 0178            if (!success)
 179            {
 0180                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 181                {
 0182                    return NotFound(ApiResponse<string>.ErrorResult(error));
 183                }
 0184                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo eliminar la novedad de período"));
 185            }
 186
 0187            return NoContent();
 188        }
 0189        catch (Exception ex)
 190        {
 0191            _logger.LogError(ex, "Error al eliminar novedad de período {Id}", id);
 0192            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 193        }
 0194    }
 195
 196    [HttpPost("{id}/confirmar")]
 197    [Authorize(Roles = "Administrador,Supervisor")]
 198    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 199    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 200    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 201    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 202    public async Task<IActionResult> ConfirmarNovedad(long id)
 203    {
 204        try
 205        {
 1206            var (success, novedad, error) = await _novedadPeriodoService.ChangeStateToConfirmedAsync(id);
 1207            if (!success)
 208            {
 0209                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 210                {
 0211                    return NotFound(ApiResponse<string>.ErrorResult(error));
 212                }
 0213                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo confirmar la novedad de período"));
 214            }
 215
 1216            return Ok(ApiResponse<object>.SuccessResult(new { confirmado = true }, "Novedad de período confirmada exitos
 217        }
 0218        catch (Exception ex)
 219        {
 0220            _logger.LogError(ex, "Error al confirmar novedad de período {Id}", id);
 0221            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 222        }
 1223    }
 224
 225    [HttpPost("{id}/anular")]
 226    [Authorize(Roles = "Administrador,Supervisor")]
 227    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 228    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 229    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 230    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 231    public async Task<IActionResult> AnularNovedad(long id)
 232    {
 233        try
 234        {
 1235            var (success, novedad, error) = await _novedadPeriodoService.AnularAsync(id);
 1236            if (!success)
 237            {
 1238                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 239                {
 0240                    return NotFound(ApiResponse<string>.ErrorResult(error));
 241                }
 1242                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo anular la novedad de período"));
 243            }
 244
 0245            return Ok(ApiResponse<object>.SuccessResult(new { anulada = true }, "Novedad de período anulada exitosamente
 246        }
 0247        catch (Exception ex)
 248        {
 0249            _logger.LogError(ex, "Error al anular novedad de período {Id}", id);
 0250            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 251        }
 1252    }
 253}
Generated by: ReportGenerator 5.5.10.0
06/22/2026 - 14:25:30
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.Logica.Services.INovedadPeriodoService,Microsoft.Extensions.Logging.ILogger`1<FAU.API.Controllers.NovedadesPeriodoController>)
GetNovedades()
GetNovedad()
CreateNovedad()
UpdateNovedad()
DeleteNovedad()
ConfirmarNovedad()
AnularNovedad()