< 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: 211
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.Mvc;
 6
 7namespace FAU.API.Controllers;
 8
 9/// <summary>
 10/// Gestión de bancos del sistema
 11/// </summary>
 12[ApiController]
 13[Route("api/[controller]")]
 14public class BancosController : ControllerBase
 15{
 16    private readonly IBancoService _bancoService;
 17    private readonly ILogger<BancosController> _logger;
 18
 1919    public BancosController(
 1920        IBancoService bancoService,
 1921        ILogger<BancosController> logger)
 22    {
 1923        _bancoService = bancoService;
 1924        _logger = logger;
 1925    }
 26
 27    /// <summary>
 28    /// Listar bancos con paginación y filtros
 29    /// GET /api/bancos?page=1&pageSize=10&q=&vigente=
 30    /// </summary>
 31    /// <param name="page">Número de página (default: 1)</param>
 32    /// <param name="pageSize">Tamaño de página (default: 10, max: 100)</param>
 33    /// <param name="q">Búsqueda por nombre o código</param>
 34    /// <param name="vigente">Filtrar por estado vigente</param>
 35    [HttpGet]
 36    [FAU.API.Security.RequirePermission(PermisoEnum.VerBancos)]
 37    public async Task<IActionResult> GetBancos(
 38        [FromQuery] int page = 1,
 39        [FromQuery] int pageSize = 10,
 40        [FromQuery] string? q = null,
 41        [FromQuery] bool? vigente = null)
 42    {
 43        try
 44        {
 345            var resultado = await _bancoService.GetPagedAsync(page, pageSize, q, vigente);
 46
 247            var response = new
 248            {
 049                items = resultado.Items.Select(b => new
 050                {
 051                    id = b.Id,
 052                    nombre = b.Nombre,
 053                    codigo = b.Codigo,
 054                    vigente = b.Vigente
 055                }),
 256                page = resultado.Page,
 257                pageSize = resultado.PageSize,
 258                totalCount = resultado.TotalCount,
 259                totalPages = resultado.TotalPages,
 260                hasPreviousPage = resultado.HasPreviousPage,
 261                hasNextPage = resultado.HasNextPage
 262            };
 63
 264            return Ok(ApiResponse<object>.SuccessResult(response));
 65        }
 166        catch (Exception ex)
 67        {
 168            _logger.LogError(ex, "Error al obtener bancos");
 169            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 70        }
 371    }
 72
 73    /// <summary>
 74    /// Obtener detalle de un banco por ID
 75    /// GET /api/bancos/{id}
 76    /// </summary>
 77    [HttpGet("{id}")]
 78    [FAU.API.Security.RequirePermission(PermisoEnum.VerBancos)]
 79    public async Task<IActionResult> GetBanco(long id)
 80    {
 81        try
 82        {
 383            var banco = await _bancoService.GetByIdAsync(id);
 84
 285            if (banco == null)
 86            {
 187                return NotFound(ApiResponse<string>.ErrorResult("Banco no encontrado"));
 88            }
 89
 190            var response = new
 191            {
 192                id = banco.Id,
 193                nombre = banco.Nombre,
 194                codigo = banco.Codigo,
 195                vigente = banco.Vigente
 196            };
 97
 198            return Ok(ApiResponse<object>.SuccessResult(response));
 99        }
 1100        catch (Exception ex)
 101        {
 1102            _logger.LogError(ex, "Error al obtener banco {Id}", id);
 1103            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 104        }
 3105    }
 106
 107    /// <summary>
 108    /// Crear un nuevo banco
 109    /// POST /api/bancos
 110    /// </summary>
 111    [HttpPost]
 112    [FAU.API.Security.RequirePermission(PermisoEnum.CrearBanco)]
 113    public async Task<IActionResult> CreateBanco([FromBody] CreateBancoRequest request)
 114    {
 115        try
 116        {
 117            // Validaciones
 5118            if (string.IsNullOrWhiteSpace(request.Nombre))
 119            {
 1120                return BadRequest(ApiResponse<string>.ErrorResult("El nombre del banco es requerido"));
 121            }
 122
 4123            if (string.IsNullOrWhiteSpace(request.Codigo))
 124            {
 1125                return BadRequest(ApiResponse<string>.ErrorResult("El código del banco es requerido"));
 126            }
 127
 3128            var (success, banco, error) = await _bancoService.CreateAsync(
 3129                request.Nombre,
 3130                request.Codigo,
 3131                request.Vigente);
 132
 2133            if (!success)
 134            {
 1135                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 136                {
 1137                    return Conflict(ApiResponse<string>.ErrorResult(error));
 138                }
 0139                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al crear banco"));
 140            }
 141
 1142            var response = new
 1143            {
 1144                id = banco!.Id,
 1145                creado = true
 1146            };
 147
 1148            return CreatedAtAction(
 1149                nameof(GetBanco),
 1150                new { id = banco.Id },
 1151                ApiResponse<object>.SuccessResult(response, "Banco creado exitosamente"));
 152        }
 1153        catch (Exception ex)
 154        {
 1155            _logger.LogError(ex, "Error al crear banco");
 1156            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 157        }
 5158    }
 159
 160    /// <summary>
 161    /// Editar un banco existente (incluye activar/desactivar)
 162    /// PUT /api/bancos/{id}
 163    /// </summary>
 164    [HttpPut("{id}")]
 165    [FAU.API.Security.RequirePermission(PermisoEnum.ActualizarBanco)]
 166    public async Task<IActionResult> UpdateBanco(long id, [FromBody] UpdateBancoRequest request)
 167    {
 168        try
 169        {
 170            // Validar que al menos un campo se está actualizando
 8171            if (string.IsNullOrWhiteSpace(request.Nombre) &&
 8172                string.IsNullOrWhiteSpace(request.Codigo) &&
 8173                !request.Vigente.HasValue)
 174            {
 1175                return BadRequest(ApiResponse<string>.ErrorResult("Debe proporcionar al menos un campo para actualizar")
 176            }
 177
 7178            var (success, banco, error) = await _bancoService.UpdateAsync(
 7179                id,
 7180                request.Nombre,
 7181                request.Codigo,
 7182                request.Vigente);
 183
 6184            if (!success)
 185            {
 2186                if (error?.Contains("no encontrado", StringComparison.OrdinalIgnoreCase) == true)
 187                {
 1188                    return NotFound(ApiResponse<string>.ErrorResult(error));
 189                }
 1190                if (error?.Contains("ya existe", StringComparison.OrdinalIgnoreCase) == true)
 191                {
 1192                    return Conflict(ApiResponse<string>.ErrorResult(error));
 193                }
 0194                return BadRequest(ApiResponse<string>.ErrorResult(error ?? "Error al actualizar banco"));
 195            }
 196
 4197            var response = new
 4198            {
 4199                actualizado = true
 4200            };
 201
 4202            return Ok(ApiResponse<object>.SuccessResult(response, "Banco actualizado exitosamente"));
 203        }
 1204        catch (Exception ex)
 205        {
 1206            _logger.LogError(ex, "Error al actualizar banco {Id}", id);
 1207            return StatusCode(500, ApiResponse<string>.ErrorResult("Error interno del servidor"));
 208        }
 8209    }
 210}
 211
Generated by: ReportGenerator 5.5.10.0
05/14/2026 - 23:28:37
GitHub | reportgenerator.io

Methods/Properties

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