< Summary

Information
Class: FAU.DataAccess.Repositories.ReportePresupuestalRepository
Assembly: FAU.DataAccess
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.DataAccess/Repositories/ReportePresupuestalRepository.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 163
Coverable lines: 163
Total lines: 216
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 18
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
ObtenerVersionMaximaAsync()100%210%
ObtenerItemsConDatosAsync()0%620%
ObtenerMovimientosAsync()0%620%
ObtenerResumenPeriodoAnteriorAsync()0%4260%
ObtenerNoDisponiblesAsync()0%620%

File(s)

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

#LineLine coverage
 1using FAU.Entidades;
 2using Microsoft.EntityFrameworkCore;
 3
 4namespace FAU.DataAccess.Repositories;
 5
 6public class ReportePresupuestalRepository : IReportePresupuestalRepository
 7{
 8    private readonly ApplicationDbContext _context;
 9
 010    public ReportePresupuestalRepository(ApplicationDbContext context)
 11    {
 012        _context = context;
 013    }
 14
 15    public async Task<int> ObtenerVersionMaximaAsync(long periodoId)
 16    {
 017        return await _context.LiquidacionItems
 018            .AsNoTracking()
 019            .Where(i => i.PeriodoId == periodoId)
 020            .MaxAsync(i => (int?)i.Version) ?? 0;
 021    }
 22
 23    public async Task<List<ItemConDatos>> ObtenerItemsConDatosAsync(long periodoId, int version)
 24    {
 025        var items = await _context.LiquidacionItems
 026            .AsNoTracking()
 027            .Where(i => i.PeriodoId == periodoId && i.Version == version)
 028            .ToListAsync();
 29
 030        if (items.Count == 0)
 031            return new List<ItemConDatos>();
 32
 033        var cedulas = items.Select(i => i.Cedula).ToHashSet();
 34
 35        // Cargar relaciones activas de las cédulas presentes
 036        var relaciones = await _context.RelacionesLaborales
 037            .AsNoTracking()
 038            .Include(r => r.Persona)
 039            .Include(r => r.Grado)
 040            .Include(r => r.Escalafon)
 041            .Include(r => r.Regimen)
 042            .Include(r => r.Programa)
 043            .Include(r => r.Unidad)
 044            .Where(r => r.Estado == EstadoRelacion.Activo && cedulas.Contains(r.Persona.Cedula))
 045            .ToListAsync();
 46
 047        var relacionPorCedula = relaciones
 048            .GroupBy(r => r.Persona.Cedula)
 049            .ToDictionary(g => g.Key, g => g.First());
 50
 051        return items
 052            .Select(i =>
 053            {
 054                if (!relacionPorCedula.TryGetValue(i.Cedula, out var rel))
 055                    return null;
 056
 057                return new ItemConDatos(
 058                    Cedula: i.Cedula,
 059                    Nombre: rel.Persona.NombreCompleto,
 060                    Grado: rel.Grado.Denominacion,
 061                    Escalafon: rel.Escalafon.Denominacion,
 062                    Regimen: rel.Regimen.NumeroLey,
 063                    RegimenId: rel.RegimenId,
 064                    Programa: rel.Programa.Denominacion,
 065                    ProgramaId: rel.ProgramaId,
 066                    Unidad: rel.Unidad.Denominacion,
 067                    RubroContable: i.RubroContable,
 068                    Importe: i.Importe
 069                );
 070            })
 071            .Where(x => x is not null)
 072            .Select(x => x!)
 073            .ToList();
 074    }
 75
 76    public async Task<List<MovimientoConDatos>> ObtenerMovimientosAsync(long periodoId)
 77    {
 078        var periodo = await _context.PeriodosLiquidacion
 079            .AsNoTracking()
 080            .FirstOrDefaultAsync(p => p.Id == periodoId);
 81
 082        if (periodo is null)
 083            return new List<MovimientoConDatos>();
 84
 085        var desde = new DateTime(periodo.Anio, periodo.Mes, 1);
 086        var hasta = desde.AddMonths(1);
 87
 088        return await _context.MovimientosLaborales
 089            .AsNoTracking()
 090            .Include(m => m.RelacionLaboral)
 091                .ThenInclude(r => r.Persona)
 092            .Include(m => m.TipoMovimiento)
 093            .Where(m => m.FechaMovimiento >= desde && m.FechaMovimiento < hasta)
 094            .Select(m => new MovimientoConDatos(
 095                m.RelacionLaboral.Persona.Cedula,
 096                m.RelacionLaboral.Persona.NombreCompleto,
 097                m.TipoMovimiento.Nombre,
 098                m.FechaMovimiento,
 099                m.Observaciones,
 0100                m.TipoMovimiento.EsAlta
 0101            ))
 0102            .ToListAsync();
 0103    }
 104
 105    public async Task<Dictionary<string, DiferenciaFilaDto>?> ObtenerResumenPeriodoAnteriorAsync(long periodoId)
 106    {
 0107        var periodoActual = await _context.PeriodosLiquidacion
 0108            .AsNoTracking()
 0109            .FirstOrDefaultAsync(p => p.Id == periodoId);
 110
 0111        if (periodoActual is null)
 0112            return null;
 113
 114        // Buscar el período CERRADA más reciente anterior al actual (por anio/mes)
 0115        var periodoAnterior = await _context.PeriodosLiquidacion
 0116            .AsNoTracking()
 0117            .Where(p => p.Estado == Periodo.EstadoCerrada
 0118                && (p.Anio < periodoActual.Anio
 0119                    || (p.Anio == periodoActual.Anio && p.Mes < periodoActual.Mes)))
 0120            .OrderByDescending(p => p.Anio)
 0121            .ThenByDescending(p => p.Mes)
 0122            .FirstOrDefaultAsync();
 123
 0124        if (periodoAnterior is null)
 0125            return null;
 126
 0127        var versionAnterior = await _context.LiquidacionItems
 0128            .AsNoTracking()
 0129            .Where(i => i.PeriodoId == periodoAnterior.Id)
 0130            .MaxAsync(i => (int?)i.Version) ?? 0;
 131
 0132        var items = await _context.LiquidacionItems
 0133            .AsNoTracking()
 0134            .Where(i => i.PeriodoId == periodoAnterior.Id && i.Version == versionAnterior)
 0135            .ToListAsync();
 136
 0137        if (items.Count == 0)
 0138            return new Dictionary<string, DiferenciaFilaDto>();
 139
 0140        var cedulas = items.Select(i => i.Cedula).ToHashSet();
 141
 142        // Sin filtro de estado: los funcionarios dados de baja ya no son Activo
 0143        var relaciones = await _context.RelacionesLaborales
 0144            .AsNoTracking()
 0145            .Include(r => r.Persona)
 0146            .Include(r => r.Grado)
 0147            .Include(r => r.Regimen)
 0148            .Include(r => r.Programa)
 0149            .Where(r => cedulas.Contains(r.Persona.Cedula))
 0150            .ToListAsync();
 151
 0152        var relacionPorCedula = relaciones
 0153            .GroupBy(r => r.Persona.Cedula)
 0154            .ToDictionary(g => g.Key, g => g.First());
 155
 0156        return items
 0157            .GroupBy(i => i.Cedula)
 0158            .Select(g =>
 0159            {
 0160                var cedula = g.Key;
 0161                var liquido = g.Sum(i => i.Importe);
 0162                if (!relacionPorCedula.TryGetValue(cedula, out var rel))
 0163                    return new DiferenciaFilaDto { Cedula = cedula, Liquido = liquido };
 0164
 0165                return new DiferenciaFilaDto
 0166                {
 0167                    Cedula   = cedula,
 0168                    Nombre   = rel.Persona.NombreCompleto,
 0169                    Grado    = rel.Grado.Denominacion,
 0170                    Regimen  = rel.Regimen.NumeroLey,
 0171                    Programa = rel.Programa.Denominacion,
 0172                    Liquido  = liquido
 0173                };
 0174            })
 0175            .ToDictionary(f => f.Cedula);
 0176    }
 177
 178    public async Task<List<NoDisponibleRaw>> ObtenerNoDisponiblesAsync(long periodoId, int version)
 179    {
 180        // Funcionarios en situaciones que no afectan cobro
 0181        var relaciones = await _context.RelacionesLaborales
 0182            .AsNoTracking()
 0183            .Include(r => r.Persona)
 0184            .Include(r => r.Situacion)
 0185            .Where(r => r.Estado == EstadoRelacion.Activo && !r.Situacion.AfectaCobro)
 0186            .ToListAsync();
 187
 0188        if (relaciones.Count == 0)
 0189            return new List<NoDisponibleRaw>();
 190
 0191        var cedulas = relaciones.Select(r => r.Persona.Cedula).ToHashSet();
 192
 193        // Calcular total liquidado por cédula en el período
 0194        var totales = await _context.LiquidacionItems
 0195            .AsNoTracking()
 0196            .Where(i => i.PeriodoId == periodoId && i.Version == version && cedulas.Contains(i.Cedula))
 0197            .GroupBy(i => i.Cedula)
 0198            .Select(g => new { Cedula = g.Key, Total = g.Sum(i => i.Importe) })
 0199            .ToDictionaryAsync(x => x.Cedula, x => x.Total);
 200
 0201        return relaciones
 0202            .GroupBy(r => r.Persona.Cedula)
 0203            .Select(g =>
 0204            {
 0205                var rel = g.First();
 0206                var total = totales.TryGetValue(rel.Persona.Cedula, out var t) ? t : 0m;
 0207                return new NoDisponibleRaw(
 0208                    Cedula: rel.Persona.Cedula,
 0209                    Nombre: rel.Persona.NombreCompleto,
 0210                    Situacion: rel.Situacion.Denominacion,
 0211                    TotalLiquidado: total
 0212                );
 0213            })
 0214            .ToList();
 0215    }
 216}
Generated by: ReportGenerator 5.5.10.0
06/26/2026 - 02:06:31
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.DataAccess.ApplicationDbContext)
ObtenerVersionMaximaAsync()
ObtenerItemsConDatosAsync()
ObtenerMovimientosAsync()
ObtenerResumenPeriodoAnteriorAsync()
ObtenerNoDisponiblesAsync()