bdpformulas 1.0.58 → 1.0.60

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

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

package/build/strategies/pecuary/Constantes.d.ts

@@ -20,5 +20,5 @@ export declare const RUBROS: {
     ACT_PEC_NOV: string;
     ACT_PEC_SALDO: string;
 };
-export declare const getOrden: (rubro: string) => 3 | 1 | 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | undefined;
+export declare const getOrden: (rubro: string) => 3 | 1 | 2 | 4 | 6 | 5 | 7 | 8 | 9 | 10 | undefined;
 export declare const getMap: (array: any[], key: string) => any;

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

@@ -1,5 +1,5 @@
-import { Strategy } from "../../strategy.interface";
-import { AuxiliarSchemaType } from "../../models/pecuary/auxiliar.schema";
+import { Strategy } from '../../strategy.interface';
+import { AuxiliarSchemaType } from '../../models/pecuary/auxiliar.schema';
 export default class Auxiliar implements Strategy {
     execute(data: AuxiliarSchemaType): any;
 }

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../eeff/admFinanciera/utils");
 //@ts-ignore
 const calcularHato = (data) => {
     const gestiones = data.reduce((acc, item) => {
@@ -50,7 +51,7 @@ const calcularHato = (data) => {
             }
             if (!(item.RubroId in acc)) {
                 acc[item.RubroId] = item.CantidadCabezas * item.PrecioCabeza;
-                acc.Total = acc.Total + (item.CantidadCabezas * item.PrecioCabeza);
+                acc.Total = acc.Total + item.CantidadCabezas * item.PrecioCabeza;
             }
             return acc;
         }, {});
@@ -62,11 +63,15 @@ class Auxiliar {
         data.PropiedadesGanaderas.forEach((item) => {
             item.Total = 0;
             item.Rubros.forEach((rubro) => {
-                if (rubro.PrecioCabezaBalance > 0)
-                    rubro.Total = parseFloat(rubro.CantidadCabezas) * parseFloat(rubro.PrecioCabezaBalance);
+                const precioCabezaBalance = (0, utils_1.ourParseFloat)(rubro.PrecioCabezaBalance);
+                if (precioCabezaBalance)
+                    rubro.Total =
+                        parseFloat(rubro.CantidadCabezas) * precioCabezaBalance;
                 else
-                    rubro.Total = parseFloat(rubro.CantidadCabezas) * parseFloat(rubro.CantidadCabezas);
-                item.Total = item.Total + rubro.Total;
+                    rubro.Total =
+                        parseFloat(rubro.CantidadCabezas) *
+                            parseFloat(rubro.PrecioCabeza);
+                item.Total += rubro.Total;
             });
         });
         data.HistoricoHato = calcularHato(data.HistoricoHato);

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

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

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

@@ -1,13 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const utils_1 = require("../eeff/admFinanciera/utils");
 const gCuentaIngreso = 'ACT_CN_40001';
 const gCuentaCosto = 'ACT_CN_41002';
 const gCuentaGasto = 'ACT_CN_43002';
 const gCuentaOtrosIngresosDet = 'ACT_CN_45001';
 class BalancePecStrategy {
     actividades;
+    camposCalculadosDefinidos;
     constructor() {
         this.actividades = [];
+        this.camposCalculadosDefinidos = [
+            {
+                RubroId: 'ACT_CN_41002',
+                Correlativos: '*',
+                Familiar: false,
+                Empresa: true
+            }
+        ];
     }
     execute(data) {
         if (!this.actividades || this.actividades.length == 0)
@@ -15,9 +26,10 @@ class BalancePecStrategy {
         const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
         const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
         const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
-        for (let actividad of this.actividades) {
+        const cuentaOtrosIngresosCopy = getCuentasCopy(data, gCuentaOtrosIngresosDet, true);
+        for (const actividad of this.actividades) {
             anadirIngresosAuxPec(actividad, data);
-            anadirIngresoVenta(actividad, data);
+            //anadirIngresoVenta(actividad, data)
             anadirCosto(actividad, data);
             anadirGasto(actividad, data);
             anadirOtrosIngresos(actividad, data);
@@ -25,100 +37,125 @@ class BalancePecStrategy {
         sumarizarCuentas(`${gCuentaIngreso}.1`, gCuentaIngreso, data, cuentasIngresosCopy);
         sumarizarCuentas(`${gCuentaCosto}.1`, gCuentaCosto, data, cuentasCostoCopy);
         sumarizarCuentas(`${gCuentaGasto}.1`, gCuentaGasto, data, cuentaGastoCopy);
+        sumarizarCuentas(`${gCuentaOtrosIngresosDet}.1`, gCuentaOtrosIngresosDet, data, cuentaOtrosIngresosCopy, true);
+        data.camposCalculadosDefinidos = this.camposCalculadosDefinidos;
+        console.log((0, lodash_1.cloneDeep)(data));
         return data;
     }
 }
 exports.default = BalancePecStrategy;
-const getCuentasCopy = (data, rubroId) => {
+const getCuentasCopy = (data, rubroId, withZero = false) => {
     if (!data.eerr || data.eerr.length == 0)
         throw new Error('Debe ingresar cuentas EERR');
-    let originalData = new Map();
+    const 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}`, { ...cuentaIngreso });
+        const key = withZero ? `${rubroId}_0_${i}` : `${rubroId}_${i}`;
+        const cuentaIngreso = data.eerrMap.get(key);
+        cuentaIngreso.MontoEmpresa =
+            Math.round(parseFloat(cuentaIngreso.MontoEmpresa) * 100) / 100;
+        cuentaIngreso.MontoFamiliar =
+            Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
+        originalData.set(key, { ...cuentaIngreso });
     }
     return originalData;
 };
 const anadirIngresosAuxPec = (actividad, data) => {
     const rango = data.eerr[0].Rango;
-    for (let i = 1; i <= rango - 1; i++) {
+    for (let i = 1; i <= rango; i++) {
         const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}_${i}`);
-        let copy = { ...cuentaIngreso };
+        const copy = { ...cuentaIngreso };
         copy.RubroId = `${gCuentaIngreso}.1`;
         copy.Descripcion = `Ingresos por Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-        copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaIngreso}_${actividad.AuxPec.ActividadEconomicaId}`;
         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;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        const historicoHato = actividad.AuxPec?.HistoricoHato;
+        if (historicoHato) {
+            const historico = historicoHato.at(i - 1);
+            const filaTotales = historico?.find((h) => h.key === 'TOTALES');
+            if (filaTotales)
+                copy.MontoEmpresa = parseFloat(filaTotales.Total);
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
-const anadirIngresoVenta = (actividad, data) => {
-    const rango = data.eerr[0].Rango;
-    const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}${rango}`);
-    let copy = { ...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';
+/* const anadirIngresoVenta = (actividad: any, data: any) => {
+    const rango = data.eerr[0].Rango
+    const cuentaIngreso = data.eerrMap.get(`${gCuentaIngreso}${rango}`)
+    const copy = { ...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);
+        copy.MontoEmpresa = actividad.Ventas.Ventas.reduce(
+            (acc: any, item: any) => {
+                acc += parseFloat(item.IngresoTotal)
+                return acc
+            },
+            0
+        )
     }
-    data.eerr.push(copy);
-};
+
+    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 = { ...cuentaCosto };
+        const copy = { ...cuentaCosto };
         copy.RubroId = `${gCuentaCosto}.1`;
         copy.Descripcion = `Costos de Ventas ${actividad.Desarrollo.ActividadGanadera}`;
-        copy.UUID = `${gCuentaCosto}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaCosto}_${actividad.AuxPec.ActividadEconomicaId}`;
         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;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        if (i < rango) {
+            const porcentaje = data.eerrMap.get(`ACT_CN_41001_${i}`);
+            const ingreso = data.eerrMap.get(`ACT_CN_40001_${actividad.AuxPec.ActividadEconomicaId}_${i}`);
+            copy.MontoEmpresa =
+                ((0, utils_1.ourParseFloat)(ingreso?.MontoEmpresa) *
+                    (0, utils_1.ourParseFloat)(porcentaje?.MontoEmpresa)) /
+                    100;
+        }
+        if (i === rango && actividad.Costos.Calculo) {
+            const filaTotal = actividad.Costos.Calculo.find((value) => value.RubroId === 'TOT01');
+            if (filaTotal) {
+                copy.MontoEmpresa = (0, utils_1.ourParseFloat)(filaTotal.Total);
+            }
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
 const anadirGasto = (actividad, data) => {
     const rango = data.eerr[0].Rango;
     const cuentaGasto = data.eerrMap.get(`${gCuentaGasto}_${rango}`);
+    const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
     for (let i = 1; i <= rango; i++) {
-        let copy = { ...cuentaGasto };
+        const copy = { ...cuentaGasto };
         copy.RubroId = `${gCuentaGasto}.1`;
-        copy.UUID = `${gCuentaGasto}_${actividad.AuxPec.ActividadEconomicaId}_${i}`;
+        copy.UUID = `${gCuentaGasto}_${actividad.AuxPec.ActividadEconomicaId}`;
         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;
-        }
+        copy.Clasificador = 'SBCT';
+        copy.MontoEmpresa = (0, utils_1.ourParseFloat)(otrosGastos.GastosOperativos);
+        copy.Subcuenta = true;
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
 const calcularOtrosGastos = (gastos) => {
@@ -139,39 +176,54 @@ 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 = { ...cuentaOtrosIngresos };
-        copy.UUID = `${gCuentaOtrosIngresosDet}_${actividad.AuxPec.ActividadEconomicaId}_${rango}`;
+        const copy = { ...cuentaOtrosIngresos };
+        copy.RubroId = `${gCuentaOtrosIngresosDet}.1`;
+        copy.UUID = `${gCuentaOtrosIngresosDet}_${actividad.AuxPec.ActividadEconomicaId}`;
         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.MontoFamiliar = actividad.Ventas.OtrosIngresos.reduce((acc, item) => {
-                acc += parseFloat(item.Monto);
-                return acc;
-            }, 0);
-            copy.MontoFamiliar = Math.round(copy.MontoFamiliar * 100) / 100;
+        copy.Clasificador = 'SBCT';
+        copy.Subcuenta = true;
+        if (rango == i && actividad.Ventas?.OtrosIngresos) {
+            copy.MontoFamiliar = calcularOtrosIngresos(actividad.Ventas.OtrosIngresos, data.cantidadProyeccion);
         }
         data.eerr.push(copy);
+        data.eerrMap.set(`${copy.UUID}_${i}`, copy);
     }
 };
-const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal) => {
+function calcularOtrosIngresos(otrosIngresos, cantidadProyeccion) {
+    return otrosIngresos.reduce((acc, curr) => {
+        let suma = 0;
+        for (let j = 1; j <= cantidadProyeccion; j++) {
+            suma += (0, utils_1.ourParseFloat)(curr[`Gestion${j}`]);
+        }
+        return acc + suma;
+    }, 0);
+}
+const sumarizarCuentas = (rubroOrigen, rubroDestino, data, dataOriginal, withZero = false) => {
     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;
-        }
+        const cuentaOrigen = data.eerr.filter((item) => item.RubroId == rubroOrigen && item.Correlativo == i);
+        if (!cuentaOrigen || cuentaOrigen.length == 0)
+            throw new Error('No existe el rubro Calculado ${rubroOrigen}_${i} en el EERR');
+        cuentaOrigen.forEach((itemCuentaOrigen) => {
+            const key = withZero
+                ? `${rubroDestino}_0_${i}`
+                : `${rubroDestino}_${i}`;
+            const original = dataOriginal.get(key);
+            if (original.MontoEmpresa == 0 || original.MontoFamiliar == 0) {
+                const cuentaDestino = data.eerrMap.get(key);
+                if (original.MontoEmpresa == 0)
+                    cuentaDestino.MontoEmpresa += itemCuentaOrigen.MontoEmpresa;
+                if (original.MontoFamiliar == 0)
+                    cuentaDestino.MontoFamiliar +=
+                        itemCuentaOrigen.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

@@ -1,6 +1,14 @@
-import { Strategy } from "../../strategy.interface";
+import { Strategy } from '../../strategy.interface';
 export default class FlujoProyectadoPecStrategy implements Strategy {
     actividades: any[];
     constructor();
     execute(data: any): any;
+    private setParametrosEngorde;
+    private addIngresoAnual;
+    private addCostoAnual;
+    private getPorcentaje;
+    private addGastoAnual;
+    private addOtroIngresoFamiliarAnual;
+    private getGastosFamiliares;
+    private setGastosFamiliares;
 }