bdpformulas 1.0.35 → 1.0.37

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

@@ -1,35 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const balanceAux_calc_1 = require("../common/balanceCalculos/balanceAux.calc");
 class BalanceAgrStrategy {
     constructor() {
         this.actividades = [];
     }
     execute(data) {
-        data.eerr = calcularEERR(data.eerr, this.actividades);
+        if (!this.actividades || this.actividades.length == 0)
+            throw new Error('Debe ingresar actividades Agrícolas');
+        let acumuladoActividades = null;
+        for (let actividad of this.actividades) {
+            let actividadCalculada = calcularActividad(actividad);
+            acumuladoActividades = addAcumulado(acumuladoActividades, actividadCalculada);
+        }
+        data.eerrMap = calcularEERR(data.eerrMap, data.eerr, acumuladoActividades);
         return data;
     }
 }
 exports.default = BalanceAgrStrategy;
-const calcularEERR = (eerr, actividades) => {
-    // const totalesOtrosIngresos = getOtrosIngresos(ventas)
-    // const mapVentas = getVentasXGestion(ventas)
-    // const costoTotal = calcularCostoTotal(costos)
-    // const gastos = calcularOtrosGastos(costos)
-    //
-    // console.log('mapVentas',mapVentas)
-    // console.log('totalesOtrosIngresos',totalesOtrosIngresos)
-    // console.log('costoTotal',costoTotal)
-    // console.log('gastos',gastos)
-    return eerr;
+const addAcumulado = (acumuladoActividades, actividadCalculada) => {
+    if (acumuladoActividades == null)
+        return actividadCalculada;
+    else {
+        for (let [key, value] of actividadCalculada.ventas) {
+            if (acumuladoActividades.ventas.has(key)) {
+                let acumulado = acumuladoActividades.ventas.get(key);
+                acumulado += value;
+                acumuladoActividades.ventas.set(key, acumulado);
+            }
+        }
+        acumuladoActividades.otrosIngresos += actividadCalculada.otrosIngresos;
+        acumuladoActividades.costoTotal += actividadCalculada.costoTotal;
+        acumuladoActividades.otrosGastos.GastosOperativos += actividadCalculada.otrosGastos.GastosOperativos;
+        acumuladoActividades.otrosGastos.GastosFamiliares += actividadCalculada.otrosGastos.GastosFamiliares;
+        return acumuladoActividades;
+    }
+};
+const calcularActividad = (actividades) => {
+    const ventas = getVentasXGestion(actividades.Ventas);
+    const otrosIngresos = getOtrosIngresos(actividades.Ventas);
+    const costoTotal = calcularCostoTotal(actividades.Costos);
+    const otrosGastos = calcularOtrosGastos(actividades.OtrosGastos);
+    return { ventas: ventas,
+        otrosIngresos: otrosIngresos,
+        costoTotal: costoTotal,
+        otrosGastos: otrosGastos };
+};
+const calcularEERR = (eerrMap, eerr, consolidado) => {
+    if (consolidado) {
+        for (let [key, value] of consolidado.ventas) {
+            const rubroKey = `ACT_CN_40001_${key}`;
+            if (!eerrMap.has(rubroKey))
+                throw new Error(`No existe el rubro llave ${rubroKey}`);
+            if (eerrMap.get(rubroKey).MontoEmpresa == 0)
+                eerrMap.get(rubroKey).MontoEmpresa = value;
+        }
+        setValueInOtros('ACT_CN_41002', eerrMap, eerr, { MontoEmpresa: consolidado.costoTotal }, 'COSTOS AGR Costo Total');
+        setValueInOtros('ACT_CN_43002', eerrMap, eerr, { MontoEmpresa: consolidado.otrosGastos.GastosOperativos }, 'Gastos AGR  Total Gastos Operativos');
+        setValueInOtros('ACT_CN_43004', eerrMap, eerr, { MontoFamiliar: consolidado.otrosGastos.GastosFamiliares }, 'Gastos AGR  Total Gastos Familiares');
+        setValueInOtros('ACT_CN_45001', eerrMap, eerr, { MontoFamiliar: consolidado.otrosIngresos }, 'Ventas AGR  Otros Ingresos');
+    }
+    return eerrMap;
+};
+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)) {
+        (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;
+    }
 };
 //@ts-ignore
 const getOtrosIngresos = (ventas) => {
-    const ingresosTotales = ventas.OtrosIngresos.reduce((acc, item) => {
+    let ingresosTotales = ventas.OtrosIngresos.reduce((acc, item) => {
         for (let i = 1; i <= 12; i++) {
-            acc += item[`Gestion${i}`];
+            acc += parseFloat(item[`Gestion${i}`]);
         }
         return acc;
     }, 0);
+    ingresosTotales = Math.round(ingresosTotales * 100) / 100;
     return ingresosTotales;
 };
 //@ts-ignore
@@ -42,36 +97,38 @@ const getVentasXGestion = (ventas) => {
             if (!acc.has(i)) {
                 acc.set(i, 0);
             }
-            let value = acc.get(i);
-            value += item[`Gestion${i}`];
-            acc.set(i, value);
+            let value = parseFloat(acc.get(i));
+            value += parseFloat(item[`Gestion${i}`]);
+            acc.set(i, Math.round(value * 100) / 100);
         }
         return acc;
     }, new Map());
