< 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: 254
Line coverage: 22.9%
Branch coverage
15%
Covered branches: 10
Total branches: 66
Branch coverage: 15.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%210%
GetNovedad()0%156120%
CreateNovedad()25%481650%
UpdateNovedad()0%210140%
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.API.Security;
 2using FAU.Entidades;
 3using FAU.Logica.DTOs;
 4using FAU.Logica.Services;
 5using Microsoft.AspNetCore.Authorization;
 6using Microsoft.AspNetCore.Http;
 7using Microsoft.AspNetCore.Mvc;
 8
 9namespace FAU.API.Controllers;
 10
 11[ApiController]
 12[Route("api/novedades-periodo")]
 13[Authorize(Roles = "Administrador,Operador")]
 14[Produces("application/json")]
 15public class NovedadesPeriodoController : ControllerBase
 16{
 17    private readonly INovedadPeriodoService _novedadPeriodoService;
 18    private readonly ILogger<NovedadesPeriodoController> _logger;
 19
 420    public NovedadesPeriodoController(
 421        INovedadPeriodoService novedadPeriodoService,
 422        ILogger<NovedadesPeriodoController> logger)
 23    {
 424        _novedadPeriodoService = novedadPeriodoService;
 425        _logger = logger;
 426    }
 27
 28    [HttpGet]
 29    [ProducesResponseType(typeof(ApiResponse<PagedResult<NovedadPeriodoDto>>), StatusCodes.Status200OK)]
 30    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 31    public async Task<IActionResult> GetNovedades(
 32        [FromQuery] int page = 1,
 33        [FromQuery] int pageSize = 10,
 34        [FromQuery] long? periodoId = null,
 35        [FromQuery] long? personaId = null,
 36        [FromQuery] string? tipo = null,
 37        [FromQuery] string? estado = null)
 38    {
 39        try
 40        {
 041            var resultado = await _novedadPeriodoService.GetPaginatedAsync(page, pageSize, periodoId, personaId, tipo, e
 42
 043            return Ok(ApiResponse<PagedResult<NovedadPeriodoDto>>.SuccessResult(resultado));
 44        }
 045        catch (Exception ex)
 46        {
 047            _logger.LogError(ex, "Error al obtener novedades de período");
 048            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 49        }
 050    }
 51
 52    [HttpGet("{id}")]
 53    [ProducesResponseType(typeof(ApiResponse<NovedadPeriodoDto>), StatusCodes.Status200OK)]
 54    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 55    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 56    public async Task<IActionResult> GetNovedad(long id)
 57    {
 58        try
 59        {
 060            var novedad = await _novedadPeriodoService.GetByIdAsync(id);
 061            if (novedad == null)
 62            {
 063                return NotFound(ApiResponse<string>.ErrorResult("Novedad de período no encontrada"));
 64            }
 65
 066            var response = new NovedadPeriodoDto
 067            {
 068                Id = novedad.Id,
 069                PeriodoId = novedad.PeriodoId,
 070                PersonaId = novedad.PersonaId,
 071                Cedula = novedad.Persona?.Cedula ?? string.Empty,
 072                NombreCompleto = novedad.Persona?.NombreCompleto ?? string.Empty,
 073                Tipo = novedad.Tipo,
 074                DiasAfectados = novedad.DiasAfectados,
 075                PorcentajeSubsidio = novedad.PorcentajeSubsidio,
 076                FechaDesde = novedad.FechaDesde ?? DateTime.MinValue,
 077                FechaHasta = novedad.FechaHasta,
 078                Observaciones = novedad.Observaciones,
 079                Estado = novedad.Estado,
 080                CreadoPor = novedad.CreadoPor,
 081                CreadoEn = novedad.CreadoEn,
 082                ConfirmadoPor = novedad.ConfirmadoPor,
 083                ConfirmadoEn = novedad.ConfirmadoEn
 084            };
 85
 086            return Ok(ApiResponse<NovedadPeriodoDto>.SuccessResult(response));
 87        }
 088        catch (Exception ex)
 89        {
 090            _logger.LogError(ex, "Error al obtener novedad de período {Id}", id);
 091            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 92        }
 093    }
 94
 95    [HttpPost]
 96    [RequirePermission(PermisoEnum.CrearNovedades)]
 97    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status201Created)]
 98    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 99    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 100    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 101    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 102    public async Task<IActionResult> CreateNovedad([FromBody] CrearNovedadPeriodoRequest request)
 103    {
 104        try
 105        {
 2106            var (success, novedad, error) = await _novedadPeriodoService.CreateAsync(request);
 2107            if (!success)
 108            {
 1109                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 110                {
 1111                    return Conflict(ApiResponse<string>.ErrorResult(error));
 112                }
 0113                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true ||
 0114                    error?.Contains("no existe", StringComparison.OrdinalIgnoreCase) == true)
 115                {
 0116                    return NotFound(ApiResponse<string>.ErrorResult(error));
 117                }
 118
 0119                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear la novedad de período"));
 120            }
 121
 1122            var response = new { id = novedad!.Id, creado = true };
 1123            return CreatedAtAction(nameof(GetNovedad), new { id = novedad.Id }, ApiResponse<object>.SuccessResult(respon
 124        }
 0125        catch (Exception ex)
 126        {
 0127            _logger.LogError(ex, "Error al crear novedad de período");
 0128            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 129        }
 2130    }
 131
 132    [HttpPut("{id}")]
 133    [RequirePermission(PermisoEnum.CrearNovedades)]
 134    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 135    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 136    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 137    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 138    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 139    public async Task<IActionResult> UpdateNovedad(long id, [FromBody] ActualizarNovedadPeriodoRequest request)
 140    {
 141        try
 142        {
 0143            var (success, novedad, error) = await _novedadPeriodoService.UpdateAsync(id, request);
 0144            if (!success)
 145            {
 0146                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 147                {
 0148                    return NotFound(ApiResponse<string>.ErrorResult(error));
 149                }
 0150                if (error?.Contains("solo se pueden", StringComparison.OrdinalIgnoreCase) == true ||
 0151                    error?.Contains("debe proporcionar", StringComparison.OrdinalIgnoreCase) == true)
 152                {
 0153                    return BadRequest(ApiResponse<string>.ErrorResult(error));
 154                }
 155
 0156                return Conflict(ApiResponse<string>.ErrorResult(error));
 157            }
 158
 0159            return Ok(ApiResponse<object>.SuccessResult(new { actualizado = true }, "Novedad de período actualizada exit
 160        }
 0161        catch (Exception ex)
 162        {
 0163            _logger.LogError(ex, "Error al actualizar novedad de período {Id}", id);
 0164            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 165        }
 0166    }
 167
 168    [HttpDelete("{id}")]
 169    [RequirePermission(PermisoEnum.CrearNovedades)]
 170    [ProducesResponseType(StatusCodes.Status204NoContent)]
 171    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 172    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 173    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 174    public async Task<IActionResult> DeleteNovedad(long id)
 175    {
 176        try
 177        {
 0178            var (success, novedad, error) = await _novedadPeriodoService.DeleteAsync(id);
 0179            if (!success)
 180            {
 0181                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 182                {
 0183                    return NotFound(ApiResponse<string>.ErrorResult(error));
 184                }
 0185                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo eliminar la novedad de período"));
 186            }
 187
 0188            return NoContent();
 189        }
 0190        catch (Exception ex)
 191        {
 0192            _logger.LogError(ex, "Error al eliminar novedad de período {Id}", id);
 0193            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 194        }
 0195    }
 196
 197    [HttpPost("{id}/confirmar")]
 198    [RequirePermission(PermisoEnum.ConfirmarNovedades)]
 199    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 200    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 201    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 202    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 203    public async Task<IActionResult> ConfirmarNovedad(long id)
 204    {
 205        try
 206        {
 1207            var (success, novedad, error) = await _novedadPeriodoService.ChangeStateToConfirmedAsync(id);
 1208            if (!success)
 209            {
 0210                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 211                {
 0212                    return NotFound(ApiResponse<string>.ErrorResult(error));
 213                }
 0214                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo confirmar la novedad de período"));
 215            }
 216
 1217            return Ok(ApiResponse<object>.SuccessResult(new { confirmado = true }, "Novedad de período confirmada exitos
 218        }
 0219        catch (Exception ex)
 220        {
 0221            _logger.LogError(ex, "Error al confirmar novedad de período {Id}", id);
 0222            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 223        }
 1224    }
 225
 226    [HttpPost("{id}/anular")]
 227    [RequirePermission(PermisoEnum.ConfirmarNovedades)]
 228    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 229    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 230    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 231    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 232    public async Task<IActionResult> AnularNovedad(long id)
 233    {
 234        try
 235        {
 1236            var (success, novedad, error) = await _novedadPeriodoService.AnularAsync(id);
 1237            if (!success)
 238            {
 1239                if (error?.Contains("no encontrada", StringComparison.OrdinalIgnoreCase) == true)
 240                {
 0241                    return NotFound(ApiResponse<string>.ErrorResult(error));
 242                }
 1243                return Conflict(ApiResponse<string>.ErrorResult(error ?? "No se pudo anular la novedad de período"));
 244            }
 245
 0246            return Ok(ApiResponse<object>.SuccessResult(new { anulada = true }, "Novedad de período anulada exitosamente
 247        }
 0248        catch (Exception ex)
 249        {
 0250            _logger.LogError(ex, "Error al anular novedad de período {Id}", id);
 0251            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 252        }
 1253    }
 254}
Generated by: ReportGenerator 5.5.10.0
06/18/2026 - 03:39:18
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()