< Summary

Information
Class: FAU.API.Controllers.FictosController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/FictosController.cs
Line coverage
33%
Covered lines: 39
Uncovered lines: 78
Coverable lines: 117
Total lines: 253
Line coverage: 33.3%
Branch coverage
20%
Covered branches: 2
Total branches: 10
Branch coverage: 20%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
Listar()100%1161.53%
Obtener()0%620%
Crear()0%3250%
Actualizar()0%620%
DarBaja()100%210%
Reactivar()100%210%
ValidarImportacion()100%210%
AplicarImportacion()50%2266.66%
ObtenerUsuarioId()50%22100%
EsNoEncontrado(...)100%210%

File(s)

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

#LineLine coverage
 1using FAU.Logica.DTOs;
 2using FAU.Logica.Services;
 3using Microsoft.AspNetCore.Authorization;
 4using Microsoft.AspNetCore.Mvc;
 5
 6namespace FAU.API.Controllers;
 7
 8/// <summary>
 9/// Gestión del padrón permanente de fictos.
 10/// </summary>
 11[ApiController]
 12[Route("api/fictos")]
 13[Authorize(Roles = "Administrador,Supervisor,Usuario")]
 14[Produces("application/json")]
 15public class FictosController : ControllerBase
 16{
 17    private readonly IFictoPersonaService _servicio;
 18    private readonly ICurrentUserContext _usuarioActual;
 19    private readonly ILogger<FictosController> _logger;
 20
 321    public FictosController(
 322        IFictoPersonaService servicio,
 323        ICurrentUserContext usuarioActual,
 324        ILogger<FictosController> logger)
 25    {
 326        _servicio = servicio;
 327        _usuarioActual = usuarioActual;
 328        _logger = logger;
 329    }
 30
 31    [HttpGet]
 32    [ProducesResponseType(typeof(ApiResponse<PagedResult<FictoPersonaDto>>), StatusCodes.Status200OK)]
 33    public async Task<IActionResult> Listar(
 34        [FromQuery] int pagina = 1,
 35        [FromQuery] int tamano = 20,
 36        [FromQuery] string? busqueda = null,
 37        [FromQuery] string? tipo = null,
 38        [FromQuery] bool? activo = null)
 39    {
 40        try
 41        {
 142            var resultado = await _servicio.ObtenerPaginadoAsync(
 143                pagina,
 144                tamano,
 145                busqueda,
 146                tipo,
 147                activo);
 148            return Ok(ApiResponse<PagedResult<FictoPersonaDto>>.SuccessResult(resultado));
 49        }
 050        catch (ArgumentException ex)
 51        {
 052            return BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 53        }
 054        catch (Exception ex)
 55        {
 056            _logger.LogError(ex, "Error al listar fictos permanentes");
 057            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 58        }
 159    }
 60
 61    [HttpGet("{id:long}")]
 62    [ProducesResponseType(typeof(ApiResponse<FictoPersonaDto>), StatusCodes.Status200OK)]
 63    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 64    public async Task<IActionResult> Obtener(long id)
 65    {
 66        try
 67        {
 068            var ficto = await _servicio.ObtenerPorIdAsync(id);
 069            return ficto is null
 070                ? NotFound(ApiResponse<string>.ErrorResult("Ficto no encontrado"))
 071                : Ok(ApiResponse<FictoPersonaDto>.SuccessResult(ficto));
 72        }
 073        catch (Exception ex)
 74        {
 075            _logger.LogError(ex, "Error al obtener el ficto {FictoId}", id);
 076            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 77        }
 078    }
 79
 80    [HttpPost]
 81    [ProducesResponseType(typeof(ApiResponse<FictoPersonaDto>), StatusCodes.Status201Created)]
 82    public async Task<IActionResult> Crear([FromBody] CrearFictoPersonaRequest request)
 83    {
 84        try
 85        {
 186            var ficto = await _servicio.CrearAsync(
 187                request,
 188                ObtenerUsuarioId(),
 189                _usuarioActual.Host);
 190            return CreatedAtAction(
 191                nameof(Obtener),
 192                new { id = ficto.Id },
 193                ApiResponse<FictoPersonaDto>.SuccessResult(ficto, "Ficto creado exitosamente"));
 94        }
 095        catch (ArgumentException ex)
 96        {
 097            return EsNoEncontrado(ex.Message)
 098                ? NotFound(ApiResponse<string>.ErrorResult(ex.Message))
 099                : BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 100        }
 0101        catch (InvalidOperationException ex)
 102        {
 0103            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 104        }
 0105        catch (Exception ex)
 106        {
 0107            _logger.LogError(ex, "Error al crear un ficto permanente");
 0108            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 109        }
 1110    }
 111
 112    [HttpPut("{id:long}")]
 113    [ProducesResponseType(typeof(ApiResponse<FictoPersonaDto>), StatusCodes.Status200OK)]
 114    public async Task<IActionResult> Actualizar(
 115        long id,
 116        [FromBody] ActualizarFictoPersonaRequest request)
 117    {
 118        try
 119        {
 0120            var ficto = await _servicio.ActualizarAsync(
 0121                id,
 0122                request,
 0123                ObtenerUsuarioId(),
 0124                _usuarioActual.Host);
 0125            return Ok(ApiResponse<FictoPersonaDto>.SuccessResult(
 0126                ficto,
 0127                "Ficto actualizado exitosamente"));
 128        }
 0129        catch (ArgumentException ex)
 130        {
 0131            return EsNoEncontrado(ex.Message)
 0132                ? NotFound(ApiResponse<string>.ErrorResult(ex.Message))
 0133                : BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 134        }
 0135        catch (InvalidOperationException ex)
 136        {
 0137            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 138        }
 0139        catch (Exception ex)
 140        {
 0141            _logger.LogError(ex, "Error al actualizar el ficto {FictoId}", id);
 0142            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 143        }
 0144    }
 145
 146    [HttpDelete("{id:long}")]
 147    [ProducesResponseType(StatusCodes.Status204NoContent)]
 148    public async Task<IActionResult> DarBaja(long id)
 149    {
 150        try
 151        {
 0152            await _servicio.DarBajaAsync(id, ObtenerUsuarioId(), _usuarioActual.Host);
 0153            return NoContent();
 154        }
 0155        catch (ArgumentException ex)
 156        {
 0157            return NotFound(ApiResponse<string>.ErrorResult(ex.Message));
 158        }
 0159        catch (InvalidOperationException ex)
 160        {
 0161            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 162        }
 0163        catch (Exception ex)
 164        {
 0165            _logger.LogError(ex, "Error al dar de baja el ficto {FictoId}", id);
 0166            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 167        }
 0168    }
 169
 170    [HttpPost("{id:long}/reactivar")]
 171    [ProducesResponseType(typeof(ApiResponse<FictoPersonaDto>), StatusCodes.Status200OK)]
 172    public async Task<IActionResult> Reactivar(long id)
 173    {
 174        try
 175        {
 0176            var ficto = await _servicio.ReactivarAsync(
 0177                id,
 0178                ObtenerUsuarioId(),
 0179                _usuarioActual.Host);
 0180            return Ok(ApiResponse<FictoPersonaDto>.SuccessResult(
 0181                ficto,
 0182                "Ficto reactivado exitosamente"));
 183        }
 0184        catch (ArgumentException ex)
 185        {
 0186            return NotFound(ApiResponse<string>.ErrorResult(ex.Message));
 187        }
 0188        catch (InvalidOperationException ex)
 189        {
 0190            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 191        }
 0192        catch (Exception ex)
 193        {
 0194            _logger.LogError(ex, "Error al reactivar el ficto {FictoId}", id);
 0195            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 196        }
 0197    }
 198
 199    [HttpPost("importacion/validar")]
 200    [ProducesResponseType(typeof(ApiResponse<ResultadoValidacionImportacionFictosDto>), StatusCodes.Status200OK)]
 201    public async Task<IActionResult> ValidarImportacion([FromBody] ImportarFictosRequest request)
 202    {
 203        try
 204        {
 0205            var resultado = await _servicio.ValidarImportacionAsync(request);
 0206            return Ok(ApiResponse<ResultadoValidacionImportacionFictosDto>.SuccessResult(resultado));
 207        }
 0208        catch (Exception ex)
 209        {
 0210            _logger.LogError(ex, "Error al validar una importación de fictos");
 0211            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 212        }
 0213    }
 214
 215    [HttpPost("importacion/aplicar")]
 216    [ProducesResponseType(typeof(ApiResponse<ResultadoImportacionFictosDto>), StatusCodes.Status200OK)]
 217    [ProducesResponseType(typeof(ApiResponse<ResultadoImportacionFictosDto>), StatusCodes.Status409Conflict)]
 218    public async Task<IActionResult> AplicarImportacion([FromBody] ImportarFictosRequest request)
 219    {
 220        try
 221        {
 1222            var resultado = await _servicio.AplicarImportacionAsync(
 1223                request,
 1224                ObtenerUsuarioId(),
 1225                _usuarioActual.Host);
 1226            if (!resultado.Aplicado)
 227            {
 1228                return Conflict(new ApiResponse<ResultadoImportacionFictosDto>
 1229                {
 1230                    Success = false,
 1231                    Data = resultado,
 1232                    Error = "La importación contiene errores y no se aplicó."
 1233                });
 234            }
 235
 0236            return Ok(ApiResponse<ResultadoImportacionFictosDto>.SuccessResult(
 0237                resultado,
 0238                "Fictos importados exitosamente"));
 239        }
 0240        catch (Exception ex)
 241        {
 0242            _logger.LogError(ex, "Error al aplicar una importación de fictos");
 0243            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 244        }
 1245    }
 246
 247    private long ObtenerUsuarioId() =>
 2248        _usuarioActual.UserId
 2249        ?? throw new UnauthorizedAccessException("No se pudo identificar al usuario autenticado.");
 250
 251    private static bool EsNoEncontrado(string mensaje) =>
 0252        mensaje.Contains("no encontr", StringComparison.OrdinalIgnoreCase);
 253}
Generated by: ReportGenerator 5.5.10.0
06/30/2026 - 23:42:29
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.Logica.Services.IFictoPersonaService,FAU.Logica.Services.ICurrentUserContext,Microsoft.Extensions.Logging.ILogger`1<FAU.API.Controllers.FictosController>)
Listar()
Obtener()
Crear()
Actualizar()
DarBaja()
Reactivar()
ValidarImportacion()
AplicarImportacion()
ObtenerUsuarioId()
EsNoEncontrado(System.String)