-    return Array.from(result.values());
+    return result;
 };
 //@ts-ignore
 const calcularCostoTotal = (costos) => {
     let numero = 0;
-    const filter = costos.filter((item) => item.ActividadProductoId == 0);
-    if (filter.length > 0) {
-        numero = filter[0].Total;
+    if (costos && costos.Meses) {
+        const filter = costos.Meses.filter((item) => item.ActividadProductoId == 0);
+        if (filter.length > 0) {
+            numero = parseFloat(filter[0].Total);
+        }
+        numero = Math.round(numero * 100) / 100;
     }
-    numero = Math.round(numero * 100) / 100;
     return numero;
 };
 //@ts-ignore
 const calcularOtrosGastos = (gastos) => {
     const gastosOperativos = gastos.Operativos.reduce((acc, item) => {
-        acc += item.ImporteAnual;
+        acc += parseFloat(item.ImporteAnual);
         return acc;
     }, 0);
     const gastosFamiliares = gastos.Familiares.reduce((acc, item) => {
-        acc += item.ImporteAnual;
+        acc += parseFloat(item.ImporteAnual);
         return acc;
     }, 0);
     return {
-        GastosOperativos: gastosOperativos,
-        GastosFamiliares: gastosFamiliares
+        GastosOperativos: Math.round(gastosOperativos * 100) / 100,
+        GastosFamiliares: Math.round(gastosFamiliares * 100) / 100
     };
 };

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

@@ -23,14 +23,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 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/declaracionJurada.calc");
+const flujoAux_calc_1 = require("./common/balanceCalculos/flujoAux.calc");
 class Balance {
     execute(data) {
         let result = {};
-        const balanceClone = trasponer(commmon.clone(data.balance));
-        const eerrClone = trasponer(commmon.clone(data.eerr));
+        const balanceClone = balanceCalc.trasponer(commmon.clone(data.balance));
+        const eerrClone = balanceCalc.trasponer(commmon.clone(data.eerr));
+        let balanceMap = balanceCalc.getBalanceHashMap(data.balance);
+        let eerrMap = balanceCalc.getBalanceHashMap(data.eerr);
+        (0, declaracionJurada_calc_1.anadirDeclaracionJurada)(balanceMap, data.balance, data.declaracionJurada.Balance);
+        data.eerrMap = eerrMap;
+        (0, flujoAux_calc_1.setFlujoInEERR)(data);
         if (data.strategy != null)
             data = data.strategy.execute(data);
+        delete data.eerrMap;
+        data.balance = Array.from(balanceMap.values());
+        data.eerr = Array.from(eerrMap.values());
         result.balance = calcularBalance(data.balance);
         result.eerr = calcularEERR(data.eerr);
         result.DataOriginal = {
@@ -45,7 +56,8 @@ const calcularBalance = (balance) => {
     let i = 0;
     let result = balance.map((item) => {
         i++;
-        return Object.assign(Object.assign({}, item), { MontoEmpresa: parseFloat(item.MontoEmpresa), MontoFamiliar: parseFloat(item.MontoFamiliar), MontoTotal: parseFloat(item.MontoEmpresa) + parseFloat(item.MontoFamiliar), IdVirtual: i });
+        const esGrupo = item.Clasificador == 'P' || item.Clasificador == 'C';
+        return Object.assign(Object.assign({}, item), { MontoEmpresa: (!esGrupo ? parseFloat(item.MontoEmpresa) : 0), MontoFamiliar: (!esGrupo ? parseFloat(item.MontoFamiliar) : 0), MontoTotal: (!esGrupo ? parseFloat(item.MontoEmpresa) + parseFloat(item.MontoFamiliar) : 0), IdVirtual: i });
     });
     result = sumarizarCuenta(['ACT_CN_11000', 'ACT_CN_12000',
         'ACT_CN_21000', 'ACT_CN_22000', 'ACT_CN_30000'], result);
@@ -59,14 +71,15 @@ const calcularBalance = (balance) => {
     result = adicionarCuenta('ACT_CN_30000', 'ACT_CN_39000', result);
     result = adicionarCuenta('ACT_CN_20000', 'ACT_CN_39900', result);
     result = adicionarCuenta('ACT_CN_30000', 'ACT_CN_39900', result);
-    result = trasponer(result);
+    result = balanceCalc.trasponer(result);
     return result;
 };
 const calcularEERR = (eerr) => {
     let i = 0;
     let result = eerr.map((item) => {
         i++;
-        return Object.assign(Object.assign({}, item), { MontoEmpresa: parseFloat(item.MontoEmpresa), MontoFamiliar: parseFloat(item.MontoFamiliar), MontoTotal: parseFloat(item.MontoEmpresa) + parseFloat(item.MontoFamiliar), IdVirtual: i });
+        const esGrupo = item.Clasificador == 'P' || item.Clasificador == 'C';
+        return Object.assign(Object.assign({}, item), { MontoEmpresa: (!esGrupo ? parseFloat(item.MontoEmpresa) : 0), MontoFamiliar: (!esGrupo ? parseFloat(item.MontoFamiliar) : 0), MontoTotal: (!esGrupo ? parseFloat(item.MontoEmpresa) + parseFloat(item.MontoFamiliar) : 0), IdVirtual: i });
     });
     //Ingresos
     result = sumarizarCuenta(['ACT_CN_40000'], result);
@@ -99,7 +112,7 @@ const calcularEERR = (eerr) => {
     //Utilidad neta
     result = adicionarCuenta('ACT_CN_46000', 'ACT_CN_47000', result);
     result = adicionarCuenta('ACT_CN_46001', 'ACT_CN_47000', result, true);
-    result = trasponer(result);
+    result = balanceCalc.trasponer(result);
     return result;
 };
 const adicionarCuenta = (origen, destino, datos, isNegative = false) => {
@@ -151,46 +164,3 @@ const sumarizarCuenta = (rubros, datos) => {
     });
     return datos;
 };
-//@ts-ignore
-const trasponer = (data) => {
-    let result = data.reduce((acc, item) => {
-        const uuid = item.UUID != null ? item.UUID : '0';
-        const key = `${item.RubroId}_${uuid}`;
-        if (!acc.has(key)) {
-            acc.set(key, {
-                RubroId: item.RubroId,
-                RubroPadreId: item.RubroPadreId,
-                Descripcion: item.Descripcion,
-                IndicadorABM: item.IndicadorABM,
-                Clasificador: item.Clasificador,
-                Borrable: (item.Clasificador == 'HABM'),
-                Editable: item.Editable,
-                Secuencia: item.Secuencia,
-                UUID: item.UUID,
-                Rango: item.Rango,
-            });
-            for (let i = 1; i <= item.Rango; i++) {
-                acc.get(key)[`MontoEmpresa_${i}`] = 0;
-                acc.get(key)[`MontoFamiliar_${i}`] = 0;
-                acc.get(key)[`MontoTotal_${i}`] = 0;
-                acc.get(key)[`Fecha_${i}`] = null;
-            }
-        }
-        acc.get(key)[`MontoEmpresa_${item.Correlativo}`] = item.MontoEmpresa;
-        acc.get(key)[`MontoFamiliar_${item.Correlativo}`] = item.MontoFamiliar;
-        acc.get(key)[`MontoTotal_${item.Correlativo}`] = item.MontoTotal;
-        acc.get(key)[`Fecha_${item.Correlativo}`] = item.Fecha;
-        return acc;
-    }, new Map());
-    result = Array.from(result.values());
-    result = result.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
-    return result;
-};
-// const esBorrable=(rubroId: string )=>{
-//
-//     // const rubrosBorrables = ['ACT_CN_11004','ACT_CN_12005',
-//     //                                   'ACT_CN_21003','ACT_CN_22003','ACT_CN_30002',
-//     //                                   'ACT_CN_40002','ACT_CN_41003','ACT_CN_43004','ACT_CN_45001']
-//     return (rubrosBorrables.includes(rubroId))
-// }
-//

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

@@ -1,2 +1,4 @@
 export declare const clone: (data: any) => any;
+export declare const getBalanceHashMap: (balance: any) => any;
+export declare const trasponer: (data: any) => any;
 export declare const calcularPorcentaje: (balance: any) => void;

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

@@ -1,10 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcularPorcentaje = exports.clone = void 0;
+exports.calcularPorcentaje = exports.trasponer = exports.getBalanceHashMap = exports.clone = void 0;
 const clone = (data) => {
     return JSON.parse(JSON.stringify(data));
 };
 exports.clone = clone;
+const getBalanceHashMap = (balance) => {
+    if (!balance || balance.length == 0)
+        throw new Error('Debe ingresar un balance válido');
+    const result = balance.reduce((acc, item) => {
+        if (item.Clasificador !== 'CT') {
+            let key = `${item.RubroId}_${item.Correlativo}`;
+            if (item.Clasificador !== 'H') {
+                key = `${item.RubroId}_${!item.UUID ? '0' : item.UUID}_${item.Correlativo}`;
+            }
+            if (!acc.has(key)) {
+                acc.set(key, Object.assign({}, item));
+            }
+        }
+        return acc;
+    }, new Map());
+    return result;
+};
+exports.getBalanceHashMap = getBalanceHashMap;
+const trasponer = (data) => {
+    let result = data.reduce((acc, item) => {
+        const uuid = item.UUID != null ? item.UUID : '0';
+        const key = `${item.RubroId}_${uuid}`;
+        if (!acc.has(key)) {
+            acc.set(key, {
+                RubroId: item.RubroId,
+                RubroPadreId: item.RubroPadreId,
+                Descripcion: item.Descripcion,
+                IndicadorABM: item.IndicadorABM,
+                Clasificador: item.Clasificador,
+                Borrable: (item.Clasificador == 'HABM'),
+                Editable: item.Editable,
+                Secuencia: item.Secuencia,
+                UUID: item.UUID,
+                Rango: item.Rango,
+            });
+            for (let i = 1; i <= item.Rango; i++) {
+                acc.get(key)[`MontoEmpresa_${i}`] = 0;
+                acc.get(key)[`MontoFamiliar_${i}`] = 0;
+                acc.get(key)[`MontoTotal_${i}`] = 0;
+                acc.get(key)[`Fecha_${i}`] = null;
+            }
+        }
+        acc.get(key)[`MontoEmpresa_${item.Correlativo}`] = item.MontoEmpresa;
+        acc.get(key)[`MontoFamiliar_${item.Correlativo}`] = item.MontoFamiliar;
+        acc.get(key)[`MontoTotal_${item.Correlativo}`] = item.MontoTotal;
+        acc.get(key)[`Fecha_${item.Correlativo}`] = item.Fecha;
+        return acc;
+    }, new Map());
+    result = Array.from(result.values());
+    result = result.sort((a, b) => a.RubroId.localeCompare(b.RubroId));
+    return result;
+};
+exports.trasponer = trasponer;
 const calcularPorcentaje = (balance) => {
 };
 exports.calcularPorcentaje = calcularPorcentaje;

package/build/strategies/common/balanceCalculos/balanceAux.calc.d.ts

@@ -0,0 +1 @@
+export declare const anadirNuevoRubro: (muestra: any, balanceMap: any, values: any, descripcion: string) => void;

package/build/strategies/common/balanceCalculos/balanceAux.calc.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anadirNuevoRubro = void 0;
+const anadirNuevoRubro = (muestra, balanceMap, values, descripcion) => {
+    for (let i = 1; i <= muestra.Rango; i++) {
+        let newData = Object.assign(Object.assign({}, muestra), { Descripcion: `${muestra.Descripcion} ${descripcion}`, Fecha: null, Correlativo: i, MontoFamiliar: 0, MontoEmpresa: 0, IndicadorABM: 'N', Editable: false, Clasificador: 'CT' });
+        if (i == muestra.Rango) {
+            if (values.MontoEmpresa && values.MontoEmpresa > 0)
+                newData.MontoEmpresa = values.MontoEmpresa;
+            if (values.MontoFamiliar && values.MontoFamiliar > 0)
+                newData.MontoFamiliar = values.MontoFamiliar;
+        }
+        balanceMap.set(`${muestra.RubroId}_${i}`, newData);
+    }
+};
+exports.anadirNuevoRubro = anadirNuevoRubro;

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

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

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anadirDeclaracionJurada = void 0;
+const balanceAux_calc_1 = require("./balanceAux.calc");
+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/balanceCalculos/flujoAux.calc.d.ts

@@ -0,0 +1 @@
+export declare const setFlujoInEERR: (data: any) => Promise<void>;

package/build/strategies/common/balanceCalculos/flujoAux.calc.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFlujoInEERR = void 0;
+const setFlujoInEERR = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    if (data.flujoProyectado && data.flujoProyectado.FlujoProyectadoMensual
+        && data.flujoProyectado.FlujoProyectadoMensual.length > 0) {
+        let gastosFinancierosEmp = data.flujoProyectado.FlujoProyectadoMensual.
+            filter((value) => value.RubroId == 'ACT_CNFL_61001').reduce((acc, item) => {
+            for (let i = 1; i <= 12; i++) {
+                acc += parseFloat(item[`Monto${i}`]);
+            }
+            return acc;
+        }, 0);
+        const rango = data.eerrMap.get('ACT_CN_43003_1').Rango;
+        data.eerrMap.get(`ACT_CN_43003_${rango}`).MontoEmpresa = gastosFinancierosEmp;
+    }
+});
+exports.setFlujoInEERR = setFlujoInEERR;

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;