< 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
100%
Covered lines: 96
Uncovered lines: 0
Coverable lines: 96
Total lines: 253
Line coverage: 100%
Branch coverage
86%
Covered branches: 62
Total branches: 72
Branch coverage: 86.1%
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%11100%
GetNovedad()75%1212100%
CreateNovedad()93.75%1616100%
UpdateNovedad()85%2020100%
DeleteNovedad()87.5%88100%
ConfirmarNovedad()87.5%88100%
AnularNovedad()87.5%88100%

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
 2719    public NovedadesPeriodoController(
 2720        INovedadPeriodoService novedadPeriodoService,
 2721        ILogger<NovedadesPeriodoController> logger)
 22    {
 2723        _novedadPeriodoService = novedadPeriodoService;
 2724        _logger = logger;
 2725    }
 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        {
 240            var resultado = await _novedadPeriodoService.GetPaginatedAsync(page, pageSize, periodoId, personaId, tipo, e
 41
 142            return Ok(ApiResponse<PagedResult<NovedadPeriodoDto>>.SuccessResult(resultado));
 43        }
 144        catch (Exception ex)
 45        {
 146            _logger.LogError(ex, "Error al obtener novedades de período");
 147            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 48        }
 249    }
 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        {
 359            var novedad = await _novedadPeriodoService.GetByIdAsync(id);
 260            if (novedad == null)
 61            {
 162                return NotFound(ApiResponse<string>.ErrorResult("Novedad de período no encontrada"));
 63            }
 64
 165            var response = new NovedadPeriodoDto
 166            {
 167                Id = novedad.Id,
 168                PeriodoId = novedad.PeriodoId,
 169                PersonaId = novedad.PersonaId,
 170                Cedula = novedad.Persona?.Cedula ?? string.Empty,
 171                NombreCompleto = novedad.Persona?.NombreCompleto ?? string.Empty,
 172                Tipo = novedad.Tipo,
 173                DiasAfectados = novedad.DiasAfectados,
 174                PorcentajeSubsidio = novedad.PorcentajeSubsidio,
 175                FechaDesde = novedad.FechaDesde ?? DateTime.MinValue,
 176                FechaHasta = novedad.FechaHasta,
 177                Observaciones = novedad.Observaciones,
 178                Estado = novedad.Estado,
 179                CreadoPor = novedad.CreadoPor,
 180                CreadoEn = novedad.CreadoEn,
 181                ConfirmadoPor = novedad.ConfirmadoPor,
 182                ConfirmadoEn = novedad.ConfirmadoEn
 183            };
 84
 185            return Ok(ApiResponse<NovedadPeriodoDto>.SuccessResult(response));
 86        }
 187        catch (Exception ex)
 88        {
 189            _logger.LogError(ex, "Error al obtener novedad de período {Id}", id);
 190            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 91        }
 392    }
 93
 94    [HttpPost]
 95    [Authorize(Roles = "Administrador,Supervisor,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        {
 5105            var (success, novedad, error) = await _novedadPeriodoService.CreateAsync(request);
 4106            if (!success)
 107            {
 3108                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 109                {
 1110                    return Conflict(ApiResponse<string>.ErrorResult(error));
 111                }
 2112                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true ||
 2113                    error?.Contains("no existe", StringComparison.OrdinalIgnoreCase) == true)
 114                {
 1115                    return NotFound(ApiResponse<string>.ErrorResult(error));
 116                }
 117
 1118                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        }
 1124        catch (Exception ex)
 125        {
 1126            _logger.LogError(ex, "Error al crear novedad de período");
 1127            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 128        }
 5129    }
 130
 131    [HttpPut("{id}")]
 132    [Authorize(Roles = "Administrador,Supervisor,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        {
 5142            var (success, novedad, error) = await _novedadPeriodoService.UpdateAsync(id, request);
 4143            if (!success)
 144            {
 3145                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 146                {
 1147                    return NotFound(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 148                }
 2149                if (error?.Contains("solo se pueden", StringComparison.OrdinalIgnoreCase) == true ||
 2150                    error?.Contains("debe proporcionar", StringComparison.OrdinalIgnoreCase) == true)
 151                {
 1152                    return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 153                }
 154
 1155                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error desconocido"));
 156            }
 157
 1158            return Ok(ApiResponse<object>.SuccessResult(new { actualizado = true }, "Novedad de período actualizada exit
 159        }
 1160        catch (Exception ex)
 161        {
 1162            _logger.LogError(ex, "Error al actualizar novedad de período {Id}", id);
 1163            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 164        }
 5165    }
 166
 167    [HttpDelete("{id}")]
 168    [Authorize(Roles = "Administrador,Supervisor,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        {
 4177            var (success, novedad, error) = await _novedadPeriodoService.DeleteAsync(id);
 3178            if (!success)
 179            {
 2180                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 181                {
 1182                    return NotFound(ApiResponse<string>.ErrorResult(error));
 183                }
 1184                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo eliminar la novedad de período"));
 185            }
 186
 1187            return NoContent();
 188        }
 1189        catch (Exception ex)
 190        {
 1191            _logger.LogError(ex, "Error al eliminar novedad de período {Id}", id);
 1192            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 193        }
 4194    }
 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        {
 4206            var (success, novedad, error) = await _novedadPeriodoService.ChangeStateToConfirmedAsync(id);
 3207            if (!success)
 208            {
 2209                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 210                {
 1211                    return NotFound(ApiResponse<string>.ErrorResult(error));
 212                }
 1213                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        }
 1218        catch (Exception ex)
 219        {
 1220            _logger.LogError(ex, "Error al confirmar novedad de período {Id}", id);
 1221            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 222        }
 4223    }
 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        {
 4235            var (success, novedad, error) = await _novedadPeriodoService.AnularAsync(id);
 3236            if (!success)
 237            {
 2238                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 239                {
 1240                    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
 1245            return Ok(ApiResponse<object>.SuccessResult(new { anulada = true }, "Novedad de período anulada exitosamente
 246        }
 1247        catch (Exception ex)
 248        {
 1249            _logger.LogError(ex, "Error al anular novedad de período {Id}", id);
 1250            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 251        }
 4252    }
 253}
Generated by: ReportGenerator 5.5.10.0
07/10/2026 - 04:04:48
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()