< 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
100%
Covered lines: 117
Uncovered lines: 0
Coverable lines: 117
Total lines: 253
Line coverage: 100%
Branch coverage
90%
Covered branches: 9
Total branches: 10
Branch coverage: 90%
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%11100%
Obtener()100%22100%
Crear()100%22100%
Actualizar()100%22100%
DarBaja()100%11100%
Reactivar()100%11100%
ValidarImportacion()100%11100%
AplicarImportacion()100%22100%
ObtenerUsuarioId()50%22100%
EsNoEncontrado(...)100%11100%

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
 2921    public FictosController(
 2922        IFictoPersonaService servicio,
 2923        ICurrentUserContext usuarioActual,
 2924        ILogger<FictosController> logger)
 25    {
 2926        _servicio = servicio;
 2927        _usuarioActual = usuarioActual;
 2928        _logger = logger;
 2929    }
 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        {
 342            var resultado = await _servicio.ObtenerPaginadoAsync(
 343                pagina,
 344                tamano,
 345                busqueda,
 346                tipo,
 347                activo);
 148            return Ok(ApiResponse<PagedResult<FictoPersonaDto>>.SuccessResult(resultado));
 49        }
 150        catch (ArgumentException ex)
 51        {
 152            return BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 53        }
 154        catch (Exception ex)
 55        {
 156            _logger.LogError(ex, "Error al listar fictos permanentes");
 157            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 58        }
 359    }
 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        {
 368            var ficto = await _servicio.ObtenerPorIdAsync(id);
 269            return ficto is null
 270                ? NotFound(ApiResponse<string>.ErrorResult("Ficto no encontrado"))
 271                : Ok(ApiResponse<FictoPersonaDto>.SuccessResult(ficto));
 72        }
 173        catch (Exception ex)
 74        {
 175            _logger.LogError(ex, "Error al obtener el ficto {FictoId}", id);
 176            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 77        }
 378    }
 79
 80    [HttpPost]
 81    [ProducesResponseType(typeof(ApiResponse<FictoPersonaDto>), StatusCodes.Status201Created)]
 82    public async Task<IActionResult> Crear([FromBody] CrearFictoPersonaRequest request)
 83    {
 84        try
 85        {
 586            var ficto = await _servicio.CrearAsync(
 587                request,
 588                ObtenerUsuarioId(),
 589                _usuarioActual.Host);
 190            return CreatedAtAction(
 191                nameof(Obtener),
 192                new { id = ficto.Id },
 193                ApiResponse<FictoPersonaDto>.SuccessResult(ficto, "Ficto creado exitosamente"));
 94        }
 295        catch (ArgumentException ex)
 96        {
 297            return EsNoEncontrado(ex.Message)
 298                ? NotFound(ApiResponse<string>.ErrorResult(ex.Message))
 299                : BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 100        }
 1101        catch (InvalidOperationException ex)
 102        {
 1103            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 104        }
 1105        catch (Exception ex)
 106        {
 1107            _logger.LogError(ex, "Error al crear un ficto permanente");
 1108            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 109        }
 5110    }
 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        {
 5120            var ficto = await _servicio.ActualizarAsync(
 5121                id,
 5122                request,
 5123                ObtenerUsuarioId(),
 5124                _usuarioActual.Host);
 1125            return Ok(ApiResponse<FictoPersonaDto>.SuccessResult(
 1126                ficto,
 1127                "Ficto actualizado exitosamente"));
 128        }
 2129        catch (ArgumentException ex)
 130        {
 2131            return EsNoEncontrado(ex.Message)
 2132                ? NotFound(ApiResponse<string>.ErrorResult(ex.Message))
 2133                : BadRequest(ApiResponse<string>.ErrorResult(ex.Message));
 134        }
 1135        catch (InvalidOperationException ex)
 136        {
 1137            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 138        }
 1139        catch (Exception ex)
 140        {
 1141            _logger.LogError(ex, "Error al actualizar el ficto {FictoId}", id);
 1142            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 143        }
 5144    }
 145
 146    [HttpDelete("{id:long}")]
 147    [ProducesResponseType(StatusCodes.Status204NoContent)]
 148    public async Task<IActionResult> DarBaja(long id)
 149    {
 150        try
 151        {
 4152            await _servicio.DarBajaAsync(id, ObtenerUsuarioId(), _usuarioActual.Host);
 1153            return NoContent();
 154        }
 1155        catch (ArgumentException ex)
 156        {
 1157            return NotFound(ApiResponse<string>.ErrorResult(ex.Message));
 158        }
 1159        catch (InvalidOperationException ex)
 160        {
 1161            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 162        }
 1163        catch (Exception ex)
 164        {
 1165            _logger.LogError(ex, "Error al dar de baja el ficto {FictoId}", id);
 1166            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 167        }
 4168    }
 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        {
 4176            var ficto = await _servicio.ReactivarAsync(
 4177                id,
 4178                ObtenerUsuarioId(),
 4179                _usuarioActual.Host);
 1180            return Ok(ApiResponse<FictoPersonaDto>.SuccessResult(
 1181                ficto,
 1182                "Ficto reactivado exitosamente"));
 183        }
 1184        catch (ArgumentException ex)
 185        {
 1186            return NotFound(ApiResponse<string>.ErrorResult(ex.Message));
 187        }
 1188        catch (InvalidOperationException ex)
 189        {
 1190            return Conflict(ApiResponse<string>.ErrorResult(ex.Message));
 191        }
 1192        catch (Exception ex)
 193        {
 1194            _logger.LogError(ex, "Error al reactivar el ficto {FictoId}", id);
 1195            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 196        }
 4197    }
 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        {
 2205            var resultado = await _servicio.ValidarImportacionAsync(request);
 1206            return Ok(ApiResponse<ResultadoValidacionImportacionFictosDto>.SuccessResult(resultado));
 207        }
 1208        catch (Exception ex)
 209        {
 1210            _logger.LogError(ex, "Error al validar una importación de fictos");
 1211            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 212        }
 2213    }
 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        {
 3222            var resultado = await _servicio.AplicarImportacionAsync(
 3223                request,
 3224                ObtenerUsuarioId(),
 3225                _usuarioActual.Host);
 2226            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
 1236            return Ok(ApiResponse<ResultadoImportacionFictosDto>.SuccessResult(
 1237                resultado,
 1238                "Fictos importados exitosamente"));
 239        }
 1240        catch (Exception ex)
 241        {
 1242            _logger.LogError(ex, "Error al aplicar una importación de fictos");
 1243            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 244        }
 3245    }
 246
 247    private long ObtenerUsuarioId() =>
 21248        _usuarioActual.UserId
 21249        ?? throw new UnauthorizedAccessException("No se pudo identificar al usuario autenticado.");
 250
 251    private static bool EsNoEncontrado(string mensaje) =>
 4252        mensaje.Contains("no encontr", StringComparison.OrdinalIgnoreCase);
 253}
Generated by: ReportGenerator 5.5.10.0
07/10/2026 - 13:26:03
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)