bdpformulas 1.0.40 → 1.0.42

package/build/index.d.ts

@@ -8,6 +8,10 @@ import CostosPrd from "./strategies/production/costos.strategy";
 import CostosAgr from "./strategies/agriculture/costos.strategy";
 import BalanceAgrStrategy from "./strategies/agriculture/balanceAgr.strategy";
 import FlujoProyectadoAgrStrategy from "./strategies/agriculture/flujoProyAgr.strategy";
+import BalancePecStrategy from "./strategies/pecuary/balancePec.strategy";
+import FlujoProyectadoPecStrategy from "./strategies/pecuary/flujoProyPec.strategy";
+import BalancePrdStrategy from "./strategies/production/balancePrd.strategy";
+import FlujoProyectadoPrdStrategy from "./strategies/production/flujoProyPrd.strategy";
 import Balance from "./strategies/balance.strategy";
 import FlujoProyectado from "./strategies/flujoProyectado.strategy";
 import AnalisisFinancieros from "./strategies/analisisFinancieros.strategy";
@@ -16,10 +20,14 @@ declare const Pecuario: {
     Desarrollo: typeof Desarrollo;
     VentasPec: typeof VentasPec;
     CostosPec: typeof CostosPec;
+    BalancePecStrategy: typeof BalancePecStrategy;
+    FlujoProyectadoPecStrategy: typeof FlujoProyectadoPecStrategy;
 };
 declare const Produccion: {
     VentasPrd: typeof VentasPrd;
     CostosPrd: typeof CostosPrd;
+    BalancePrdStrategy: typeof BalancePrdStrategy;
+    FlujoProyectadoPrdStrategy: typeof FlujoProyectadoPrdStrategy;
 };
 declare const Agricola: {
     CostosAgr: typeof CostosAgr;

package/build/index.js

@@ -15,6 +15,10 @@ const costos_strategy_2 = __importDefault(require("./strategies/production/costo
 const costos_strategy_3 = __importDefault(require("./strategies/agriculture/costos.strategy"));
 const balanceAgr_strategy_1 = __importDefault(require("./strategies/agriculture/balanceAgr.strategy"));
 const flujoProyAgr_strategy_1 = __importDefault(require("./strategies/agriculture/flujoProyAgr.strategy"));
+const balancePec_strategy_1 = __importDefault(require("./strategies/pecuary/balancePec.strategy"));
+const flujoProyPec_strategy_1 = __importDefault(require("./strategies/pecuary/flujoProyPec.strategy"));
+const balancePrd_strategy_1 = __importDefault(require("./strategies/production/balancePrd.strategy"));
+const flujoProyPrd_strategy_1 = __importDefault(require("./strategies/production/flujoProyPrd.strategy"));
 const balance_strategy_1 = __importDefault(require("./strategies/balance.strategy"));
 const flujoProyectado_strategy_1 = __importDefault(require("./strategies/flujoProyectado.strategy"));
 const analisisFinancieros_strategy_1 = __importDefault(require("./strategies/analisisFinancieros.strategy"));
@@ -22,12 +26,16 @@ const Pecuario = {
     Auxiliar: anexo_strategy_1.default,
     Desarrollo: desarrollo_strategy_1.default,
     VentasPec: ventas_strategy_1.default,
-    CostosPec: costos_strategy_1.default
+    CostosPec: costos_strategy_1.default,
+    BalancePecStrategy: balancePec_strategy_1.default,
+    FlujoProyectadoPecStrategy: flujoProyPec_strategy_1.default
 };
 exports.Pecuario = Pecuario;
 const Produccion = {
     VentasPrd: ventas_strategy_2.default,
-    CostosPrd: costos_strategy_2.default
+    CostosPrd: costos_strategy_2.default,
+    BalancePrdStrategy: balancePrd_strategy_1.default,
+    FlujoProyectadoPrdStrategy: flujoProyPrd_strategy_1.default
 };
 exports.Produccion = Produccion;
 const Agricola = {

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

@@ -13,6 +13,7 @@ export default class FlujoConstructor {
     proyectarIngreso: () => void;
     proyectarCosto: () => void;
     proyectarGasto: () => void;
+    agregarQuitarClones: () => void;
     moverDetalledesdeMensual: () => void;
     calcularTotalDetalle: (sumandosArray: string[], total: string) => void;
     calcularPorcentajeIngresCostos: () => void;

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

@@ -8,6 +8,7 @@ class FlujoConstructor {
                 this.proyectarIngreso();
                 this.proyectarCosto();
                 this.proyectarGasto();
+                this.agregarQuitarClones();
                 this.moverDetalledesdeMensual();
                 this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900');
                 this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900');
@@ -134,6 +135,40 @@ class FlujoConstructor {
                 rowGasto[`Monto${i}`] = Math.round(rowGasto[`Monto${i}`] * 100) / 100;
             }
         };
+        this.agregarQuitarClones = () => {
+            let filter = this.data.FlujoProyectadoMensual.filter((item) => item.Clasificador == 'DETL' || item.Clasificador == 'HABM');
+            filter.map((item) => {
+                if (!this.mapObject.has(`${item.RubroId}_CLONE_${item.UUID}`)) {
+                    let newItem = {
+                        ActividadId: item.ActividadId,
+                        RubroId: item.RubroId,
+                        RubroPadreId: item.RubroPadreId,
+                        Descripcion: item.Descripcion,
+                        UUID: item.UUID,
+                        Clasificador: item.Clasificador,
+                        Entidad: item.Entidad,
+                        Operacion: item.Operacion,
+                        Comprar: item.Comprar,
+                        Variable: item.Variable,
+                        IndicadorABM: item.IndicadorABM,
+                        MontoCajaPercent: item.MontoCajaPercent,
+                    };
+                    for (let i = 1; i <= this.rango; i++) {
+                        newItem[`Monto${i}`] = 0;
+                    }
+                    this.array.push(newItem);
+                    this.mapObject.set(`${item.RubroId}_CLONE_${item.UUID}`, newItem);
+                }
+            });
+            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);
+                }
+            }
+        };
         this.moverDetalledesdeMensual = () => {
             let filter = this.data.FlujoProyectadoMensual.filter((item) => item.RubroId == 'ACT_CNFL_61001' || item.RubroId == 'ACT_CNFL_73000');
             filter.map((item) => {

package/build/strategies/pecuary/balancePec.strategy.d.ts

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

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gCuentaIngreso = 'ACT_CN_40001';
+const gCuentaCosto = 'ACT_CN_41002';
+const gCuentaGasto = 'ACT_CN_43002';
+const gCuentaOtrosIngresosDet = 'ACT_CN_45001';
+class BalancePecStrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        if (!this.actividades || this.actividades.length == 0)
+            throw new Error('Debe ingresar actividades Pecuarias');
+        const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
+        const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
+        const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
+        for (let actividad of this.actividades) {
+            anadirIngresosAuxPec(actividad, data);
+            anadirIngresoVenta(actividad, data);
+            anadirCosto(actividad, data);
+            anadirGasto(actividad, data);
+            anadirOtrosIngresos(actividad, data);
+        }
+        sumarizarCuentas(`${gCuentaIngreso}.1`, gCuentaIngreso, data, cuentasIngresosCopy);
+        sumarizarCuentas(`${gCuentaCosto}.1`, gCuentaCosto, data, cuentasCostoCopy);
+        sumarizarCuentas(`${gCuentaGasto}.1`, gCuentaGasto, data, cuentaGastoCopy);
+        return data;
+    }
+}
+exports.default = BalancePecStrategy;
+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 anadirIngresosAuxPec = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    for (let i = 1; i <= rango - 1; i++) {
+        const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}_${i}`);
+        let copy = Object.assign({}, cuentaIngreso);
+        copy.RubroId = `${gCuentaIngreso}.1`;
+        copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+        copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        if (actividad.AuxPec && actividad.AuxPec.HistoricoHato && actividad.AuxPec.HistoricoHato.length > 0) {
+            const historico = actividad.AuxPec.HistoricoHato.find((value) => value.Gestion === i && value.key == 'TOTALES');
+            if (historico)
+                copy.MontoEmpresa = Math.round(parseFloat(historico.Total) * 100) / 100;
+        }
+        data.eerr.push(copy);
+    }
+};
+const anadirIngresoVenta = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}${rango}`);
+    let copy = Object.assign({}, cuentaIngreso);
+    copy.RubroId = `${gCuentaIngreso}.1`;
+    copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+    copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${rango}`;
+    copy.MontoEmpresa = 0;
+    copy.MontoFamiliar = 0;
+    copy.Correlativo = rango;
+    copy.Clasificador = 'CT';
+    if (actividad.Ventas.Ventas && actividad.Ventas.Ventas.length > 0) {
+        copy.MontoEmpresa = actividad.Ventas.Ventas.reduce((acc, item) => {
+            acc += parseFloat(item.IngresoTotal);
+            return acc;
+        }, 0);
+    }
+    data.eerr.push(copy);
+};
+const anadirCosto = (actividad, data) => {
+    const rango = data.eerr[0].Rango;
+    const cuentaCosto = data.eerrMap.get(`${gCuentaCosto}_${rango}`);
+    for (let i = 1; i <= rango; i++) {
+        let copy = Object.assign({}, cuentaCosto);
+        copy.RubroId = `${gCuentaCosto}.1`;
+        copy.Descripcion = `Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+        copy.UUID = `${gCuentaCosto}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.MontoEmpresa = 0;
+        copy.MontoFamiliar = 0;
+        copy.Correlativo = i;
+        copy.Clasificador = 'CT';
+        if (rango == i && actividad.Costos.Calculo && actividad.Costos.Calculo.length > 0) {
+            const monto = actividad.Costos.Calculo.find((value) => value.RubroId === 'TOT01');
+            if (!monto)
+                throw new Error('No existe el rubro TOT01 en los costos');
+            copy.MontoEmpresa = Math.round(parseFloat(monto.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.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.Descripcion = `Gastos Administrativos Operativos ${actividad.Desarrollo.ActividadGanadera}`;
+        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 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.AuxPec.ActividadEconomicaId}_${rango}`;
+        copy.Descripcion = `Otros Ingresos ${actividad.Desarrollo.ActividadGanadera}`;
+        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.MontoEmpresa = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
+                acc += parseFloat(item.Monto);
+                return acc;
+            }, 0);
+            copy.MontoEmpresa = Math.round(copy.MontoEmpresa * 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/pecuary/flujoProyPec.strategy.d.ts

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

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

@@ -0,0 +1,191 @@
+"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 FlujoProyectadoPecStrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        if (!this.actividades || this.actividades.length == 0)
+            throw new Error('Debe ingresar actividades Agrícolas');
+        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 = [];
+        for (let actividad of this.actividades) {
+            addIngresosM(actividad, data);
+            addCostosM(actividad, data);
+            addGastosM(actividad, data);
+            otrosIngresoM(actividad, data);
+            gastosFamiliaresM(actividad, data);
+            sumaDesarrollo.push(getDesarrolloSuma(actividad));
+        }
+        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);
+        return data;
+    }
+}
+exports.default = FlujoProyectadoPecStrategy;
+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 getDesarrolloSuma = (actividad) => {
+    const ventasCantidad = actividad.Desarrollo.VentasCantidad.find((item) => item.RubroId == 'TOT01');
+    if (!ventasCantidad)
+        throw new Error('No se econtró el Monto de desarrollo');
+    let result = 0;
+    for (let i = 1; i <= actividad.Desarrollo.CantidadProyeccion; i++) {
+        result += parseFloat(ventasCantidad[`C-${i}`]);
+    }
+    return result;
+};
+const addIngresosM = (actividad, data) => {
+    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');
+    let row = Object.assign({}, rubro);
+    row.Descripcion = `Ingresos ${actividad.Desarrollo.ActividadGanadera}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_INGRESO}_${actividad.Desarrollo.ActividadEconomicaId}`;
+    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 costos = actividad.Costos.Calculo.find((item) => item.RubroId == 'TOT01');
+    if (!costos)
+        throw new Error('No se encontro el costo cálculo de la actividad');
+    let row = Object.assign({}, rubro);
+    row.Descripcion = `(-) Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_COSTOS}_${actividad.Desarrollo.ActividadEconomicaId}`;
+    row.RubroId = `${RUBRO_COSTOS}.1`;
+    for (let i = 1; i <= 12; i++) {
+        row[`Monto${i}`] = Math.round(parseFloat(costos[`C-${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 ${actividad.Desarrollo.ActividadGanadera}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_GASTOS}_${actividad.Desarrollo.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.Desarrollo.ActividadGanadera}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_OTROS_INGRESOS}_${actividad.Desarrollo.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 Operativo ${actividad.Desarrollo.ActividadGanadera}`;
+    row.Clasificador = 'CT';
+    row.Editable = false;
+    row.UUID = `${RUBRO_GASTOS_FAMILIARES}_${actividad.Desarrollo.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 addCalculosBase = (data, sumaDesarrollo) => {
+    const ingresos = data.FlujoProyectadoMensualMap.get(`$${RUBRO_INGRESO}_0`);
+    let sumaIngresos = 0;
+    for (let i = 1; i <= 12; i++) {
+        sumaIngresos += parseFloat(ingresos[`Monto${i}`]);
+    }
+    let sumaHato = sumaDesarrollo.reduce((acc, item) => {
+        acc += item;
+        return acc;
+    }, 0);
+    const sumaProyectada = Math.round((sumaIngresos * data.Desarrollo.CantidadProyeccion) * 100) / 100;
+    let result = {
+        EsEngorde: data.Parametros.EsEngorde,
+        SumaAnnoBase: sumaProyectada,
+        SumaHato: sumaHato,
+        Conclusion: 'NA'
+    };
+    if (result.EsEngorde == 'SI' || result.SumaAnnoBase < result.SumaHato)
+        result.Conclusion = 'FLUJO_HISTORICO';
+    else {
+        if (result.SumaHato < result.SumaAnnoBase)
+            result.Conclusion = 'DESARROLLO_HATO';
+    }
+};
+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/build/strategies/production/balancePrd.strategy.d.ts

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BalancePrdtrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        return data;
+    }
+}
+exports.default = BalancePrdtrategy;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FlujoProyectadoPrdStrategy {
+    constructor() {
+        this.actividades = [];
+    }
+    execute(data) {
+        return data;
+    }
+}
+exports.default = FlujoProyectadoPrdStrategy;

package/build/strategies/production/ventas.detail/ingresosCalc.js

@@ -14,8 +14,6 @@ const calcularProductos = (data) => {
         subtotal[`CDesc-${item.Correlativo}`] = item.CorrelativoDesc;
     });
     for (let i = 1; i < data.Rango; i++) {
-        // console.log('cantidad',i,cantidad[`CDesc-${i+1}`])
-        // console.log('cantidad',i,cantidad[`CDesc-${i}`])
         cantidad[`V-${i}`] = cantidad[`C-${i + 1}`] - cantidad[`C-${i}`];
         cantidad[`VDesc-${i}`] = cantidad[`CDesc-${i + 1}`].slice(-4) + ' - ' + cantidad[`CDesc-${i}`].slice(-4);
         precio[`V-${i}`] = precio[`C-${i + 1}`] - precio[`C-${i}`];

package/package.json

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