< Summary

Information
Class: FAU.API.Controllers.BancosController
Assembly: FAU.API
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.API/Controllers/BancosController.cs
Line coverage
90%
Covered lines: 83
Uncovered lines: 9
Coverable lines: 92
Total lines: 227
Line coverage: 90.2%
Branch coverage
75%
Covered branches: 24
Total branches: 32
Branch coverage: 75%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetBancos()100%11100%
GetBanco()100%22100%
CreateBanco()66.66%121296%
UpdateBanco()77.77%181895.83%

File(s)

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

#LineLine coverage
 1using FAU.Logica.DTOs;
 2using FAU.Logica.Services;
 3using FAU.Entidades;
 4using Microsoft.AspNetCore.Authorization;
 5using Microsoft.AspNetCore.Http;
 6using Microsoft.AspNetCore.Mvc;
 7
 8namespace FAU.API.Controllers;
 9
 10/// <summary>
 11/// Gestión de bancos del sistema
 12/// </summary>
 13[ApiController]
 14[Route("api/[controller]")]
 15[Produces("application/json")]
 16public class BancosController : ControllerBase
 17{
 18    private readonly IBancoService _bancoService;
 19    private readonly ILogger<BancosController> _logger;
 20
 1921    public BancosController(
 1922        IBancoService bancoService,
 1923        ILogger<BancosController> logger)
 24    {
 1925        _bancoService = bancoService;
 1926        _logger = logger;
 1927    }
 28
 29    /// <summary>
 30    /// Listar bancos con paginación y filtros
 31    /// GET /api/bancos?page=1&pageSize=10&q=&vigente=
 32    /// </summary>
 33    /// <param name="page">Número de página (default: 1)</param>
 34    /// <param name="pageSize">Tamaño de página (default: 10, max: 100)</param>
 35    /// <param name="q">Búsqueda por nombre o código</param>
 36    /// <param name="vigente">Filtrar por estado vigente</param>
 37    [HttpGet]
 38    [FAU.API.Security.RequirePermission(PermisoEnum.VerBancos)]
 39    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 40    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 41    public async Task<IActionResult> GetBancos(
 42        [FromQuery] int page = 1,
 43        [FromQuery] int pageSize = 10,
 44        [FromQuery] string? q = null,
 45        [FromQuery] bool? vigente = null)
 46    {
 47        try
 48        {
 349            var resultado = await _bancoService.GetPagedAsync(page, pageSize, q, vigente);
 50
 251            var response = new
 252            {
 053                items = resultado.Items.Select(b => new
 054                {
 055                    id = b.Id,
 056                    nombre = b.Nombre,
 057                    codigo = b.Codigo,
 058                    vigente = b.Vigente
 059                }),
 260                page = resultado.Page,
 261                pageSize = resultado.PageSize,
 262                totalCount = resultado.TotalCount,
 263                totalPages = resultado.TotalPages,
 264                hasPreviousPage = resultado.HasPreviousPage,
 265                hasNextPage = resultado.HasNextPage
 266            };
 67
 268            return Ok(ApiResponse<object>.SuccessResult(response));
 69        }
 170        catch (Exception ex)
 71        {
 172            _logger.LogError(ex, "Error al obtener bancos");
 173            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 74        }
 375    }
 76
 77    /// <summary>
 78    /// Obtener detalle de un banco por ID
 79    /// GET /api/bancos/{id}
 80    /// </summary>
 81    [HttpGet("{id}")]
 82    [FAU.API.Security.RequirePermission(PermisoEnum.VerBancos)]
 83    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 84    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 85    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 86    public async Task<IActionResult> GetBanco(long id)
 87    {
 88        try
 89        {
 390            var banco = await _bancoService.GetByIdAsync(id);
 91
 292            if (banco == null)
 93            {
 194                return NotFound(ApiResponse<string>.ErrorResult("Banco no encontrado"));
 95            }
 96
 197            var response = new
 198            {
 199                id = banco.Id,
 1100                nombre = banco.Nombre,
 1101                codigo = banco.Codigo,
 1102                vigente = banco.Vigente
 1103            };
 104
 1105            return Ok(ApiResponse<object>.SuccessResult(response));
 106        }
 1107        catch (Exception ex)
 108        {
 1109            _logger.LogError(ex, "Error al obtener banco {Id}", id);
 1110            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 111        }
 3112    }
 113
 114    /// <summary>
 115    /// Crear un nuevo banco
 116    /// POST /api/bancos
 117    /// </summary>
 118    [HttpPost]
 119    [FAU.API.Security.RequirePermission(PermisoEnum.CrearBanco)]
 120    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status201Created)]
 121    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 122    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 123    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 124    public async Task<IActionResult> CreateBanco([FromBody] CreateBancoRequest request)
 125    {
 126        try
 127        {
 128            // Validaciones
 5129            if (string.IsNullOrWhiteSpace(request.Nombre))
 130            {
 1131                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del banco es requerido"));
 132            }
 133
 4134            if (string.IsNullOrWhiteSpace(request.Codigo))
 135            {
 1136                return BadRequest(ApiResponse<string>.ErrorResult("El código del banco es requerido"));
 137            }
 138
 3139            var (success, banco, error) = await _bancoService.CreateAsync(
 3140                request.Nombre,
 3141                request.Codigo,
 3142                request.Vigente);
 143
 2144            if (!success)
 145            {
 1146                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 147                {
 1148                    return Conflict(ApiResponse<string>.ErrorResult(error));
 149                }
 0150                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear banco"));
 151            }
 152
 1153            var response = new
 1154            {
 1155                id = banco!.Id,
 1156                creado = true
 1157            };
 158
 1159            return CreatedAtAction(
 1160                nameof(GetBanco),
 1161                new { id = banco.Id },
 1162                ApiResponse<object>.SuccessResult(response, "Banco creado exitosamente"));
 163        }
 1164        catch (Exception ex)
 165        {
 1166            _logger.LogError(ex, "Error al crear banco");
 1167            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 168        }
 5169    }
 170
 171    /// <summary>
 172    /// Editar un banco existente (incluye activar/desactivar)
 173    /// PUT /api/bancos/{id}
 174    /// </summary>
 175    [HttpPut("{id}")]
 176    [FAU.API.Security.RequirePermission(PermisoEnum.ActualizarBanco)]
 177    [ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status200OK)]
 178    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status400BadRequest)]
 179    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status404NotFound)]
 180    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status409Conflict)]
 181    [ProducesResponseType(typeof(ApiResponse<string>), StatusCodes.Status500InternalServerError)]
 182    public async Task<IActionResult> UpdateBanco(long id, [FromBody] UpdateBancoRequest request)
 183    {
 184        try
 185        {
 186            // Validar que al menos un campo se está actualizando
 8187            if (string.IsNullOrWhiteSpace(request.Nombre) &&
 8188                string.IsNullOrWhiteSpace(request.Codigo) &&
 8189                !request.Vigente.HasValue)
 190            {
 1191                return BadRequest(ApiResponse<string>.ErrorResult("Debe proporcionar al menos un campo para actualizar")
 192            }
 193
 7194            var (success, banco, error) = await _bancoService.UpdateAsync(
 7195                id,
 7196                request.Nombre,
 7197                request.Codigo,
 7198                request.Vigente);
 199
 6200            if (!success)
 201            {
 2202                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 203                {
 1204                    return NotFound(ApiResponse<string>.ErrorResult(error));
 205                }
 1206                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 207                {
 1208                    return Conflict(ApiResponse<string>.ErrorResult(error));
 209                }
 0210                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar banco"));
 211            }
 212
 4213            var response = new
 4214            {
 4215                actualizado = true
 4216            };
 217
 4218            return Ok(ApiResponse<object>.SuccessResult(response, "Banco actualizado exitosamente"));
 219        }
 1220        catch (Exception ex)
 221        {
 1222            _logger.LogError(ex, "Error al actualizar banco {Id}", id);
 1223            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 224        }
 8225    }
 226}
 227
Generated by: ReportGenerator 5.5.10.0
06/18/2026 - 03:39:18
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.Logica.Services.IBancoService,Microsoft.Extensions.Logging.ILogger`1<FAU.API.Controllers.BancosController>)
GetBancos()
GetBanco()
CreateBanco()
UpdateBanco()