< Summary

Information
Class: FAU.DataAccess.Repositories.TipoBeneficioRepository
Assembly: FAU.DataAccess
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.DataAccess/Repositories/TipoBeneficioRepository.cs
Line coverage
37%
Covered lines: 55
Uncovered lines: 90
Coverable lines: 145
Total lines: 261
Line coverage: 37.9%
Branch coverage
37%
Covered branches: 9
Total branches: 24
Branch coverage: 37.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%
ObtenerPorIdAsync()100%11100%
ObtenerPorCodigoAsync()100%11100%
ObtenerPaginadoAsync()100%44100%
CrearAsync()100%11100%
ActualizarAsync()100%11100%
EliminarAsync()100%22100%
ExisteCodigoAsync()100%22100%
ExistePorIdAsync()100%11100%
TieneHistoricoBeneficiosAsync()100%11100%
TieneLiquidacionesAbiertasAsync()6.25%1961611.11%
ExisteTablaAsync()100%210%
ExisteColumnaAsync()100%210%
ExisteLiquidacionDirectaAbiertaAsync()100%210%
ExisteLiquidacionPorItemsAbiertaAsync()100%210%

File(s)

/home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.DataAccess/Repositories/TipoBeneficioRepository.cs

#LineLine coverage
 1using System.Data;
 2using FAU.Entidades;
 3using Microsoft.EntityFrameworkCore;
 4
 5namespace FAU.DataAccess.Repositories;
 6
 7public class TipoBeneficioRepository : ITipoBeneficioRepository
 8{
 9    private readonly ApplicationDbContext _context;
 10
 1811    public TipoBeneficioRepository(ApplicationDbContext context)
 12    {
 1813        _context = context;
 1814    }
 15
 16    public async Task<TipoBeneficio?> ObtenerPorIdAsync(long id)
 17    {
 318        return await _context.TiposBeneficio
 319            .FirstOrDefaultAsync(tb => tb.Id == id);
 320    }
 21
 22    public async Task<TipoBeneficio?> ObtenerPorCodigoAsync(string codigo)
 23    {
 224        var codigoNormalizado = codigo.Trim().ToUpperInvariant();
 25
 226        return await _context.TiposBeneficio
 227            .FirstOrDefaultAsync(tb => tb.Codigo.ToUpper() == codigoNormalizado);
 228    }
 29
 30    public async Task<(IEnumerable<TipoBeneficio> Items, int TotalCount)> ObtenerPaginadoAsync(
 31        int pagina,
 32        int tamano,
 33        string? busqueda = null,
 34        bool? activo = null)
 35    {
 436        var query = _context.TiposBeneficio.AsQueryable();
 37
 438        if (!string.IsNullOrWhiteSpace(busqueda))
 39        {
 140            var termino = busqueda.Trim().ToLower();
 141            query = query.Where(tb =>
 142                tb.Codigo.ToLower().Contains(termino) ||
 143                tb.Nombre.ToLower().Contains(termino));
 44        }
 45
 446        if (activo.HasValue)
 47        {
 148            query = query.Where(tb => tb.Activo == activo.Value);
 49        }
 50
 451        var totalCount = await query.CountAsync();
 52
 453        var items = await query
 454            .OrderBy(tb => tb.Nombre)
 455            .Skip((pagina - 1) * tamano)
 456            .Take(tamano)
 457            .ToListAsync();
 58
 459        return (items, totalCount);
 460    }
 61
 62    public async Task<TipoBeneficio> CrearAsync(TipoBeneficio tipoBeneficio)
 63    {
 2064        _context.TiposBeneficio.Add(tipoBeneficio);
 2065        await _context.SaveChangesAsync();
 2066        return tipoBeneficio;
 2067    }
 68
 69    public async Task<TipoBeneficio> ActualizarAsync(TipoBeneficio tipoBeneficio)
 70    {
 171        _context.TiposBeneficio.Update(tipoBeneficio);
 172        await _context.SaveChangesAsync();
 173        return tipoBeneficio;
 174    }
 75
 76    public async Task EliminarAsync(long id)
 77    {
 278        var entidad = await _context.TiposBeneficio.FindAsync(id);
 279        if (entidad == null)
 80        {
 181            return;
 82        }
 83
 184        _context.TiposBeneficio.Remove(entidad);
 185        await _context.SaveChangesAsync();
 286    }
 87
 88    public async Task<bool> ExisteCodigoAsync(string codigo, long? excluirId = null)
 89    {
 390        var codigoNormalizado = codigo.Trim().ToUpperInvariant();
 91
 392        var query = _context.TiposBeneficio
 393            .Where(tb => tb.Codigo.ToUpper() == codigoNormalizado);
 94
 395        if (excluirId.HasValue)
 96        {
 197            query = query.Where(tb => tb.Id != excluirId.Value);
 98        }
 99
 3100        return await query.AnyAsync();
 3101    }
 102
 103    public async Task<bool> ExistePorIdAsync(long id)
 104    {
 3105        return await _context.TiposBeneficio.AnyAsync(tb => tb.Id == id);
 3106    }
 107
 108    public async Task<bool> TieneHistoricoBeneficiosAsync(long tipoBeneficioId)
 109    {
 2110        return await _context.BeneficiosSociales
 2111            .AnyAsync(bs => bs.TipoBeneficioId == tipoBeneficioId);
 2112    }
 113
 114    public async Task<bool> TieneLiquidacionesAbiertasAsync(long tipoBeneficioId)
 115    {
 1116        if (!_context.Database.IsRelational())
 117        {
 1118            return false;
 119        }
 120
 0121        var conexion = _context.Database.GetDbConnection();
 0122        var abrirConexion = conexion.State != ConnectionState.Open;
 123
 0124        if (abrirConexion)
 125        {
 0126            await conexion.OpenAsync();
 127        }
 128
 129        try
 130        {
 0131            var existeLiquidaciones = await ExisteTablaAsync(conexion, "liquidaciones");
 0132            if (!existeLiquidaciones)
 133            {
 0134                return false;
 135            }
 136
 0137            var tieneEstado = await ExisteColumnaAsync(conexion, "liquidaciones", "estado");
 0138            if (!tieneEstado)
 139            {
 0140                return false;
 141            }
 142
 0143            var tieneTipoBeneficioDirecto = await ExisteColumnaAsync(conexion, "liquidaciones", "tipo_beneficio_id");
 0144            if (tieneTipoBeneficioDirecto)
 145            {
 0146                return await ExisteLiquidacionDirectaAbiertaAsync(conexion, tipoBeneficioId);
 147            }
 148
 0149            var existeLiquidacionItems = await ExisteTablaAsync(conexion, "liquidacion_items");
 0150            if (!existeLiquidacionItems)
 151            {
 0152                return false;
 153            }
 154
 0155            var liquidacionItemsTieneTipo = await ExisteColumnaAsync(conexion, "liquidacion_items", "tipo_beneficio_id")
 0156            var liquidacionItemsTieneLiquidacionId = await ExisteColumnaAsync(conexion, "liquidacion_items", "liquidacio
 0157            var liquidacionesTieneId = await ExisteColumnaAsync(conexion, "liquidaciones", "id");
 158
 0159            if (liquidacionItemsTieneTipo && liquidacionItemsTieneLiquidacionId && liquidacionesTieneId)
 160            {
 0161                return await ExisteLiquidacionPorItemsAbiertaAsync(conexion, tipoBeneficioId);
 162            }
 163
 0164            return false;
 165        }
 166        finally
 167        {
 0168            if (abrirConexion)
 169            {
 0170                await conexion.CloseAsync();
 171            }
 172        }
 1173    }
 174
 175    private static async Task<bool> ExisteTablaAsync(System.Data.Common.DbConnection conexion, string nombreTabla)
 176    {
 0177        using var comando = conexion.CreateCommand();
 0178        comando.CommandText = @"
 0179            SELECT EXISTS (
 0180                SELECT 1
 0181                FROM information_schema.tables
 0182                WHERE table_schema = 'public'
 0183                  AND table_name = @tabla
 0184            );";
 185
 0186        var parametro = comando.CreateParameter();
 0187        parametro.ParameterName = "@tabla";
 0188        parametro.Value = nombreTabla;
 0189        comando.Parameters.Add(parametro);
 190
 0191        var resultado = await comando.ExecuteScalarAsync();
 0192        return Convert.ToBoolean(resultado);
 0193    }
 194
 195    private static async Task<bool> ExisteColumnaAsync(System.Data.Common.DbConnection conexion, string nombreTabla, str
 196    {
 0197        using var comando = conexion.CreateCommand();
 0198        comando.CommandText = @"
 0199            SELECT EXISTS (
 0200                SELECT 1
 0201                FROM information_schema.columns
 0202                WHERE table_schema = 'public'
 0203                  AND table_name = @tabla
 0204                  AND column_name = @columna
 0205            );";
 206
 0207        var parametroTabla = comando.CreateParameter();
 0208        parametroTabla.ParameterName = "@tabla";
 0209        parametroTabla.Value = nombreTabla;
 0210        comando.Parameters.Add(parametroTabla);
 211
 0212        var parametroColumna = comando.CreateParameter();
 0213        parametroColumna.ParameterName = "@columna";
 0214        parametroColumna.Value = nombreColumna;
 0215        comando.Parameters.Add(parametroColumna);
 216
 0217        var resultado = await comando.ExecuteScalarAsync();
 0218        return Convert.ToBoolean(resultado);
 0219    }
 220
 221    private static async Task<bool> ExisteLiquidacionDirectaAbiertaAsync(System.Data.Common.DbConnection conexion, long 
 222    {
 0223        using var comando = conexion.CreateCommand();
 0224        comando.CommandText = @"
 0225            SELECT EXISTS (
 0226                SELECT 1
 0227                FROM liquidaciones l
 0228                WHERE l.tipo_beneficio_id = @tipoBeneficioId
 0229                  AND LOWER(COALESCE(l.estado, '')) IN ('abierta', 'abierto', 'pendiente', 'en_proceso')
 0230            );";
 231
 0232        var parametro = comando.CreateParameter();
 0233        parametro.ParameterName = "@tipoBeneficioId";
 0234        parametro.Value = tipoBeneficioId;
 0235        comando.Parameters.Add(parametro);
 236
 0237        var resultado = await comando.ExecuteScalarAsync();
 0238        return Convert.ToBoolean(resultado);
 0239    }
 240
 241    private static async Task<bool> ExisteLiquidacionPorItemsAbiertaAsync(System.Data.Common.DbConnection conexion, long
 242    {
 0243        using var comando = conexion.CreateCommand();
 0244        comando.CommandText = @"
 0245            SELECT EXISTS (
 0246                SELECT 1
 0247                FROM liquidacion_items li
 0248                INNER JOIN liquidaciones l ON l.id = li.liquidacion_id
 0249                WHERE li.tipo_beneficio_id = @tipoBeneficioId
 0250                  AND LOWER(COALESCE(l.estado, '')) IN ('abierta', 'abierto', 'pendiente', 'en_proceso')
 0251            );";
 252
 0253        var parametro = comando.CreateParameter();
 0254        parametro.ParameterName = "@tipoBeneficioId";
 0255        parametro.Value = tipoBeneficioId;
 0256        comando.Parameters.Add(parametro);
 257
 0258        var resultado = await comando.ExecuteScalarAsync();
 0259        return Convert.ToBoolean(resultado);
 0260    }
 261}
Generated by: ReportGenerator 5.5.10.0
07/10/2026 - 13:26:03
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.DataAccess.ApplicationDbContext)
ObtenerPorIdAsync()
ObtenerPorCodigoAsync()
ObtenerPaginadoAsync()
CrearAsync()
ActualizarAsync()
EliminarAsync()
ExisteCodigoAsync()
ExistePorIdAsync()
TieneHistoricoBeneficiosAsync()
TieneLiquidacionesAbiertasAsync()
ExisteTablaAsync()
ExisteColumnaAsync()
ExisteLiquidacionDirectaAbiertaAsync()
ExisteLiquidacionPorItemsAbiertaAsync()