bdpformulas 1.0.36 → 1.0.37

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

@@ -1,15 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const ventas_calc_1 = require("./ventas.detail/ventas.calc");
 class FlujoProyectadoAgrStrategy {
     constructor() {
         this.actividades = [];
     }
     execute(data) {
-        data.eerr = calcular(data, this.actividades);
+        if (!this.actividades || this.actividades.length == 0)
+            throw new Error('Debe ingresar actividades Agrícolas');
+        calcularFlujoMensual(data, this.actividades);
         return data;
     }
 }
 exports.default = FlujoProyectadoAgrStrategy;
-const calcular = (data, actividades) => {
+const calcularFlujoMensual = (data, actividades) => {
+    const consolidadoIngresos = [];
+    const consolidadoCostos = [];
+    const gastosOperativos = [];
+    const gastosFamiliares = [];
+    const consolidadoOtrosIngresos = [];
+    for (let actividad of actividades) {
+        (0, ventas_calc_1.addCalculoIngresosVentas)(actividad.Ventas);
+        consolidadoIngresos.push(getIngresoActividad(actividad));
+        consolidadoCostos.push(getCostosActividad(actividad));
+        gastosOperativos.push(getGastos(actividad, 'Operativos'));
+        gastosFamiliares.push(getGastos(actividad, 'Familiares'));
+        consolidadoOtrosIngresos.push(getOtrosIngresos(actividad));
+    }
+    for (let i = 1; i <= 12; i++) {
+        setValues(data, consolidadoIngresos, 'ACT_CNFL_40001', i);
+        setValues(data, consolidadoCostos, 'ACT_CNFL_50001', i);
+        setValues(data, gastosOperativos, 'ACT_CNFL_60001', i);
+        setValues(data, gastosFamiliares, 'ACT_CNFL_70002', i);
+        setValues(data, consolidadoOtrosIngresos, 'ACT_CNFL_70001', i);
+    }
     return data;
 };
+//@ts-ignore
+const setValues = (data, consolidado, rubroId, i) => {
+    let row = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
+    if (parseFloat(row[`Monto${i}`]) == 0) {
+        consolidado.forEach((item) => {
+            if (item) {
+                row[`Monto${i}`] += item[`Monto${i}`];
+            }
+        });
+        row[`Monto${i}`] = Math.round(parseFloat(row[`Monto${i}`]) * 100) / 100;
+    }
+};
+//@ts-ignore
+const getIngresoActividad = (actividad) => {
+    if (!actividad.Ventas.CalculoIngreso)
+        return null;
+    const total = actividad.Ventas.CalculoIngreso.find((item) => item.ActividadProductoId == 0);
+    let result = Object.assign(Object.assign({}, total), { Descripcion: `Ventas Act:${total.ActividadEconomicaId}` });
+    return result;
+};
+//@ts-ignore
+const getCostosActividad = (actividad) => {
+    if (!actividad.Costos.Meses || actividad.Costos.Meses.length == 0)
+        return null;
+    const total = actividad.Costos.Meses.find((item) => item.ActividadProductoId == 0);
+    let result = Object.assign(Object.assign({}, total), { Descripcion: `Costos Act:${total.ActividadEconomicaId}` });
+    return result;
+};
+//@ts-ignore
+const getGastos = (actividad, tipo) => {
+    if (!actividad.OtrosGastos[tipo] || actividad.OtrosGastos[tipo].length == 0)
+        return null;
+    const total = actividad.OtrosGastos[tipo].reduce((acc, item) => {
+        acc += Math.round(parseFloat(item.ImporteMensual) * 100) / 100;
+        return acc;
+    }, 0);
+    let result = { Descripcion: `Gastos ${tipo} Act:${total.ActividadEconomicaId}` };
+    for (let i = 1; i <= 12; i++) {
+        result[`Monto${i}`] = total;
+    }
+    return result;
+};
+//@ts-ignore
+const getOtrosIngresos = (actividad) => {
+    if (!actividad.Ventas.OtrosIngresos || actividad.Ventas.OtrosIngresos.length == 0)
+        return null;
+    let result = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
+        for (let i = 1; i <= 12; i++) {
+            if (!acc[`Monto${i}`])
+                acc[`Monto${i}`] = 0;
+            acc[`Monto${i}`] += parseFloat(item[`Gestion${i}`]);
+        }
+        return acc;
+    }, { Descripcion: `` });
+    return result;
+};

package/build/strategies/agriculture/ventas.detail/ventas.calc.d.ts

@@ -0,0 +1,2 @@
+export declare const addCalculoIngresosVentas: (ventas: any) => void;
+export declare const calcularIngreso: (producto: any) => any;

