bdpformulas 1.0.59 → 1.0.60

package/build/strategies/balance.strategy.js

@@ -69,6 +69,12 @@ class Balance {
                 Familiar: true,
                 Empresa: true
             },
+            {
+                RubroId: 'ACT_CN_12004',
+                Correlativos: 'ultima',
+                Familiar: true,
+                Empresa: true
+            },
             {
                 RubroId: 'ACT_CN_21001',
                 Correlativos: 'ultima',
@@ -149,7 +155,7 @@ class Balance {
         data.balance = Array.from(balanceMap.values());
         data.eerr = Array.from(eerrMap.values());
         result.balance = calcularBalance(data.balance, data.cantidadGestiones);
-        result.eerr = calcularEERR(data.eerr, data.cantidadGestiones);
+        result.eerr = calcularEERR(data.eerr, data.cantidadGestiones, data.tipoConsolidado);
         result.DataOriginal = {
             balance: balanceClone,
             eerr: eerrClone
@@ -227,23 +233,25 @@ function calcularCapital(datos, cantidadGestiones) {
         el.MontoTotal = el.MontoEmpresa + el.MontoFamiliar;
     });
 }
-const calcularEERR = (eerr, cantidadGestiones) => {
+const calcularEERR = (eerr, cantidadGestiones, tipoConsolidado) => {
     let i = 0;
-    //calcular porcentajes
-    calcularPorcentajes({
-        rubroDatos: 'ACT_CN_40001',
-        rubroPorcentajes: 'ACT_CN_41001',
-        rubroDestino: 'ACT_CN_41002',
-        cantidadGestiones,
-        datos: eerr
-    });
-    calcularPorcentajes({
-        rubroDatos: 'ACT_CN_40001',
-        rubroPorcentajes: 'ACT_CN_43001',
-        rubroDestino: 'ACT_CN_43002',
-        cantidadGestiones,
-        datos: eerr
-    });
+    if (tipoConsolidado !== 'GANADERIA') {
+        //calcular porcentajes
+        calcularPorcentajes({
+            rubroDatos: 'ACT_CN_40001',
+            rubroPorcentajes: 'ACT_CN_41001',
+            rubroDestino: 'ACT_CN_41002',
+            cantidadGestiones,
+            datos: eerr
+        });
+        calcularPorcentajes({
+            rubroDatos: 'ACT_CN_40001',
+            rubroPorcentajes: 'ACT_CN_43001',
+            rubroDestino: 'ACT_CN_43002',
+            cantidadGestiones,
+            datos: eerr
+        });
+    }
     let result = eerr.map((item) => {
         i++;
         const esGrupo = item.Clasificador == 'P' || item.Clasificador == 'C';
@@ -288,9 +296,30 @@ const calcularEERR = (eerr, cantidadGestiones) => {
     //Utilidad neta
     result = adicionarCuenta('ACT_CN_46000', 'ACT_CN_47000', result);
     result = adicionarCuenta('ACT_CN_46001', 'ACT_CN_47000', result, true);
+    if (tipoConsolidado === 'GANADERIA') {
+        calcularCostoVentasPecuario(result, cantidadGestiones);
+    }
     result = balanceCalc.trasponer(result);
     return result;
 };
+function calcularCostoVentasPecuario(datos, cantidadGestiones) {
+    const totalIngresos = datos.find((el) => el.RubroId === 'ACT_CN_40003' &&
+        el.Correlativo === cantidadGestiones);
+    const costos = datos.find((el) => el.RubroId === 'ACT_CN_41002.1' &&
+        el.Correlativo === cantidadGestiones);
+    const costosPorcentaje = datos.find((el) => el.RubroId === 'ACT_CN_41001' &&
+        el.Correlativo === cantidadGestiones);
+    if (costosPorcentaje) {
+        const montoTotal = (0, utils_1.ourParseFloat)(totalIngresos?.MontoEmpresa);
+        if (montoTotal) {
+            costosPorcentaje.MontoEmpresa =
+                ((0, utils_1.ourParseFloat)(costos?.MontoEmpresa) / montoTotal) * 100;
+            costosPorcentaje.MontoTotal =
+                (0, utils_1.ourParseFloat)(costosPorcentaje.MontoFamiliar) +
+                    costosPorcentaje.MontoEmpresa;
+        }
+    }
+}
 function calcularPorcentajes({ rubroDatos, rubroPorcentajes, datos, cantidadGestiones, rubroDestino }) {
     const porcentajes = datos.filter((el) => el.RubroId === rubroPorcentajes);
     const montos = datos.filter((el) => el.RubroId === rubroDatos);
@@ -350,7 +379,7 @@ const adicionarCuenta = (origen, destino, datos, isNegative = false) => {
     return datos;
 };
 const sumarizarCuenta = (rubros, datos) => {
-    const filtrados = datos.filter((item) => rubros.includes(item.RubroPadreId));
+    const filtrados = datos.filter((item) => !item.Subcuenta && rubros.includes(item.RubroPadreId));
     const grupos = datos.filter((item) => rubros.includes(item.RubroId));
     const suma = filtrados.reduce((acc, item) => {
         const key = `${item.RubroPadreId}_${item.Correlativo}`;

package/build/strategies/common/flujoCalculos/flujoConstructor.d.ts

@@ -11,14 +11,14 @@ export default class FlujoConstructor {
     limpiarCamposCalculados: () => void;
     calcularFlujoCajaMensual(): void;
     calcularFlujoAcumuladoMensual: (data: any) => void;
-    calcularTotal: (sumandosArray: string[], total: string) => void;
+    calcularTotal: (sumandosArray: string[], total: string, data?: any[]) => void;
     replicarCuenta: (cuentaOrigen: string, cuentaDestino: string) => void;
     calcularResta: (positivoRubro: string, negativoRubro: string, destinoRubro: string) => void;
     proyectarIngreso: () => void;
     proyectarCosto: () => void;
     proyectarGasto: () => void;
     agregarQuitarClones: () => void;
-    moverDetalledesdeMensual: () => void;
+    moverDetalleDesdeMensual: () => void;
     calcularTotalDetalle: (sumandosArray: string[], total: string) => void;
     calcularPorcentajeIngresCostos: () => void;
     calcularOtrosIngresosAnuales: () => void;

package/build/strategies/common/flujoCalculos/flujoConstructor.js

@@ -26,26 +26,42 @@ class FlujoConstructor {
     calcularFlujo = () => {
         this.limpiarCamposCalculados();
         if (this.tipo == 'ANUAL') {
-            this.proyectarIngreso();
-            this.proyectarCosto();
-            this.proyectarGasto();
+            if (this.data.TipoConsolidado !== 'GANADERIA') {
+                this.proyectarIngreso();
+                this.proyectarCosto();
+                this.proyectarGasto();
+            }
             this.agregarQuitarClones();
             this.setearCamposAnual();
             //   this.moverDetalledesdeMensual()
             /* this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900')
             this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900') */
-            this.calcularOtrosIngresosAnuales();
-            this.calcularGastosFamiliares();
+            if (this.data.TipoConsolidado !== 'GANADERIA') {
+                this.calcularOtrosIngresosAnuales();
+                this.calcularGastosFamiliares();
+            }
             this.calcularFlujoInversiones();
         }
         this.calcularTotal(['ACT_CNFL_40001', 'ACT_CNFL_40002'], 'ACT_CNFL_49000'); //Total Ingresos
         this.calcularTotal(['ACT_CNFL_50001', 'ACT_CNFL_50002'], 'ACT_CNFL_59000'); //Total Costos
         this.calcularResta('ACT_CNFL_49000', 'ACT_CNFL_59000', 'ACT_CNFL_59999'); //Utilidad Bruta
-        this.calcularTotal(['ACT_CNFL_61001'], 'ACT_CNFL_61900'); //subtotal Gastos Operativos
+        if (this.tipo === 'MENSUAL') {
+            //subtotal Gastos Operativos
+            this.calcularTotal(['ACT_CNFL_61001'], 'ACT_CNFL_61900');
+        }
+        else {
+            this.calcularTotal(['ACT_CNFL_61001'], 'ACT_CNFL_61900', this.array.filter((el) => el.Comprar == 'NO'));
+        }
         this.calcularTotal(['ACT_CNFL_60001', 'ACT_CNFL_60002', 'ACT_CNFL_61900'], 'ACT_CNFL_69000'); //Total Gastos Operativos
         this.calcularResta('ACT_CNFL_59999', 'ACT_CNFL_69000', 'ACT_CNFL_69999'); //Utilidad Operativa
         this.calcularResta('ACT_CNFL_70001', 'ACT_CNFL_70002', 'ACT_CNFL_72000'); //Total Otros Ingresos e Egresos
-        this.calcularTotal(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
+        if (this.tipo === 'MENSUAL') {
+            // subtotal gastos financieros
+            this.calcularTotal(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
+        }
+        else {
+            this.calcularTotal(['ACT_CNFL_73000'], 'ACT_CNFL_73900', this.array.filter((el) => el.Comprar == 'NO'));
+        }
         this.calcularResta('ACT_CNFL_72000', 'ACT_CNFL_73900', 'ACT_CNFL_79000'); //Resultado Otros Ingresos e Egresos
         this.calcularTotal(['ACT_CNFL_69999', 'ACT_CNFL_79000'], 'ACT_CNFL_79999'); //Utilidad Neta
         if (this.tipo == 'MENSUAL') {
@@ -60,17 +76,21 @@ class FlujoConstructor {
             this.calcularFlujoAcumuladoMensual(this.data);
         }
         else if (this.tipo == 'ANUAL') {
+            //this.moverDetalleDesdeMensual()
             this.calcularExcedenteDeficit();
             this.calcularFlujoAcumuladoAnual();
             this.adicionarCapacidadPago();
             this.getFlujoEfectivo();
         }
-        this.array.map((item) => {
-            item.MontoTotal = 0;
-            for (let i = 1; i <= this.rango; i++) {
-                item.MontoTotal += parseFloat(item[`Monto${i}`]);
+        this.array.forEach((item) => {
+            const avoided = ['ACT_CNFL_82300'];
+            if (!avoided.includes(item.RubroId)) {
+                item.MontoTotal = 0;
+                for (let i = 1; i <= this.rango; i++) {
+                    item.MontoTotal += parseFloat(item[`Monto${i}`]);
+                }
+                item.MontoTotal = Math.round(item.MontoTotal * 100) / 100;
             }
-            item.MontoTotal = Math.round(item.MontoTotal * 100) / 100;
         });
         if (this.tipo == 'MENSUAL') {
             this.calcularPorcentajeIngresCostos();
@@ -143,9 +163,11 @@ class FlujoConstructor {
             rowAcumulado[`Monto${i}`] =
                 Math.round(rowAcumulado[`Monto${i}`] * 100) / 100;
         }
+        rowAcumulado.MontoTotal = rowAcumulado[`Monto${this.rango}`];
     };
-    calcularTotal = (sumandosArray, total) => {
-        const rows = this.array.filter((item) => sumandosArray.includes(item.RubroId));
+    calcularTotal = (sumandosArray, total, data = this.array) => {
+        const rows = data.filter((item) => item.IndicadorABM !== 'B' &&
+            sumandosArray.includes(item.RubroId));
         const destino = this.mapObject.get(`${total}_0`);
         rows.map((item) => {
             for (let i = 1; i <= this.rango; i++) {
@@ -191,22 +213,11 @@ class FlujoConstructor {
                 rowIngresos[`Monto${i}`] = anterior * (1 + variacion + I10);
             }
         }
-        if (this.data.TipoConsolidad == 'GANADERIA' &&
-            this.data.ParametrosEngorde.Conclusion == 'DESARROLLO_HATO') {
-            for (let i = 1; i <= this.rango; i++) {
-                rowIngresos[`Monto${i}`] =
-                    this.data.ParametrosEngorde.SumaDesarrolloAnual[`C-${i}`] *
-                        (1 + rowVariacionIngresos[`Monto${i}`] + I10);
-                rowIngresos[`Monto${i}`] =
-                    Math.round(rowIngresos[`Monto${i}`] * 100) / 100;
-            }
-        }
     };
     proyectarCosto = () => {
         const rowIngresos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_40001_0');
         const rowVariacionCostos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_30002_0');
         const rowCosto = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_50001_0');
-        const rowTotalIngresoM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
         for (let i = 1; i <= this.rango; i++) {
             const variacion = (0, utils_1.ourParseFloat)(rowVariacionCostos[`Monto${i}`]) / 100;
             if (i == 1) {
@@ -223,25 +234,6 @@ class FlujoConstructor {
                     (0, utils_1.ourParseFloat)(rowCosto[`Monto${i - 1}`]) * (1 + variacion);
             }
         }
-        if (this.data.TipoConsolidad == 'GANADERIA' &&
-            this.data.ParametrosEngorde.Conclusion != 'DESARROLLO_HATO') {
-            for (let i = 1; i <= this.rango; i++) {
-                if (i == 1) {
-                    rowCosto[`Monto1`] =
-                        ((rowTotalIngresoM[`MontoTotal`] *
-                            rowCosto.MontoCajaPercent) /
-                            100) *
-                            (1 + rowVariacionCostos[`Monto${i}`]);
-                }
-                else {
-                    rowCosto[`Monto${i}`] =
-                        rowIngresos[`Monto${i - 1}`] *
-                            (1 + rowVariacionCostos[`Monto${i}`]);
-                }
-                rowCosto[`Monto${i}`] =
-                    Math.round(rowCosto[`Monto${i}`] * 100) / 100;
-            }
-        }
     };
     proyectarGasto = () => {
         const rowIngresos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_40001_0');
@@ -265,29 +257,34 @@ class FlujoConstructor {
         }
     };
     agregarQuitarClones = () => {
-        const filter = this.data.FlujoProyectadoMensual.filter((item) => item.Clasificador == 'DETL' || item.Clasificador == 'HABM');
+        const filter = this.data.FlujoProyectadoMensual.filter((item) => item.IndicadorABM !== 'B' &&
+            (item.Clasificador == 'DETL' || item.Clasificador == 'HABM'));
         filter.map((item) => {
-            if (!this.mapObject.has(`${item.RubroId}_CLONE_${item.UUID}`)) {
-                const newItem = {
-                    ActividadId: item.ActividadId,
-                    RubroId: item.RubroId,
-                    RubroPadreId: item.RubroPadreId,
-                    Descripcion: item.Descripcion,
-                    UUID: `CLONE_${item.UUID}`,
-                    Clasificador: item.Clasificador,
-                    Entidad: item.Entidad,
-                    Operacion: item.Operacion,
-                    Comprar: item.Comprar,
-                    Variable: item.Variable,
-                    IndicadorABM: item.IndicadorABM,
-                    MontoCajaPercent: item.MontoCajaPercent
-                };
+            const key = `${item.RubroId}_CLONE_${item.UUID}`;
+            const UUID = `CLONE_${item.UUID}`;
+            const clone = {
+                ...item,
+                UUID
+            };
+            let total = 0;
+            for (let i = 1; i <= this.rango; i++) {
+                clone[`Monto${i}`] = 0;
+                total += (0, utils_1.ourParseFloat)(item[`Monto${i}`]);
+            }
+            clone['Monto1'] = total;
+            item.MontoTotal = total;
+            if (!this.mapObject.has(key)) {
                 for (let i = 1; i <= this.rango; i++) {
-                    newItem[`Monto${i}`] = 0;
+                    clone[`Monto${i}`] = 0;
                 }
-                this.array.push(newItem);
-                this.mapObject.set(`${item.RubroId}_CLONE_${item.UUID}`, newItem);
+                this.array.push(clone);
+            }
+            else {
+                const index = this.array.findIndex((el) => el.UUID === UUID);
+                if (index >= 0)
+                    this.array[index] = clone;
             }
+            this.mapObject.set(`${item.RubroId}_CLONE_${item.UUID}`, clone);
         });
         const anuales = this.array.filter((item) => item.Clasificador == 'DETL' || item.Clasificador == 'HABM');
         for (const anualItem of anuales) {
@@ -299,14 +296,17 @@ class FlujoConstructor {
             }
         }
     };
-    moverDetalledesdeMensual = () => {
-        const filter = this.data.FlujoProyectadoMensual.filter((item) => item.RubroId == 'ACT_CNFL_61001' ||
-            item.RubroId == 'ACT_CNFL_73000');
-        filter.map((item) => {
+    moverDetalleDesdeMensual = () => {
+        const mensuales = this.data.FlujoProyectadoMensual.filter((item) => item.IndicadorABM !== 'B' &&
+            (item.RubroId == 'ACT_CNFL_61001' ||
+                item.RubroId == 'ACT_CNFL_73000'));
+        mensuales.forEach((item) => {
             if (this.mapObject.has(`${item.RubroId}_CLONE_${item.UUID}`)) {
                 const detalle = this.mapObject.get(`${item.RubroId}_CLONE_${item.UUID}`);
-                if (detalle.Monto1 == 0)
-                    detalle.Monto1 = item.MontoTotal;
+                detalle.Descripcion = item.Descripcion;
+                detalle.Comprar = item.Comprar;
+                detalle.Operacion = item.Operacion;
+                detalle.Monto1 = item.MontoTotal;
             }
         });
     };
@@ -322,19 +322,21 @@ class FlujoConstructor {
         });
     };
     calcularPorcentajeIngresCostos = () => {
-        const filaIngresos = this.array.find((el) => el.RubroId === 'ACT_CNFL_40001');
-        const filaCostos = this.array.find((el) => el.RubroId === 'ACT_CNFL_50001');
-        const filaGastos = this.array.find((el) => el.RubroId === 'ACT_CNFL_60001');
-        if (filaCostos) {
-            filaCostos.MontoCajaPercent = Math.abs(((0, utils_1.ourParseFloat)(filaCostos.MontoTotal) /
-                (0, utils_1.ourParseFloat)(filaIngresos?.MontoTotal)) *
-                100);
-        }
-        if (filaGastos) {
-            filaGastos.MontoCajaPercent = Math.abs(((0, utils_1.ourParseFloat)(filaGastos.MontoTotal) /
-                (0, utils_1.ourParseFloat)(filaIngresos?.MontoTotal)) *
-                100);
-        }
+        const filasIngresos = this.array.filter((el) => el.RubroId.includes('ACT_CNFL_40001'));
+        const filasCostos = this.array.filter((el) => el.RubroId.includes('ACT_CNFL_50001'));
+        const filasGastos = this.array.filter((el) => el.RubroId.includes('ACT_CNFL_60001'));
+        filasCostos.forEach((el, i) => {
+            const ingresoMonto = (0, utils_1.ourParseFloat)(filasIngresos.at(i)?.MontoTotal);
+            if (ingresoMonto > 0) {
+                el.MontoCajaPercent = Math.abs(((0, utils_1.ourParseFloat)(el.MontoTotal) / ingresoMonto) * 100);
+            }
+        });
+        filasGastos.forEach((el, i) => {
+            const ingresoMonto = (0, utils_1.ourParseFloat)(filasIngresos.at(i)?.MontoTotal);
+            if (ingresoMonto > 0) {
+                el.MontoCajaPercent = Math.abs(((0, utils_1.ourParseFloat)(el.MontoTotal) / ingresoMonto) * 100);
+            }
+        });
         const otrosIngresos = this.array.filter((el) => el.RubroId === 'ACT_CNFL_40002' && el.IndicadorABM !== 'B');
         const otrosCostos = this.array.filter((el) => el.RubroId === 'ACT_CNFL_50002' && el.IndicadorABM !== 'B');
         otrosCostos.forEach((el, i) => {
@@ -468,7 +470,12 @@ class FlujoConstructor {
                 indiceRentabilidad += valueFlujo;
             }
         }
-        indiceRentabilidad /= -totalFlujoInversiones[`Monto1`];
+        if (totalFlujoInversiones['Monto1']) {
+            indiceRentabilidad /= -totalFlujoInversiones[`Monto1`];
+        }
+        else {
+            indiceRentabilidad = 0;
+        }
         const VAN = calcularVAN(tasaDescuento, result
             .filter((item) => item.Anno > 0)
             .map((item) => item.FlujoDeEfectivo), totalFlujoInversiones[`Monto1`]);

package/build/strategies/common/flujoCalculos/supuestos.calc.d.ts

@@ -1,2 +1,2 @@
-export declare const getSupuestosEmpty: (data: any) => any[];
-export declare const getSupuestos: (data: any) => any[];
+export declare const getSupuestosEmpty: (data: any) => any;
+export declare const getSupuestos: (data: any) => any;

package/build/strategies/pecuary/balancePec.strategy.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const utils_1 = require("../eeff/admFinanciera/utils");
 const gCuentaIngreso = 'ACT_CN_40001';
 const gCuentaCosto = 'ACT_CN_41002';
 const gCuentaGasto = 'ACT_CN_43002';
@@ -10,12 +12,6 @@ class BalancePecStrategy {
     constructor() {
         this.actividades = [];
         this.camposCalculadosDefinidos = [
-            {
-                RubroId: 'ACT_CN_12004',
-                Correlativos: 'ultima',
-                Familiar: true,
-                Empresa: true
-            },
             {
                 RubroId: 'ACT_CN_41002',
                 Correlativos: '*',
@@ -30,9 +26,10 @@ class BalancePecStrategy {
         const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
         const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
         const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
+        const cuentaOtrosIngresosCopy = getCuentasCopy(data, gCuentaOtrosIngresosDet, true);
         for (const actividad of this.actividades) {
             anadirIngresosAuxPec(actividad, data);
-            anadirIngresoVenta(actividad, data);
+            //anadirIngresoVenta(actividad, data)
             anadirCosto(actividad, data);
             anadirGasto(actividad, data);
             anadirOtrosIngresos(actividad, data);
@@ -40,68 +37,77 @@ class BalancePecStrategy {
         sumarizarCuentas(`${gCuentaIngreso}.1`, gCuentaIngreso, data, cuentasIngresosCopy);
         sumarizarCuentas(`${gCuentaCosto}.1`, gCuentaCosto, data, cuentasCostoCopy);
         sumarizarCuentas(`${gCuentaGasto}.1`, gCuentaGasto, data, cuentaGastoCopy);
+        sumarizarCuentas(`${gCuentaOtrosIngresosDet}.1`, gCuentaOtrosIngresosDet, data, cuentaOtrosIngresosCopy, true);
         data.camposCalculadosDefinidos = this.camposCalculadosDefinidos;
+        console.log((0, lodash_1.cloneDeep)(data));
         return data;
     }
 }
 exports.default = BalancePecStrategy;
-const getCuentasCopy = (data, rubroId) => {
+const getCuentasCopy = (data, rubroId, withZero = false) => {
     if (!data.eerr || data.eerr.length == 0)
         throw new Error('Debe ingresar cuentas EERR');
     const originalData = new Map();
     const rango = data.eerr[0].Rango;
     for (let i = 1; i <= rango; i++) {
-        const cuentaIngreso = data.eerrMap.get(`${rubroId}_${i}`);
+        const key = withZero ? `${rubroId}_0_${i}` : `${rubroId}_${i}`;
+        const cuentaIngreso = data.eerrMap.get(key);
         cuentaIngreso.MontoEmpresa =
             Math.round(parseFloat(cuentaIngreso.MontoEmpresa) * 100) / 100;
         cuentaIngreso.MontoFamiliar =
             Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
-        originalData.set(`${rubroId}_${i}`, { ...cuentaIngreso });
+        originalData.set(key, { ...cuentaIngreso });
     }
     return originalData;
 };
 const anadirIngresosAuxPec = (actividad, data) => {
     const rango = data.eerr[0].Rango;
-    for (let i = 1; i <= rango - 1; i++) {
+    for (let i = 1; i <= rango; i++) {
         const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}_${i}`);
         const copy = { ...cuentaIngreso };
         copy.RubroId = `${gCuentaIngreso}.1`;
         copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-        copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}`;
         copy.MontoEmpresa = 0;
         copy.MontoFamiliar = 0;
         copy.Correlativo = i;
-        copy.Clasificador = 'CT';
-        if (actividad.AuxPec &&
-            actividad.AuxPec.HistoricoHato &&
-            actividad.AuxPec.HistoricoHato.length > 0) {
-            const historico = actividad.AuxPec.HistoricoHato.find((value) => value.Gestion === i && value.key == 'TOTALES');
-            if (historico)
-                copy.MontoEmpresa =
-                    Math.round(parseFloat(historico.Total) * 100) / 100;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        const historicoHato = actividad.AuxPec?.HistoricoHato;
+        if (historicoHato) {
+            const historico = historicoHato.at(i - 1);
+            const filaTotales = historico?.find((h) => h.key === 'TOTALES');
+            if (filaTotales)
+                copy.MontoEmpresa = parseFloat(filaTotales.Total);
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
-const anadirIngresoVenta = (actividad, data) => {
-    const rango = data.eerr[0].Rango;
-    const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}${rango}`);
-    const copy = { ...cuentaIngreso };
-    copy.RubroId = `${gCuentaIngreso}.1`;
-    copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-    copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${rango}`;
-    copy.MontoEmpresa = 0;
-    copy.MontoFamiliar = 0;
-    copy.Correlativo = rango;
-    copy.Clasificador = 'CT';
+/* const anadirIngresoVenta = (actividad: any, data: any) => {
+    const rango = data.eerr[0].Rango
+    const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}${rango}`)
+    const copy = { ...cuentaIngreso }
+    copy.RubroId = `${gCuentaIngreso}.1`
+    copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`
+    copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${rango}`
+    copy.MontoEmpresa = 0
+    copy.MontoFamiliar = 0
+    copy.Correlativo = rango
+    copy.Clasificador = 'CT'
+
     if (actividad.Ventas.Ventas && actividad.Ventas.Ventas.length > 0) {
-        copy.MontoEmpresa = actividad.Ventas.Ventas.reduce((acc, item) => {
-            acc += parseFloat(item.IngresoTotal);
-            return acc;
-        }, 0);
+        copy.MontoEmpresa = actividad.Ventas.Ventas.reduce(
+            (acc: any, item: any) => {
+                acc += parseFloat(item.IngresoTotal)
+                return acc
+            },
+            0
+        )
     }
-    data.eerr.push(copy);
-};
+
+    data.eerr.push(copy)
+} */
 const anadirCosto = (actividad, data) => {
     const rango = data.eerr[0].Rango;
     const cuentaCosto = data.eerrMap.get(`${gCuentaCosto}_${rango}`);
@@ -109,40 +115,47 @@ const anadirCosto = (actividad, data) => {
         const copy = { ...cuentaCosto };
         copy.RubroId = `${gCuentaCosto}.1`;
         copy.Descripcion = `Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-        copy.UUID = `${gCuentaCosto}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaCosto}_${actividad.AuxPec.ActividadEconomicaId}`;
         copy.MontoEmpresa = 0;
         copy.MontoFamiliar = 0;
         copy.Correlativo = i;
-        copy.Clasificador = 'CT';
-        if (rango == i &&
-            actividad.Costos.Calculo &&
-            actividad.Costos.Calculo.length > 0) {
-            const monto = actividad.Costos.Calculo.find((value) => value.RubroId === 'TOT01');
-            if (!monto)
-                throw new Error('No existe el rubro TOT01 en los costos');
-            copy.MontoEmpresa = Math.round(parseFloat(monto.Total) * 100) / 100;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        if (i < rango) {
+            const porcentaje = data.eerrMap.get(`ACT_CN_41001_${i}`);
+            const ingreso = data.eerrMap.get(`ACT_CN_40001_${actividad.AuxPec.ActividadEconomicaId}_${i}`);
+            copy.MontoEmpresa =
+                ((0, utils_1.ourParseFloat)(ingreso?.MontoEmpresa) *
+                    (0, utils_1.ourParseFloat)(porcentaje?.MontoEmpresa)) /
+                    100;
+        }
+        if (i === rango && actividad.Costos.Calculo) {
+            const filaTotal = actividad.Costos.Calculo.find((value) => value.RubroId === 'TOT01');
+            if (filaTotal) {
+                copy.MontoEmpresa = (0, utils_1.ourParseFloat)(filaTotal.Total);
+            }
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
 const anadirGasto = (actividad, data) => {
     const rango = data.eerr[0].Rango;
     const cuentaGasto = data.eerrMap.get(`${gCuentaGasto}_${rango}`);
+    const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
     for (let i = 1; i <= rango; i++) {
         const copy = { ...cuentaGasto };
         copy.RubroId = `${gCuentaGasto}.1`;
-        copy.UUID = `${gCuentaGasto}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaGasto}_${actividad.AuxPec.ActividadEconomicaId}`;
         copy.Descripcion = `Gastos Administrativos Operativos ${actividad.Desarrollo.ActividadGanadera}`;
         copy.MontoEmpresa = 0;
         copy.MontoFamiliar = 0;
         copy.Correlativo = i;
-        copy.Clasificador = 'CT';
-        if (rango == i) {
-            const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
-            copy.MontoEmpresa =
-                Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
-        }
+        copy.Clasificador = 'SBCT';
+        copy.MontoEmpresa = (0, utils_1.ourParseFloat)(otrosGastos.GastosOperativos);
+        copy.Subcuenta = true;
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
 const calcularOtrosGastos = (gastos) => {
@@ -164,42 +177,53 @@ const anadirOtrosIngresos = (actividad, data) => {
     const cuentaOtrosIngresos = data.eerr.find((item) => item.RubroId == gCuentaOtrosIngresosDet);
     for (let i = 1; i <= rango; i++) {
         const copy = { ...cuentaOtrosIngresos };
-        copy.UUID = `${gCuentaOtrosIngresosDet}_${actividad.AuxPec.ActividadEconomicaId}_${rango}`;
+        copy.RubroId = `${gCuentaOtrosIngresosDet}.1`;
+        copy.UUID = `${gCuentaOtrosIngresosDet}_${actividad.AuxPec.ActividadEconomicaId}`;
         copy.Descripcion = `Otros Ingresos ${actividad.Desarrollo.ActividadGanadera}`;
         copy.MontoEmpresa = 0;
         copy.MontoFamiliar = 0;
         copy.Correlativo = i;
-        copy.Clasificador = 'CT';
-        if (rango == i &&
-            actividad.Ventas &&
-            actividad.Ventas.OtrosIngresos &&
-            actividad.Ventas.OtrosIngresos.length > 0) {
-            copy.MontoFamiliar = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
-                acc += parseFloat(item.Monto);
-                return acc;
-            }, 0);
-            copy.MontoFamiliar = Math.round(copy.MontoFamiliar * 100) / 100;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        if (rango == i && actividad.Ventas?.OtrosIngresos) {
+            copy.MontoFamiliar = calcularOtrosIngresos(actividad.Ventas.OtrosIngresos, data.cantidadProyeccion);
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
-const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal) => {
+function calcularOtrosIngresos(otrosIngresos, cantidadProyeccion) {
+    return otrosIngresos.reduce((acc, curr) => {
+        let suma = 0;
+        for (let j = 1; j <= cantidadProyeccion; j++) {
+            suma += (0, utils_1.ourParseFloat)(curr[`Gestion${j}`]);
+        }
+        return acc + suma;
+    }, 0);
+}
+const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal, withZero = false) => {
     const rango = data.eerr[0].Rango;
     for (let i = 1; i <= rango; i++) {
-        const cuentaOrigen = data.eerr.find((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
-        if (!cuentaOrigen)
-            throw new Error(`No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR`);
-        const original = dataOriginal.get(`${rubroDestino}_${i}`);
-        if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
-            const cuentaDestino = data.eerrMap.get(`${rubroDestino}_${i}`);
-            if (original.MontoEmpresa == 0)
-                cuentaDestino.MontoEmpresa += cuentaOrigen.MontoEmpresa;
-            if (original.MontoFamiliar == 0)
-                cuentaDestino.MontoFamiliar += cuentaOrigen.MontoFamiliar;
-            cuentaDestino.MontoEmpresa =
-                Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
-            cuentaDestino.MontoFamiliar =
-                Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
-        }
+        const cuentaOrigen = data.eerr.filter((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
+        if (!cuentaOrigen || cuentaOrigen.length == 0)
+            throw new Error('No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR');
+        cuentaOrigen.forEach((itemCuentaOrigen) => {
+            const key = withZero
+                ? `${rubroDestino}_0_${i}`
+                : `${rubroDestino}_${i}`;
+            const original = dataOriginal.get(key);
+            if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
+                const cuentaDestino = data.eerrMap.get(key);
+                if (original.MontoEmpresa == 0)
+                    cuentaDestino.MontoEmpresa += itemCuentaOrigen.MontoEmpresa;
+                if (original.MontoFamiliar == 0)
+                    cuentaDestino.MontoFamiliar +=
+                        itemCuentaOrigen.MontoFamiliar;
+                cuentaDestino.MontoEmpresa =
+                    Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
+                cuentaDestino.MontoFamiliar =
+                    Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
+            }
+        });
     }
 };

package/build/strategies/pecuary/flujoProyPec.strategy.d.ts

@@ -1,6 +1,14 @@
-import { Strategy } from "../../strategy.interface";
+import { Strategy } from '../../strategy.interface';
 export default class FlujoProyectadoPecStrategy implements Strategy {
     actividades: any[];
     constructor();
     execute(data: any): any;
+    private setParametrosEngorde;
+    private addIngresoAnual;
+    private addCostoAnual;
+    private getPorcentaje;
+    private addGastoAnual;
+    private addOtroIngresoFamiliarAnual;
+    private getGastosFamiliares;
+    private setGastosFamiliares;
 }

package/build/strategies/pecuary/flujoProyPec.strategy.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const utils_1 = require("../eeff/admFinanciera/utils");
 const RUBRO_INGRESO = 'ACT_CNFL_40001';
 const RUBRO_COSTOS = 'ACT_CNFL_50001';
 const RUBRO_GASTOS = 'ACT_CNFL_60001';
@@ -18,187 +20,383 @@ class FlujoProyectadoPecStrategy {
         const copiaGastos = getCuentaCopy(RUBRO_GASTOS, data);
         const copiaOtrosIngresos = getCuentaCopy(RUBRO_OTROS_INGRESOS, data);
         const copiaGastosFamiliares = getCuentaCopy(RUBRO_GASTOS_FAMILIARES, data);
-        let sumaDesarrollo = [];
-        //@ts-ignore
-        let sumaDesarrolloAnual = null;
-        for (let actividad of this.actividades) {
+        const copiaIngresoAnual = getCuentaCopy(RUBRO_INGRESO, data, false);
+        const copiaCostosAnual = getCuentaCopy(RUBRO_INGRESO, data, false);
+        const copiaGastosAnual = getCuentaCopy(RUBRO_INGRESO, data, false);
+        const copiaOtrosIngresosAnual = getCuentaCopy(RUBRO_OTROS_INGRESOS, data, false);
+        if (!Array.isArray(data.ParametrosEngorde)) {
+            data.ParametrosEngorde = [];
+        }
+        let sumaGastosFamiliares = 0;
+        for (const actividad of this.actividades) {
             addIngresosM(actividad, data);
             addCostosM(actividad, data);
             addGastosM(actividad, data);
             otrosIngresoM(actividad, data);
             gastosFamiliaresM(actividad, data);
-            sumaDesarrollo.push(getDesarrolloSuma(actividad));
-            sumaDesarrolloAnual = getSumaDesarrolloAnualByAnno(actividad, data, sumaDesarrolloAnual);
+            this.setParametrosEngorde(actividad, data);
+            this.addIngresoAnual(actividad, data);
+            this.addCostoAnual(actividad, data);
+            this.addGastoAnual(actividad, data);
+            this.addOtroIngresoFamiliarAnual(actividad, data);
+            sumaGastosFamiliares += this.getGastosFamiliares(actividad);
         }
+        this.setGastosFamiliares(sumaGastosFamiliares, data);
         sumarizarCuenta(RUBRO_INGRESO, data, copiaIngreso);
         sumarizarCuenta(RUBRO_COSTOS, data, copiaCostos);
         sumarizarCuenta(RUBRO_GASTOS, data, copiaGastos);
         sumarizarCuenta(RUBRO_OTROS_INGRESOS, data, copiaOtrosIngresos);
         sumarizarCuenta(RUBRO_GASTOS_FAMILIARES, data, copiaGastosFamiliares);
-        addCalculosBase(data, sumaDesarrollo, sumaDesarrolloAnual);
+        sumarizarCuenta(RUBRO_INGRESO, data, copiaIngresoAnual, false);
+        sumarizarCuenta(RUBRO_COSTOS, data, copiaCostosAnual, false);
+        sumarizarCuenta(RUBRO_GASTOS, data, copiaGastosAnual, false);
+        sumarizarCuenta(RUBRO_OTROS_INGRESOS, data, copiaOtrosIngresosAnual, false);
+        console.log((0, lodash_1.cloneDeep)(data));
         return data;
     }
+    setParametrosEngorde(actividad, data) {
+        const totalEstacionalidad = actividad.Ventas.EstacionalidadCalc.find((el) => el.RubroId === 'TOT01');
+        const sumaAnnoBase = (0, utils_1.ourParseFloat)(totalEstacionalidad?.Total) * 10;
+        const proyeccionVentasTotales = actividad.Desarrollo.VentasCantidad.find((el) => el.RubroId === 'TOT01');
+        let sumaHato = 0;
+        for (let i = 1; i <= 10; i++) {
+            sumaHato += (0, utils_1.ourParseFloat)(proyeccionVentasTotales?.[`C-${i}`]);
+        }
+        const parametroEngorde = data.Parametros.ParametrosActividad.find((el) => el.ActividadId == actividad.ActividadEconomicaId);
+        let existe = data.ParametrosEngorde.find((p) => p.ActividadEconomicaId == actividad.ActividadEconomicaId);
+        if (!existe) {
+            existe = {
+                ActividadEconomicaId: actividad.ActividadEconomicaId,
+                Descripcion: actividad.Descripcion
+            };
+            data.ParametrosEngorde.push(existe);
+        }
+        existe.SumaAnnoBase = sumaAnnoBase;
+        existe.SumaHato = sumaHato;
+        existe.EsEngorde = parametroEngorde?.EsEngorde ?? 'NO';
+        let conclusion = '';
+        if (sumaAnnoBase < sumaHato || existe.EsEngorde === 'SI') {
+            conclusion = 'FLUJO HISTORICO';
+        }
+        else if (sumaHato < sumaAnnoBase) {
+            conclusion = 'DESARROLLO DE HATO';
+        }
+        existe.Conclusion = conclusion;
+    }
+    addIngresoAnual(actividad, data) {
+        const rubro = data.FlujoProyectadoAnualMap.get(`${RUBRO_INGRESO}_0`);
+        const row = { ...rubro };
+        row.Descripcion = `Ingresos ${actividad.Desarrollo.ActividadGanadera}`;
+        row.Clasificador = 'SBCT';
+        row.Editable = false;
+        row.UUID = `${RUBRO_INGRESO}_${actividad.Desarrollo.ActividadEconomicaId}`;
+        row.RubroId = `${RUBRO_INGRESO}.1`;
+        const totalesCalculoIngresos = actividad.Ventas.EstacionalidadCalc.find((el) => el.RubroId === 'TOT01');
+        const totalesCantidad = actividad.Desarrollo.VentasCantidad.find((el) => el.RubroId === 'TOT01');
+        const I10 = 0;
+        const parametroEngorde = data.ParametrosEngorde.find((el) => el.ActividadEconomicaId === actividad.ActividadEconomicaId);
+        const variaciones = data.FlujoProyectadoAnualMap.get('ACT_CNFL_30001_0');
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            if (i == 1) {
+                row[`Monto${i}`] = (0, utils_1.ourParseFloat)(totalesCalculoIngresos?.Total);
+            }
+            else {
+                const variacion = (0, utils_1.ourParseFloat)(variaciones?.[`Monto${i}`]) / 100;
+                if (parametroEngorde?.Conclusion === 'DESARROLLO DE HATO') {
+                    row[`Monto${i}`] =
+                        (0, utils_1.ourParseFloat)(totalesCantidad?.[`C-${i - 1}`]) *
+                            (1 + variacion + I10);
+                }
+                else {
+                    row[`Monto${i}`] =
+                        (0, utils_1.ourParseFloat)(row[`Monto${i - 1}`]) *
+                            (1 + variacion + I10);
+                }
+            }
+        }
+        const existente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
+        if (existente >= 0) {
+            data.FlujoProyectadoAnual[existente] = row;
+        }
+        else {
+            data.FlujoProyectadoAnual.push(row);
+        }
+    }
+    addCostoAnual(actividad, data) {
+        const rubro = data.FlujoProyectadoAnualMap.get(`${RUBRO_COSTOS}_0`);
+        const row = { ...rubro };
+        row.Descripcion = `(-) Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+        row.Clasificador = 'SBCT';
+        row.Editable = false;
+        row.UUID = `${RUBRO_COSTOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
+        row.RubroId = `${RUBRO_COSTOS}.1`;
+        const filaIngresos = data.FlujoProyectadoAnual.find((el) => el.UUID === `${RUBRO_INGRESO}_${actividad.ActividadEconomicaId}`);
+        const porcentaje = this.getPorcentaje(actividad, data);
+        const parametroEngorde = data.ParametrosEngorde.find((el) => el.ActividadEconomicaId === actividad.ActividadEconomicaId);
+        const variaciones = data.FlujoProyectadoAnualMap.get('ACT_CNFL_30001_0');
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            if (i == 1) {
+                row[`Monto${i}`] =
+                    (0, utils_1.ourParseFloat)(filaIngresos?.[`Monto${i}`]) * porcentaje;
+            }
+            else {
+                const variacion = (0, utils_1.ourParseFloat)(variaciones?.[`Monto${i}`]) / 100;
+                if (parametroEngorde?.Conclusion === 'DESARROLLO DE HATO') {
+                    row[`Monto${i}`] =
+                        (0, utils_1.ourParseFloat)(filaIngresos?.[`Monto${i}`]) *
+                            porcentaje *
+                            (1 + variacion);
+                }
+                else {
+                    row[`Monto${i}`] =
+                        (0, utils_1.ourParseFloat)(row[`Monto${i - 1}`]) * (1 + variacion);
+                }
+            }
+        }
+        const existente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
+        if (existente >= 0) {
+            data.FlujoProyectadoAnual[existente] = row;
+        }
+        else {
+            data.FlujoProyectadoAnual.push(row);
+        }
+    }
+    getPorcentaje(actividad, data) {
+        const filaIngresosMensual = data.FlujoProyectadoMensual.find((el) => el.UUID === `${RUBRO_INGRESO}_${actividad.ActividadEconomicaId}`);
+        const filaCostosMensual = data.FlujoProyectadoMensual.find((el) => el.UUID === `${RUBRO_COSTOS}_${actividad.ActividadEconomicaId}`);
+        let totalIngresos = 0;
+        let totalMensual = 0;
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            totalIngresos += (0, utils_1.ourParseFloat)(filaIngresosMensual?.[`Monto${i}`]);
+            totalMensual += (0, utils_1.ourParseFloat)(filaCostosMensual?.[`Monto${i}`]);
+        }
+        return totalIngresos > 0 ? totalMensual / totalIngresos : 0;
+    }
+    addGastoAnual(actividad, data) {
+        const rubro = data.FlujoProyectadoAnualMap.get(`${RUBRO_GASTOS}_0`);
+        const row = { ...rubro };
+        row.Descripcion = `(-) Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+        row.Clasificador = 'SBCT';
+        row.Editable = false;
+        row.UUID = `${RUBRO_GASTOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
+        row.RubroId = `${RUBRO_GASTOS}.1`;
+        const variaciones = data.FlujoProyectadoAnualMap.get('ACT_CNFL_30003_0');
+        const gastos = calcularOtrosGastos(actividad.OtrosGastos, 'Anual');
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            const variacion = (0, utils_1.ourParseFloat)(variaciones?.[`Monto${i}`]) / 100;
+            if (i == 1) {
+                row[`Monto${i}`] = (0, utils_1.ourParseFloat)(gastos.GastosOperativos);
+            }
+            else if (i == 2) {
+                row[`Monto${i}`] =
+                    (0, utils_1.ourParseFloat)(gastos.GastosOperativos) * (1 + variacion);
+            }
+            else {
+                row[`Monto${i}`] =
+                    (0, utils_1.ourParseFloat)(row[`Monto${i - 1}`]) * (1 + variacion);
+            }
+        }
+        const existente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
+        if (existente >= 0) {
+            data.FlujoProyectadoAnual[existente] = row;
+        }
+        else {
+            data.FlujoProyectadoAnual.push(row);
+        }
+    }
+    addOtroIngresoFamiliarAnual(actividad, data) {
+        const rubro = data.FlujoProyectadoAnualMap.get(`${RUBRO_OTROS_INGRESOS}_0`);
+        const row = { ...rubro };
+        row.Descripcion = `Otros Ingresos Familiares ${actividad.Desarrollo.ActividadGanadera}`;
+        row.Clasificador = 'SBCT';
+        row.Editable = false;
+        row.UUID = `${RUBRO_OTROS_INGRESOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
+        row.RubroId = `${RUBRO_OTROS_INGRESOS}.1`;
+        const filaOtrosIngresosMensual = data.FlujoProyectadoMensual.find((el) => el.UUID ===
+            `${RUBRO_OTROS_INGRESOS}_${actividad.Desarrollo.ActividadEconomicaId}`);
+        let total = 0;
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            total += (0, utils_1.ourParseFloat)(filaOtrosIngresosMensual?.[`Monto${i}`]);
+        }
+        for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+            row[`Monto${i}`] = total;
+        }
+        const existente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
+        if (existente >= 0) {
+            data.FlujoProyectadoAnual[existente] = row;
+        }
+        else {
+            data.FlujoProyectadoAnual.push(row);
+        }
+    }
+    getGastosFamiliares(actividad) {
+        return calcularOtrosGastos(actividad.OtrosGastos, 'Anual')
+            .GastosFamiliares;
+    }
+    setGastosFamiliares(totalGastos, data) {
+        const filaGastos = data.FlujoProyectadoAnual.find((el) => el.RubroId === RUBRO_GASTOS_FAMILIARES);
+        if (filaGastos) {
+            const porcentaje = (0, utils_1.ourParseFloat)(filaGastos.MontoCajaPercent) / 100;
+            for (let i = 1; i <= data.DatosEvaluacion.CantidadProyeccion; i++) {
+                if (i == 1) {
+                    filaGastos[`Monto${i}`] = totalGastos;
+                }
+                else if (i == 2) {
+                    filaGastos[`Monto${i}`] = totalGastos * (1 + porcentaje);
+                }
+                else {
+                    filaGastos[`Monto${i}`] =
+                        (0, utils_1.ourParseFloat)(filaGastos[`Monto${i - 1}`]) *
+                            (1 + porcentaje);
+                }
+            }
+        }
+    }
 }
 exports.default = FlujoProyectadoPecStrategy;
-const getCuentaCopy = (rubroId, data) => {
-    const cuenta = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
+const getCuentaCopy = (rubroId, data, mensual = true) => {
+    const fuente = mensual
+        ? data.FlujoProyectadoMensualMap
+        : data.FlujoProyectadoAnualMap;
+    const cuenta = fuente.get(`${rubroId}_0`);
     return { ...cuenta };
 };
-const sumarizarCuenta = (rubroId, data, copia) => {
-    const cuenta = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
-    const detalles = data.FlujoProyectadoMensual.filter((item) => item.RubroId == `${rubroId}.1`);
-    for (let detalle of detalles) {
+const sumarizarCuenta = (rubroId, data, copia, mensual = true) => {
+    const fuenteMap = mensual
+        ? data.FlujoProyectadoMensualMap
+        : data.FlujoProyectadoAnualMap;
+    const fuenteArray = mensual
+        ? data.FlujoProyectadoMensual
+        : data.FlujoProyectadoAnual;
+    const cuenta = fuenteMap.get(`${rubroId}_0`);
+    const detalles = fuenteArray.filter((item) => item.RubroId == `${rubroId}.1`);
+    for (const detalle of detalles) {
         for (let i = 1; i <= 12; i++) {
             if (copia[`Monto${i}`] == 0)
                 cuenta[`Monto${i}`] += parseFloat(detalle[`Monto${i}`]);
         }
     }
 };
-const getSumaDesarrolloAnualByAnno = (actividad, data, suma) => {
-    const CantidadProyeccion = data.DatosEvaluacion.CantidadProyeccion;
-    const ventasCantidad = actividad.Desarrollo.VentasCantidad.find((item) => item.RubroId == 'TOT01');
-    if (!suma) {
-        suma = {};
-        for (let i = 1; i <= CantidadProyeccion; i++) {
-            suma[`C-${i}`] = ventasCantidad[`C-${i}`];
-        }
-    }
-    return suma;
-};
-const getDesarrolloSuma = (actividad) => {
-    const ventasCantidad = actividad.Desarrollo.VentasCantidad.find((item) => item.RubroId == 'TOT01');
-    if (!ventasCantidad)
-        throw new Error('No se econtró el Monto de desarrollo');
-    let result = 0;
-    for (let i = 1; i <= actividad.Desarrollo.CantidadProyeccion; i++) {
-        result += parseFloat(ventasCantidad[`C-${i}`]);
-    }
-    return result;
-};
 const addIngresosM = (actividad, data) => {
     const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_INGRESO}_0`);
     const ingresos = actividad.Ventas.EstacionalidadCalc.find((item) => item.RubroId == 'TOT01');
     if (!ingresos)
         throw new Error('No se encontro la estacionalidad Calc de la actividad');
-    let row = { ...rubro };
+    const row = { ...rubro };
     row.Descripcion = `Ingresos ${actividad.Desarrollo.ActividadGanadera}`;
-    row.Clasificador = 'CT';
+    row.Clasificador = 'SBCT';
     row.Editable = false;
     row.UUID = `${RUBRO_INGRESO}_${actividad.Desarrollo.ActividadEconomicaId}`;
     row.RubroId = `${RUBRO_INGRESO}.1`;
     for (let i = 1; i <= 12; i++) {
         row[`Monto${i}`] = Math.round(parseFloat(ingresos[`C${i}`]) * 100) / 100;
     }
-    data.FlujoProyectadoMensual.push(row);
+    const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
+    if (existente >= 0) {
+        data.FlujoProyectadoMensual[existente] = row;
+    }
+    else {
+        data.FlujoProyectadoMensual.push(row);
+    }
 };
 const addCostosM = (actividad, data) => {
     const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_COSTOS}_0`);
     const costos = actividad.Costos.Calculo.find((item) => item.RubroId == 'TOT01');
     if (!costos)
         throw new Error('No se encontro el costo cálculo de la actividad');
-    let row = { ...rubro };
+    const row = { ...rubro };
     row.Descripcion = `(-) Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-    row.Clasificador = 'CT';
+    row.Clasificador = 'SBCT';
     row.Editable = false;
     row.UUID = `${RUBRO_COSTOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
     row.RubroId = `${RUBRO_COSTOS}.1`;
     for (let i = 1; i <= 12; i++) {
         row[`Monto${i}`] = Math.round(parseFloat(costos[`C-${i}`]) * 100) / 100;
     }
-    data.FlujoProyectadoMensual.push(row);
+    const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
+    if (existente >= 0) {
+        data.FlujoProyectadoMensual[existente] = row;
+    }
+    else {
+        data.FlujoProyectadoMensual.push(row);
+    }
 };
 const addGastosM = (actividad, data) => {
     const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_GASTOS}_0`);
     const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
     if (!otrosGastos)
         throw new Error('No se encontro los gastos de la actividad');
-    let row = { ...rubro };
+    const row = { ...rubro };
     row.Descripcion = `(-) Gastos Operativo ${actividad.Desarrollo.ActividadGanadera}`;
-    row.Clasificador = 'CT';
+    row.Clasificador = 'SBCT';
     row.Editable = false;
     row.UUID = `${RUBRO_GASTOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
     row.RubroId = `${RUBRO_GASTOS}.1`;
     for (let i = 1; i <= 12; i++) {
-        row[`Monto${i}`] = Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
+        row[`Monto${i}`] =
+            Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
+    }
+    const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
+    if (existente >= 0) {
+        data.FlujoProyectadoMensual[existente] = row;
+    }
+    else {
+        data.FlujoProyectadoMensual.push(row);
     }
-    data.FlujoProyectadoMensual.push(row);
 };
 const otrosIngresoM = (actividad, data) => {
     const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_OTROS_INGRESOS}_0`);
     const otrosIngresos = actividad.Ventas.OtrosIngresos;
     if (!otrosIngresos)
         throw new Error('No se encontro la estacionalidad Calc de la actividad');
-    let row = { ...rubro };
+    const row = { ...rubro };
     row.Descripcion = `Otros Ingresos Familiares ${actividad.Desarrollo.ActividadGanadera}`;
-    row.Clasificador = 'CT';
+    row.Clasificador = 'SBCT';
     row.Editable = false;
     row.UUID = `${RUBRO_OTROS_INGRESOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
     row.RubroId = `${RUBRO_OTROS_INGRESOS}.1`;
-    if (otrosIngresos.length == 0) {
-        const suma = otrosIngresos.reduce((acc, item) => {
-            acc += parseFloat(item.Monto);
-            return acc;
+    for (let i = 1; i <= 12; i++) {
+        row[`Monto${i}`] = otrosIngresos.reduce((acc, row) => {
+            return acc + (0, utils_1.ourParseFloat)(row[`Gestion${i}`]);
         }, 0);
-        for (let i = 1; i <= 12; i++) {
-            row[`Monto${i}`] = suma;
-        }
+    }
+    const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
+    if (existente >= 0) {
+        data.FlujoProyectadoMensual[existente] = row;
     }
     else {
-        for (let i = 1; i <= 12; i++) {
-            row[`Monto${i}`] = Math.round(parseFloat(otrosIngresos[`C${i}`]) * 100) / 100;
-        }
+        data.FlujoProyectadoMensual.push(row);
     }
-    data.FlujoProyectadoMensual.push(row);
 };
 const gastosFamiliaresM = (actividad, data) => {
     const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_GASTOS_FAMILIARES}_0`);
     const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
     if (!otrosGastos)
         throw new Error('No se encontro los gastos de la actividad');
-    let row = { ...rubro };
+    const row = { ...rubro };
     row.Descripcion = `(-) Gastos Familiares ${actividad.Desarrollo.ActividadGanadera}`;
-    row.Clasificador = 'CT';
+    row.Clasificador = 'SBCT';
     row.Editable = false;
     row.UUID = `${RUBRO_GASTOS_FAMILIARES}_${actividad.Desarrollo.ActividadEconomicaId}`;
     row.RubroId = `${RUBRO_GASTOS_FAMILIARES}.1`;
     for (let i = 1; i <= 12; i++) {
-        row[`Monto${i}`] = Math.round(parseFloat(otrosGastos.gastosFamiliares) * 100) / 100;
+        row[`Monto${i}`] = (0, utils_1.ourParseFloat)(otrosGastos.GastosFamiliares);
     }
-    data.FlujoProyectadoMensual.push(row);
-};
-const addCalculosBase = (data, sumaDesarrollo, sumaDesarrolloAnual) => {
-    const ingresos = data.FlujoProyectadoMensualMap.get(`${RUBRO_INGRESO}_0`);
-    let sumaIngresos = 0;
-    for (let i = 1; i <= 12; i++) {
-        sumaIngresos += parseFloat(ingresos[`Monto${i}`]);
+    const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
+    if (existente >= 0) {
+        data.FlujoProyectadoMensual[existente] = row;
     }
-    let sumaHato = sumaDesarrollo.reduce((acc, item) => {
-        acc += item;
-        return acc;
-    }, 0);
-    const sumaProyectada = Math.round((sumaIngresos * data.DatosEvaluacion.CantidadProyeccion) * 100) / 100;
-    let result = {
-        EsEngorde: data.Parametros.EsEngorde,
-        SumaAnnoBase: sumaProyectada,
-        SumaHato: sumaHato,
-        Conclusion: 'NA'
-    };
-    result.SumaDesarrolloAnual = sumaDesarrolloAnual;
-    if (result.EsEngorde == 'SI' || result.SumaAnnoBase < result.SumaHato)
-        result.Conclusion = 'FLUJO_HISTORICO';
     else {
-        if (result.SumaHato < result.SumaAnnoBase)
-            result.Conclusion = 'DESARROLLO_HATO';
+        data.FlujoProyectadoMensual.push(row);
     }
-    data.ParametrosEngorde = result;
 };
-const calcularOtrosGastos = (gastos) => {
+const calcularOtrosGastos = (gastos, tipoImporte = 'Mensual') => {
     const gastosOperativos = gastos.Operativos.reduce((acc, item) => {
-        acc += parseFloat(item.ImporteMensual);
+        acc += parseFloat(item[`Importe${tipoImporte}`]);
         return acc;
     }, 0);
     const gastosFamiliares = gastos.Familiares.reduce((acc, item) => {
-        acc += parseFloat(item.ImporteMensual);
+        acc += parseFloat(item[`Importe${tipoImporte}`]);
         return acc;
     }, 0);
     return {

package/build/strategies/production/balancePrd.strategy.js

@@ -204,20 +204,23 @@ const anadirOtrosIngresos = (actividad, data) => {
 const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal) => {
     const rango = data.eerr[0].Rango;
     for (let i = 1; i <= rango; i++) {
-        const cuentaOrigen = data.eerr.find((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
-        if (!cuentaOrigen)
-            throw new Error(`No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR`);
-        const original = dataOriginal.get(`${rubroDestino}_${i}`);
-        if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
-            const cuentaDestino = data.eerrMap.get(`${rubroDestino}_${i}`);
-            if (original.MontoEmpresa == 0)
-                cuentaDestino.MontoEmpresa += cuentaOrigen.MontoEmpresa;
-            if (original.MontoFamiliar == 0)
-                cuentaDestino.MontoFamiliar += cuentaOrigen.MontoFamiliar;
-            cuentaDestino.MontoEmpresa =
-                Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
-            cuentaDestino.MontoFamiliar =
-                Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
-        }
+        const cuentaOrigen = data.eerr.filter((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
+        if (!cuentaOrigen || cuentaOrigen.length == 0)
+            throw new Error('No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR');
+        cuentaOrigen.forEach((itemCuentaOrigen) => {
+            const original = dataOriginal.get(`${rubroDestino}_${i}`);
+            if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
+                const cuentaDestino = data.eerrMap.get(`${rubroDestino}_${i}`);
+                if (original.MontoEmpresa == 0)
+                    cuentaDestino.MontoEmpresa += itemCuentaOrigen.MontoEmpresa;
+                if (original.MontoFamiliar == 0)
+                    cuentaDestino.MontoFamiliar +=
+                        itemCuentaOrigen.MontoFamiliar;
+                cuentaDestino.MontoEmpresa =
+                    Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
+                cuentaDestino.MontoFamiliar =
+                    Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
+            }
+        });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bdpformulas",
-  "version": "1.0.59",
+  "version": "1.0.60",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/tsconfig.json

@@ -82,7 +82,7 @@
 
     /* Type Checking */
     "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    "noImplicitAny": false,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
     // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */