bdpformulas 1.0.42 → 1.0.44

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

@@ -7,7 +7,7 @@ class BalanceAgrStrategy {
     }
     execute(data) {
         if (!this.actividades || this.actividades.length == 0)
-            throw new Error('Debe ingresar actividades Agrícolas');
+            return data;
         let acumuladoActividades = null;
         for (let actividad of this.actividades) {
             let actividadCalculada = calcularActividad(actividad);
@@ -55,10 +55,10 @@ const calcularEERR = (eerrMap, eerr, consolidado) => {
             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');
+        setValueInOtros('ACT_CN_41002', eerrMap, eerr, { MontoEmpresa: consolidado.costoTotal }, 'Costos de Ventas COSTOS AGR Costo Total');
+        setValueInOtros('ACT_CN_43002', eerrMap, eerr, { MontoEmpresa: consolidado.otrosGastos.GastosOperativos }, 'Gastos Administrativos/Operativos Gastos AGR  Total Gastos Operativos');
+        setValueInOtros('ACT_CN_43004', eerrMap, eerr, { MontoFamiliar: consolidado.otrosGastos.GastosFamiliares }, 'Gastos Familiares Gastos AGR  Total Gastos Familiares');
+        setValueInOtros('ACT_CN_45001', eerrMap, eerr, { MontoFamiliar: consolidado.otrosIngresos }, 'Otros Ingresos Ventas AGR');
     }
     return eerrMap;
 };

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

@@ -7,7 +7,7 @@ class FlujoProyectadoAgrStrategy {
     }
     execute(data) {
         if (!this.actividades || this.actividades.length == 0)
-            throw new Error('Debe ingresar actividades Agrícolas');
+            return data;
         calcularFlujoMensual(data, this.actividades);
         return data;
     }

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

@@ -3,7 +3,7 @@ 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' });
+        let newData = Object.assign(Object.assign({}, 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;

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

@@ -60,10 +60,12 @@ const anadirDeclaracionJurada = (balanceMap, balanceArray, declaracionJurada) =>
         }
     }
     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;
+    if (balanceMap.get(keyCapital).MontoEmpresa == 0)
+        balanceMap.get(keyCapital).MontoEmpresa = declaracionMap.get('Total').TotalActivosE -
+            declaracionMap.get('Total').TotalPasivosE;
+    if (balanceMap.get(keyCapital).MontoFamiliar == 0)
+        balanceMap.get(keyCapital).MontoFamiliar = declaracionMap.get('Total').TotalActivosF -
+            declaracionMap.get('Total').TotalPasivosF;
 };
 exports.anadirDeclaracionJurada = anadirDeclaracionJurada;
 const arrayValue = (array, key) => {

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

@@ -9,7 +9,7 @@ class FlujoConstructor {
                 this.proyectarCosto();
                 this.proyectarGasto();
                 this.agregarQuitarClones();
-                this.moverDetalledesdeMensual();
+                //this.moverDetalledesdeMensual()
                 this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
                 this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900');
                 this.calcularOtrosIngresosAnuales();
@@ -98,18 +98,27 @@ class FlujoConstructor {
             const I10 = 0;
             for (let i = 1; i <= this.rango; i++) {
                 if (i == 1) {
-                    rowIngresos[`Monto${i}`] = rowTotalIngresoM[`Monto12`] * (1 + rowVariacionIngresos[`Monto${i}`] + I10);
+                    rowIngresos[`Monto${i}`] = rowTotalIngresoM[`MontoTotal`] * (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;
             }
+            if (this.data.TipoConsolidad == 'GANADERIA' &&
+                this.data.ParametrosEngorde.Conclusion == 'DESARROLLO_HATO') {
+                for (let i = 1; i <= this.rango; i++) {
+                    rowIngresos[`Monto${i}`] = this.data.ParametrosEngorde.SumaDesarrolloAnual[`C-${i}`] *
+                        (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');
+            const rowTotalIngresoM = this.data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
             for (let i = 1; i <= this.rango; i++) {
                 if (i == 1) {
                     rowCosto[`Monto1`] = (rowIngresos[`Monto1`] * rowCosto.MontoCajaPercent / 100) + (1 + rowVariacionCostos[`Monto${i}`]);
@@ -119,6 +128,18 @@ class FlujoConstructor {
                 }
                 rowCosto[`Monto${i}`] = Math.round(rowCosto[`Monto${i}`] * 100) / 100;
             }
+            if (this.data.TipoConsolidad == 'GANADERIA' &&
+                this.data.ParametrosEngorde.Conclusion != 'DESARROLLO_HATO') {
+                for (let i = 1; i <= this.rango; i++) {
+                    if (i == 1) {
+                        rowCosto[`Monto1`] = (rowTotalIngresoM[`MontoTotal`] * 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');
@@ -162,10 +183,9 @@ class FlujoConstructor {
             });
             let anuales = this.array.filter((item) => item.Clasificador == 'DETL' || item.Clasificador == 'HABM');
             for (let anualItem of anuales) {
-                let key = `${anualItem.RubroId}_${anualItem.UUID}`.replace('_CLONE_', '');
-                if (!this.data.FlujoProyectadoMensualMap.has(key)) {
-                    this.array = this.array.filter((item) => item.RubroId == anualItem.RubroId ||
-                        item.UUID == anualItem.UUID);
+                let key = `${anualItem.RubroId}_${anualItem.UUID}`.replace('_CLONE', '');
+                if (!this.data.FlujoProyectadoMensualMap.has(key) && anualItem.UUID) {
+                    this.data.FlujoProyectadoAnual = this.data.FlujoProyectadoAnual.filter((item) => item.UUID != anualItem.UUID);
                 }
             }
         };

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

@@ -11,7 +11,10 @@ const getFlujoMap = (data, rango) => {
         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}`]);
+            if (!item[`Monto${i}`])
+                item[`Monto${i}`] = 0;
+            else
+                item[`Monto${i}`] = parseFloat(item[`Monto${i}`]);
         }
         acc.set(key, item);
         return acc;

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

@@ -10,7 +10,7 @@ class BalancePecStrategy {
     }
     execute(data) {
         if (!this.actividades || this.actividades.length == 0)
-            throw new Error('Debe ingresar actividades Pecuarias');
+            return data;
         const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
         const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
         const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
@@ -148,11 +148,11 @@ const anadirOtrosIngresos = (actividad, data) => {
         copy.Clasificador = 'CT';
         if (rango == i && actividad.Ventas && actividad.Ventas.OtrosIngresos &&
             actividad.Ventas.OtrosIngresos.length > 0) {
-            copy.MontoEmpresa = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
+            copy.MontoFamiliar = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
                 acc += parseFloat(item.Monto);
                 return acc;
             }, 0);
-            copy.MontoEmpresa = Math.round(copy.MontoEmpresa * 100) / 100;
+            copy.MontoFamiliar = Math.round(copy.MontoFamiliar * 100) / 100;
         }
         data.eerr.push(copy);
     }

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

@@ -11,13 +11,15 @@ class FlujoProyectadoPecStrategy {
     }
     execute(data) {
         if (!this.actividades || this.actividades.length == 0)
-            throw new Error('Debe ingresar actividades Agrícolas');
+            return data;
         const copiaIngreso = getCuentaCopy(RUBRO_INGRESO, data);
         const copiaCostos = getCuentaCopy(RUBRO_COSTOS, data);
         const copiaGastos = getCuentaCopy(RUBRO_GASTOS, data);
         const copiaOtrosIngresos = getCuentaCopy(RUBRO_OTROS_INGRESOS, data);
         const copiaGastosFamiliares = getCuentaCopy(RUBRO_GASTOS_FAMILIARES, data);
         let sumaDesarrollo = [];
+        //@ts-ignore
+        let sumaDesarrolloAnual = null;
         for (let actividad of this.actividades) {
             addIngresosM(actividad, data);
             addCostosM(actividad, data);
@@ -25,13 +27,14 @@ class FlujoProyectadoPecStrategy {
             otrosIngresoM(actividad, data);
             gastosFamiliaresM(actividad, data);
             sumaDesarrollo.push(getDesarrolloSuma(actividad));
+            sumaDesarrolloAnual = getSumaDesarrolloAnualByAnno(actividad, data, sumaDesarrolloAnual);
         }
         sumarizarCuenta(RUBRO_INGRESO, data, copiaIngreso);
         sumarizarCuenta(RUBRO_COSTOS, data, copiaCostos);
         sumarizarCuenta(RUBRO_GASTOS, data, copiaGastos);
         sumarizarCuenta(RUBRO_OTROS_INGRESOS, data, copiaOtrosIngresos);
         sumarizarCuenta(RUBRO_GASTOS_FAMILIARES, data, copiaGastosFamiliares);
-        addCalculosBase(data, sumaDesarrollo);
+        addCalculosBase(data, sumaDesarrollo, sumaDesarrolloAnual);
         return data;
     }
 }
@@ -42,7 +45,7 @@ const getCuentaCopy = (rubroId, data) => {
 };
 const sumarizarCuenta = (rubroId, data, copia) => {
     const cuenta = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
-    const detalles = data.FlujoProyectadoMensual.filter((item) => item.RubroId == `$${rubroId}.1`);
+    const detalles = data.FlujoProyectadoMensual.filter((item) => item.RubroId == `${rubroId}.1`);
     for (let detalle of detalles) {
         for (let i = 1; i <= 12; i++) {
             if (copia[`Monto${i}`] == 0)
@@ -50,6 +53,17 @@ const sumarizarCuenta = (rubroId, data, copia) => {
         }
     }
 };
+const getSumaDesarrolloAnualByAnno = (actividad, data, suma) => {
+    const CantidadProyeccion = data.DatosEvaluacion.CantidadProyeccion;
+    const ventasCantidad = actividad.Desarrollo.VentasCantidad.find((item) => item.RubroId == 'TOT01');
+    if (!suma) {
+        suma = {};
+        for (let i = 1; i <= CantidadProyeccion; i++) {
+            suma[`C-${i}`] = ventasCantidad[`C-${i}`];
+        }
+    }
+    return suma;
+};
 const getDesarrolloSuma = (actividad) => {
     const ventasCantidad = actividad.Desarrollo.VentasCantidad.find((item) => item.RubroId == 'TOT01');
     if (!ventasCantidad)
@@ -61,7 +75,7 @@ const getDesarrolloSuma = (actividad) => {
     return result;
 };
 const addIngresosM = (actividad, data) => {
-    const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_INGRESO}_0`);
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_INGRESO}_0`);
     const ingresos = actividad.Ventas.EstacionalidadCalc.find((item) => item.RubroId == 'TOT01');
     if (!ingresos)
         throw new Error('No se encontro la estacionalidad Calc de la actividad');
@@ -77,7 +91,7 @@ const addIngresosM = (actividad, data) => {
     data.FlujoProyectadoMensual.push(row);
 };
 const addCostosM = (actividad, data) => {
-    const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_COSTOS}_0`);
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_COSTOS}_0`);
     const costos = actividad.Costos.Calculo.find((item) => item.RubroId == 'TOT01');
     if (!costos)
         throw new Error('No se encontro el costo cálculo de la actividad');
@@ -93,7 +107,7 @@ const addCostosM = (actividad, data) => {
     data.FlujoProyectadoMensual.push(row);
 };
 const addGastosM = (actividad, data) => {
-    const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_GASTOS}_0`);
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_GASTOS}_0`);
     const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
     if (!otrosGastos)
         throw new Error('No se encontro los gastos de la actividad');
@@ -109,7 +123,7 @@ const addGastosM = (actividad, data) => {
     data.FlujoProyectadoMensual.push(row);
 };
 const otrosIngresoM = (actividad, data) => {
-    const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_OTROS_INGRESOS}_0`);
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_OTROS_INGRESOS}_0`);
     const otrosIngresos = actividad.Ventas.OtrosIngresos;
     if (!otrosIngresos)
         throw new Error('No se encontro la estacionalidad Calc de la actividad');
@@ -141,7 +155,7 @@ const gastosFamiliaresM = (actividad, data) => {
     if (!otrosGastos)
         throw new Error('No se encontro los gastos de la actividad');
     let row = Object.assign({}, rubro);
-    row.Descripcion = `(-) Gastos Operativo ${actividad.Desarrollo.ActividadGanadera}`;
+    row.Descripcion = `(-) Gastos Familiares ${actividad.Desarrollo.ActividadGanadera}`;
     row.Clasificador = 'CT';
     row.Editable = false;
     row.UUID = `${RUBRO_GASTOS_FAMILIARES}_${actividad.Desarrollo.ActividadEconomicaId}`;
@@ -151,8 +165,8 @@ const gastosFamiliaresM = (actividad, data) => {
     }
     data.FlujoProyectadoMensual.push(row);
 };
-const addCalculosBase = (data, sumaDesarrollo) => {
-    const ingresos = data.FlujoProyectadoMensualMap.get(`$${RUBRO_INGRESO}_0`);
+const addCalculosBase = (data, sumaDesarrollo, sumaDesarrolloAnual) => {
+    const ingresos = data.FlujoProyectadoMensualMap.get(`${RUBRO_INGRESO}_0`);
     let sumaIngresos = 0;
     for (let i = 1; i <= 12; i++) {
         sumaIngresos += parseFloat(ingresos[`Monto${i}`]);
@@ -161,19 +175,21 @@ const addCalculosBase = (data, sumaDesarrollo) => {
         acc += item;
         return acc;
     }, 0);
-    const sumaProyectada = Math.round((sumaIngresos * data.Desarrollo.CantidadProyeccion) * 100) / 100;
+    const sumaProyectada = Math.round((sumaIngresos * data.DatosEvaluacion.CantidadProyeccion) * 100) / 100;
     let result = {
         EsEngorde: data.Parametros.EsEngorde,
         SumaAnnoBase: sumaProyectada,
         SumaHato: sumaHato,
         Conclusion: 'NA'
     };
+    result.SumaDesarrolloAnual = sumaDesarrolloAnual;
     if (result.EsEngorde == 'SI' || result.SumaAnnoBase < result.SumaHato)
         result.Conclusion = 'FLUJO_HISTORICO';
     else {
         if (result.SumaHato < result.SumaAnnoBase)
             result.Conclusion = 'DESARROLLO_HATO';
     }
+    data.ParametrosEngorde = result;
 };
 const calcularOtrosGastos = (gastos) => {
     const gastosOperativos = gastos.Operativos.reduce((acc, item) => {

package/build/strategies/production/balancePrd.strategy.d.ts

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

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

@@ -1,11 +1,192 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class BalancePrdtrategy {
+const gCuentaIngreso = 'ACT_CN_40001';
+const gCuentaCosto = 'ACT_CN_41002';
+const gCuentaGasto = 'ACT_CN_43002';
+const gCuentaGastoFamiliares = 'ACT_CN_45003';
+const gCuentaOtrosIngresosDet = 'ACT_CN_45001';
+class BalancePrdStrategy {
     constructor() {
         this.actividades = [];
     }
     execute(data) {
+        if (!this.actividades || this.actividades.length == 0)
+            return data;
+        //@ts-ignore
+        const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
+        //@ts-ignore
+        const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
+        //@ts-ignore
+        const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
+        const cuentaGastoFamiliarCopy = getCuentasCopy(data, gCuentaGastoFamiliares);
+        for (let actividad of this.actividades) {
+            anadirIngreso(actividad, data);
+            anadirCosto(actividad, data);
+            anadirGasto(actividad, data);
+            anadirOtrosIngresos(actividad, data);
+            anadirGastoFamiliares(actividad, data);
+        }
+        sumarizarCuentas(`${gCuentaIngreso}.1`, gCuentaIngreso, data, cuentasIngresosCopy);
+        sumarizarCuentas(`${gCuentaCosto}.1`, gCuentaCosto, data, cuentasCostoCopy);
+        sumarizarCuentas(`${gCuentaGasto}.1`, gCuentaGasto, data, cuentaGastoCopy);
+        sumarizarCuentas(`${gCuentaGastoFamiliares}.1`, gCuentaGastoFamiliares, data, cuentaGastoFamiliarCopy);
         return data;
     }
 }
-exports.default = BalancePrdtrategy;
+exports.default = BalancePrdStrategy;
+const getCuentasCopy = (data, rubroId) => {
+    if (!data.eerr || data.eerr.length == 0)
+        throw new Error('Debe ingresar cuentas EERR');
+    let originalData = new Map();
+    const rango = data.eerr[0].Rango;
+    for (let i = 1; i <= rango; i++) {
+        let cuentaIngreso = data.eerrMap.get(`${rubroId}_${i}`);
+        cuentaIngreso.MontoEmpresa = Math.round(parseFloat(cuentaIngreso.MontoEmpresa) * 100) / 100;
+        cuentaIngreso.MontoFamiliar = Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
+        originalData.set(`${rubroId}_${i}`, Object.assign({}, cuentaIngreso));
+    }
+    //console.log('originalData '+rubroId,Array.from(originalData.keys()) )
+    return originalData;
+};
+const anadirIngreso = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const productos = actividad.Ventas.Productos;
+    if (productos && productos.length > 0) {
+        for (const producto of productos) {
+            const subtotal = actividad.Ventas.
+                Ingresos.find((item) => item.Id == 'SUBTOTAL' && item.ProductoId == producto.ProductoId);
+            for (let i = 1; i <= rango; i++) {
+                const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}_${i}`);
+                let copy = Object.assign({}, cuentaIngreso);
+                copy.RubroId = `${gCuentaIngreso}.1`;
+                copy.Descripcion = `Ingresos por Ventas ${producto.ProductoId} ${producto.Descripcion}`;
+                copy.UUID = `${gCuentaIngreso}_${actividad.ActividadEconomicaId}_${producto.ProductoId}_${i}`;
+                copy.MontoEmpresa = 0;
+                copy.MontoFamiliar = 0;
+                copy.Correlativo = i;
+                copy.Clasificador = 'CT';
+                if (subtotal && subtotal[`C-${i}`]) {
+                    copy.MontoEmpresa = Math.round(parseFloat(subtotal[`C-${i}`]) * 100) / 100;
+                }
+                data.eerr.push(copy);
+            }
+        }
+    }
+};
+const anadirCosto = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const productos = actividad.Ventas.Productos;
+    if (productos && productos.length > 0) {
+        for (const producto of productos) {
+            const subtotal = actividad.
+                Costos.Meses.find((item) => item.ProductoId == producto.ProductoId);
+            for (let i = 1; i <= rango; i++) {
+                const cuentaIngreso = data.eerrMap.get(`${gCuentaCosto}_${i}`);
+                let copy = Object.assign({}, cuentaIngreso);
+                copy.RubroId = `${gCuentaCosto}.1`;
+                copy.Descripcion = `Ingresos por Ventas ${producto.ProductoId} ${producto.Descripcion}`;
+                copy.UUID = `${gCuentaCosto}_${actividad.ActividadEconomicaId}_${producto.ProductoId}_${i}`;
+                copy.MontoEmpresa = 0;
+                copy.MontoFamiliar = 0;
+                copy.Correlativo = i;
+                copy.Clasificador = 'CT';
+                if (i == rango && subtotal) {
+                    copy.MontoEmpresa = Math.round(parseFloat(subtotal.Total) * 100) / 100;
+                }
+                data.eerr.push(copy);
+            }
+        }
+    }
+};
+const anadirGasto = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const cuentaGasto = data.eerrMap.get(`${gCuentaGasto}_${rango}`);
+    for (let i = 1; i <= rango; i++) {
+        let copy = Object.assign({}, cuentaGasto);
+        copy.RubroId = `${gCuentaGasto}.1`;
+        copy.UUID = `${gCuentaGasto}_${actividad.ActividadEconomicaId}_${i}`;
+        copy.Descripcion = `Gastos Administrativos Operativos Actividad: ${actividad.ActividadEconomicaId}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        if (rango == i) {
+            const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
+            copy.MontoEmpresa = Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
+        }
+        data.eerr.push(copy);
+    }
+};
+const anadirGastoFamiliares = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const cuentaGasto = data.eerrMap.get(`${gCuentaGastoFamiliares}_${rango}`);
+    for (let i = 1; i <= rango; i++) {
+        let copy = Object.assign({}, cuentaGasto);
+        copy.RubroId = `${gCuentaGastoFamiliares}.1`;
+        copy.UUID = `${gCuentaGastoFamiliares}_${actividad.ActividadEconomicaId}_${i}`;
+        copy.Descripcion = `Gastos Familiares Actividad: ${actividad.ActividadEconomicaId}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        if (rango == i) {
+            const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
+            copy.MontoFamiliar = Math.round(parseFloat(otrosGastos.GastosFamiliares) * 100) / 100;
+        }
+        data.eerr.push(copy);
+    }
+};
+const calcularOtrosGastos = (gastos) => {
+    const gastosOperativos = gastos.Operativos.reduce((acc, item) => {
+        acc += parseFloat(item.ImporteAnual);
+        return acc;
+    }, 0);
+    const gastosFamiliares = gastos.Familiares.reduce((acc, item) => {
+        acc += parseFloat(item.ImporteAnual);
+        return acc;
+    }, 0);
+    return {
+        GastosOperativos: Math.round(gastosOperativos * 100) / 100,
+        GastosFamiliares: Math.round(gastosFamiliares * 100) / 100
+    };
+};
+const anadirOtrosIngresos = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const cuentaOtrosIngresos = data.eerr.find((item) => item.RubroId == gCuentaOtrosIngresosDet);
+    for (let i = 1; i <= rango; i++) {
+        let copy = Object.assign({}, cuentaOtrosIngresos);
+        copy.UUID = `${gCuentaOtrosIngresosDet}_${actividad.ActividadEconomicaId}_${rango}`;
+        copy.Descripcion = `Otros Ingresos ${actividad.ActividadEconomicaId}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        if (rango == i && actividad.Ventas && actividad.Ventas.OtrosIngresos &&
+            actividad.Ventas.OtrosIngresos.length > 0) {
+            copy.MontoFamiliar = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
+                acc += parseFloat(item.Monto);
+                return acc;
+            }, 0);
+            copy.MontoFamiliar = Math.round(copy.MontoFamiliar * 100) / 100;
+        }
+        data.eerr.push(copy);
+    }
+};
+const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal) => {
+    const rango = data.eerr[0].Rango;
+    for (let i = 1; i <= rango; i++) {
+        const cuentaOrigen = data.eerr.find((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
+        if (!cuentaOrigen)
+            throw new Error(`No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR`);
+        const original = dataOriginal.get(`${rubroDestino}_${i}`);
+        if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
+            const cuentaDestino = data.eerrMap.get(`${rubroDestino}_${i}`);
+            if (original.MontoEmpresa == 0)
+                cuentaDestino.MontoEmpresa += cuentaOrigen.MontoEmpresa;
+            if (original.MontoFamiliar == 0)
+                cuentaDestino.MontoFamiliar += cuentaOrigen.MontoFamiliar;
+            cuentaDestino.MontoEmpresa = Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
+            cuentaDestino.MontoFamiliar = Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
+        }
+    }
+};

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

@@ -1,11 +1,162 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const RUBRO_INGRESO = 'ACT_CNFL_40001';
+const RUBRO_COSTOS = 'ACT_CNFL_50001';
+const RUBRO_GASTOS = 'ACT_CNFL_60001';
+const RUBRO_OTROS_INGRESOS = 'ACT_CNFL_70001';
+const RUBRO_GASTOS_FAMILIARES = 'ACT_CNFL_70002';
 class FlujoProyectadoPrdStrategy {
     constructor() {
         this.actividades = [];
     }
     execute(data) {
+        const copiaIngreso = getCuentaCopy(RUBRO_INGRESO, data);
+        const copiaCostos = getCuentaCopy(RUBRO_COSTOS, data);
+        const copiaGastos = getCuentaCopy(RUBRO_GASTOS, data);
+        const copiaOtrosIngresos = getCuentaCopy(RUBRO_OTROS_INGRESOS, data);
+        const copiaGastosFamiliares = getCuentaCopy(RUBRO_GASTOS_FAMILIARES, data);
+        for (let actividad of this.actividades) {
+            addIngresosM(actividad, data);
+            addCostosM(actividad, data);
+            addGastosM(actividad, data);
+            otrosIngresoM(actividad, data);
+            gastosFamiliaresM(actividad, data);
+        }
+        sumarizarCuenta(RUBRO_INGRESO, data, copiaIngreso);
+        sumarizarCuenta(RUBRO_COSTOS, data, copiaCostos);
+        sumarizarCuenta(RUBRO_GASTOS, data, copiaGastos);
+        sumarizarCuenta(RUBRO_OTROS_INGRESOS, data, copiaOtrosIngresos);
+        sumarizarCuenta(RUBRO_GASTOS_FAMILIARES, data, copiaGastosFamiliares);
         return data;
     }
 }
 exports.default = FlujoProyectadoPrdStrategy;
+const getCuentaCopy = (rubroId, data) => {
+    const cuenta = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
+    return Object.assign({}, cuenta);
+};
+const sumarizarCuenta = (rubroId, data, copia) => {
+    const cuenta = data.FlujoProyectadoMensualMap.get(`${rubroId}_0`);
+    const detalles = data.FlujoProyectadoMensual.filter((item) => item.RubroId == `${rubroId}.1`);
+    for (let detalle of detalles) {
+        for (let i = 1; i <= 12; i++) {
+            if (copia[`Monto${i}`] == 0)
+                cuenta[`Monto${i}`] += parseFloat(detalle[`Monto${i}`]);
+        }
+    }
+};
+const addIngresosM = (actividad, data) => {
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_INGRESO}_0`);
+    const productos = actividad.Ventas.Productos;
+    if (productos && productos.length > 0) {
+        for (const producto of productos) {
+            const ingresos = actividad.Ventas.EstacionalidadCalc.find((item) => item.ProductoId == producto.ProductoId);
+            if (!ingresos)
+                throw new Error('No se encontro la estacionalidad Calc de la actividad');
+            let row = Object.assign({}, rubro);
+            row.Descripcion = `Ingresos Actividad ${actividad.ActividadEconomicaId} - Producto ${ingresos.Descripcion}`;
+            row.Clasificador = 'CT';
+            row.Editable = false;
+            row.UUID = `${RUBRO_INGRESO}_${actividad.ActividadEconomicaId}_${producto.ProductoId}`;
+            row.RubroId = `${RUBRO_INGRESO}.1`;
+            for (let i = 1; i <= 12; i++) {
+                row[`Monto${i}`] = Math.round(parseFloat(ingresos[`C-${i}`]) * 100) / 100;
+            }
+            data.FlujoProyectadoMensual.push(row);
+        }
+    }
+};
+const addCostosM = (actividad, data) => {
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_COSTOS}_0`);
+    const productos = actividad.Ventas.Productos;
+    if (productos && productos.length > 0) {
+        for (const producto of productos) {
+            const costos = actividad.Costos.Meses.find((item) => item.ProductoId == producto.ProductoId);
+            if (!costos)
+                throw new Error(`No se encontro el costo cálculo para el producto ${producto.ProductoId}`);
+            let row = Object.assign({}, rubro);
+            row.Descripcion = `(-) Costos de Ventas Actividad: $${actividad.ActividadEconomicaId} Producto ${producto.ProductoId}`;
+            row.Clasificador = 'CT';
+            row.Editable = false;
+            row.UUID = `${RUBRO_COSTOS}_${actividad.ActividadEconomicaId}_${producto.ProductoId}`;
+            row.RubroId = `${RUBRO_COSTOS}.1`;
+            for (let i = 1; i <= 12; i++) {
+                row[`Monto${i}`] = Math.round(parseFloat(costos[`Monto${i}`]) * 100) / 100;
+            }
+            data.FlujoProyectadoMensual.push(row);
+        }
+    }
+};
+const addGastosM = (actividad, data) => {
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_GASTOS}_0`);
+    const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
+    if (!otrosGastos)
+        throw new Error('No se encontro los gastos de la actividad');
+    let row = Object.assign({}, rubro);
+    row.Descripcion = `(-) Gastos Operativo ActividadId:${actividad.ActividadEconomicaId}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_GASTOS}_${actividad.ActividadEconomicaId}`;
+    row.RubroId = `${RUBRO_GASTOS}.1`;
+    for (let i = 1; i <= 12; i++) {
+        row[`Monto${i}`] = Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
+    }
+    data.FlujoProyectadoMensual.push(row);
+};
+const otrosIngresoM = (actividad, data) => {
+    const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_OTROS_INGRESOS}_0`);
+    const otrosIngresos = actividad.Ventas.OtrosIngresos;
+    if (!otrosIngresos)
+        throw new Error('No se encontro la estacionalidad Calc de la actividad');
+    let row = Object.assign({}, rubro);
+    row.Descripcion = `Otros Ingresos Familiares Actividad: ${actividad.ActividadEconomicaId}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_OTROS_INGRESOS}_${actividad.ActividadEconomicaId}`;
+    row.RubroId = `${RUBRO_OTROS_INGRESOS}.1`;
+    if (otrosIngresos.length == 0) {
+        const suma = otrosIngresos.reduce((acc, item) => {
+            acc += parseFloat(item.Monto);
+            return acc;
+        }, 0);
+        for (let i = 1; i <= 12; i++) {
+            row[`Monto${i}`] = suma;
+        }
+    }
+    else {
+        for (let i = 1; i <= 12; i++) {
+            row[`Monto${i}`] = Math.round(parseFloat(otrosIngresos[`C-${i}`]) * 100) / 100;
+        }
+    }
+    data.FlujoProyectadoMensual.push(row);
+};
+const gastosFamiliaresM = (actividad, data) => {
+    const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_GASTOS_FAMILIARES}_0`);
+    const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
+    if (!otrosGastos)
+        throw new Error('No se encontro los gastos de la actividad');
+    let row = Object.assign({}, rubro);
+    row.Descripcion = `(-) Gastos Familiares Actividad ${actividad.ActividadEconomicaId}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_GASTOS_FAMILIARES}_${actividad.ActividadEconomicaId}`;
+    row.RubroId = `${RUBRO_GASTOS_FAMILIARES}.1`;
+    for (let i = 1; i <= 12; i++) {
+        row[`Monto${i}`] = Math.round(parseFloat(otrosGastos.gastosFamiliares) * 100) / 100;
+    }
+    data.FlujoProyectadoMensual.push(row);
+};
+const calcularOtrosGastos = (gastos) => {
+    const gastosOperativos = gastos.Operativos.reduce((acc, item) => {
+        acc += parseFloat(item.ImporteMensual);
+        return acc;
+    }, 0);
+    const gastosFamiliares = gastos.Familiares.reduce((acc, item) => {
+        acc += parseFloat(item.ImporteMensual);
+        return acc;
+    }, 0);
+    return {
+        GastosOperativos: Math.round(gastosOperativos * 100) / 100,
+        GastosFamiliares: Math.round(gastosFamiliares * 100) / 100
+    };
+};

package/package.json

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