package/build/strategies/agriculture/ventas.detail/ventas.calc.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcularIngreso = exports.addCalculoIngresosVentas = void 0;
+const addCalculoIngresosVentas = (ventas) => {
+    if (!ventas || !ventas.Productos || ventas.Productos.length == 0)
+        return;
+    const calculoIngreso = ventas.Productos.reduce((acc, producto) => {
+        const ingreso = (0, exports.calcularIngreso)(producto);
+        if (!acc.has(0))
+            acc.set(0, Object.assign(Object.assign({}, ingreso), { ActividadProductoId: 0, ActividadProductoDesc: 'Total' }));
+        else {
+            for (let i = 1; i <= 12; i++) {
+                acc.get(0)[`Monto${i}`] += ingreso[`Monto${i}`];
+            }
+        }
+        acc.set(ingreso.ActividadProductoId, ingreso);
+        return acc;
+    }, new Map());
+    ventas.CalculoIngreso = Array.from(calculoIngreso.values());
+};
+exports.addCalculoIngresosVentas = addCalculoIngresosVentas;
+const calcularIngreso = (producto) => {
+    let result = {};
+    const ingresoTotalCampanna = parseFloat(producto.IngresoTotalCampanna);
+    const estacionalidad = producto.Estacionalidad[0];
+    result.ActividadEconomicaId = estacionalidad.ActividadEconomicaId;
+    result.ActividadProductoId = estacionalidad.ActividadProductoId;
+    result.ActividadProductoDesc = estacionalidad.ActividadProductoDesc;
+    let acum = 0;
+    for (let i = 1; i <= 12; i++) {
+        result[`Monto${i}`] =
+            Math.round(ingresoTotalCampanna * parseFloat(estacionalidad[`Gestion${i}`]) * 100) / 100;
+        acum += result[`Monto${i}`];
+    }
+    result.Total = acum;
+    return result;
+};
+exports.calcularIngreso = calcularIngreso;

package/build/strategies/balance.strategy.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const balanceCalc = __importStar(require("./common/balance.calc"));
 const commmon = __importStar(require("./common/balance.calc"));
