bdpformulas 1.0.45 → 1.0.47

package/build/index.d.ts

@@ -12,9 +12,13 @@ import BalancePecStrategy from "./strategies/pecuary/balancePec.strategy";
 import FlujoProyectadoPecStrategy from "./strategies/pecuary/flujoProyPec.strategy";
 import BalancePrdStrategy from "./strategies/production/balancePrd.strategy";
 import FlujoProyectadoPrdStrategy from "./strategies/production/flujoProyPrd.strategy";
+import BalanceEEFFStrategy from "./strategies/eeff/balanceEEFF.strategy";
+import FlujoProyectadoEEFFStrategy from "./strategies/eeff/flujoProyEEFF.strategy";
 import Balance from "./strategies/balance.strategy";
 import FlujoProyectado from "./strategies/flujoProyectado.strategy";
 import AnalisisFinancieros from "./strategies/analisisFinancieros.strategy";
+import BalanceGeneralStrategy from "./strategies/general/balanceGeneral.strategy";
+import FlujoProyectadoGeneralStrategy from "./strategies/general/flujoProyGeneral.strategy";
 declare const Pecuario: {
     Auxiliar: typeof Auxiliar;
     Desarrollo: typeof Desarrollo;
@@ -34,9 +38,17 @@ declare const Agricola: {
     BalanceAgrStrategy: typeof BalanceAgrStrategy;
     FlujoProyectadoAgrStrategy: typeof FlujoProyectadoAgrStrategy;
 };
+declare const EEFF: {
+    BalanceEEFFStrategy: typeof BalanceEEFFStrategy;
+    FlujoProyectadoEEFFStrategy: typeof FlujoProyectadoEEFFStrategy;
+};
+declare const General: {
+    BalanceGeneralStrategy: typeof BalanceGeneralStrategy;
+    FlujoProyectadoGeneralStrategy: typeof FlujoProyectadoGeneralStrategy;
+};
 declare const Actividades: {
     Balance: typeof Balance;
     FlujoProyectado: typeof FlujoProyectado;
     AnalisisFinancieros: typeof AnalisisFinancieros;
 };
-export { Context, Agricola, Pecuario, Produccion, Actividades };
+export { Context, Agricola, Pecuario, Produccion, EEFF, Actividades, General };

package/build/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Actividades = exports.Produccion = exports.Pecuario = exports.Agricola = exports.Context = void 0;
+exports.General = exports.Actividades = exports.EEFF = exports.Produccion = exports.Pecuario = exports.Agricola = exports.Context = void 0;
 const anexo_strategy_1 = __importDefault(require("./strategies/pecuary/anexo.strategy"));
 const desarrollo_strategy_1 = __importDefault(require("./strategies/pecuary/desarrollo.strategy"));
 const ventas_strategy_1 = __importDefault(require("./strategies/pecuary/ventas.strategy"));
@@ -19,9 +19,13 @@ const balancePec_strategy_1 = __importDefault(require("./strategies/pecuary/bala
 const flujoProyPec_strategy_1 = __importDefault(require("./strategies/pecuary/flujoProyPec.strategy"));
 const balancePrd_strategy_1 = __importDefault(require("./strategies/production/balancePrd.strategy"));
 const flujoProyPrd_strategy_1 = __importDefault(require("./strategies/production/flujoProyPrd.strategy"));
+const balanceEEFF_strategy_1 = __importDefault(require("./strategies/eeff/balanceEEFF.strategy"));
+const flujoProyEEFF_strategy_1 = __importDefault(require("./strategies/eeff/flujoProyEEFF.strategy"));
 const balance_strategy_1 = __importDefault(require("./strategies/balance.strategy"));
 const flujoProyectado_strategy_1 = __importDefault(require("./strategies/flujoProyectado.strategy"));
 const analisisFinancieros_strategy_1 = __importDefault(require("./strategies/analisisFinancieros.strategy"));
+const balanceGeneral_strategy_1 = __importDefault(require("./strategies/general/balanceGeneral.strategy"));
+const flujoProyGeneral_strategy_1 = __importDefault(require("./strategies/general/flujoProyGeneral.strategy"));
 const Pecuario = {
     Auxiliar: anexo_strategy_1.default,
     Desarrollo: desarrollo_strategy_1.default,
@@ -44,6 +48,16 @@ const Agricola = {
     FlujoProyectadoAgrStrategy: flujoProyAgr_strategy_1.default
 };
 exports.Agricola = Agricola;
+const EEFF = {
+    BalanceEEFFStrategy: balanceEEFF_strategy_1.default,
+    FlujoProyectadoEEFFStrategy: flujoProyEEFF_strategy_1.default
+};
+exports.EEFF = EEFF;
+const General = {
+    BalanceGeneralStrategy: balanceGeneral_strategy_1.default,
+    FlujoProyectadoGeneralStrategy: flujoProyGeneral_strategy_1.default
+};
+exports.General = General;
 const Actividades = {
     Balance: balance_strategy_1.default,
     FlujoProyectado: flujoProyectado_strategy_1.default,

package/build/strategies/agriculture/balanceAgr.strategy.js

@@ -66,14 +66,15 @@ const setValueInOtros = (rubroKey, eerrMap, eerr, values, descripcion) => {
     const muestra = eerr.find((item) => item.RubroId === rubroKey);
     if (!muestra)
         throw new Error(`No existe el rubro ${rubroKey}`);
-    if (!eerrMap.has(rubroKey)) {
+    if (!eerrMap.has(`${rubroKey}_${muestra.Rango}`)) {
         (0, balanceAux_calc_1.anadirNuevoRubro)(muestra, eerrMap, values, descripcion);
     }
     else {
-        if (values.MontoEmpresa && values.MontoEmpresa > 0)
-            eerrMap.get(`${rubroKey}_${muestra.Rango}`).MontoEmpresa = values.MontoEmpresa;
-        if (values.MontoFamiliar && values.MontoFamiliar > 0)
-            eerrMap.get(`${rubroKey}_${muestra.Rango}`).MontoFamiliar = values.MontoFamiliar;
+        let column = eerrMap.get(`${rubroKey}_${muestra.Rango}`);
+        if (values.MontoEmpresa && values.MontoEmpresa > 0 && column.MontoEmpresa == 0)
+            column.MontoEmpresa = values.MontoEmpresa;
+        if (values.MontoFamiliar && values.MontoFamiliar > 0 && column.MontoFamiliar == 0)
+            column.MontoFamiliar = values.MontoFamiliar;
     }
 };
 //@ts-ignore

package/build/strategies/balance.strategy.js

@@ -35,6 +35,7 @@ class Balance {
         let balanceMap = balanceCalc.getBalanceHashMap(data.balance);
         let eerrMap = balanceCalc.getBalanceHashMap(data.eerr);
         (0, declaracionJurada_calc_1.anadirDeclaracionJurada)(balanceMap, data.balance, data.declaracionJurada.Balance);
+        data.balanceMap = balanceMap;
         data.eerrMap = eerrMap;
         (0, flujoAux_calc_1.setFlujoInEERR)(data);
         if (data.strategy != null)

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

@@ -9,7 +9,7 @@ class FlujoConstructor {
                 this.proyectarCosto();
                 this.proyectarGasto();
                 this.agregarQuitarClones();
-                //this.moverDetalledesdeMensual()
+                //   this.moverDetalledesdeMensual()
                 this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
                 this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900');
                 this.calcularOtrosIngresosAnuales();
@@ -165,7 +165,7 @@ class FlujoConstructor {
                         RubroId: item.RubroId,
                         RubroPadreId: item.RubroPadreId,
                         Descripcion: item.Descripcion,
-                        UUID: item.UUID,
+                        UUID: `CLONE_${item.UUID}`,
                         Clasificador: item.Clasificador,
                         Entidad: item.Entidad,
                         Operacion: item.Operacion,

package/build/strategies/eeff/balanceEEFF.strategy.d.ts

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

package/build/strategies/eeff/balanceEEFF.strategy.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BalanceEEFFStrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        if (!this.actividades || this.actividades.length == 0)
+            return data;
+        //Quitamos estos rubros 
+        data.errr = data.eerr.filter((item) => item.RubroId != 'ACT_CN_41001');
+        data.errr = data.eerr.filter((item) => item.RubroId != 'ACT_CN_43001');
+        for (let actividad of this.actividades) {
+            anadirGrupoBalance(actividad, ['ACT_EF_11001'], actividad.Balance, 'ACT_CN_11001', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_11002', 'ACT_EF_11003'], actividad.Balance, 'ACT_CN_11002', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_11004'], actividad.Balance, 'ACT_CN_11003', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_11005', 'ACT_EF_11006',
+                'ACT_EF_11008', 'ACT_EF_11009',
+                'ACT_EF_11010', 'ACT_EF_11011'], actividad.Balance, 'ACT_CN_11004', data.balance, data.balanceMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_12005', 'ACT_EF_12006'], actividad.Balance, 'ACT_CN_12001', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_12001', 'ACT_EF_12002', 'ACT_EF_12007'], actividad.Balance, 'ACT_CN_12002', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_12003', 'ACT_EF_12009'], actividad.Balance, 'ACT_CN_12004', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_12004', 'ACT_EF_12008',
+                'ACT_EF_12010', 'ACT_EF_12011', 'ACT_EF_12012'], actividad.Balance, 'ACT_CN_12005', data.balance, data.balanceMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_21001', 'ACT_EF_21002',
+                'ACT_EF_21003', 'ACT_EF_21004', 'ACT_EF_21008'], actividad.Balance, 'ACT_CN_21001', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_21005', 'ACT_EF_21006', 'ACT_EF_21007', 'ACT_EF_21009'], actividad.Balance, 'ACT_CN_21002', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_21010', 'ACT_EF_21011', 'ACT_EF_21012'], actividad.Balance, 'ACT_CN_21003', data.balance, data.balanceMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_22001',
+                'ACT_EF_22002',
+                'ACT_EF_22003'], actividad.Balance, 'ACT_CN_22001', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_22004', 'ACT_EF_22005',
+                'ACT_EF_22006', 'ACT_EF_22007'], actividad.Balance, 'ACT_CN_22002', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_22008', 'ACT_EF_22009', 'ACT_EF_22010'], actividad.Balance, 'ACT_CN_22003', data.balance, data.balanceMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_31001', 'ACT_EF_31002'], actividad.Balance, 'ACT_CN_30001', data.balance, data.balanceMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_31003', 'ACT_EF_31004',
+                'ACT_EF_31005', 'ACT_EF_31006', 'ACT_EF_31007'], actividad.Balance, 'ACT_CN_30002', data.balance, data.balanceMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_41000'], actividad.EERR, 'ACT_CN_40001', data.eerr, data.eerrMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_42001'], actividad.EERR, 'ACT_CN_41002', data.eerr, data.eerrMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_43001', 'ACT_EF_43002'], actividad.EERR, 'ACT_CN_43002', data.eerr, data.eerrMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_44001', 'ACT_EF_44002'], actividad.EERR, 'ACT_CN_43003', data.eerr, data.eerrMap);
+            anadirGrupoBalance(actividad, ['ACT_EF_44004', 'ACT_EF_44007'], actividad.EERR, 'ACT_CN_43004', data.eerr, data.eerrMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_44003', 'ACT_EF_44005', 'ACT_EF_44006'], actividad.EERR, 'ACT_CN_45001', data.eerr, data.eerrMap, true);
+            anadirGrupoBalance(actividad, ['ACT_EF_45001'], actividad.EERR, 'ACT_CN_46001', data.eerr, data.eerrMap);
+        }
+        sumarizarCuentas('ACT_CN_11001', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_11002', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_11003', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_12001', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_12002', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_12004', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_21001', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_21002', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_22001', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_22002', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_30001', data, data.balanceMap);
+        sumarizarCuentas('ACT_CN_40001', data, data.eerrMap);
+        sumarizarCuentas('ACT_CN_41002', data, data.eerrMap);
+        sumarizarCuentas('ACT_CN_43002', data, data.eerrMap);
+        sumarizarCuentas('ACT_CN_43003', data, data.eerrMap);
+        sumarizarCuentas('ACT_CN_46001', data, data.eerrMap);
+        return data;
+    }
+}
+exports.default = BalanceEEFFStrategy;
+const anadirGrupoBalance = (actividad, rubros, grupoActividad, rubroDestino, data, map, esDetalle = false) => {
+    const rango = data[0].Rango;
+    if (!rubroDestino)
+        throw new Error(`No existe el rubro Calculado ${rubroDestino} en el objeto`);
+    const sumado = grupoActividad.filter((item) => rubros.includes(item.RubroId))
+        .reduce((acc, item) => {
+        if (!acc)
+            acc = item;
+        else {
+            for (let i = 1; i <= rango; i++) {
+                acc[`Gestion${i}`] += parseFloat(acc[`Gestion${i}`]) + parseFloat(item[`Gestion${i}`]);
+                acc[`Gestion${i}`] = Math.round(acc[`Gestion${i}`] * 100) / 100;
+            }
+        }
+        return acc;
+    }, null);
+    for (let i = 1; i <= rango; i++) {
+        const cuenta = data.find((item) => item.RubroId == rubroDestino);
+        let copy = Object.assign({}, cuenta);
+        copy.RubroId = (esDetalle ? `${rubroDestino}` : `${rubroDestino}.1`);
+        copy.Descripcion = `${cuenta.Descripcion} ${actividad.ActividadEconomicaId} ${actividad.Descripcion}`;
+        copy.UUID = `${rubroDestino}_${actividad.ActividadEconomicaId}_${i}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        copy.MontoEmpresa = Math.round(parseFloat(sumado[`Gestion${i}`]) * 100) / 100;
+        data.push(copy);
+    }
+};
+const sumarizarCuentas = (rubro, data, map) => {
+    const dataOriginal = getCuentasCopy(data, rubro, map);
+    const rango = data.eerr[0].Rango;
+    for (let i = 1; i <= rango; i++) {
+        let cuentaOrigen = data.eerr.find((item) => item.RubroId == rubro && item.Correlativo == i);
+        if (!cuentaOrigen) {
+            cuentaOrigen = data.balance.find((item) => item.RubroId == rubro && item.Correlativo == i);
+            if (!cuentaOrigen)
+                throw new Error(`No existe el rubro Calculado ${rubro}_${i} en el EERR`);
+        }
+        const original = dataOriginal.get(`${rubro}_${i}`);
+        if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
+            const cuentaDestino = map.get(`${rubro}_${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 getCuentasCopy = (data, rubroId, map) => {
+    if (!data.eerr || data.eerr.length == 0)
+        throw new Error('Debe ingresar cuentas EERR');
+    let originalData = new Map();
+    const rango = data.eerr[0].Rango;
+    for (let i = 1; i <= rango; i++) {
+        let cuentaIngreso = map.get(`${rubroId}_${i}`);
+        cuentaIngreso.MontoEmpresa = Math.round(parseFloat(cuentaIngreso.MontoEmpresa) * 100) / 100;
+        cuentaIngreso.MontoFamiliar = Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
+        originalData.set(`${rubroId}_${i}`, Object.assign({}, cuentaIngreso));
+    }
+    return originalData;
+};

package/build/strategies/eeff/flujoProyEEFF.strategy.d.ts

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

package/build/strategies/eeff/flujoProyEEFF.strategy.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlujoProyectadoEEFFStrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        if (!this.actividades || this.actividades.length == 0)
+            return data;
+        for (let actividad of this.actividades) {
+            agregarGrupo(['BP_ACT_EF_41000'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_40001', data);
+            agregarGrupo(['BP_ACT_EF_42001'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_50001', data);
+            agregarGrupo(['BP_ACT_EF_43001'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_60001', data);
+            agregarGrupo(['BP_ACT_EF_43002'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_60002', data);
+            agregarGrupo(['BP_ACT_EF_44001', 'BP_ACT_EF_44002'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_61001', data);
+            agregarGrupo(['BP_ACT_EF_44002.1', 'BP_ACT_EF_44003', 'BP_ACT_EF_44005', 'BP_ACT_EF_44006'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_70001', data);
+            agregarGrupo(['BP_ACT_EF_44005.1', 'BP_ACT_EF_44004', 'BP_ACT_EF_44007'], actividad, actividad.BalanceProyectado.EERR, 'ACT_CNFL_70002', data);
+            agregarGrupo(['BP_ACT_FJ_10501', 'BP_ACT_FJ_10502', 'BP_ACT_FJ_10505'], actividad, actividad.BalanceProyectado.FlujoCaja, 'ACT_CNFL_80001', data);
+            agregarGrupo(['BP_ACT_FJ_10504', 'BP_ACT_FJ_10506', 'BP_ACT_FJ_10507'], actividad, actividad.BalanceProyectado.FlujoCaja, 'ACT_CNFL_80002', data);
+        }
+        sumarizarCuenta('ACT_CNFL_40001', data);
+        sumarizarCuenta('ACT_CNFL_50001', data);
+        sumarizarCuenta('ACT_CNFL_60001', data);
+        sumarizarCuenta('ACT_CNFL_70001', data);
+        sumarizarCuenta('ACT_CNFL_70002', data);
+        sumarizarCuenta('ACT_CNFL_80001', data);
+        sumarizarCuenta('ACT_CNFL_80002', data);
+        return data;
+    }
+}
+exports.default = FlujoProyectadoEEFFStrategy;
+const agregarGrupo = (rubros, actividad, grupoActividad, rubroDestino, data) => {
+    const rango = data.DatosEvaluacion.CantidadProyeccion;
+    if (!rango)
+        throw new Error('No existe el rango en la evaluacion');
+    const sumado = grupoActividad.filter((item) => rubros.includes(item.RubroId))
+        .reduce((acc, item) => {
+        if (!acc) {
+            acc = item;
+            for (let i = 1; i <= rango; i++) {
+                if (!acc[`Gestion${i}`])
+                    acc[`Gestion${i}`] = 0;
+            }
+        }
+        else {
+            for (let i = 1; i <= rango; i++) {
+                if (!item[`Gestion${i}`])
+                    item[`Gestion${i}`] = 0;
+                acc[`Gestion${i}`] += parseFloat(acc[`Gestion${i}`]) + parseFloat(item[`Gestion${i}`]);
+                acc[`Gestion${i}`] = Math.round(acc[`Gestion${i}`] * 100) / 100;
+            }
+        }
+        return acc;
+    }, null);
+    const rubro = data.FlujoProyectadoAnual[0];
+    let row = Object.assign({}, rubro);
+    row.RubroId = rubroDestino;
+    row.Clasificador = 'CT';
+    row.Descripcion = `Actividad: ${actividad.Descripcion}`;
+    row.Editable = false;
+    row.UUID = `${rubroDestino}_${actividad.ActividadEconomicaId}`;
+    row.RubroId = `${rubroDestino}.1`;
+    for (let i = 1; i <= rango; i++) {
+        row[`Monto${i}`] = Math.round(parseFloat(sumado[`Gestion${i}`]) * 100) / 100;
+    }
+    data.FlujoProyectadoAnual.push(row);
+};
+const sumarizarCuenta = (rubroId, data) => {
+    const rango = data.DatosEvaluacion.CantidadProyeccion;
+    const copia = getCuentaCopy(rubroId, data);
+    const cuenta = data.FlujoProyectadoAnualMap.get(`${rubroId}_0`);
+    const detalles = data.FlujoProyectadoAnual.filter((item) => item.RubroId == `${rubroId}.1`);
+    for (let detalle of detalles) {
+        for (let i = 1; i <= rango; i++) {
+            if (!copia || copia[`Monto${i}`] == 0)
+                cuenta[`Monto${i}`] += parseFloat(detalle[`Monto${i}`]);
+        }
+    }
+};
+const getCuentaCopy = (rubroId, data) => {
+    const cuenta = data.FlujoProyectadoAnualMap.get(`${rubroId}_0`);
+    return Object.assign({}, cuenta);
+};

package/build/strategies/flujoProyectado.strategy.js

@@ -38,8 +38,8 @@ class FlujoProyectado {
         result = data;
         const cloneFlujoProyectadoMensual = commmon.clone(data.FlujoProyectadoMensual);
         const cloneFlujoProyectadoAnual = commmon.clone(data.FlujoProyectadoAnual);
-        data.FlujoProyectadoMensual = data.FlujoProyectadoMensual.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
-        data.FlujoProyectadoAnual = data.FlujoProyectadoAnual.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
+        // data.FlujoProyectadoMensual = data.FlujoProyectadoMensual.sort((a: any, b: any) => a.RubroId.localeCompare(b.RubroId));
+        // data.FlujoProyectadoAnual = data.FlujoProyectadoAnual.sort((a: any, b: any) => a.RubroId.localeCompare(b.RubroId));
         data.FlujoProyectadoMensualMap = (0, flujoProyectado_calc_1.getFlujoMap)(data.FlujoProyectadoMensual, 12);
         data.FlujoProyectadoAnualMap = (0, flujoProyectado_calc_1.getFlujoMap)(data.FlujoProyectadoAnual, data.DatosEvaluacion.CantidadProyeccion);
         if (data.strategy != null)
@@ -51,10 +51,14 @@ class FlujoProyectado {
         result.HistoricoGrafico = (0, flujoProyectado_calc_1.getHistoricoFlujoCaja)(data);
         delete result.FlujoProyectadoMensualMap;
         delete result.FlujoProyectadoAnualMap;
+        data.FlujoProyectadoMensual = data.FlujoProyectadoMensual.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
+        data.FlujoProyectadoAnual = data.FlujoProyectadoAnual.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
         result.DataOriginal = {
             FlujoProyectadoMensual: cloneFlujoProyectadoMensual,
             FlujoProyectadoAnual: cloneFlujoProyectadoAnual
         };
+        if (result.TipoConsolidado == 'EEFF' || result.TipoConsolidado == 'GENERAL')
+            delete result.FlujoProyectadoMensual;
         delete result.strategy;
         return result;
     }

package/build/strategies/general/balanceGeneral.strategy.d.ts

@@ -0,0 +1,6 @@
+import { Strategy } from "../../strategy.interface";
+export default class BalanceGeneralStrategy implements Strategy {
+    actividades: any;
+    constructor();
+    execute(data: any): any;
+}

package/build/strategies/general/balanceGeneral.strategy.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BalanceGeneralStrategy {
+    constructor() {
+        this.actividades = {};
+    }
+    execute(data) {
+        if (!this.actividades || !this.actividades.Consolidados ||
+            this.actividades.Consolidados.length == 0)
+            return data;
+        for (let consolidado of this.actividades.Consolidados) {
+            procesarConsolidado(consolidado.BalanceCalc.balance, data.balance, consolidado.Tipo);
+            procesarConsolidado(consolidado.BalanceCalc.eerr, data.eerr, consolidado.Tipo);
+        }
+        sumarizarCuenta(this.actividades.Consolidados[0].BalanceCalc.balance, data.balance, data.balanceMap);
+        sumarizarCuenta(this.actividades.Consolidados[0].BalanceCalc.eerr, data.eerr, data.eerrMap);
+        return data;
+    }
+}
+exports.default = BalanceGeneralStrategy;
+const procesarConsolidado = (consolidado, data, tipoConsolidado) => {
+    const rubros = consolidado.filter((item) => item.Clasificador == 'H' || item.Clasificador == 'HABM');
+    if (rubros.length > 0) {
+        const rango = rubros[0].Rango;
+        for (const rubro of rubros) {
+            for (let i = 1; i <= rango; i++) {
+                const cuenta = data.find((item) => item.RubroId == rubro.RubroId);
+                let copy = Object.assign({}, cuenta);
+                copy.RubroId = (rubro.Clasificador == 'HABM' ? `${rubro.RubroId}` : `${rubro.RubroId}.1`);
+                copy.Descripcion = `${cuenta.Descripcion} - Consolidado ${tipoConsolidado} `;
+                copy.UUID = `${rubro.RubroId}_${tipoConsolidado}_${i}`;
+                copy.MontoEmpresa = 0;
+                copy.MontoFamiliar = 0;
+                copy.Correlativo = i;
+                copy.Clasificador = 'CT';
+                copy.MontoEmpresa = Math.round(parseFloat(rubro[`MontoEmpresa_${i}`]) * 100) / 100;
+                copy.MontoFamiliar = Math.round(parseFloat(rubro[`MontoFamiliar_${i}`]) * 100) / 100;
+                data.push(copy);
+            }
+        }
+    }
+};
+const sumarizarCuenta = (consolidado, data, map) => {
+    const rubros = consolidado.filter((item) => item.Clasificador == 'H');
+    for (const rubro of rubros) {
+        sumarizarCuentas(rubro.RubroId, data, map);
+    }
+};
+const sumarizarCuentas = (rubro, data, map) => {
+    const rango = data[0].Rango;
+    for (let i = 1; i <= rango; i++) {
+        let cuentaOrigen = data.find((item) => item.RubroId == rubro && item.Correlativo == i);
+        const cuentaDestino = map.get(`${rubro}_${i}`);
+        cuentaDestino.MontoEmpresa += cuentaOrigen.MontoEmpresa;
+        cuentaDestino.MontoFamiliar += cuentaOrigen.MontoFamiliar;
+        cuentaDestino.MontoEmpresa = Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
+        cuentaDestino.MontoFamiliar = Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
+    }
+};

package/build/strategies/general/flujoProyGeneral.strategy.d.ts

@@ -0,0 +1,6 @@
+import { Strategy } from "../../strategy.interface";
+export default class FlujoProyectadoBalanceStrategy implements Strategy {
+    actividades: any;
+    constructor();
+    execute(data: any): any;
+}

package/build/strategies/general/flujoProyGeneral.strategy.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlujoProyectadoBalanceStrategy {
+    constructor() {
+        this.actividades = {};
+    }
+    execute(data) {
+        if (!this.actividades || !this.actividades.Consolidados || this.actividades.Consolidados.length == 0)
+            return data;
+        for (let consolidado of this.actividades.Consolidados) {
+            procesarAnual(consolidado.FlujoCalc.FlujoProyectadoAnual, data, consolidado.Tipo);
+        }
+        sumarizarCuenta(this.actividades.Consolidados[0].FlujoCalc.FlujoProyectadoAnual, data);
+        return data;
+    }
+}
+exports.default = FlujoProyectadoBalanceStrategy;
+const procesarAnual = (consolidado, data, tipoConsolidado) => {
+    const rubros = consolidado.filter((item) => ['HM', 'HABM', 'DETL'].includes(item.Clasificador));
+    const rango = data.DatosEvaluacion.CantidadProyeccion;
+    if (rubros.length == 0) {
+        for (const rubroItem of rubros) {
+            const rubro = data.FlujoProyectadoAnual[0];
+            let row = Object.assign({}, rubro);
+            row.Clasificador = 'CT';
+            row.Descripcion = `${rubroItem.Descripcion} - ${tipoConsolidado}`;
+            row.Editable = false;
+            row.UUID = `${rubro.RubroId}_${tipoConsolidado}`;
+            row.RubroId = (rubro.Clasificador == 'HABM' || rubro.Clasificador == 'DETL' ? `${rubro.RubroId}` : `${rubro.RubroId}.1`);
+            for (let i = 1; i <= rango; i++) {
+                row[`Monto${i}`] = Math.round(parseFloat(rubro[`Monto${i}`]) * 100) / 100;
+            }
+            data.FlujoProyectadoAnual.push(row);
+        }
+    }
+};
+const sumarizarCuenta = (consolidado, data) => {
+    const rubros = consolidado.filter((item) => ['HM'].includes(item.Clasificador));
+    for (const rubroItem of rubros) {
+        sumarizarCuentas(rubroItem.RubroId, data);
+    }
+};
+const sumarizarCuentas = (rubroId, data) => {
+    const rango = data.DatosEvaluacion.CantidadProyeccion;
+    const cuenta = data.FlujoProyectadoAnualMap.get(`${rubroId}_0`);
+    const detalles = data.FlujoProyectadoAnual.filter((item) => item.RubroId == `${rubroId}.1`);
+    for (let detalle of detalles) {
+        for (let i = 1; i <= rango; i++) {
+            cuenta[`Monto${i}`] += parseFloat(detalle[`Monto${i}`]);
+        }
+    }
+};

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

@@ -39,7 +39,6 @@ const getCuentasCopy = (data, rubroId) => {
         cuentaIngreso.MontoFamiliar = Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
         originalData.set(`${rubroId}_${i}`, Object.assign({}, cuentaIngreso));
     }
-    //console.log('originalData '+rubroId,Array.from(originalData.keys()) )
     return originalData;
 };
 const anadirIngresosAuxPec = (actividad, data) => {

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

@@ -45,7 +45,6 @@ const getCuentasCopy = (data, rubroId) => {
         cuentaIngreso.MontoFamiliar = Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
         originalData.set(`${rubroId}_${i}`, Object.assign({}, cuentaIngreso));
     }
-    //console.log('originalData '+rubroId,Array.from(originalData.keys()) )
     return originalData;
 };
 const anadirIngreso = (actividad, data) => {

package/package.json

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