bdpformulas 1.0.58 → 1.0.60

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.d.ts

@@ -1,6 +1,7 @@
-import { Strategy } from "../../strategy.interface";
+import { Strategy } from '../../strategy.interface';
 export default class BalancePrdStrategy implements Strategy {
     actividades: any[];
+    private camposCalculadosDefinidos;
     constructor();
     execute(data: any): any;
 }