-const declaracionJurada_calc_1 = require("./common/balanceCalculos/declaracionJurada.calc");
+const declaracionJurada_calc_1 = require("./common/declaracionJurada.calc");
 const flujoAux_calc_1 = require("./common/balanceCalculos/flujoAux.calc");
 class Balance {
     execute(data) {

package/build/strategies/common/declaracionJurada.calc.d.ts

@@ -0,0 +1,2 @@
+export declare const getCajaInicial: (declaracionJurada: any) => any;
+export declare const anadirDeclaracionJurada: (balanceMap: any, balanceArray: any, declaracionJurada: any) => void;

package/build/strategies/common/declaracionJurada.calc.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anadirDeclaracionJurada = exports.getCajaInicial = void 0;
+const balanceAux_calc_1 = require("./balanceCalculos/balanceAux.calc");
+const getCajaInicial = (declaracionJurada) => {
+    if (!declaracionJurada || !declaracionJurada.Balance || declaracionJurada.Balance.length == 0)
+        return 0;
+    const disponibilidades = declaracionJurada.Balance.find((value) => value.RubroId === 'SOL_ACT_001');
+    if (!disponibilidades)
+        throw new Error('No se encontró el rubro de Disponibilidades en el balance de la declaración jurada');
+    return disponibilidades.MontoFamiliar;
+};
+exports.getCajaInicial = getCajaInicial;
+const anadirDeclaracionJurada = (balanceMap, balanceArray, declaracionJurada) => {
+    const rango = balanceArray[0].Rango;
+    if (!declaracionJurada || declaracionJurada.length == 0)
+        throw new Error('Debe ingresar un Declaración Jurada válida');
+    const declaracionMap = declaracionJurada.reduce((acc, item) => {
+        acc.set(item.RubroId, item);
+        if (!acc.has('Total')) {
+            acc.set('Total', { TotalActivosE: 0, TotalPasivosE: 0, TotalActivosF: 0, TotalPasivosF: 0 });
+        }
+        if (item.TipoRubroId === 'ACTIVOS') {
+            acc.get('Total').TotalActivosE += parseFloat(item.MontoEmpresa);
+            acc.get('Total').TotalActivosF += parseFloat(item.MontoFamiliar);
+        }
+        if (item.TipoRubroId === 'PASIVOS') {
+            acc.get('Total').TotalPasivosE += parseFloat(item.MontoEmpresa);
+            acc.get('Total').TotalPasivosF += parseFloat(item.MontoFamiliar);
+        }
+        return acc;
+    }, new Map());
+    let referencia = [];
+    referencia.push(arrayValue(['SOL_ACT_001'], 'ACT_CN_11001'));
+    referencia.push(arrayValue(['SOL_ACT_002'], 'ACT_CN_11002'));
+    referencia.push(arrayValue(['SOL_ACT_011'], 'ACT_CN_11003'));
+    referencia.push(arrayValue(['SOL_ACT_003'], 'ACT_CN_12001'));
+    referencia.push(arrayValue(['SOL_ACT_005', 'SOL_ACT_007', 'SOL_ACT_008', 'SOL_ACT_009', 'SOL_ACT_010'], 'ACT_CN_12002'));
+    referencia.push(arrayValue(['SOL_ACT_004'], 'ACT_CN_12003'));
+    referencia.push(arrayValue(['SOL_ACT_006', 'SOL_ACT_012'], 'ACT_CN_12004'));
+    referencia.push(arrayValue(['SOL_PAS_001'], 'ACT_CN_21001'));
+    referencia.push(arrayValue(['SOL_PAS_002'], 'ACT_CN_21002'));
+    referencia.push(arrayValue(['SOL_PAS_003'], 'ACT_CN_22001'));
+    referencia.push(arrayValue(['SOL_PAS_004'], 'ACT_CN_22002'));
+    for (const item of referencia) {
+        const key = `${item.key}_${rango}`;
+        if (balanceMap.has(key)) {
+            if (balanceMap.get(key).MontoEmpresa == 0 || balanceMap.get(key).MontoFamiliar == 0) {
+                const values = getValuesFromDj(item.array, declaracionMap);
+                if (balanceMap.get(key).MontoEmpresa == 0)
+                    balanceMap.get(key).MontoEmpresa = values.montoEmpresa;
+                if (balanceMap.get(key).MontoFamiliar == 0)
+                    balanceMap.get(key).MontoFamiliar = values.montoFamiliar;
+            }
+        }
+        else {
+            const some = balanceArray.find((value) => value.RubroId === item.ley);
+            const values = getValuesFromDj(item.array, declaracionMap);
+            (0, balanceAux_calc_1.anadirNuevoRubro)(some, balanceMap, values, '(Declaración Jurada)');
+        }
+    }
+    const keyCapital = `ACT_CN_30001_${rango}`;
+    balanceMap.get(keyCapital).MontoEmpresa = declaracionMap.get('Total').TotalActivosE -
+        declaracionMap.get('Total').TotalPasivosE;
+    balanceMap.get(keyCapital).MontoFamiliar = declaracionMap.get('Total').TotalActivosF -
+        declaracionMap.get('Total').TotalPasivosF;
+};
+exports.anadirDeclaracionJurada = anadirDeclaracionJurada;
+const arrayValue = (array, key) => {
+    return {
+        array: array,
+        key: key
+    };
+};
+const getValuesFromDj = (arrayDj, declaracionMap) => {
+    let montoFamiliar = 0;
+    let montoEmpresa = 0;
+    for (const djItem of arrayDj) {
+        montoEmpresa += parseFloat(declaracionMap.get(djItem).MontoEmpresa);
+        montoFamiliar += parseFloat(declaracionMap.get(djItem).MontoFamiliar);
+    }
+    return { montoFamiliar, montoEmpresa };
+};

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

@@ -0,0 +1,24 @@
+export default class FlujoConstructor {
+    tipo: string;
+    rango: number;
+    private mapObject;
+    private array;
+    private data;
+    constructor(tipo: string, data: any);
+    calcularFlujo: () => void;
+    calcularFlujoAcumuladoMensual: (data: any) => void;
+    calcularTotal: (sumandosArray: string[], total: string) => void;
+    calcularResta: (positivoRubro: string, negativoRubro: string, destinoRubro: string) => void;
+    proyectarIngreso: () => void;
+    proyectarCosto: () => void;
+    proyectarGasto: () => void;
+    moverDetalledesdeMensual: () => void;
+    calcularTotalDetalle: (sumandosArray: string[], total: string) => void;
+    calcularPorcentajeIngresCostos: () => void;
+    calcularOtrosIngresosAnuales: () => void;
+    calcularGastosFamiliares: () => void;
+    calcularFlujoInversiones: () => void;
+    calcularFlujoAcumuladoAnual: () => void;
+    adicionarCapacidadPago: () => void;
+    getFlujoEfectivo: () => void;
+}

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

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlujoConstructor {
+    constructor(tipo, data) {
+        this.calcularFlujo = () => {
+            if (this.tipo == 'ANUAL') {
+                this.proyectarIngreso();
+                this.proyectarCosto();
+                this.proyectarGasto();
+                this.moverDetalledesdeMensual();
+                this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
+                this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900');
+                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
+            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');
+            this.calcularResta('ACT_CNFL_72000', 'ACT_CNFL_73900', 'ACT_CNFL_79000'); //Resultado Otros Ingresos e Egresos
+            this.calcularResta('ACT_CNFL_69999', 'ACT_CNFL_79000', 'ACT_CNFL_79999'); //Utilidad Neta
+            this.calcularTotal(['ACT_CNFL_80001', 'ACT_CNFL_80002'], 'ACT_CNFL_80900'); //Total Flujo de Inversión
+            this.calcularTotal(['ACT_CNFL_81001'], 'ACT_CNFL_81090'); //subtotal Ingresos de Efectivo
+            this.calcularTotal(['ACT_CNFL_81200'], 'ACT_CNFL_81290'); //subtotal Cuota BDP
+            this.calcularResta('ACT_CNFL_81090', 'ACT_CNFL_81290', 'ACT_CNFL_82100'); //Total Flujo financiero
+            if (this.tipo == 'MENSUAL') {
+                this.calcularTotal(['ACT_CNFL_79999', 'ACT_CNFL_80900', 'ACT_CNFL_82100'], 'ACT_CNFL_82200');
+                this.calcularFlujoAcumuladoMensual(this.data);
+            }
+            else if (this.tipo == 'ANUAL') {
+                this.calcularFlujoAcumuladoAnual();
+                this.calcularTotal(['ACT_CNFL_79999', 'ACT_CNFL_80900', 'ACT_CNFL_82100'], 'ACT_CNFL_82110');
+                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}`]);
+                }
+                item.MontoTotal = Math.round(item.MontoTotal * 100) / 100;
+            });
+            if (this.tipo == 'MENSUAL') {
+                this.calcularPorcentajeIngresCostos();
+            }
+        };
+        this.calcularFlujoAcumuladoMensual = (data) => {
+            let rowTotal = this.mapObject.get(`ACT_CNFL_82200_0`);
+            let rowAcumulado = this.mapObject.get(`ACT_CNFL_82300_0`);
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    rowAcumulado[`Monto${i}`] = parseFloat(rowTotal[`Monto${i}`]) + parseFloat(data.CajaInicial);
+                }
+                else {
+                    rowAcumulado[`Monto${i}`] = rowTotal[`Monto${i}`] + rowAcumulado[`Monto${i - 1}`];
+                }
+                rowAcumulado[`Monto${i}`] = Math.round(rowAcumulado[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.calcularTotal = (sumandosArray, total) => {
+            const rows = this.array.filter((item) => sumandosArray.includes(item.RubroId));
+            let destino = this.mapObject.get(`${total}_0`);
+            rows.map((item) => {
+                for (let i = 1; i <= this.rango; i++) {
+                    destino[`Monto${i}`] += parseFloat(item[`Monto${i}`]);
+                    destino[`Monto${i}`] = Math.round(destino[`Monto${i}`] * 100) / 100;
+                }
+            });
+        };
+        this.calcularResta = (positivoRubro, negativoRubro, destinoRubro) => {
+            const positivo = this.mapObject.get(`${positivoRubro}_0`);
+            const negativo = this.mapObject.get(`${negativoRubro}_0`);
+            let destino = this.mapObject.get(`${destinoRubro}_0`);
+            for (let i = 1; i <= this.rango; i++) {
+                destino[`Monto${i}`] = positivo[`Monto${i}`] - negativo[`Monto${i}`];
+                destino[`Monto${i}`] = Math.round(destino[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.proyectarIngreso = () => {
+            const rowTotalIngresoM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
+            const rowVariacionIngresos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_30001_0');
+            const rowIngresos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_40001_0');
+            const I10 = 0;
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    rowIngresos[`Monto${i}`] = rowTotalIngresoM[`Monto12`] * (1 + rowVariacionIngresos[`Monto${i}`] + I10);
+                }
+                else {
+                    rowIngresos[`Monto${i}`] = rowIngresos[`Monto${i - 1}`] * (1 + rowVariacionIngresos[`Monto${i}`] + I10);
+                }
+                rowIngresos[`Monto${i}`] = Math.round(rowIngresos[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.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');
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    rowCosto[`Monto1`] = (rowIngresos[`Monto1`] * 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;
+            }
+        };
+        this.proyectarGasto = () => {
+            const rowIngresos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_40001_0');
+            const rowVariacionGastos = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_30003_0');
+            const rowGasto = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_60001_0');
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    rowGasto[`Monto1`] = (rowIngresos[`Monto1`] *
+                        rowGasto.MontoCajaPercent / 100) + (1 + rowVariacionGastos[`Monto${i}`]);
+                }
+                else {
+                    rowGasto[`Monto${i}`] = rowIngresos[`Monto${i - 1}`] * (1 + rowVariacionGastos[`Monto${i}`]);
+                }
+                rowGasto[`Monto${i}`] = Math.round(rowGasto[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.moverDetalledesdeMensual = () => {
+            let filter = this.data.FlujoProyectadoMensual.filter((item) => item.RubroId == 'ACT_CNFL_61001' || item.RubroId == 'ACT_CNFL_73000');
+            filter.map((item) => {
+                if (this.mapObject.has(`${item.RubroId}_CLONE_${item.UUID}`)) {
+                    let detalle = this.mapObject.get(`${item.RubroId}_CLONE_${item.UUID}`);
+                    if (detalle.Monto1 == 0)
+                        detalle.Monto1 = item.MontoTotal;
+                }
+            });
+        };
+        this.calcularTotalDetalle = (sumandosArray, total) => {
+            const rows = this.array.filter((item) => sumandosArray.includes(item.RubroId) && item.Comprar == 'NO');
+            let destino = this.mapObject.get(`${total}_0`);
+            rows.map((item) => {
+                for (let i = 1; i <= this.rango; i++) {
+                    destino[`Monto${i}`] += parseFloat(item[`Monto${i}`]);
+                    destino[`Monto${i}`] = Math.round(destino[`Monto${i}`] * 100) / 100;
+                }
+            });
+        };
+        this.calcularPorcentajeIngresCostos = () => {
+            const rowTotalIngresoM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
+            let costos = this.array.filter((item) => item.RubroId === 'ACT_CNFL_50001' || item.RubroId === 'ACT_CNFL_50002' ||
+                item.RubroId === 'ACT_CNFL_60001' || item.RubroId === 'ACT_CNFL_60002');
+            costos.map((item) => {
+                if (rowTotalIngresoM.MontoTotal != 0)
+                    item.MontoCajaPercent = Math.round(parseFloat(item.MontoTotal) /
+                        parseFloat(rowTotalIngresoM.MontoTotal) * 100);
+                else
+                    item.MontoCajaPercent = 0;
+                if (item.RubroId == 'ACT_CNFL_50001' || item.RubroId === 'ACT_CNFL_60001') {
+                    this.data.FlujoProyectadoAnualMap.get(`${item.RubroId}_0`).MontoCajaPercent = item.MontoCajaPercent;
+                }
+            });
+            this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_82300_0').MontoCajaPercent = this.data.CajaInicial;
+        };
+        this.calcularOtrosIngresosAnuales = () => {
+            const rowOtrosIngresosM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_70001_0');
+            let rowOtrosIngresosA = this.mapObject.get('ACT_CNFL_70001_0');
+            for (let i = 1; i <= this.rango; i++) {
+                rowOtrosIngresosA[`Monto${i}`] = rowOtrosIngresosM.MontoTotal;
+                rowOtrosIngresosA[`Monto${i}`] = Math.round(rowOtrosIngresosA[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.calcularGastosFamiliares = () => {
+            const rowOtrosIngresosM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_70002_0');
+            let rowGastosFamiliares = this.mapObject.get('ACT_CNFL_70002_0');
+            if (!rowGastosFamiliares.MontoCajaPercent)
+                rowGastosFamiliares.MontoCajaPercent = 0;
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    rowGastosFamiliares[`Monto${i}`] = rowOtrosIngresosM.MontoTotal *
+                        (1 + (rowGastosFamiliares.MontoCajaPercent / 100));
+                }
+                else {
+                    rowGastosFamiliares[`Monto${i}`] = rowGastosFamiliares[`Monto${i - 1}`] *
+                        (1 + (rowGastosFamiliares.MontoCajaPercent / 100));
+                }
+                rowGastosFamiliares[`Monto${i}`] = Math.round(rowGastosFamiliares[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.calcularFlujoInversiones = () => {
+            const rowInversionM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_80001_0');
+            const rowAportePropioM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_80002_0');
+            let rowInversion = this.mapObject.get('ACT_CNFL_80001_0');
+            let rowAportePropio = this.mapObject.get('ACT_CNFL_80002_0');
+            if (rowInversion.Monto1 > 0)
+                rowInversion.Monto1 = rowInversionM.MontoTotal;
+            if (rowAportePropio.Monto1 > 0)
+                rowAportePropio.Monto1 = rowAportePropioM.MontoTotal;
+        };
+        this.calcularFlujoAcumuladoAnual = () => {
+            let flujoAcumulado = this.mapObject.get('ACT_CNFL_82300_0');
+            let excedente = this.mapObject.get('ACT_CNFL_82110_0');
+            let saldoInicialCaja = this.mapObject.get('ACT_CNFL_82120_0');
+            saldoInicialCaja.Monto1 = this.data.CajaInicial;
+            for (let i = 1; i <= this.rango; i++) {
+                if (i == 1) {
+                    flujoAcumulado[`Monto${i}`] = parseFloat(excedente[`Monto${i}`]) +
+                        parseFloat(saldoInicialCaja[`Monto${i}`]);
+                }
+                else {
+                    flujoAcumulado[`Monto${i}`] = parseFloat(flujoAcumulado[`Monto${i - 1}`]) +
+                        parseFloat(excedente[`Monto${i}`]);
+                }
+                flujoAcumulado[`Monto${i}`] = Math.round(flujoAcumulado[`Monto${i}`] * 100) / 100;
+            }
+        };
+        this.adicionarCapacidadPago = () => {
+            const utilidadNeta = this.mapObject.get('ACT_CNFL_82300_0');
+            const cuotaBdp = this.mapObject.get('ACT_CNFL_82300_0');
+            let result = {};
+            let acumulado = 0;
+            for (let i = 2; i <= this.rango; i++) {
+                if (utilidadNeta[`Monto${i}`] && utilidadNeta[`Monto${i}`] > 0)
+                    result[`Monto${i}`] = cuotaBdp[`Monto${i}`] / utilidadNeta[`Monto${i}`];
+                else
+                    result[`Monto${i}`] = 0;
+                result[`Monto${i}`] = Math.round(result[`Monto${i}`] * 100) / 100;
+                acumulado += result[`Monto${i}`];
+            }
+            result.PorcentajePromedio = Math.round(acumulado / this.rango * 100) / 100;
+            result.CapacidadMaxima = (acumulado / (this.rango - 1)) > 80 ? 'VERDADERO' : 'FALSO';
+            this.data.Pie = result;
+        };
+        this.getFlujoEfectivo = () => {
+            const tasaDescuento = Math.round(parseFloat(this.data.Parametros.TasaDescuento) * 100) / 100;
+            const totalFlujoInversiones = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_80900_0');
+            const excedente = this.data.FlujoProyectadoAnualMap.get('ACT_CNFL_82110_0');
+            let result = [];
+            let resultMap = new Map();
+            let indiceRentabilidad = 0;
+            for (let i = 0; i <= this.rango; i++) {
+                let value = {};
+                if (i == 0) {
+                    value = { Anno: i, FlujoDeEfectivo: totalFlujoInversiones[`Monto1`] * -1, FlujoEfectivoDescontado: 0 };
+                    result.push(value);
+                    resultMap.set(i, value);
+                }
+                else {
+                    value = { Anno: i, FlujoDeEfectivo: excedente[`Monto${i}`], FlujoEfectivoDescontado: 0 };
+                    result.push(value);
+                    resultMap.set(i, value);
+                }
+                value.FlujoEfectivoDescontado = value.FlujoDeEfectivo / Math.pow(1 + tasaDescuento, i);
+                indiceRentabilidad += value.FlujoDeEfectivo / Math.pow(1 + tasaDescuento, i);
+            }
+            indiceRentabilidad = Math.round((indiceRentabilidad / totalFlujoInversiones[`Monto1`]) * 100) / 100;
+            const VAN = calcularVAN(tasaDescuento, result.filter((item => item.Anno > 0)).
+                map((item) => item.FlujoDeEfectivo), totalFlujoInversiones[`Monto1`]);
+            const TIR = calcularTIR(result.map(item => item.FlujoDeEfectivo), totalFlujoInversiones[`Monto1`]);
+            let vars = [{ Descripcion: 'Tasa de descuento', Valor: tasaDescuento },
+                { Descripcion: 'VAN', Valor: VAN },
+                { Descripcion: 'TIR', Valor: TIR },
+                { Descripcion: 'Índice de Rentabilidad', Valor: indiceRentabilidad },
+            ];
+            this.data.FlujoDeEfectivo = result;
+            this.data.FlujoEfectivoVars = vars;
+        };
+        this.tipo = tipo;
+        if (tipo == 'MENSUAL') {
+            this.rango = 12;
+            this.mapObject = data.FlujoProyectadoMensualMap;
+            this.array = data.FlujoProyectadoMensual;
+            this.data = data;
+        }
+        else {
+            this.rango = data.DatosEvaluacion.CantidadProyeccion;
+            this.mapObject = data.FlujoProyectadoAnualMap;
+            this.array = data.FlujoProyectadoAnual;
+            this.data = data;
+        }
+    }
+}
+exports.default = FlujoConstructor;
+const calcularVAN = (tasaDescuento, flujosDeCaja, inversionInicial) => {
+    let VAN = -inversionInicial;
+    for (let t = 0; t < flujosDeCaja.length; t++) {
+        VAN += flujosDeCaja[t] / Math.pow(1 + tasaDescuento, t + 1);
+    }
+    return VAN;
+};
+const calcularTIR = (flujosDeCaja, inversionInicial, precision = 1e-6) => {
+    let tasaMin = 0;
+    let tasaMax = 1;
+    let tasaMed = (tasaMin + tasaMax) / 2;
+    while ((tasaMax - tasaMin) > precision) {
+        let VAN = calcularVAN(tasaMed, flujosDeCaja, inversionInicial);
+        if (VAN > 0) {
+            tasaMin = tasaMed;
+        }
+        else {
+            tasaMax = tasaMed;
+        }
+        tasaMed = (tasaMin + tasaMax) / 2;
+    }
+    return tasaMed;
+};

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

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

package/build/strategies/common/flujoCalculos/supuestos.calc.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupuestos = exports.getSupuestosEmpty = void 0;
+const getSupuesto = (descripcion, descripcionCorta, valores) => {
+    let obj = {};
+    obj.Descripcion = descripcion;
+    obj.Corta = descripcionCorta;
+    obj.TipoValorFlujo = 'OTROS';
+    obj.ValorFlujo = 0;
+    obj.OtrosValor = 0;
+    obj.Valores = valores;
+    return obj;
+};
+const getValoresVacios = (rango) => {
+    let array = [];
+    for (let i = 1; i <= rango; i++) {
+        array.push({
+            Correlativo: i,
+            CorrelativoDesc: '-',
+            MontoPorcentual: 0
+        });
+    }
+    return array;
+};
+const getRango = (data) => {
+    let rango = 0;
+    if (!data.DatosEvaluacion || !data.DatosEvaluacion.Gestiones || data.DatosEvaluacion.Gestiones.length == 0)
+        throw new Error('No se encontraron gestiones definidas en la evaluación');
+    else
+        rango = data.DatosEvaluacion.Gestiones.length;
+    return rango;
+};
+const getSupuestosEmpty = (data) => {
+    let array = [];
+    let rango = getRango(data);
+    array.push(getSupuesto("% DE COSTOS", "% Costo", getValoresVacios(rango)));
+    array.push(getSupuesto("% GASTOS OPERATIVOS", "% G.O.", getValoresVacios(rango)));
+    return array;
+};
+exports.getSupuestosEmpty = getSupuestosEmpty;
+const getSupuestos = (data) => {
+    let rango = getRango(data);
+    if (!data.balance || !data.balance.eerr)
+        return (0, exports.getSupuestosEmpty)(data);
+    let CostoVentasValuePercent = data.balance.eerr.find((item) => item.RubroId === 'ACT_CN_41001');
+    let GastosAdmValuePercent = data.balance.eerr.find((item) => item.RubroId === 'ACT_CN_43001');
+    CostoVentasValuePercent =
+        getSupuesto("% DE COSTOS", "% Costo", getValores(CostoVentasValuePercent, rango));
+    GastosAdmValuePercent =
+        getSupuesto("% GASTOS OPERATIVOS", "% G.O.", getValores(GastosAdmValuePercent, rango));
+    CostoVentasValuePercent = calcularValorOtros(CostoVentasValuePercent, data.FlujoProyectadoMensualMap, 'COSTOS');
+    GastosAdmValuePercent = calcularValorOtros(GastosAdmValuePercent, data.FlujoProyectadoMensualMap, 'GASTOS');
+    CostoVentasValuePercent = calcularValores(CostoVentasValuePercent, data.Parametros.PorcentajeCostos, rango);
+    GastosAdmValuePercent = calcularValores(GastosAdmValuePercent, data.Parametros.PorcentajeGastos, rango);
+    return [CostoVentasValuePercent, GastosAdmValuePercent];
+};
+exports.getSupuestos = getSupuestos;
+const calcularValorOtros = (supuesto, data, tipo) => {
+    let rubroId = '';
+    if (tipo == 'COSTOS')
+        rubroId = 'ACT_CNFL_50001_0';
+    else if (tipo == 'GASTOS')
+        rubroId = 'ACT_CNFL_60001_0';
+    supuesto.OtrosValor =
+        data.get(rubroId).MontoCajaPercent;
+    return supuesto;
+};
+const calcularValores = (supuesto, tipoConfig, rango) => {
+    if (tipoConfig === 'PROMEDIO') {
+        let suma = supuesto.Valores.reduce((acc, item) => {
+            acc += item.MontoPorcentual;
+            return acc;
+        }, 0);
+        suma = Math.round(suma * 100) / 100;
+        supuesto.ValorFlujo = suma;
+        return supuesto;
+    }
+    else if (tipoConfig === 'PROMEDIO2') {
+        let suma = supuesto.Valores.reduce((acc, item) => {
+            if (item.Correlativo == rango - 1 || item.Correlativo == rango)
+                acc += item.MontoPorcentual;
+            return acc;
+        }, 0);
+        suma = Math.round(suma * 100) / 100;
+        supuesto.ValorFlujo = suma;
+        return;
+    }
+    else if (tipoConfig === 'MENOR') {
+        let menor = supuesto.Valores.reduce((acc, item) => {
+            if (acc > item.MontoPorcentual || acc == -1)
+                acc = item.MontoPorcentual;
+            return acc;
+        }, -1);
+        menor = Math.round(menor * 100) / 100;
+        supuesto.ValorFlujo = menor;
+    }
+    else if (tipoConfig === 'ULTIMA_GES') {
+        let ultimo = supuesto.Valores.reduce((acc, item) => {
+            if (item.Correlativo == rango)
+                acc = item.MontoPorcentual;
+            return acc;
+        }, 0);
+        ultimo = Math.round(ultimo * 100) / 100;
+        supuesto.ValorFlujo = ultimo;
+    }
+    else if (tipoConfig === 'OTROS') {
+        supuesto.ValorFlujo = supuesto.OtrosValor;
+    }
+    return supuesto;
+};
+const getValores = (rowEERR, rango) => {
+    if (!rowEERR)
+        return getValoresVacios(rango);
+    let array = [];
+    for (let i = 1; i <= rango; i++) {
+        array.push({
+            Correlativo: i,
+            CorrelativoDesc: rowEERR[`Fecha_${i}`],
+            MontoPorcentual: parseFloat(rowEERR[`MontoEmpresa_${i}`])
+        });
+    }
+    return array;
+};

package/build/strategies/common/flujoProyectado.calc.d.ts

@@ -1,12 +1,4 @@
-export declare const getSupuestosEmpty: (data: any) => any[];
+export declare const getFlujoMap: (data: any, rango: number) => any;
+export declare const calcularFlujoMensual: (data: any) => void;
+export declare const calcularFlujoAnual: (data: any) => void;
 export declare const getHistoricoFlujoCaja: (data: any) => any[];
-export declare const getFlujoEfectivo: (data: any) => {
-    Anno: number;
-    FlujoDeEfectivo: number;
-    FlujoEfectivoDescontado: number;
-}[];
-export declare const getFlujoEfectivoExtra: (data: any) => {
-    Descripcion: string;
-    Valor: number;
-}[];
-export declare const getPieFlujo: (data: any) => any;

package/build/strategies/common/flujoProyectado.calc.js

@@ -1,73 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPieFlujo = exports.getFlujoEfectivoExtra = exports.getFlujoEfectivo = exports.getHistoricoFlujoCaja = exports.getSupuestosEmpty = void 0;
-const getSupuestos = (descripcion, descripcionCorta) => {
-    let obj = {};
-    obj.Descripcion = descripcion;
-    obj.Corta = descripcionCorta;
-    obj.TipoValorFlujo = 'OTROS';
-    obj.ValorFlujo = 0;
-    obj.OtrosValor = 0;
-    obj.Valores = [
-        {
-            Correlativo: 1,
-            CorrelativoDesc: '01-20XX',
-            MontoPorcentual: 0
+exports.getHistoricoFlujoCaja = exports.calcularFlujoAnual = exports.calcularFlujoMensual = exports.getFlujoMap = void 0;
+const flujoConstructor_1 = __importDefault(require("./flujoCalculos/flujoConstructor"));
+const getFlujoMap = (data, rango) => {
+    return data.reduce((acc, item) => {
+        let key = `${item.RubroId}_0`;
+        if (item.Clasificador == 'HABM' || item.Clasificador == 'DETL')
+            key = `${item.RubroId}_${item.UUID ? item.UUID : '0'}`;
+        for (let i = 1; i <= rango; i++) {
+            item[`Monto${i}`] = parseFloat(item[`Monto${i}`]);
         }
-    ];
-    return obj;
+        acc.set(key, item);
+        return acc;
+    }, new Map());
+};
+exports.getFlujoMap = getFlujoMap;
+const calcularFlujoMensual = (data) => {
+    const flujoConstructor = new flujoConstructor_1.default('MENSUAL', data);
+    flujoConstructor.calcularFlujo();
 };
-const getSupuestosEmpty = (data) => {
-    let array = [];
-    array.push(getSupuestos("% DE COSTOS", "% Costo"));
-    array.push(getSupuestos("% GASTOS OPERATIVOS", "% G.O."));
-    return array;
+exports.calcularFlujoMensual = calcularFlujoMensual;
+const calcularFlujoAnual = (data) => {
+    const flujoConstructor = new flujoConstructor_1.default('ANUAL', data);
+    flujoConstructor.calcularFlujo();
 };
-exports.getSupuestosEmpty = getSupuestosEmpty;
+exports.calcularFlujoAnual = calcularFlujoAnual;
 const getHistoricoFlujoCaja = (data) => {
-    const meses = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"];
-    const anoActual = new Date().getFullYear(); // Obtiene el año actual
     const datos = [];
-    meses.forEach((mes, index) => {
-        datos.push([`${mes}-${anoActual}`, 0]);
-    });
+    const totalIngresos = data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
+    for (let i = 1; i <= 12; i++) {
+        datos.push({ Fecha: totalIngresos[`Fecha${i}`], Monto: totalIngresos[`Monto${i}`] });
+    }
     return datos;
 };
 exports.getHistoricoFlujoCaja = getHistoricoFlujoCaja;
-const getFlujoEfectivo = (data) => {
-    const value = [{ Anno: 0, FlujoDeEfectivo: 0, FlujoEfectivoDescontado: 0 },
-        { Anno: 1, FlujoDeEfectivo: 0, FlujoEfectivoDescontado: 0 }];
-    return value;
-};
-exports.getFlujoEfectivo = getFlujoEfectivo;
-const getFlujoEfectivoExtra = (data) => {
-    const value = [{ Descripcion: 'Tasa de descuento', Valor: 0 },
-        { Descripcion: 'VAN', Valor: 0 },
-        { Descripcion: 'TIR', Valor: 0 },
-        { Descripcion: 'Índice de Rentabilidad', Valor: 0 },
-    ];
-    return value;
-};
-exports.getFlujoEfectivoExtra = getFlujoEfectivoExtra;
-const getPieFlujo = (data) => {
-    let result = {};
-    result.PlazoAnnos = 0;
-    result.CapacidadPago = 0;
-    result.DescripcionResulta = "VERDADERO";
-    result.PorcentajePagoPromedio = [
-        { Correlativo: 1, MontoPorcentual: 0 },
-        { Correlativo: 2, MontoPorcentual: 0 },
-        { Correlativo: 3, MontoPorcentual: 0 },
-        { Correlativo: 4, MontoPorcentual: 0 },
-        { Correlativo: 5, MontoPorcentual: 0 },
-        { Correlativo: 6, MontoPorcentual: 0 },
-        { Correlativo: 7, MontoPorcentual: 0 },
-        { Correlativo: 8, MontoPorcentual: 0 },
-        { Correlativo: 9, MontoPorcentual: 0 },
-        { Correlativo: 10, MontoPorcentual: 0 },
-        { Correlativo: 11, MontoPorcentual: 0 },
-        { Correlativo: 12, MontoPorcentual: 0 },
-    ];
-    return result;
-};
-exports.getPieFlujo = getPieFlujo;

package/build/strategies/flujoProyectado.strategy.js

@@ -1,18 +1,64 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const commmon = __importStar(require("./common/balance.calc"));
+//@ts-ignore
+const supuestosCalc = __importStar(require("./common/flujoCalculos/supuestos.calc"));
+//@ts-ignore
+const declaracionJuradaCalc = __importStar(require("./common/declaracionJurada.calc"));
+//@ts-ignore
+const flujoProyectadoCalc = __importStar(require("./common/flujoProyectado.calc"));
+//@ts-ignore
 const flujoProyectado_calc_1 = require("./common/flujoProyectado.calc");
-//import * as commmon from "./common/balance.calc";
 class FlujoProyectado {
     execute(data) {
         let result = {};
         result = data;
+        const cloneFlujoProyectadoMensual = commmon.clone(data.FlujoProyectadoMensual);
+        const cloneFlujoProyectadoAnual = commmon.clone(data.FlujoProyectadoAnual);
+        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)
+            data = data.strategy.execute(data);
+        result.CajaInicial = declaracionJuradaCalc.getCajaInicial(data.declaracionJurada);
+        flujoProyectadoCalc.calcularFlujoMensual(data);
+        result.Supuestos = supuestosCalc.getSupuestos(data);
+        flujoProyectadoCalc.calcularFlujoAnual(data);
+        //result.HistoricoGrafico = getHistoricoFlujoCaja(data)
+        //
+        //result.FlujoEfectivo = getFlujoEfectivo(data)
+        //result.FlujoEfectivoVars = getFlujoEfectivoExtra(data)
+        // data.FlujoProyectadoMensual = Array.from(data.FlujoProyectadoMensualMap.values())
+        //data.FlujoProyectadoAnual = Array.from(data.FlujoProyectadoAnualMap.values())
+        delete result.FlujoProyectadoMensualMap;
+        delete result.FlujoProyectadoAnualMap;
+        result.DataOriginal = {
+            FlujoProyectadoMensual: cloneFlujoProyectadoMensual,
+            FlujoProyectadoAnual: cloneFlujoProyectadoAnual
+        };
         delete result.strategy;
-        result.CajaInicial = 0;
-        result.Supuestos = (0, flujoProyectado_calc_1.getSupuestosEmpty)(data);
-        result.HistoricoGrafico = (0, flujoProyectado_calc_1.getHistoricoFlujoCaja)(data);
-        result.FlujoEfectivo = (0, flujoProyectado_calc_1.getFlujoEfectivo)(data);
-        result.FlujoEfectivoVars = (0, flujoProyectado_calc_1.getFlujoEfectivoExtra)(data);
-        result.Pie = (0, flujoProyectado_calc_1.getPieFlujo)(data);
         return result;
     }
 }

package/package.json

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