< Summary

Information
Class: FAU.API.Controllers.PeriodosController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/PeriodosController.cs
Line coverage
57%
Covered lines: 80
Uncovered lines: 60
Coverable lines: 140
Total lines: 308
Line coverage: 57.1%
Branch coverage
62%
Covered branches: 45
Total branches: 72
Branch coverage: 62.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
AbrirPeriodo()80%131069.23%
GetUltimos()0%620%
GetPeriodoActivo()100%2262.5%
GetPeriodo()100%2262.5%
GetPrecondiciones()0%620%
ValidarInsumos()0%620%
CerrarInsumos()75%211673.33%
ReabrirInsumos()75%12860%
ReabrirDesdeCalculada()0%7280%
Calcular()66.66%151272.22%
Cerrar()87.5%10870%
MapearPeriodo(...)100%11100%

File(s)

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

#LineLine coverage
 1using FAU.API.Security;
 2using FAU.Entidades;
 3using FAU.Logica.DTOs;
 4using FAU.Logica.Exceptions;
 5using FAU.Logica.Services;
 6using Microsoft.AspNetCore.Authorization;
 7using Microsoft.AspNetCore.Mvc;
 8
 9namespace FAU.API.Controllers;
 10
 11[ApiController]
 12[Route("api/liquidacion/[controller]")]
 13[Authorize(Roles = "Administrador")]
 14public class PeriodosController : ControllerBase
 15{
 16    private readonly IPeriodoService _periodoService;
 17    private readonly ILiquidacionService _liquidacionService;
 18    private readonly ILogger<PeriodosController> _logger;
 19
 1920    public PeriodosController(
 1921        IPeriodoService periodoService,
 1922        ILiquidacionService liquidacionService,
 1923        ILogger<PeriodosController> logger)
 24    {
 1925        _periodoService       = periodoService;
 1926        _liquidacionService   = liquidacionService;
 1927        _logger               = logger;
 1928    }
 29
 30    [HttpPost]
 31    public async Task<IActionResult> AbrirPeriodo([FromBody] AbrirPeriodoRequest request)
 32    {
 33        try
 34        {
 335            if (!ModelState.IsValid)
 36            {
 037                return BadRequest(ApiResponse<string>.ErrorResult("Solicitud de apertura de período inválida"));
 38            }
 39
 340            var (success, periodo, error) = await _periodoService.AbrirPeriodoAsync(request.Anio, request.Mes);
 41
 342            if (!success)
 43            {
 244                if (error?.Contains("Ya existe un período activo", StringComparison.OrdinalIgnoreCase) == true)
 45                {
 146                    return Conflict(ApiResponse<string>.ErrorResult(error));
 47                }
 48
 149                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al abrir el período"));
 50            }
 51
 152            var dto = MapearPeriodo(periodo!);
 153            return CreatedAtAction(nameof(GetPeriodo), new { id = periodo!.Id }, ApiResponse<PeriodoDto>.SuccessResult(d
 54        }
 055        catch (Exception ex)
 56        {
 057            _logger.LogError(ex, "Error al abrir período");
 058            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 59        }
 360    }
 61
 62    [HttpGet]
 63    public async Task<IActionResult> GetUltimos([FromQuery] int cantidad = 6)
 64    {
 65        try
 66        {
 067            var periodos = await _periodoService.ObtenerUltimosAsync(Math.Min(cantidad, 12));
 068            return Ok(ApiResponse<List<PeriodoDto>>.SuccessResult(periodos.Select(MapearPeriodo).ToList()));
 69        }
 070        catch (Exception ex)
 71        {
 072            _logger.LogError(ex, "Error al obtener últimos períodos");
 073            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 74        }
 075    }
 76
 77    [HttpGet("activo")]
 78    public async Task<IActionResult> GetPeriodoActivo()
 79    {
 80        try
 81        {
 282            var periodo = await _periodoService.ObtenerEnCursoAsync();
 283            if (periodo == null)
 84            {
 185                return NotFound(ApiResponse<string>.ErrorResult("No hay un período activo"));
 86            }
 87
 188            return Ok(ApiResponse<PeriodoDto>.SuccessResult(MapearPeriodo(periodo)));
 89        }
 090        catch (Exception ex)
 91        {
 092            _logger.LogError(ex, "Error al obtener período activo");
 093            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 94        }
 295    }
 96
 97    [HttpGet("{id}")]
 98    public async Task<IActionResult> GetPeriodo(long id)
 99    {
 100        try
 101        {
 2102            var periodo = await _periodoService.ObtenerPorIdAsync(id);
 2103            if (periodo == null)
 104            {
 1105                return NotFound(ApiResponse<string>.ErrorResult("Período no encontrado"));
 106            }
 107
 1108            return Ok(ApiResponse<PeriodoDto>.SuccessResult(MapearPeriodo(periodo)));
 109        }
 0110        catch (Exception ex)
 111        {
 0112            _logger.LogError(ex, "Error al obtener período {Id}", id);
 0113            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 114        }
 2115    }
 116
 117    [HttpGet("{id}/precondiciones")]
 118    public async Task<IActionResult> GetPrecondiciones(long id)
 119    {
 120        try
 121        {
 0122            var precondiciones = await _periodoService.ObtenerPrecondicionesAsync(id);
 0123            if (precondiciones == null)
 0124                return NotFound(ApiResponse<string>.ErrorResult("Período no encontrado"));
 0125            return Ok(ApiResponse<PrecondicionesDto>.SuccessResult(precondiciones));
 126        }
 0127        catch (Exception ex)
 128        {
 0129            _logger.LogError(ex, "Error al obtener precondiciones del período {Id}", id);
 0130            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 131        }
 0132    }
 133
 134    [HttpGet("{id}/validar-insumos")]
 135    public async Task<IActionResult> ValidarInsumos(long id)
 136    {
 137        try
 138        {
 0139            var validacion = await _periodoService.ValidarInsumosAsync(id);
 0140            if (validacion == null)
 0141                return NotFound(ApiResponse<string>.ErrorResult("Período no encontrado"));
 0142            return Ok(ApiResponse<ValidacionInsumosDto>.SuccessResult(validacion));
 143        }
 0144        catch (Exception ex)
 145        {
 0146            _logger.LogError(ex, "Error al validar insumos del período {Id}", id);
 0147            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 148        }
 0149    }
 150
 151    [HttpPost("{id}/cerrar-insumos")]
 152    public async Task<IActionResult> CerrarInsumos(long id, [FromBody] CerrarInsumosRequest? request = null)
 153    {
 154        try
 155        {
 4156            var (success, periodo, validacion, error) =
 4157                await _periodoService.CerrarInsumosAsync(id, request?.Confirmaciones);
 158
 4159            if (!success)
 160            {
 3161                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 1162                    return NotFound(ApiResponse<string>.ErrorResult(error));
 2163                if (error?.Contains("Solo se puede", StringComparison.OrdinalIgnoreCase) == true)
 1164                    return Conflict(ApiResponse<string>.ErrorResult(error));
 1165                if (validacion != null)
 1166                    return UnprocessableEntity(validacion);
 0167                return UnprocessableEntity(ApiResponse<string>.ErrorResult(error ?? "Error al cerrar insumos"));
 168            }
 169
 1170            return Ok(ApiResponse<PeriodoDto>.SuccessResult(MapearPeriodo(periodo!), "Insumos cerrados. Período listo pa
 171        }
 0172        catch (Exception ex)
 173        {
 0174            _logger.LogError(ex, "Error al cerrar insumos del período {Id}", id);
 0175            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 176        }
 4177    }
 178
 179    [HttpPost("{id}/reabrir-insumos")]
 180    [RequirePermission(PermisoEnum.ReabrirPeriodo)]
 181    public async Task<IActionResult> ReabrirInsumos(long id)
 182    {
 183        try
 184        {
 2185            var (success, periodo, error) = await _periodoService.ReabrirInsumosAsync(id);
 186
 2187            if (!success)
 188            {
 1189                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 0190                    return NotFound(ApiResponse<string>.ErrorResult(error));
 1191                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error al reabrir insumos"));
 192            }
 193
 1194            return Ok(ApiResponse<PeriodoDto>.SuccessResult(MapearPeriodo(periodo!), "Insumos reabiertos. Período en est
 195        }
 0196        catch (Exception ex)
 197        {
 0198            _logger.LogError(ex, "Error al reabrir insumos del período {Id}", id);
 0199            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 200        }
 2201    }
 202
 203    [HttpPost("{id}/reabrir")]
 204    [RequirePermission(PermisoEnum.ReabrirPeriodo)]
 205    public async Task<IActionResult> ReabrirDesdeCalculada(long id)
 206    {
 207        try
 208        {
 0209            var (success, periodo, error) = await _periodoService.ReabrirDesdeCalculadaAsync(id);
 210
 0211            if (!success)
 212            {
 0213                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 0214                    return NotFound(ApiResponse<string>.ErrorResult(error));
 0215                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error al reabrir período"));
 216            }
 217
 0218            return Ok(ApiResponse<PeriodoDto>.SuccessResult(
 0219                MapearPeriodo(periodo!),
 0220                "Período reabierto. Realizá las correcciones y volvé a calcular. El próximo cálculo generará una nueva v
 221        }
 0222        catch (Exception ex)
 223        {
 0224            _logger.LogError(ex, "Error al reabrir período {Id}", id);
 0225            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 226        }
 0227    }
 228
 229    [HttpPost("{id}/calcular")]
 230    public async Task<IActionResult> Calcular(long id)
 231    {
 232        try
 233        {
 234            // 1. Marcar período como EN_CALCULO
 3235            var (success, periodo, error) = await _periodoService.IniciarCalculoAsync(id);
 3236            if (!success)
 237            {
 2238                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 1239                    return NotFound(ApiResponse<string>.ErrorResult(error));
 1240                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error al iniciar cálculo"));
 241            }
 242
 243            // 2. Ejecutar el cálculo — la versión se determina automáticamente (max+1)
 1244            var (exitoCalculo, errorCalculo, version) = await _liquidacionService.GenerarLiquidacionAsync(id);
 245
 246            // 3. Finalizar — éxito o error vuelve a LISTA_CALCULO para reintentar
 1247            await _periodoService.FinalizarCalculoAsync(id, exitoCalculo);
 248
 1249            if (!exitoCalculo)
 0250                return StatusCode(500, ApiResponse<string>.ErrorResult(errorCalculo ?? "Error durante el cálculo"));
 251
 1252            var periodoFinal = await _periodoService.ObtenerPorIdAsync(id);
 1253            return Ok(ApiResponse<PeriodoDto>.SuccessResult(
 1254                MapearPeriodo(periodoFinal!),
 1255                $"Liquidación versión {version} generada correctamente."));
 256        }
 0257        catch (Exception ex)
 258        {
 0259            await _periodoService.FinalizarCalculoAsync(id, exitoso: false).ConfigureAwait(false);
 0260            _logger.LogError(ex, "Error al calcular período {Id}", id);
 0261            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 262        }
 3263    }
 264
 265    [HttpPost("{id}/cerrar")]
 266    [RequirePermission(PermisoEnum.CerrarPeriodo)]
 267    public async Task<IActionResult> Cerrar(long id)
 268    {
 269        try
 270        {
 3271            var (success, periodo, error) = await _periodoService.CerrarAsync(id);
 272
 3273            if (!success)
 274            {
 2275                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 1276                    return NotFound(ApiResponse<string>.ErrorResult(error));
 1277                return Conflict(ApiResponse<string>.ErrorResult(error ?? "Error al cerrar período"));
 278            }
 279
 1280            return Ok(ApiResponse<PeriodoDto>.SuccessResult(MapearPeriodo(periodo!), "Período cerrado definitivamente.")
 281        }
 0282        catch (Exception ex)
 283        {
 0284            _logger.LogError(ex, "Error al cerrar período {Id}", id);
 0285            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 286        }
 3287    }
 288
 289    private static PeriodoDto MapearPeriodo(Periodo periodo)
 290    {
 7291        return new PeriodoDto
 7292        {
 7293            Id = periodo.Id,
 7294            Anio = periodo.Anio,
 7295            Mes = periodo.Mes,
 7296            Estado = periodo.Estado,
 7297            SnapshotId = periodo.SnapshotId,
 7298            FechaApertura = periodo.FechaApertura,
 7299            UsuarioApertura = periodo.UsuarioApertura,
 7300            HashSnapshot = periodo.HashSnapshot,
 7301            FechaCierreInsumos = periodo.FechaCierreInsumos,
 7302            UsuarioCierreInsumosId = periodo.UsuarioCierreInsumosId,
 7303            FechaCalculo = periodo.FechaCalculo,
 7304            FechaCierre = periodo.FechaCierre,
 7305            UsuarioCierreId = periodo.UsuarioCierreId
 7306        };
 307    }
 308}
Generated by: ReportGenerator 5.5.10.0
06/16/2026 - 04:47:14
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.Logica.Services.IPeriodoService,FAU.Logica.Services.ILiquidacionService,Microsoft.Extensions.Logging.ILogger`1<FAU.API.Controllers.PeriodosController>)
AbrirPeriodo()
GetUltimos()
GetPeriodoActivo()
GetPeriodo()
GetPrecondiciones()
ValidarInsumos()
CerrarInsumos()
ReabrirInsumos()
ReabrirDesdeCalculada()
Calcular()
Cerrar()
MapearPeriodo(FAU.Entidades.Periodo)