< 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
91%
Covered lines: 135
Uncovered lines: 12
Coverable lines: 147
Total lines: 389
Line coverage: 91.8%
Branch coverage
87%
Covered branches: 61
Total branches: 70
Branch coverage: 87.1%
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(...)82.35%473477.77%
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>
 38470    protected virtual IReadOnlySet<int> CodigosExcluidosDecreto => EmptySet;
 71
 72    /// <summary>Ítems emitidos pero que NO contribuyen a la base SDL. Override por subclase.</summary>
 27173    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    {
 5587        var resultado = new ResultadoCalculo();
 88        try
 89        {
 5590            var wpara53 = CalcularItemsBase(funcionario, insumos, acumuladores, resultado);
 5391            wpara53 += AgregarItemsDecreto(funcionario, insumos, acumuladores, resultado);
 5392            wpara53 += AgregarItemsCondicionales(funcionario, insumos, acumuladores, resultado);
 93
 5394            if (wpara53 > 0)
 95            {
 96                decimal wPara10;
 5297                if (DebeCalcularSDL(funcionario, insumos))
 98                {
 4999                    var sdl = Math.Round(wpara53 * 0.053m, 2);
 49100                    AgregarItem(Codigos.Sdl, sdl, insumos, acumuladores, resultado);
 49101                    wPara10 = wpara53 + sdl;
 102                }
 103                else
 104                {
 3105                    wPara10 = wpara53;
 106                }
 52107                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).
 53113            var esOficial = insumos.OrdenPorGrado.TryGetValue(funcionario.GradoId, out var gradoOrden)
 53114                ? gradoOrden >= 7
 53115                : (funcionario.Grado?.EsOficial ?? false);
 53116            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
 53122            if (!funcionario.Situacion.AfectaCobro)
 10123                foreach (var item in resultado.Items)
 4124                    item.EsReferencia = true;
 125
 53126            resultado.Estado = resultado.Incidencias.Count > 0
 53127                ? EstadoCalculo.Revisar
 53128                : EstadoCalculo.Calculado;
 53129        }
 2130        catch (Exception ex)
 131        {
 2132            resultado.Estado = EstadoCalculo.Error;
 2133            resultado.MensajeError = ex.Message;
 2134        }
 135
 55136        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    {
 53159        decimal extraWPara53 = 0m;
 160
 161        // Entran en base SDL (confirmado por fórmula PDF 048.012)
 53162        extraWPara53 += AgregarDecretoSdl(Codigos.CompCargo, funcionario, insumos, acumuladores, resultado);       // 04
 53163        extraWPara53 += AgregarDecretoSdl(Codigos.AumEsp85Mil, funcionario, insumos, acumuladores, resultado);
 53164        extraWPara53 += AgregarDecretoSdl(Codigos.RecSalarial2007, funcionario, insumos, acumuladores, resultado);
 53165        extraWPara53 += AgregarDecretoSdl(Codigos.RecSalarial466, funcionario, insumos, acumuladores, resultado);
 53166        extraWPara53 += AgregarDecretoSdl(Codigos.CompCombatientes, funcionario, insumos, acumuladores, resultado);
 53167        extraWPara53 += AgregarDecretoSdl(Codigos.EquipoOficiales, funcionario, insumos, acumuladores, resultado);
 168
 169        // NO entran en base SDL (Calc_Hab.prg confirmado)
 53170        AgregarDecretoNoSdl(Codigos.AumEsp92, funcionario, insumos, acumuladores, resultado);
 53171        AgregarDecretoNoSdl(Codigos.Ley17269, funcionario, insumos, acumuladores, resultado);
 53172        AgregarDecretoNoSdl(Codigos.AumDec191_003, funcionario, insumos, acumuladores, resultado);
 53173        AgregarDecretoNoSdl(Codigos.Ley19355, funcionario, insumos, acumuladores, resultado);
 53174        AgregarDecretoNoSdl(Codigos.IncrSubEscK, funcionario, insumos, acumuladores, resultado);    // 048.042 — "No va?
 53175        AgregarDecretoNoSdl(Codigos.PartEspLey18719, funcionario, insumos, acumuladores, resultado); // 048.038 — NO ent
 53176        AgregarDecretoNoSdl(Codigos.CompLey18834, funcionario, insumos, acumuladores, resultado);
 53177        AgregarDecretoNoSdl(Codigos.Ley20075Art80, funcionario, insumos, acumuladores, resultado);    // 042.403 Oficial
 53178        AgregarDecretoNoSdl(Codigos.Ley20075Art80Sub, funcionario, insumos, acumuladores, resultado); // 042.623 Subalte
 53179        AgregarDecretoNoSdl(Codigos.DifEquipoSinAportes, funcionario, insumos, acumuladores, resultado);
 53180        AgregarDecretoNoSdl(Codigos.DifEquipoConAportes, funcionario, insumos, acumuladores, resultado);
 53181        AgregarDecretoNoSdl(Codigos.ViaticossinAportes, funcionario, insumos, acumuladores, resultado);
 53182        AgregarDecretoNoSdl(Codigos.ViaticosConAportes, funcionario, insumos, acumuladores, resultado);
 53183        AgregarDecretoNoSdl(Codigos.CompPAN, funcionario, insumos, acumuladores, resultado);
 53184        AgregarDecretoNoSdl(Codigos.CompSAR, funcionario, insumos, acumuladores, resultado);
 53185        AgregarDecretoNoSdl(Codigos.CompDI, funcionario, insumos, acumuladores, resultado);         // 043.002 Compl. DI
 53186        AgregarDecretoNoSdl(Codigos.CompDiOficial, funcionario, insumos, acumuladores, resultado);  // 299 043.003 Ofici
 53187        AgregarDecretoNoSdl(Codigos.CompDiSubalterno, funcionario, insumos, acumuladores, resultado); // 315 043.003 Sub
 188
 53189        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    {
 53201        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.
 53205        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.
 53213        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 (data-driven: si el grado tiene remuneración, se emite)
 53221        var remPrimaTec = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.PrimaTecnicaPerm);
 53222        if (remPrimaTec is not null)
 0223            AgregarItem(Codigos.PrimaTecnicaPerm, remPrimaTec.Monto, insumos, acumuladores, resultado);
 224
 225        // 042.019 — Riesgo de Vuelo (si relacion_laboral.riesgo_vuelo > 0); PDF: SÍ entra en SDL y DI
 53226        if (funcionario.RiesgoVuelo.HasValue && funcionario.RiesgoVuelo.Value > 0)
 227        {
 0228            var remVuelo = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.RiesgoVuelo);
 0229            if (remVuelo is not null)
 230            {
 0231                AgregarItem(Codigos.RiesgoVuelo, remVuelo.Monto, insumos, acumuladores, resultado);
 0232                extraWPara53 += remVuelo.Monto;
 233            }
 234        }
 235
 236        // 044.001 — Progresivo / Prima por Antigüedad
 237        // FechaBase: oficiales desde FechaAscensoOficial; tropa desde FechaInicio.
 238        // anios_inactivos: períodos de baja ya registrados en relacion_laboral.
 53239        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 53240        var fechaBaseProgresivo = funcionario.FechaAscensoOficial ?? funcionario.FechaInicio;
 53241        var aniosBrutos = Math.Max(0, (int)((fechaPeriodo - fechaBaseProgresivo).TotalDays / 365.25));
 53242        var anios = Math.Max(0, aniosBrutos - (funcionario.AniosInactivos ?? 0));
 53243        if (anios > 0)
 244        {
 53245            var remProg = insumos.ObtenerRemuneracion(funcionario.GradoId, Codigos.Progresivo);
 53246            if (remProg is not null)
 247            {
 3248                var montoProg = remProg.Monto * Math.Min(anios, 30);
 3249                AgregarItem(Codigos.Progresivo, montoProg, insumos, acumuladores, resultado);
 3250                extraWPara53 += montoProg;
 251            }
 252        }
 253
 254        // PROGRE.TROPA: tramo subalterno para oficiales que ascendieron desde tropa.
 255        // FoxPro: m.anios = Anios_Trop (= fecha_asc_oficial - fecha_sub en años).
 256        // Tasa: la del grado subalterno de menor orden (SDO_1RA = $114.01/año en 2026).
 53257        if (funcionario.FechaAscensoOficial.HasValue &&
 53258            funcionario.FechaAscensoOficial.Value > funcionario.FechaInicio)
 259        {
 1260            var aniosTropa = Math.Max(0,
 1261                (int)((funcionario.FechaAscensoOficial.Value - funcionario.FechaInicio).TotalDays / 365.25));
 1262            aniosTropa = Math.Min(aniosTropa + funcionario.AniosServicioAnterior, 30);
 1263            if (aniosTropa > 0)
 264            {
 265                // Tasa subalterno: progresivo del grado con menor orden (SDO_1RA, orden=1)
 1266                var gradoId = insumos.OrdenPorGrado
 0267                    .Where(kv => kv.Value == 1)
 0268                    .Select(kv => (long?)kv.Key)
 1269                    .FirstOrDefault();
 1270                var remTropa = gradoId.HasValue
 1271                    ? insumos.ObtenerRemuneracion(gradoId.Value, Codigos.Progresivo)
 1272                    : null;
 1273                if (remTropa is not null)
 274                {
 0275                    var montoTropa = remTropa.Monto * aniosTropa;
 0276                    AgregarItem(Codigos.Progresivo, montoTropa, insumos, acumuladores, resultado);
 0277                    extraWPara53 += montoTropa;
 278                }
 279            }
 280        }
 281
 53282        return extraWPara53;
 283    }
 284
 285    /// <summary>
 286    /// Calcula Dedicación Integral (043.004).
 287    /// Override en subclases que usan porcentaje distinto o ítem diferente (p.ej. PAO).
 288    /// </summary>
 289    protected virtual void CalcularDedicacionIntegral(
 290        decimal wPara10, RelacionLaboral funcionario,
 291        InsumosPeriodo insumos, Acumuladores acumuladores, ResultadoCalculo resultado)
 292    {
 39293        if (wPara10 <= 0) return;
 39294        var di = Math.Round(wPara10 * PorcentajeDedicacionIntegral, 2);
 39295        AgregarItem(Codigos.DedicacionIntegral, di, insumos, acumuladores, resultado);
 39296    }
 297
 298    // ── Helpers internos ──────────────────────────────────────────────────────────
 299
 300    /// <summary>Agrega el ítem si existe en remuneraciones. Retorna el monto agregado (o 0).</summary>
 301    protected static decimal AgregarSiExiste(
 302        RelacionLaboral funcionario, InsumosPeriodo insumos,
 303        Acumuladores acumuladores, ResultadoCalculo resultado, int codigo)
 304    {
 1229305        var rem = insumos.ObtenerRemuneracion(funcionario.GradoId, codigo);
 2429306        if (rem is null) return 0m;
 29307        AgregarItem(codigo, rem.Monto, insumos, acumuladores, resultado);
 29308        return rem.Monto;
 309    }
 310
 311    protected static void AgregarItem(
 312        int codigo, decimal monto, InsumosPeriodo insumos,
 313        Acumuladores acumuladores, ResultadoCalculo resultado)
 314    {
 2026315        var catalogoItem = insumos.CatalogoItems.FirstOrDefault(c => c.Codigo == codigo);
 241316        resultado.Items.Add(new ItemCalculado
 241317        {
 241318            CodigoConcepto = codigo,
 241319            NombreConcepto = catalogoItem?.Nombre ?? $"Concepto {codigo}",
 241320            Importe = monto
 241321        });
 241322        if (catalogoItem is not null)
 240323            acumuladores.AgregarItem(monto, catalogoItem);
 241324    }
 325
 326    protected static int CalcularAniosServicio(RelacionLaboral funcionario, InsumosPeriodo insumos)
 327    {
 0328        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 0329        return Math.Max(0, (int)((fechaPeriodo - funcionario.FechaInicio).TotalDays / 365.25));
 330    }
 331
 332    protected static int CalcularMesesPermanencia(RelacionLaboral funcionario, InsumosPeriodo insumos)
 333    {
 50334        var fechaPeriodo = new DateTime(insumos.ParametroPeriodo.Anio, insumos.ParametroPeriodo.Mes, 1);
 50335        var meses = (fechaPeriodo.Year - funcionario.FechaInicio.Year) * 12
 50336                    + fechaPeriodo.Month - funcionario.FechaInicio.Month;
 50337        return Math.Max(0, meses);
 338    }
 339
 340    // Emite el ítem y acumula a la base SDL, respetando CodigosExcluidosDecreto/CodigosExcluidosSDL.
 341    private decimal AgregarDecretoSdl(
 342        int codigo, RelacionLaboral funcionario, InsumosPeriodo insumos,
 343        Acumuladores acumuladores, ResultadoCalculo resultado)
 344    {
 357345        if (CodigosExcluidosDecreto.Contains(codigo)) return 0m;
 279346        var monto = AgregarSiExiste(funcionario, insumos, acumuladores, resultado, codigo);
 279347        return CodigosExcluidosSDL.Contains(codigo) ? 0m : monto;
 348    }
 349
 350    // Emite el ítem sin acumularlo a la base SDL, respetando CodigosExcluidosDecreto.
 351    private void AgregarDecretoNoSdl(
 352        int codigo, RelacionLaboral funcionario, InsumosPeriodo insumos,
 353        Acumuladores acumuladores, ResultadoCalculo resultado)
 354    {
 954355        if (!CodigosExcluidosDecreto.Contains(codigo))
 950356            AgregarSiExiste(funcionario, insumos, acumuladores, resultado, codigo);
 954357    }
 358
 359    /// <summary>
 360    /// 042.414 — Reintegro de Aportes por Cambio de Régimen de Aportación.
 361    /// Fórmula PDF: Σ(069.006 + 069.008 + 069.010 + 042.092×2 + 043.002 + 042.571 + 042.572) / 0.87 × 13%
 362    /// 042.092 cuenta doble porque el régimen nuevo aplica aporte doble sobre esa compensación.
 363    /// Solo aplica en régimen Ley Nueva (llamado desde CalcularAsync junto con 042.413).
 364    /// </summary>
 365    private static void CalcularReintegroAportes(
 366        bool esOficial, Acumuladores acumuladores, InsumosPeriodo insumos, ResultadoCalculo resultado)
 367    {
 1755368        decimal Suma(int codigo) => resultado.Items.Where(i => i.CodigoConcepto == codigo).Sum(i => i.Importe);
 369
 370        // Fórmula SUM33316.PRG: acumula (item/0.87) para códigos específicos, × 13%.
 371        // 069.008 (subalterno c/aportes) o 069.006 (oficial c/aportes) — excluyentes.
 372        // Subalternos sin CAT_VIAT (cadetes, aprendices, SDO sin viático): $0 para 069.x.
 373        // 042.092 se agrega UNA vez (verificado en legacy con dos personas).
 53374        var suma69 = Suma(Codigos.ViaticoAlimentacion) > 0m ? Suma(Codigos.ViaticoAlimentacion)
 53375                   : (esOficial ? Suma(Codigos.DifEquipoConAportes) : 0m);
 376
 53377        var base042414 =
 53378            suma69                    +
 53379            Suma(Codigos.ViaticosConAportes) +
 53380            Suma(Codigos.PrimaTecnicaPTI)    +    // × 1 (no ×2, verificado legacy)
 53381            Suma(Codigos.CompDI)             +
 53382            Suma(Codigos.CompPAN)            +    // solo vía lote
 53383            Suma(Codigos.CompSAR);                // solo vía lote
 384
 103385        if (base042414 <= 0m) return;
 3386        var monto = Math.Round(base042414 / 0.87m * 0.13m, 2);
 3387        AgregarItem(Codigos.ReintegroAportes, monto, insumos, acumuladores, resultado);
 3388    }
 389}
Generated by: ReportGenerator 5.5.10.0
06/26/2026 - 02:06:31
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)