< Summary

Information
Class: FAU.Logica.Calculadores.CalculadorHaberesBase
Assembly: FAU.Logica
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Calculadores/CalculadorHaberesBase.cs
Line coverage
89%
Covered lines: 138
Uncovered lines: 17
Coverable lines: 155
Total lines: 410
Line coverage: 89%
Branch coverage
85%
Covered branches: 65
Total branches: 76
Branch coverage: 85.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
get_CodigosExcluidosDecreto()100%11100%
get_CodigosExcluidosSDL()100%11100%
get_PorcentajeDedicacionIntegral()100%11100%
DebeCalcularSDL(...)100%11100%
CalcularAsync(...)100%1414100%
AgregarItemsDecreto(...)100%11100%
AgregarItemsCondicionales(...)80%764071.69%
CalcularDedicacionIntegral(...)50%22100%
AgregarSiExiste(...)100%22100%
AgregarItem(...)100%66100%
CalcularAniosServicio(...)100%210%
CalcularMesesPermanencia(...)100%11100%
AgregarDecretoSdl(...)75%44100%
AgregarDecretoNoSdl(...)100%22100%
Suma()100%11100%
CalcularReintegroAportes(...)83.33%66100%

File(s)

/home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Calculadores/CalculadorHaberesBase.cs

#LineLine coverage
 1using FAU.Entidades;
 2using FAU.Logica.DTOs;
 3
 4namespace FAU.Logica.Calculadores;
 5
 6/// <summary>
 7/// Clase base de todas las calculadoras de haberes.
 8///
 9/// Flujo de cálculo (basado en SUM33100.PRG FoxPro):
 10///   1. CalcularItemsBase     → ítems propios de cada situación, retorna wpara53 (SIN SDL)
 11///   2. AgregarItemsDecreto   → ítems fijos por grado (decretos + recuperaciones + etc.),
 12///                              actualiza wpara53 si el ítem entra en la base SDL
 13///   3. CalcularItemsCondicionales → Riesgo de Vuelo, Progresivo, etc.
 14///   4. CalcularSDL           → 048.012 = wpara53 × 5,3%  (DESPUÉS de todos los ítems base)
 15///   5. CalcularDI            → 043.004 = wPara10 × porcentaje  (virtual, override por situación)
 16///   6. CalcularModAportes19695 → 042.413 (solo Ley Nueva)
 17///   7. CalcularReintegroAportes → 042.414 (solo Ley Nueva)
 18/// </summary>
 19public abstract class CalculadorHaberesBase : ICalculadorHaberes
 20{
 21    protected static class Codigos
 22    {
 23        internal const int SueldoBase          = 11000;
 24        internal const int SueldoReservista    = 11001;
 25        internal const int SueldoReservaJornal = 20;
 26        internal const int GastosRepresentacion = 15000;
 27        internal const int Permanencia         = 41003;
 28        internal const int CompCargo           = 42012;
 29        internal const int PermanenciaOrden    = 42014;
 30        internal const int RiesgoVuelo         = 42019;
 31        internal const int CompSuboficiales    = 42022;
 32        internal const int PrimaTecnicaPerm    = 42025;
 33        internal const int EquipoOficiales     = 42067;
 34        internal const int PrimaTecnicaPTI     = 42092;
 35        internal const int PrimaIdoneidad      = 42093;
 36        internal const int CompCombatientes    = 42103;
 37        internal const int CompLey18834        = 42536;
 38        internal const int Ley20075Art80       = 42403;
 39        internal const int Ley20075Art80Sub    = 42623;  // versión subalternos (Art.80 Ley 20.075)
 40        internal const int ModAportes          = 42413;
 41        internal const int ReintegroAportes    = 42414;
 42        internal const int CompDI              = 43002;
 43        internal const int DedicacionIntegral  = 43004;
 44        internal const int Progresivo          = 44001;
 45        internal const int AumEsp85Mil         = 48004;
 46        internal const int AumEsp92            = 48009;
 47        internal const int Sdl                 = 48012;
 48        internal const int Ley17269            = 48015;
 49        internal const int AumDec191_003       = 48017;
 50        internal const int RecSalarial2007     = 48023;
 51        internal const int RecSalarial466      = 48026;
 52        internal const int PartEspLey18719     = 48038;
 53        internal const int Ley19355            = 48040;
 54        internal const int IncrSubEscK         = 48042;
 55        internal const int CompPAN             = 42571;
 56        internal const int CompSAR             = 42572;
 57        internal const int PermanenciaOrdenSup = 60;
 58        internal const int CompDiOficial       = 299;
 59        internal const int CompDiSubalterno    = 315;
 60        internal const int DifEquipoSinAportes = 69005;
 61        internal const int DifEquipoConAportes = 69006;
 62        internal const int ViaticoAlimentacion = 69008;
 63        internal const int ViaticossinAportes  = 69009;
 64        internal const int ViaticosConAportes  = 69010;
 65    }
 66
 167    private static readonly IReadOnlySet<int> EmptySet = new HashSet<int>();
 68
 69    /// <summary>Ítems excluidos completamente de AgregarItemsDecreto. Override por subclase.</summary>
 36070    protected virtual IReadOnlySet<int> CodigosExcluidosDecreto => EmptySet;
 71
 72    /// <summary>Ítems emitidos pero que NO contribuyen a la base SDL. Override por subclase.</summary>
 26573    protected virtual IReadOnlySet<int> CodigosExcluidosSDL => EmptySet;
 74
 75    /// <summary>Porcentaje de Dedicación Integral. Override por subclase.</summary>
 376    protected virtual decimal PorcentajeDedicacionIntegral => 0.10m;
 77
 78    /// <summary>
 79    /// Controla si se calcula el SDL (048.012 = 5.3%) para este funcionario.
 80    /// Por defecto true. Sit30Calculator lo sobreescribe para excluir grados de orden < 2.
 81    /// </summary>
 4382    protected virtual bool DebeCalcularSDL(RelacionLaboral funcionario, InsumosPeriodo insumos) => true;
 83
 84    public Task<ResultadoCalculo> CalcularAsync(
 85        RelacionLaboral funcionario, InsumosPeriodo insumos, Acumuladores acumuladores)
 86    {
 5487        var resultado = new ResultadoCalculo();
 88        try
 89        {
 5490            var wpara53 = CalcularItemsBase(funcionario, insumos, acumuladores, resultado);
 5291            wpara53 += AgregarItemsDecreto(funcionario, insumos, acumuladores, resultado);
 5292            wpara53 += AgregarItemsCondicionales(funcionario, insumos, acumuladores, resultado);
 93
 5294            if (wpara53 > 0)
 95            {
 96                decimal wPara10;
 5197                if (DebeCalcularSDL(funcionario, insumos))
 98                {
 4899                    var sdl = Math.Round(wpara53 * 0.053m, 2);
 48100                    AgregarItem(Codigos.Sdl, sdl, insumos, acumuladores, resultado);
 48101                    wPara10 = wpara53 + sdl;
 102                }
 103                else
 104                {
 3105                    wPara10 = wpara53;
 106                }
 51107                CalcularDedicacionIntegral(wPara10, funcionario, insumos, acumuladores, resultado);
 108            }
 109
 110            // 042.414 — Reintegro de Aportes: aplica a TODOS los regímenes.
 111            // FoxPro SUM33316.PRG no verifica Ley Vieja/Nueva — confirmado por recibos
 112            // legacy donde aparece 042.414 sin 042.413 (que sí es exclusivo de Ley Nueva).
 52113            var esOficial = insumos.OrdenPorGrado.TryGetValue(funcionario.GradoId, out var gradoOrden)
 52114                ? gradoOrden >= 7
 52115                : (funcionario.Grado?.EsOficial ?? false);
 52116            CalcularReintegroAportes(esOficial, acumuladores, insumos, resultado);
 117
 118            // 042.413 (Mod.Aportes) se calcula en LiquidacionService DESPUÉS del paso de
 119            // compensaciones para que entren en WNominal. No calcular aquí (evita duplicado).
 120            // Solo Ley Nueva (19.695) — FoxPro SUM33315.PRG confirma condición de régimen.
 121
 52122            if (!funcionario.Situacion.AfectaCobro)
 10123                foreach (var item in resultado.Items)
 4124                    item.EsReferencia = true;
 125
 52126            resultado.Estado = resultado.Incidencias.Count > 0
 52127                ? EstadoCalculo.Revisar
 52128                : EstadoCalculo.Calculado;
 52129        }
 2130        catch (Exception ex)
 131        {
 2132            resultado.Estado = EstadoCalculo.Error;
 2133            resultado.MensajeError = ex.Message;
 2134        }
 135
 54136        return Task.FromResult(resultado);
 137    }
 138
 139    // ── Métodos abstractos/virtuales que cada calculadora puede sobreescribir ──────
 140
 141    /// <summary>
 142    /// Calcula los ítems propios de la situación.
 143    /// NO incluye SDL (048.012) ni DI (043.004) — los maneja la clase base.
 144    /// Retorna wpara53: suma de los ítems que entran en la base del SDL.
 145    /// </summary>
 146    protected abstract decimal CalcularItemsBase(
 147        RelacionLaboral funcionario, InsumosPeriodo insumos,
 148        Acumuladores acumuladores, ResultadoCalculo resultado);
 149
 150    /// <summary>
 151    /// Agrega decretos y recuperaciones fijas por grado (lookup en remuneraciones_grado).
 152    /// Subclases pueden excluir ítems via CodigosExcluidosDecreto / CodigosExcluidosSDL.
 153    /// Retorna el extra a sumar a wpara53 (solo ítems que entran en SDL).
 154    /// </summary>
 155    protected virtual decimal AgregarItemsDecreto(
 156        RelacionLaboral funcionario, InsumosPeriodo insumos,
 157        Acumuladores acumuladores, ResultadoCalculo resultado)
 158    {
 52159        decimal extraWPara53 = 0m;
 160
 161        // Entran en base SDL (confirmado por fórmula PDF 048.012)
 52162        extraWPara53 += AgregarDecretoSdl(Codigos.CompCargo, funcionario, insumos, acumuladores, resultado);       // 04
 52163        extraWPara53 += AgregarDecretoSdl(Codigos.AumEsp85Mil, funcionario, insumos, acumuladores, resultado);
 52164        extraWPara53 += AgregarDecretoSdl(Codigos.RecSalarial2007, funcionario, insumos, acumuladores, resultado);
 52165        extraWPara53 += AgregarDecretoSdl(Codigos.RecSalarial466, funcionario, insumos, acumuladores, resultado);
 52166        extraWPara53 += AgregarDecretoSdl(Codigos.CompCombatientes, funcionario, insumos, acumuladores, resultado);
 52167        extraWPara53 += AgregarDecretoSdl(Codigos.EquipoOficiales, funcionario, insumos, acumuladores, resultado);
 168
 169        // NO entran en base SDL (Calc_Hab.prg confirmado)
 52170        AgregarDecretoNoSdl(Codigos.AumEsp92, funcionario, insumos, acumuladores, resultado);
 52171        AgregarDecretoNoSdl(Codigos.Ley17269, funcionario, insumos, acumuladores, resultado);
 52172        AgregarDecretoNoSdl(Codigos.AumDec191_003, funcionario, insumos, acumuladores, resultado);
 52173        AgregarDecretoNoSdl(Codigos.Ley19355, funcionario, insumos, acumuladores, resultado);
 52174        AgregarDecretoNoSdl(Codigos.IncrSubEscK, funcionario, insumos, acumuladores, resultado);    // 048.042 — "No va?
 52175        AgregarDecretoNoSdl(Codigos.PartEspLey18719, funcionario, insumos, acumuladores, resultado); // 048.038 — NO ent
 52176        AgregarDecretoNoSdl(Codigos.CompLey18834, funcionario, insumos, acumuladores, resultado);
 52177        AgregarDecretoNoSdl(Codigos.Ley20075Art80, funcionario, insumos, acumuladores, resultado);    // 042.403 Oficial
 52178        AgregarDecretoNoSdl(Codigos.Ley20075Art80Sub, funcionario, insumos, acumuladores, resultado); // 042.623 Subalte
 52179        AgregarDecretoNoSdl(Codigos.DifEquipoSinAportes, funcionario, insumos, acumuladores, resultado);
 52180        AgregarDecretoNoSdl(Codigos.DifEquipoConAportes, funcionario, insumos, acumuladores, resultado);
 52181        AgregarDecretoNoSdl(Codigos.ViaticossinAportes, funcionario, insumos, acumuladores, resultado);
 52182        AgregarDecretoNoSdl(Codigos.ViaticosConAportes, funcionario, insumos, acumuladores, resultado);
 52183        AgregarDecretoNoSdl(Codigos.CompPAN, funcionario, insumos, acumuladores, resultado);
 52184        AgregarDecretoNoSdl(Codigos.CompSAR, funcionario, insumos, acumuladores, resultado);
 52185        AgregarDecretoNoSdl(Codigos.CompDI, funcionario, insumos, acumuladores, resultado);         // 043.002 Compl. DI
 52186        AgregarDecretoNoSdl(Codigos.CompDiOficial, funcionario, insumos, acumuladores, resultado);  // 299 043.003 Ofici
 52187        AgregarDecretoNoSdl(Codigos.CompDiSubalterno, funcionario, insumos, acumuladores, resultado); // 315 043.003 Sub
 188
 52189        return extraWPara53;
 190    }
 191
 192    /// <summary>
 193    /// Ítems condicionales: Riesgo de Vuelo, Progresivo, Prima Técnica, etc.
 194    /// Override por subclase si la situación los tiene.
 195    /// Retorna el extra a sumar a wpara53 (solo ítems en base SDL).
 196    /// </summary>
 197    protected virtual decimal AgregarItemsCondicionales(
 198        RelacionLaboral funcionario, InsumosPeriodo insumos,
 199        Acumuladores acumuladores, ResultadoCalculo resultado)
 200    {
 52201        decimal extraWPara53 = 0m;
 202
 203        // 042.092 — Prima Técnica PTI/PT (categorías A/B/C designadas por Orden del Comando)
 204        // El monto viene de remuneraciones_grado por grado. Sujeto a Montepío.
 52205        if (!string.IsNullOrEmpty(funcionario.PrimaTecnica) && funcionario.PrimaTecnica != "VACIO")
 206        {
 3207            var remPT = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.PrimaTecnicaPTI);
 3208            if (remPT is not null)
 2209                AgregarItem(Codigos.PrimaTecnicaPTI, remPT.Monto, insumos, acumuladores, resultado);
 210        }
 211
 212        // 042.093 — Prima Idoneidad (sin aporte), si el funcionario tiene superprima.
 52213        if (funcionario.Superprima)
 214        {
 1215            var remIdoneidad = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.PrimaIdoneidad);
 1216            if (remIdoneidad is not null)
 1217                AgregarItem(Codigos.PrimaIdoneidad, remIdoneidad.Monto, insumos, acumuladores, resultado);
 218        }
 219
 220        // 042.025 — Prima Técnica Permanente (entra en base SDL/DI — confirmado Calc_Hab.prg)
 52221        var remPrimaTec = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.PrimaTecnicaPerm);
 52222        if (remPrimaTec is not null)
 223        {
 0224            AgregarItem(Codigos.PrimaTecnicaPerm, remPrimaTec.Monto, insumos, acumuladores, resultado);
 0225            extraWPara53 += remPrimaTec.Monto;
 226        }
 227
 228        // 042.019 — Riesgo de Vuelo (si relacion_laboral.riesgo_vuelo > 0); PDF: SÍ entra en SDL y DI
 52229        if (funcionario.RiesgoVuelo.HasValue && funcionario.RiesgoVuelo.Value > 0)
 230        {
 0231            var remVuelo = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.RiesgoVuelo);
 0232            if (remVuelo is not null)
 233            {
 0234                AgregarItem(Codigos.RiesgoVuelo, remVuelo.Monto, insumos, acumuladores, resultado);
 0235                extraWPara53 += remVuelo.Monto;
 236            }
 237        }
 238
 239        // 044.001 — Progresivo / Prima por Antigüedad
 240        // Para tropa (FechaAscensoOficial == null): FoxPro divide el cómputo en dos tramos cortando en
 241        // FechaUltimoAscenso. Esto evita que una promoción reciente "redondee hacia arriba" el año parcial.
 242        //   años_base   = int((UltAsc − Inicio).TotalDays / 365.25)
 243        //   años_actual = int((Período − UltAsc).TotalDays / 365.25)
 244        //   total       = años_base + años_actual
 245        // Si UltAsc == Inicio (o es null), reduce a la fórmula simple desde Inicio.
 246        // Para oficiales (FechaAscensoOficial != null): usa esa fecha como base sin split.
 52247        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 248        int aniosBrutos;
 52249        if (funcionario.FechaAscensoOficial == null
 52250            && funcionario.FechaUltimoAscenso.HasValue
 52251            && funcionario.FechaUltimoAscenso.Value > funcionario.FechaInicio)
 252        {
 0253            var ultAsc = funcionario.FechaUltimoAscenso.Value;
 0254            var aBase   = Math.Max(0, (int)((ultAsc      - funcionario.FechaInicio).TotalDays / 365.25));
 0255            var aActual = Math.Max(0, (int)((fechaPeriodo - ultAsc).TotalDays / 365.25));
 0256            aniosBrutos = aBase + aActual;
 257        }
 258        else
 259        {
 52260            var fechaBase = funcionario.FechaAscensoOficial ?? funcionario.FechaInicio;
 52261            aniosBrutos = Math.Max(0, (int)((fechaPeriodo - fechaBase).TotalDays / 365.25));
 262        }
 52263        var anios = Math.Max(0, aniosBrutos - (funcionario.AniosInactivos ?? 0));
 52264        if (anios > 0)
 265        {
 52266            var remProg = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.Progresivo);
 52267            if (remProg is not null)
 268            {
 3269                var montoProg = remProg.Monto * Math.Min(anios, 30);
 3270                AgregarItem(Codigos.Progresivo, montoProg, insumos, acumuladores, resultado);
 3271                extraWPara53 += montoProg;
 272            }
 273        }
 274
 275        // PROGRE.TROPA: tramo subalterno para oficiales que ascendieron desde tropa.
 276        // FoxPro: m.anios = Anios_Trop (= fecha_asc_oficial - fecha_sub en años).
 277        // Tasa: la del grado subalterno de menor orden (SDO_1RA = $114.01/año en 2026).
 52278        if (funcionario.FechaAscensoOficial.HasValue &&
 52279            funcionario.FechaAscensoOficial.Value > funcionario.FechaInicio)
 280        {
 1281            var aniosTropa = Math.Max(0,
 1282                (int)((funcionario.FechaAscensoOficial.Value - funcionario.FechaInicio).TotalDays / 365.25));
 1283            aniosTropa = Math.Min(aniosTropa + funcionario.AniosServicioAnterior, 30);
 1284            if (aniosTropa > 0)
 285            {
 286                // Tasa subalterno: progresivo del grado con menor orden (SDO_1RA, orden=1)
 1287                var gradoId = insumos.OrdenPorGrado
 0288                    .Where(kv => kv.Value == 1)
 0289                    .Select(kv => (long?)kv.Key)
 1290                    .FirstOrDefault();
 1291                var remTropa = gradoId.HasValue
 1292                    ? insumos.ObtenerRemuneracion(gradoId.Value, Codigos.Progresivo)
 1293                    : null;
 1294                if (remTropa is not null)
 295                {
 0296                    var montoTropa = remTropa.Monto * aniosTropa;
 0297                    AgregarItem(Codigos.Progresivo, montoTropa, insumos, acumuladores, resultado);
 0298                    extraWPara53 += montoTropa;
 299                }
 300            }
 301        }
 302
 52303        return extraWPara53;
 304    }
 305
 306    /// <summary>
 307    /// Calcula Dedicación Integral (043.004).
 308    /// Override en subclases que usan porcentaje distinto o ítem diferente (p.ej. PAO).
 309    /// </summary>
 310    protected virtual void CalcularDedicacionIntegral(
 311        decimal wPara10, RelacionLaboral funcionario,
 312        InsumosPeriodo insumos, Acumuladores acumuladores, ResultadoCalculo resultado)
 313    {
 39314        if (wPara10 <= 0) return;
 39315        var di = Math.Round(wPara10 * PorcentajeDedicacionIntegral, 2);
 39316        AgregarItem(Codigos.DedicacionIntegral, di, insumos, acumuladores, resultado);
 39317    }
 318
 319    // ── Helpers internos ──────────────────────────────────────────────────────────
 320
 321    /// <summary>Agrega el ítem si existe en remuneraciones. Retorna el monto agregado (o 0).</summary>
 322    protected static decimal AgregarSiExiste(
 323        RelacionLaboral funcionario, InsumosPeriodo insumos,
 324        Acumuladores acumuladores, ResultadoCalculo resultado, int codigo)
 325    {
 1205326        var rem = insumos.ObtenerRemuneracion(funcionario.GradoId, codigo);
 2382327        if (rem is null) return 0m;
 28328        AgregarItem(codigo, rem.Monto, insumos, acumuladores, resultado);
 28329        return rem.Monto;
 330    }
 331
 332    protected static void AgregarItem(
 333        int codigo, decimal monto, InsumosPeriodo insumos,
 334        Acumuladores acumuladores, ResultadoCalculo resultado)
 335    {
 1988336        var catalogoItem = insumos.CatalogoItems.FirstOrDefault(c => c.Codigo == codigo);
 236337        resultado.Items.Add(new ItemCalculado
 236338        {
 236339            CodigoConcepto = codigo,
 236340            NombreConcepto = catalogoItem?.Nombre ?? $"Concepto {codigo}",
 236341            Importe = monto
 236342        });
 236343        if (catalogoItem is not null)
 235344            acumuladores.AgregarItem(monto, catalogoItem);
 236345    }
 346
 347    protected static int CalcularAniosServicio(RelacionLaboral funcionario, InsumosPeriodo insumos)
 348    {
 0349        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 0350        return Math.Max(0, (int)((fechaPeriodo - funcionario.FechaInicio).TotalDays / 365.25));
 351    }
 352
 353    protected static int CalcularMesesPermanencia(RelacionLaboral funcionario, InsumosPeriodo insumos)
 354    {
 49355        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 49356        var meses = (fechaPeriodo.Year - funcionario.FechaInicio.Year) * 12
 49357                    + fechaPeriodo.Month - funcionario.FechaInicio.Month;
 49358        return Math.Max(0, meses);
 359    }
 360
 361    // Emite el ítem y acumula a la base SDL, respetando CodigosExcluidosDecreto/CodigosExcluidosSDL.
 362    private decimal AgregarDecretoSdl(
 363        int codigo, RelacionLaboral funcionario, InsumosPeriodo insumos,
 364        Acumuladores acumuladores, ResultadoCalculo resultado)
 365    {
 351366        if (CodigosExcluidosDecreto.Contains(codigo)) return 0m;
 273367        var monto = AgregarSiExiste(funcionario, insumos, acumuladores, resultado, codigo);
 273368        return CodigosExcluidosSDL.Contains(codigo) ? 0m : monto;
 369    }
 370
 371    // Emite el ítem sin acumularlo a la base SDL, respetando CodigosExcluidosDecreto.
 372    private void AgregarDecretoNoSdl(
 373        int codigo, RelacionLaboral funcionario, InsumosPeriodo insumos,
 374        Acumuladores acumuladores, ResultadoCalculo resultado)
 375    {
 936376        if (!CodigosExcluidosDecreto.Contains(codigo))
 932377            AgregarSiExiste(funcionario, insumos, acumuladores, resultado, codigo);
 936378    }
 379
 380    /// <summary>
 381    /// 042.414 — Reintegro de Aportes por Cambio de Régimen de Aportación.
 382    /// Fórmula PDF: Σ(069.006 + 069.008 + 069.010 + 042.092×2 + 043.002 + 042.571 + 042.572) / 0.87 × 13%
 383    /// 042.092 cuenta doble porque el régimen nuevo aplica aporte doble sobre esa compensación.
 384    /// Solo aplica en régimen Ley Nueva (llamado desde CalcularAsync junto con 042.413).
 385    /// </summary>
 386    private static void CalcularReintegroAportes(
 387        bool esOficial, Acumuladores acumuladores, InsumosPeriodo insumos, ResultadoCalculo resultado)
 388    {
 1719389        decimal Suma(int codigo) => resultado.Items.Where(i => i.CodigoConcepto == codigo).Sum(i => i.Importe);
 390
 391        // Fórmula SUM33316.PRG: acumula (item/0.87) para códigos específicos, × 13%.
 392        // 069.008 (subalterno c/aportes) o 069.006 (oficial c/aportes) — excluyentes.
 393        // Subalternos sin CAT_VIAT (cadetes, aprendices, SDO sin viático): $0 para 069.x.
 394        // 042.092 se agrega UNA vez (verificado en legacy con dos personas).
 52395        var suma69 = Suma(Codigos.ViaticoAlimentacion) > 0m ? Suma(Codigos.ViaticoAlimentacion)
 52396                   : (esOficial ? Suma(Codigos.DifEquipoConAportes) : 0m);
 397
 52398        var base042414 =
 52399            suma69                    +
 52400            Suma(Codigos.ViaticosConAportes) +
 52401            Suma(Codigos.PrimaTecnicaPTI)    +    // × 1 (no ×2, verificado legacy)
 52402            Suma(Codigos.CompDI)             +
 52403            Suma(Codigos.CompPAN)            +    // solo vía lote
 52404            Suma(Codigos.CompSAR);                // solo vía lote
 405
 101406        if (base042414 <= 0m) return;
 3407        var monto = Math.Round(base042414 / 0.87m * 0.13m, 2);
 3408        AgregarItem(Codigos.ReintegroAportes, monto, insumos, acumuladores, resultado);
 3409    }
 410}
Generated by: ReportGenerator 5.5.10.0
06/26/2026 - 17:00:46
GitHub | reportgenerator.io

Methods/Properties

.cctor()
get_CodigosExcluidosDecreto()
get_CodigosExcluidosSDL()
get_PorcentajeDedicacionIntegral()
DebeCalcularSDL(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo)
CalcularAsync(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores)
AgregarItemsDecreto(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
AgregarItemsCondicionales(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
CalcularDedicacionIntegral(System.Decimal,FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
AgregarSiExiste(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo,System.Int32)
AgregarItem(System.Int32,System.Decimal,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
CalcularAniosServicio(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo)
CalcularMesesPermanencia(FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo)
AgregarDecretoSdl(System.Int32,FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
AgregarDecretoNoSdl(System.Int32,FAU.Entidades.RelacionLaboral,FAU.Logica.DTOs.InsumosPeriodo,FAU.Entidades.Acumuladores,FAU.Logica.Calculadores.ResultadoCalculo)
Suma()
CalcularReintegroAportes(System.Boolean,FAU.Entidades.Acumuladores,FAU.Logica.DTOs.InsumosPeriodo,FAU.Logica.Calculadores.ResultadoCalculo)