bdpformulas 1.0.36 → 1.0.38

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;