bdpformulas 1.0.63 → 1.0.64
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build/strategies/balance.strategy.js +57 -26
- package/build/strategies/common/balance.calc.js +1 -1
- package/build/strategies/common/flujoCalculos/flujoConstructor.js +5 -3
- package/build/strategies/common/flujoCalculos/supuestos.calc.js +4 -2
- package/build/strategies/common/flujoProyectado.calc.js +6 -4
- package/build/strategies/eeff/balanceEEFF.strategy.d.ts +1 -0
- package/build/strategies/eeff/balanceEEFF.strategy.js +89 -61
- package/build/strategies/eeff/flujoProyEEFF.strategy.js +41 -22
- package/build/strategies/flujoProyectado.strategy.js +5 -0
- package/build/strategies/general/balanceGeneral.strategy.js +40 -23
- package/build/strategies/general/flujoProyGeneral.strategy.d.ts +1 -1
- package/build/strategies/general/flujoProyGeneral.strategy.js +71 -27
- package/build/strategies/pecuary/balancePec.strategy.js +2 -4
- package/build/strategies/production/flujoProyPrd.strategy.js +62 -25
- package/package.json +1 -1
|
@@ -148,7 +148,7 @@ class Balance {
|
|
|
148
148
|
cantidadGestiones: data.cantidadGestiones,
|
|
149
149
|
definidos: [
|
|
150
150
|
...this.camposCalculadosDefinidos,
|
|
151
|
-
...data.camposCalculadosDefinidos
|
|
151
|
+
...(data.camposCalculadosDefinidos ?? [])
|
|
152
152
|
]
|
|
153
153
|
});
|
|
154
154
|
delete data.eerrMap;
|
|
@@ -179,6 +179,7 @@ const calcularBalance = (balance, cantidadGestiones) => {
|
|
|
179
179
|
IdVirtual: i
|
|
180
180
|
};
|
|
181
181
|
});
|
|
182
|
+
calcularCapital(result, cantidadGestiones);
|
|
182
183
|
result = sumarizarCuenta([
|
|
183
184
|
'ACT_CN_11000',
|
|
184
185
|
'ACT_CN_12000',
|
|
@@ -196,18 +197,23 @@ const calcularBalance = (balance, cantidadGestiones) => {
|
|
|
196
197
|
result = adicionarCuenta('ACT_CN_30000', 'ACT_CN_39000', result);
|
|
197
198
|
result = adicionarCuenta('ACT_CN_20000', 'ACT_CN_39900', result);
|
|
198
199
|
result = adicionarCuenta('ACT_CN_30000', 'ACT_CN_39900', result);
|
|
199
|
-
calcularCapital(result, cantidadGestiones);
|
|
200
200
|
result = balanceCalc.trasponer(result);
|
|
201
201
|
return result;
|
|
202
202
|
};
|
|
203
203
|
function calcularCapital(datos, cantidadGestiones) {
|
|
204
|
-
const totalActivos =
|
|
205
|
-
|
|
204
|
+
const totalActivos = getTotalByRubrosPadre({
|
|
205
|
+
data: datos,
|
|
206
|
+
rubrosPadre: ['ACT_CN_11000', 'ACT_CN_12000']
|
|
207
|
+
});
|
|
208
|
+
const totalPasivos = getTotalByRubrosPadre({
|
|
209
|
+
data: datos,
|
|
210
|
+
rubrosPadre: ['ACT_CN_21000', 'ACT_CN_22000']
|
|
211
|
+
});
|
|
206
212
|
const capitales = datos.filter((el) => el.RubroId === 'ACT_CN_30001' &&
|
|
207
213
|
el.Correlativo <= cantidadGestiones - 1);
|
|
208
214
|
capitales.forEach((cap) => {
|
|
209
|
-
const activo = totalActivos.
|
|
210
|
-
const pasivo = totalPasivos.
|
|
215
|
+
const activo = totalActivos.get(cap.Correlativo);
|
|
216
|
+
const pasivo = totalPasivos.get(cap.Correlativo);
|
|
211
217
|
cap.MontoEmpresa =
|
|
212
218
|
(0, utils_1.ourParseFloat)(activo?.MontoEmpresa) -
|
|
213
219
|
(0, utils_1.ourParseFloat)(pasivo?.MontoEmpresa);
|
|
@@ -216,22 +222,24 @@ function calcularCapital(datos, cantidadGestiones) {
|
|
|
216
222
|
(0, utils_1.ourParseFloat)(pasivo?.MontoFamiliar);
|
|
217
223
|
cap.MontoTotal = cap.MontoEmpresa + cap.MontoFamiliar;
|
|
218
224
|
});
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
el
|
|
224
|
-
el.
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
225
|
+
}
|
|
226
|
+
function getTotalByRubrosPadre({ data, rubrosPadre }) {
|
|
227
|
+
const clasificadoresExcluidos = ['C', 'CT', 'SBCT'];
|
|
228
|
+
return data
|
|
229
|
+
.filter((el) => rubrosPadre.includes(el.RubroPadreId) &&
|
|
230
|
+
el.IndicadorABM !== 'B' &&
|
|
231
|
+
!clasificadoresExcluidos.includes(el.Clasificador))
|
|
232
|
+
.reduce((acc, el) => {
|
|
233
|
+
if (!acc.has(el.Correlativo)) {
|
|
234
|
+
acc.set(el.Correlativo, {
|
|
235
|
+
MontoEmpresa: 0,
|
|
236
|
+
MontoFamiliar: 0
|
|
237
|
+
});
|
|
238
|
+
}
|
|
239
|
+
acc.get(el.Correlativo).MontoEmpresa += (0, utils_1.ourParseFloat)(el.MontoEmpresa);
|
|
240
|
+
acc.get(el.Correlativo).MontoFamiliar += (0, utils_1.ourParseFloat)(el.MontoFamiliar);
|
|
241
|
+
return acc;
|
|
242
|
+
}, new Map());
|
|
235
243
|
}
|
|
236
244
|
const calcularEERR = (eerr, cantidadGestiones, tipoConsolidado) => {
|
|
237
245
|
let i = 0;
|
|
@@ -289,6 +297,7 @@ const calcularEERR = (eerr, cantidadGestiones, tipoConsolidado) => {
|
|
|
289
297
|
result = adicionarCuenta('ACT_CN_45001', 'ACT_CN_45000', result);
|
|
290
298
|
result = adicionarCuenta('ACT_CN_45002', 'ACT_CN_45000', result, true);
|
|
291
299
|
result = adicionarCuenta('ACT_CN_45003', 'ACT_CN_45000', result, true);
|
|
300
|
+
result = adicionarCuenta('ACT_CN_45001D', 'ACT_CN_45000', result, true);
|
|
292
301
|
result = adicionarCuenta('ACT_CN_45000', 'ACT_CN_45900', result);
|
|
293
302
|
//Utilidad antes de impuestos
|
|
294
303
|
result = adicionarCuenta('ACT_CN_44000', 'ACT_CN_46000', result);
|
|
@@ -353,10 +362,25 @@ function calcularPorcentajes({ rubroDatos, rubroPorcentajes, datos, cantidadGest
|
|
|
353
362
|
}
|
|
354
363
|
const adicionarCuenta = (origen, destino, datos, isNegative = false) => {
|
|
355
364
|
const origenVector = datos
|
|
356
|
-
.filter((item) =>
|
|
365
|
+
.filter((item) => {
|
|
366
|
+
const activo = item.IndicadorABM !== 'B';
|
|
367
|
+
const incluyeRubro = item.RubroId == origen;
|
|
368
|
+
if (item.Subcuenta && item.SumableATotal) {
|
|
369
|
+
return activo && incluyeRubro;
|
|
370
|
+
}
|
|
371
|
+
return activo && incluyeRubro && !item.Subcuenta;
|
|
372
|
+
})
|
|
357
373
|
.reduce((acc, valor) => {
|
|
358
|
-
if (!acc.has(valor.Correlativo))
|
|
359
|
-
acc.set(valor.Correlativo,
|
|
374
|
+
if (!acc.has(valor.Correlativo)) {
|
|
375
|
+
acc.set(valor.Correlativo, {
|
|
376
|
+
MontoFamiliar: valor.MontoFamiliar,
|
|
377
|
+
MontoEmpresa: valor.MontoEmpresa
|
|
378
|
+
});
|
|
379
|
+
}
|
|
380
|
+
else {
|
|
381
|
+
acc.get(valor.Correlativo).MontoEmpresa += valor.MontoEmpresa;
|
|
382
|
+
acc.get(valor.Correlativo).MontoFamiliar += valor.MontoFamiliar;
|
|
383
|
+
}
|
|
360
384
|
return acc;
|
|
361
385
|
}, new Map());
|
|
362
386
|
const destinoVector = datos.filter((item) => item.RubroId == destino);
|
|
@@ -379,7 +403,14 @@ const adicionarCuenta = (origen, destino, datos, isNegative = false) => {
|
|
|
379
403
|
return datos;
|
|
380
404
|
};
|
|
381
405
|
const sumarizarCuenta = (rubros, datos) => {
|
|
382
|
-
const filtrados = datos.filter((item) =>
|
|
406
|
+
const filtrados = datos.filter((item) => {
|
|
407
|
+
const activo = item.IndicadorABM !== 'B';
|
|
408
|
+
const incluyeRubro = rubros.includes(item.RubroPadreId);
|
|
409
|
+
if (item.Subcuenta && item.SumableATotal) {
|
|
410
|
+
return activo && incluyeRubro;
|
|
411
|
+
}
|
|
412
|
+
return activo && incluyeRubro && !item.Subcuenta;
|
|
413
|
+
});
|
|
383
414
|
const grupos = datos.filter((item) => rubros.includes(item.RubroId));
|
|
384
415
|
const suma = filtrados.reduce((acc, item) => {
|
|
385
416
|
const key = `${item.RubroPadreId}_${item.Correlativo}`;
|
|
@@ -9,7 +9,7 @@ const getBalanceHashMap = (balance) => {
|
|
|
9
9
|
if (!balance || balance.length == 0)
|
|
10
10
|
throw new Error('Debe ingresar un balance válido');
|
|
11
11
|
const result = balance.reduce((acc, item) => {
|
|
12
|
-
if (item.Clasificador
|
|
12
|
+
if (!['CT', 'SBCT'].includes(item.Clasificador)) {
|
|
13
13
|
let key = `${item.RubroId}_${item.Correlativo}`;
|
|
14
14
|
if (item.Clasificador !== 'H') {
|
|
15
15
|
key = `${item.RubroId}_${!item.UUID ? '0' : item.UUID}_${item.Correlativo}`;
|
|
@@ -24,9 +24,11 @@ class FlujoConstructor {
|
|
|
24
24
|
}
|
|
25
25
|
}
|
|
26
26
|
calcularFlujo = () => {
|
|
27
|
+
// console.log('DATA CALCULADA', this.data)
|
|
27
28
|
this.limpiarCamposCalculados();
|
|
28
|
-
if (this.tipo == 'ANUAL'
|
|
29
|
-
|
|
29
|
+
if (this.tipo == 'ANUAL' &&
|
|
30
|
+
this.data.FlujoProyectadoMensualMap.size > 0) {
|
|
31
|
+
if (!['GENERAL', 'GANADERIA'].includes(this.data.TipoConsolidado)) {
|
|
30
32
|
this.proyectarIngreso();
|
|
31
33
|
this.proyectarCosto();
|
|
32
34
|
this.proyectarGasto();
|
|
@@ -36,7 +38,7 @@ class FlujoConstructor {
|
|
|
36
38
|
// this.moverDetalledesdeMensual()
|
|
37
39
|
/* this.calcularTotalDetalle(['ACT_CNFL_73000'], 'ACT_CNFL_73900')
|
|
38
40
|
this.calcularTotalDetalle(['ACT_CNFL_61001'], 'ACT_CNFL_61900') */
|
|
39
|
-
if (this.data.TipoConsolidado
|
|
41
|
+
if (!['GENERAL', 'GANADERIA'].includes(this.data.TipoConsolidado)) {
|
|
40
42
|
this.calcularOtrosIngresosAnuales();
|
|
41
43
|
this.calcularGastosFamiliares();
|
|
42
44
|
}
|
|
@@ -48,8 +48,10 @@ const getSupuestos = (data) => {
|
|
|
48
48
|
let GastosAdmValuePercent = data.balance.eerr.find((item) => item.RubroId === 'ACT_CN_43001');
|
|
49
49
|
CostoVentasValuePercent = getSupuesto('% DE COSTOS', '% Costo', getValores(CostoVentasValuePercent, rango));
|
|
50
50
|
GastosAdmValuePercent = getSupuesto('% GASTOS OPERATIVOS', '% G.O.', getValores(GastosAdmValuePercent, rango));
|
|
51
|
-
|
|
52
|
-
|
|
51
|
+
if (data.FlujoProyectadoMensualMap.size > 0)
|
|
52
|
+
CostoVentasValuePercent = calcularValorOtros(CostoVentasValuePercent, data.FlujoProyectadoMensualMap, 'COSTOS');
|
|
53
|
+
if (data.FlujoProyectadoMensualMap.size > 0)
|
|
54
|
+
GastosAdmValuePercent = calcularValorOtros(GastosAdmValuePercent, data.FlujoProyectadoMensualMap, 'GASTOS');
|
|
53
55
|
CostoVentasValuePercent = calcularValores(CostoVentasValuePercent, data.Parametros.PorcentajeCostos, rango);
|
|
54
56
|
GastosAdmValuePercent = calcularValores(GastosAdmValuePercent, data.Parametros.PorcentajeGastos, rango);
|
|
55
57
|
return [CostoVentasValuePercent, GastosAdmValuePercent];
|
|
@@ -22,8 +22,10 @@ const getFlujoMap = (data, rango) => {
|
|
|
22
22
|
};
|
|
23
23
|
exports.getFlujoMap = getFlujoMap;
|
|
24
24
|
const calcularFlujoMensual = (data) => {
|
|
25
|
-
|
|
26
|
-
|
|
25
|
+
if (data.FlujoProyectadoMensual && data.FlujoProyectadoMensual.length > 0) {
|
|
26
|
+
const flujoConstructor = new flujoConstructor_1.default('MENSUAL', data);
|
|
27
|
+
flujoConstructor.calcularFlujo();
|
|
28
|
+
}
|
|
27
29
|
};
|
|
28
30
|
exports.calcularFlujoMensual = calcularFlujoMensual;
|
|
29
31
|
const calcularFlujoAnual = (data) => {
|
|
@@ -36,8 +38,8 @@ const getHistoricoFlujoCaja = (data) => {
|
|
|
36
38
|
const totalIngresos = data.FlujoProyectadoMensualMap.get('ACT_CNFL_49000_0');
|
|
37
39
|
for (let i = 1; i <= 12; i++) {
|
|
38
40
|
datos.push({
|
|
39
|
-
Fecha: totalIngresos[`Fecha${i}`],
|
|
40
|
-
Monto: totalIngresos[`Monto${i}`]
|
|
41
|
+
Fecha: totalIngresos?.[`Fecha${i}`],
|
|
42
|
+
Monto: totalIngresos?.[`Monto${i}`]
|
|
41
43
|
});
|
|
42
44
|
}
|
|
43
45
|
return datos;
|
|
@@ -2,64 +2,84 @@
|
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
3
|
class BalanceEEFFStrategy {
|
|
4
4
|
actividades;
|
|
5
|
+
camposCalculadosDefinidos;
|
|
5
6
|
constructor() {
|
|
6
7
|
this.actividades = [];
|
|
8
|
+
this.camposCalculadosDefinidos = [];
|
|
7
9
|
}
|
|
8
10
|
execute(data) {
|
|
9
11
|
if (!this.actividades || this.actividades.length == 0)
|
|
10
12
|
return data;
|
|
11
|
-
//Quitamos estos rubros
|
|
12
|
-
data.errr = data.eerr.filter((item) => item.RubroId !=
|
|
13
|
-
data.errr = data.eerr.filter((item) => item.RubroId !=
|
|
13
|
+
//Quitamos estos rubros
|
|
14
|
+
data.errr = data.eerr.filter((item) => item.RubroId != "ACT_CN_41001");
|
|
15
|
+
data.errr = data.eerr.filter((item) => item.RubroId != "ACT_CN_43001");
|
|
14
16
|
for (let actividad of this.actividades) {
|
|
15
|
-
anadirGrupoBalance(actividad, [
|
|
16
|
-
anadirGrupoBalance(actividad, [
|
|
17
|
-
anadirGrupoBalance(actividad, [
|
|
18
|
-
anadirGrupoBalance(actividad, [
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
anadirGrupoBalance(actividad, [
|
|
27
|
-
|
|
28
|
-
anadirGrupoBalance(actividad, [
|
|
29
|
-
anadirGrupoBalance(actividad, [
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
anadirGrupoBalance(actividad, [
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
anadirGrupoBalance(actividad, [
|
|
44
|
-
anadirGrupoBalance(actividad, [
|
|
45
|
-
anadirGrupoBalance(actividad, [
|
|
17
|
+
anadirGrupoBalance(actividad, ["ACT_EF_11001"], actividad.Balance, "ACT_CN_11001", data.balance, data.balanceMap);
|
|
18
|
+
anadirGrupoBalance(actividad, ["ACT_EF_11002", "ACT_EF_11003"], actividad.Balance, "ACT_CN_11002", data.balance, data.balanceMap);
|
|
19
|
+
anadirGrupoBalance(actividad, ["ACT_EF_11004"], actividad.Balance, "ACT_CN_11003", data.balance, data.balanceMap);
|
|
20
|
+
anadirGrupoBalance(actividad, [
|
|
21
|
+
"ACT_EF_11005",
|
|
22
|
+
"ACT_EF_11006",
|
|
23
|
+
"ACT_EF_11008",
|
|
24
|
+
"ACT_EF_11009",
|
|
25
|
+
"ACT_EF_11010",
|
|
26
|
+
"ACT_EF_11011",
|
|
27
|
+
], actividad.Balance, "ACT_CN_11004", data.balance, data.balanceMap, true);
|
|
28
|
+
anadirGrupoBalance(actividad, ["ACT_EF_12005", "ACT_EF_12006"], actividad.Balance, "ACT_CN_12001", data.balance, data.balanceMap);
|
|
29
|
+
anadirGrupoBalance(actividad, ["ACT_EF_12001", "ACT_EF_12002", "ACT_EF_12007"], actividad.Balance, "ACT_CN_12002", data.balance, data.balanceMap);
|
|
30
|
+
anadirGrupoBalance(actividad, ["ACT_EF_12003", "ACT_EF_12009"], actividad.Balance, "ACT_CN_12004", data.balance, data.balanceMap);
|
|
31
|
+
anadirGrupoBalance(actividad, [
|
|
32
|
+
"ACT_EF_12004",
|
|
33
|
+
"ACT_EF_12008",
|
|
34
|
+
"ACT_EF_12010",
|
|
35
|
+
"ACT_EF_12011",
|
|
36
|
+
"ACT_EF_12012",
|
|
37
|
+
], actividad.Balance, "ACT_CN_12005", data.balance, data.balanceMap, true);
|
|
38
|
+
anadirGrupoBalance(actividad, [
|
|
39
|
+
"ACT_EF_21001",
|
|
40
|
+
"ACT_EF_21002",
|
|
41
|
+
"ACT_EF_21003",
|
|
42
|
+
"ACT_EF_21004",
|
|
43
|
+
"ACT_EF_21008",
|
|
44
|
+
], actividad.Balance, "ACT_CN_21001", data.balance, data.balanceMap);
|
|
45
|
+
anadirGrupoBalance(actividad, ["ACT_EF_21005", "ACT_EF_21006", "ACT_EF_21007", "ACT_EF_21009"], actividad.Balance, "ACT_CN_21002", data.balance, data.balanceMap);
|
|
46
|
+
anadirGrupoBalance(actividad, ["ACT_EF_21010", "ACT_EF_21011", "ACT_EF_21012"], actividad.Balance, "ACT_CN_21003", data.balance, data.balanceMap, true);
|
|
47
|
+
anadirGrupoBalance(actividad, ["ACT_EF_22001", "ACT_EF_22002", "ACT_EF_22003"], actividad.Balance, "ACT_CN_22001", data.balance, data.balanceMap);
|
|
48
|
+
anadirGrupoBalance(actividad, ["ACT_EF_22004", "ACT_EF_22005", "ACT_EF_22006", "ACT_EF_22007"], actividad.Balance, "ACT_CN_22002", data.balance, data.balanceMap);
|
|
49
|
+
anadirGrupoBalance(actividad, ["ACT_EF_22008", "ACT_EF_22009", "ACT_EF_22010"], actividad.Balance, "ACT_CN_22003", data.balance, data.balanceMap, true);
|
|
50
|
+
anadirGrupoBalance(actividad, ["ACT_EF_31001", "ACT_EF_31002"], actividad.Balance, "ACT_CN_30001", data.balance, data.balanceMap);
|
|
51
|
+
anadirGrupoBalance(actividad, [
|
|
52
|
+
"ACT_EF_31003",
|
|
53
|
+
"ACT_EF_31004",
|
|
54
|
+
"ACT_EF_31005",
|
|
55
|
+
"ACT_EF_31006",
|
|
56
|
+
"ACT_EF_31007",
|
|
57
|
+
], actividad.Balance, "ACT_CN_30002", data.balance, data.balanceMap, true);
|
|
58
|
+
anadirGrupoBalance(actividad, ["ACT_EF_41000"], actividad.EERR, "ACT_CN_40001", data.eerr, data.eerrMap);
|
|
59
|
+
anadirGrupoBalance(actividad, ["ACT_EF_42001"], actividad.EERR, "ACT_CN_41002", data.eerr, data.eerrMap);
|
|
60
|
+
anadirGrupoBalance(actividad, ["ACT_EF_43001", "ACT_EF_43002"], actividad.EERR, "ACT_CN_43002", data.eerr, data.eerrMap);
|
|
61
|
+
anadirGrupoBalance(actividad, ["ACT_EF_44001", "ACT_EF_44002"], actividad.EERR, "ACT_CN_43003", data.eerr, data.eerrMap);
|
|
62
|
+
anadirGrupoBalance(actividad, ["ACT_EF_44004", "ACT_EF_44007"], actividad.EERR, "ACT_CN_43004", data.eerr, data.eerrMap, true);
|
|
63
|
+
anadirGrupoBalance(actividad, ["ACT_EF_44003", "ACT_EF_44005", "ACT_EF_44006"], actividad.EERR, "ACT_CN_45001", data.eerr, data.eerrMap, true);
|
|
64
|
+
anadirGrupoBalance(actividad, ["ACT_EF_45001"], actividad.EERR, "ACT_CN_46001", data.eerr, data.eerrMap);
|
|
46
65
|
}
|
|
47
|
-
sumarizarCuentas(
|
|
48
|
-
sumarizarCuentas(
|
|
49
|
-
sumarizarCuentas(
|
|
50
|
-
sumarizarCuentas(
|
|
51
|
-
sumarizarCuentas(
|
|
52
|
-
sumarizarCuentas(
|
|
53
|
-
sumarizarCuentas(
|
|
54
|
-
sumarizarCuentas(
|
|
55
|
-
sumarizarCuentas(
|
|
56
|
-
sumarizarCuentas(
|
|
57
|
-
sumarizarCuentas(
|
|
58
|
-
sumarizarCuentas(
|
|
59
|
-
sumarizarCuentas(
|
|
60
|
-
sumarizarCuentas(
|
|
61
|
-
sumarizarCuentas(
|
|
62
|
-
sumarizarCuentas(
|
|
66
|
+
sumarizarCuentas("ACT_CN_11001", data, data.balanceMap);
|
|
67
|
+
sumarizarCuentas("ACT_CN_11002", data, data.balanceMap);
|
|
68
|
+
sumarizarCuentas("ACT_CN_11003", data, data.balanceMap);
|
|
69
|
+
sumarizarCuentas("ACT_CN_12001", data, data.balanceMap);
|
|
70
|
+
sumarizarCuentas("ACT_CN_12002", data, data.balanceMap);
|
|
71
|
+
sumarizarCuentas("ACT_CN_12004", data, data.balanceMap);
|
|
72
|
+
sumarizarCuentas("ACT_CN_21001", data, data.balanceMap);
|
|
73
|
+
sumarizarCuentas("ACT_CN_21002", data, data.balanceMap);
|
|
74
|
+
sumarizarCuentas("ACT_CN_22001", data, data.balanceMap);
|
|
75
|
+
sumarizarCuentas("ACT_CN_22002", data, data.balanceMap);
|
|
76
|
+
sumarizarCuentas("ACT_CN_30001", data, data.balanceMap);
|
|
77
|
+
sumarizarCuentas("ACT_CN_40001", data, data.eerrMap);
|
|
78
|
+
sumarizarCuentas("ACT_CN_41002", data, data.eerrMap);
|
|
79
|
+
sumarizarCuentas("ACT_CN_43002", data, data.eerrMap);
|
|
80
|
+
sumarizarCuentas("ACT_CN_43003", data, data.eerrMap);
|
|
81
|
+
sumarizarCuentas("ACT_CN_46001", data, data.eerrMap);
|
|
82
|
+
data.camposCalculadosDefinidos = this.camposCalculadosDefinidos;
|
|
63
83
|
return data;
|
|
64
84
|
}
|
|
65
85
|
}
|
|
@@ -68,13 +88,15 @@ const anadirGrupoBalance = (actividad, rubros, grupoActividad, rubroDestino, dat
|
|
|
68
88
|
const rango = data[0].Rango;
|
|
69
89
|
if (!rubroDestino)
|
|
70
90
|
throw new Error(`No existe el rubro Calculado ${rubroDestino} en el objeto`);
|
|
71
|
-
const sumado = grupoActividad
|
|
91
|
+
const sumado = grupoActividad
|
|
92
|
+
.filter((item) => rubros.includes(item.RubroId))
|
|
72
93
|
.reduce((acc, item) => {
|
|
73
94
|
if (!acc)
|
|
74
95
|
acc = item;
|
|
75
96
|
else {
|
|
76
97
|
for (let i = 1; i <= rango; i++) {
|
|
77
|
-
acc[`Gestion${i}`] +=
|
|
98
|
+
acc[`Gestion${i}`] +=
|
|
99
|
+
parseFloat(acc[`Gestion${i}`]) + parseFloat(item[`Gestion${i}`]);
|
|
78
100
|
acc[`Gestion${i}`] = Math.round(acc[`Gestion${i}`] * 100) / 100;
|
|
79
101
|
}
|
|
80
102
|
}
|
|
@@ -83,15 +105,17 @@ const anadirGrupoBalance = (actividad, rubros, grupoActividad, rubroDestino, dat
|
|
|
83
105
|
for (let i = 1; i <= rango; i++) {
|
|
84
106
|
const cuenta = data.find((item) => item.RubroId == rubroDestino);
|
|
85
107
|
let copy = { ...cuenta };
|
|
86
|
-
copy.RubroId =
|
|
108
|
+
copy.RubroId = esDetalle ? `${rubroDestino}` : `${rubroDestino}.1`;
|
|
87
109
|
copy.Descripcion = `${cuenta.Descripcion} ${actividad.ActividadEconomicaId} ${actividad.Descripcion}`;
|
|
88
|
-
copy.UUID = `${rubroDestino}_${actividad.ActividadEconomicaId}
|
|
110
|
+
copy.UUID = `${rubroDestino}_${actividad.ActividadEconomicaId}`;
|
|
89
111
|
copy.MontoEmpresa = 0;
|
|
90
112
|
copy.MontoFamiliar = 0;
|
|
91
113
|
copy.Correlativo = i;
|
|
92
|
-
copy.Clasificador =
|
|
93
|
-
copy.MontoEmpresa =
|
|
114
|
+
copy.Clasificador = "CT";
|
|
115
|
+
copy.MontoEmpresa =
|
|
116
|
+
Math.round(parseFloat(sumado[`Gestion${i}`]) * 100) / 100;
|
|
94
117
|
data.push(copy);
|
|
118
|
+
map.set(`${rubroDestino}_${actividad.ActividadEconomicaId}_${i}`, copy);
|
|
95
119
|
}
|
|
96
120
|
};
|
|
97
121
|
const sumarizarCuentas = (rubro, data, map) => {
|
|
@@ -111,20 +135,24 @@ const sumarizarCuentas = (rubro, data, map) => {
|
|
|
111
135
|
cuentaDestino.MontoEmpresa += cuentaOrigen.MontoEmpresa;
|
|
112
136
|
if (original.MontoFamiliar == 0)
|
|
113
137
|
cuentaDestino.MontoFamiliar += cuentaOrigen.MontoFamiliar;
|
|
114
|
-
cuentaDestino.MontoEmpresa =
|
|
115
|
-
|
|
138
|
+
cuentaDestino.MontoEmpresa =
|
|
139
|
+
Math.round(cuentaDestino.MontoEmpresa * 100) / 100;
|
|
140
|
+
cuentaDestino.MontoFamiliar =
|
|
141
|
+
Math.round(cuentaDestino.MontoFamiliar * 100) / 100;
|
|
116
142
|
}
|
|
117
143
|
}
|
|
118
144
|
};
|
|
119
145
|
const getCuentasCopy = (data, rubroId, map) => {
|
|
120
146
|
if (!data.eerr || data.eerr.length == 0)
|
|
121
|
-
throw new Error(
|
|
147
|
+
throw new Error("Debe ingresar cuentas EERR");
|
|
122
148
|
let originalData = new Map();
|
|
123
149
|
const rango = data.eerr[0].Rango;
|
|
124
150
|
for (let i = 1; i <= rango; i++) {
|
|
125
151
|
let cuentaIngreso = map.get(`${rubroId}_${i}`);
|
|
126
|
-
cuentaIngreso.MontoEmpresa =
|
|
127
|
-
|
|
152
|
+
cuentaIngreso.MontoEmpresa =
|
|
153
|
+
Math.round(parseFloat(cuentaIngreso.MontoEmpresa) * 100) / 100;
|
|
154
|
+
cuentaIngreso.MontoFamiliar =
|
|
155
|
+
Math.round(parseFloat(cuentaIngreso.MontoFamiliar) * 100) / 100;
|
|
128
156
|
originalData.set(`${rubroId}_${i}`, { ...cuentaIngreso });
|
|
129
157
|
}
|
|
130
158
|
return originalData;
|
|
@@ -9,23 +9,28 @@ class FlujoProyectadoEEFFStrategy {
|
|
|
9
9
|
if (!this.actividades || this.actividades.length == 0)
|
|
10
10
|
return data;
|
|
11
11
|
for (let actividad of this.actividades) {
|
|
12
|
-
agregarGrupo([
|
|
13
|
-
agregarGrupo([
|
|
14
|
-
agregarGrupo([
|
|
15
|
-
agregarGrupo([
|
|
16
|
-
agregarGrupo([
|
|
17
|
-
agregarGrupo([
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
12
|
+
agregarGrupo(["BP_ACT_EF_41000"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_40001", data);
|
|
13
|
+
agregarGrupo(["BP_ACT_EF_42001"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_50001", data);
|
|
14
|
+
agregarGrupo(["BP_ACT_EF_43001"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_60001", data);
|
|
15
|
+
agregarGrupo(["BP_ACT_EF_43002"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_60002", data);
|
|
16
|
+
agregarGrupo(["BP_ACT_EF_44001", "BP_ACT_EF_44002"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_61001", data);
|
|
17
|
+
agregarGrupo([
|
|
18
|
+
"BP_ACT_EF_44002.1",
|
|
19
|
+
"BP_ACT_EF_44003",
|
|
20
|
+
"BP_ACT_EF_44005",
|
|
21
|
+
"BP_ACT_EF_44006",
|
|
22
|
+
], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_70001", data);
|
|
23
|
+
agregarGrupo(["BP_ACT_EF_44005.1", "BP_ACT_EF_44004", "BP_ACT_EF_44007"], actividad, actividad.BalanceProyectado.EERR, "ACT_CNFL_70002", data);
|
|
24
|
+
agregarGrupo(["BP_ACT_FJ_10501", "BP_ACT_FJ_10502", "BP_ACT_FJ_10505"], actividad, actividad.BalanceProyectado.FlujoCaja, "ACT_CNFL_80001", data);
|
|
25
|
+
agregarGrupo(["BP_ACT_FJ_10504", "BP_ACT_FJ_10506", "BP_ACT_FJ_10507"], actividad, actividad.BalanceProyectado.FlujoCaja, "ACT_CNFL_80002", data);
|
|
21
26
|
}
|
|
22
|
-
sumarizarCuenta(
|
|
23
|
-
sumarizarCuenta(
|
|
24
|
-
sumarizarCuenta(
|
|
25
|
-
sumarizarCuenta(
|
|
26
|
-
sumarizarCuenta(
|
|
27
|
-
sumarizarCuenta(
|
|
28
|
-
sumarizarCuenta(
|
|
27
|
+
sumarizarCuenta("ACT_CNFL_40001", data);
|
|
28
|
+
sumarizarCuenta("ACT_CNFL_50001", data);
|
|
29
|
+
sumarizarCuenta("ACT_CNFL_60001", data);
|
|
30
|
+
sumarizarCuenta("ACT_CNFL_70001", data);
|
|
31
|
+
sumarizarCuenta("ACT_CNFL_70002", data);
|
|
32
|
+
sumarizarCuenta("ACT_CNFL_80001", data);
|
|
33
|
+
sumarizarCuenta("ACT_CNFL_80002", data);
|
|
29
34
|
return data;
|
|
30
35
|
}
|
|
31
36
|
}
|
|
@@ -33,21 +38,27 @@ exports.default = FlujoProyectadoEEFFStrategy;
|
|
|
33
38
|
const agregarGrupo = (rubros, actividad, grupoActividad, rubroDestino, data) => {
|
|
34
39
|
const rango = data.DatosEvaluacion.CantidadProyeccion;
|
|
35
40
|
if (!rango)
|
|
36
|
-
throw new Error(
|
|
37
|
-
const sumado = grupoActividad
|
|
41
|
+
throw new Error("No existe el rango en la evaluacion");
|
|
42
|
+
const sumado = grupoActividad
|
|
43
|
+
.filter((item) => rubros.includes(item.RubroId))
|
|
38
44
|
.reduce((acc, item) => {
|
|
39
45
|
if (!acc) {
|
|
40
46
|
acc = item;
|
|
41
47
|
for (let i = 1; i <= rango; i++) {
|
|
42
48
|
if (!acc[`Gestion${i}`])
|
|
43
49
|
acc[`Gestion${i}`] = 0;
|
|
50
|
+
else
|
|
51
|
+
item[`Gestion${i}`] = item[`Gestion${i}`].replace(',', '');
|
|
44
52
|
}
|
|
45
53
|
}
|
|
46
54
|
else {
|
|
47
55
|
for (let i = 1; i <= rango; i++) {
|
|
48
56
|
if (!item[`Gestion${i}`])
|
|
49
57
|
item[`Gestion${i}`] = 0;
|
|
50
|
-
|
|
58
|
+
else
|
|
59
|
+
item[`Gestion${i}`] = item[`Gestion${i}`].replace(',', '');
|
|
60
|
+
acc[`Gestion${i}`] +=
|
|
61
|
+
parseFloat(acc[`Gestion${i}`]) + parseFloat(item[`Gestion${i}`]);
|
|
51
62
|
acc[`Gestion${i}`] = Math.round(acc[`Gestion${i}`] * 100) / 100;
|
|
52
63
|
}
|
|
53
64
|
}
|
|
@@ -56,15 +67,23 @@ const agregarGrupo = (rubros, actividad, grupoActividad, rubroDestino, data) =>
|
|
|
56
67
|
const rubro = data.FlujoProyectadoAnual[0];
|
|
57
68
|
let row = { ...rubro };
|
|
58
69
|
row.RubroId = rubroDestino;
|
|
59
|
-
row.Clasificador =
|
|
70
|
+
row.Clasificador = "CT";
|
|
60
71
|
row.Descripcion = `Actividad: ${actividad.Descripcion}`;
|
|
61
72
|
row.Editable = false;
|
|
62
73
|
row.UUID = `${rubroDestino}_${actividad.ActividadEconomicaId}`;
|
|
63
74
|
row.RubroId = `${rubroDestino}.1`;
|
|
64
75
|
for (let i = 1; i <= rango; i++) {
|
|
65
|
-
row[`Monto${i}`] =
|
|
76
|
+
row[`Monto${i}`] =
|
|
77
|
+
Math.round(parseFloat(sumado[`Gestion${i}`]) * 100) / 100;
|
|
66
78
|
}
|
|
67
|
-
data.FlujoProyectadoAnual.
|
|
79
|
+
const existente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
|
|
80
|
+
if (existente >= 0) {
|
|
81
|
+
data.FlujoProyectadoAnual[existente] = row;
|
|
82
|
+
}
|
|
83
|
+
else {
|
|
84
|
+
data.FlujoProyectadoAnual.push(row);
|
|
85
|
+
}
|
|
86
|
+
// data.FlujoProyectadoAnual.push(row)
|
|
68
87
|
};
|
|
69
88
|
const sumarizarCuenta = (rubroId, data) => {
|
|
70
89
|
const rango = data.DatosEvaluacion.CantidadProyeccion;
|
|
@@ -35,6 +35,11 @@ const flujoProyectado_calc_1 = require("./common/flujoProyectado.calc");
|
|
|
35
35
|
class FlujoProyectado {
|
|
36
36
|
execute(data) {
|
|
37
37
|
let result = {};
|
|
38
|
+
// Asignar un array vacío si el flujo mensual no existe y el tipo es EEFF
|
|
39
|
+
if (['EEFF', 'GENERAL'].includes(data.TipoConsolidado) &&
|
|
40
|
+
!data.FlujoProyectadoMensual) {
|
|
41
|
+
data.FlujoProyectadoMensual = [];
|
|
42
|
+
}
|
|
38
43
|
result = data;
|
|
39
44
|
const cloneFlujoProyectadoMensual = commmon.clone(data.FlujoProyectadoMensual);
|
|
40
45
|
const cloneFlujoProyectadoAnual = commmon.clone(data.FlujoProyectadoAnual);
|
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
const utils_1 = require("../eeff/admFinanciera/utils");
|
|
3
4
|
class BalanceGeneralStrategy {
|
|
4
5
|
actividades;
|
|
5
6
|
constructor() {
|
|
@@ -11,16 +12,16 @@ class BalanceGeneralStrategy {
|
|
|
11
12
|
this.actividades.Consolidados.length == 0)
|
|
12
13
|
return data;
|
|
13
14
|
for (const consolidado of this.actividades.Consolidados) {
|
|
14
|
-
procesarConsolidado(consolidado.BalanceCalc.balance, data.balance, consolidado.Tipo);
|
|
15
|
-
procesarConsolidado(consolidado.BalanceCalc.eerr, data.eerr, consolidado.Tipo);
|
|
15
|
+
procesarConsolidado(consolidado.BalanceCalc.balance, data.balance, consolidado.Tipo, data.balanceMap);
|
|
16
|
+
procesarConsolidado(consolidado.BalanceCalc.eerr, data.eerr, consolidado.Tipo, data.eerrMap);
|
|
16
17
|
}
|
|
17
|
-
|
|
18
|
-
|
|
18
|
+
sumarizarCuentasPadre(data.balance, data.balanceMap);
|
|
19
|
+
sumarizarCuentasPadre(data.eerr, data.eerrMap);
|
|
19
20
|
return data;
|
|
20
21
|
}
|
|
21
22
|
}
|
|
22
23
|
exports.default = BalanceGeneralStrategy;
|
|
23
|
-
const procesarConsolidado = (consolidado, data, tipoConsolidado) => {
|
|
24
|
+
const procesarConsolidado = (consolidado, data, tipoConsolidado, map) => {
|
|
24
25
|
const rubros = consolidado.filter((item) => item.Clasificador == 'H' || item.Clasificador == 'HABM');
|
|
25
26
|
if (rubros.length > 0) {
|
|
26
27
|
const rango = rubros[0].Rango;
|
|
@@ -33,11 +34,14 @@ const procesarConsolidado = (consolidado, data, tipoConsolidado) => {
|
|
|
33
34
|
? `${rubro.RubroId}`
|
|
34
35
|
: `${rubro.RubroId}.1`;
|
|
35
36
|
copy.Descripcion = `${cuenta.Descripcion} - Consolidado ${tipoConsolidado} `;
|
|
36
|
-
copy.UUID = `${rubro.RubroId}_${tipoConsolidado}
|
|
37
|
+
copy.UUID = `${rubro.RubroId}_${tipoConsolidado}`;
|
|
38
|
+
copy.SumableATotal = rubro.Clasificador === 'HABM';
|
|
39
|
+
copy.Subcuenta = true;
|
|
37
40
|
copy.MontoEmpresa = 0;
|
|
38
41
|
copy.MontoFamiliar = 0;
|
|
39
42
|
copy.Correlativo = i;
|
|
40
|
-
copy.Clasificador = '
|
|
43
|
+
copy.Clasificador = 'SBCT';
|
|
44
|
+
copy.IndicadorABM = 'N';
|
|
41
45
|
copy.MontoEmpresa =
|
|
42
46
|
Math.round(parseFloat(rubro[`MontoEmpresa_${i}`]) * 100) /
|
|
43
47
|
100;
|
|
@@ -45,26 +49,39 @@ const procesarConsolidado = (consolidado, data, tipoConsolidado) => {
|
|
|
45
49
|
Math.round(parseFloat(rubro[`MontoFamiliar_${i}`]) * 100) /
|
|
46
50
|
100;
|
|
47
51
|
data.push(copy);
|
|
52
|
+
const mapKey = `${copy.RubroId}_${tipoConsolidado}_${i}`;
|
|
53
|
+
if (map.has(mapKey)) {
|
|
54
|
+
map.get(mapKey).MontoEmpresa += copy.MontoEmpresa;
|
|
55
|
+
map.get(mapKey).MontoFamiliar += copy.MontoFamiliar;
|
|
56
|
+
}
|
|
57
|
+
else {
|
|
58
|
+
map.set(mapKey, copy);
|
|
59
|
+
}
|
|
48
60
|
}
|
|
49
61
|
}
|
|
50
62
|
}
|
|
51
63
|
};
|
|
52
|
-
|
|
53
|
-
const rubros = consolidado.filter((item) => item.Clasificador == 'H');
|
|
54
|
-
for (const rubro of rubros) {
|
|
55
|
-
sumarizarCuentas(rubro.RubroId, data, map);
|
|
56
|
-
}
|
|
57
|
-
};
|
|
58
|
-
const sumarizarCuentas = (rubro, data, map) => {
|
|
64
|
+
function sumarizarCuenta({ data, map, rubroId }) {
|
|
59
65
|
const rango = data[0].Rango;
|
|
60
66
|
for (let i = 1; i <= rango; i++) {
|
|
61
|
-
const
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
cuentaDestino
|
|
65
|
-
cuentaDestino
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
67
|
+
const origenes = data.filter((el) => el.Subcuenta &&
|
|
68
|
+
el.RubroId.includes(rubroId) &&
|
|
69
|
+
el.Correlativo == i);
|
|
70
|
+
const cuentaDestino = map.get(`${rubroId}_${i}`);
|
|
71
|
+
if (cuentaDestino) {
|
|
72
|
+
cuentaDestino.MontoEmpresa = 0;
|
|
73
|
+
cuentaDestino.MontoFamiliar = 0;
|
|
74
|
+
cuentaDestino.Editable = false;
|
|
75
|
+
origenes.forEach((el) => {
|
|
76
|
+
cuentaDestino.MontoEmpresa += (0, utils_1.ourParseFloat)(el.MontoEmpresa);
|
|
77
|
+
cuentaDestino.MontoFamiliar += (0, utils_1.ourParseFloat)(el.MontoFamiliar);
|
|
78
|
+
});
|
|
79
|
+
}
|
|
69
80
|
}
|
|
70
|
-
}
|
|
81
|
+
}
|
|
82
|
+
function sumarizarCuentasPadre(data, map) {
|
|
83
|
+
const rubros = data.filter((item) => item.Clasificador == 'H');
|
|
84
|
+
rubros.forEach((el) => {
|
|
85
|
+
sumarizarCuenta({ rubroId: el.RubroId, data, map });
|
|
86
|
+
});
|
|
87
|
+
}
|
|
@@ -1,53 +1,97 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
const utils_1 = require("../eeff/admFinanciera/utils");
|
|
3
4
|
class FlujoProyectadoBalanceStrategy {
|
|
4
5
|
actividades;
|
|
5
6
|
constructor() {
|
|
6
7
|
this.actividades = {};
|
|
7
8
|
}
|
|
8
9
|
execute(data) {
|
|
9
|
-
if (!this.actividades ||
|
|
10
|
+
if (!this.actividades ||
|
|
11
|
+
!this.actividades.Consolidados ||
|
|
12
|
+
this.actividades.Consolidados.length == 0)
|
|
10
13
|
return data;
|
|
11
|
-
|
|
14
|
+
resetearSubcuentasSumadas(data.FlujoProyectadoAnual, data.DatosEvaluacion.CantidadProyeccion);
|
|
15
|
+
for (const consolidado of this.actividades.Consolidados) {
|
|
12
16
|
procesarAnual(consolidado.FlujoCalc.FlujoProyectadoAnual, data, consolidado.Tipo);
|
|
13
17
|
}
|
|
14
|
-
|
|
18
|
+
sumarizarCuentasPadre(data.FlujoProyectadoAnual, data.DatosEvaluacion.CantidadProyeccion);
|
|
15
19
|
return data;
|
|
16
20
|
}
|
|
17
21
|
}
|
|
18
22
|
exports.default = FlujoProyectadoBalanceStrategy;
|
|
19
23
|
const procesarAnual = (consolidado, data, tipoConsolidado) => {
|
|
20
|
-
const rubros = consolidado.filter((item) => ['HM', 'HABM', 'DETL'].includes(item.Clasificador));
|
|
24
|
+
const rubros = consolidado.filter((item) => ['HM', 'HABM', 'DETL', 'CT'].includes(item.Clasificador));
|
|
21
25
|
const rango = data.DatosEvaluacion.CantidadProyeccion;
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
26
|
+
for (const rubroItem of rubros) {
|
|
27
|
+
const row = { ...rubroItem };
|
|
28
|
+
const esDetalle = rubroItem.Clasificador == 'HABM' || rubroItem.Clasificador == 'DETL';
|
|
29
|
+
row.Subcuenta = true;
|
|
30
|
+
row.ClasificadorOriginal = rubroItem.Clasificador;
|
|
31
|
+
row.Clasificador = 'SBCT';
|
|
32
|
+
row.Descripcion = `${rubroItem.Descripcion} - ${tipoConsolidado}`;
|
|
33
|
+
row.Editable = false;
|
|
34
|
+
row.MontoCajaPercent = row.MontoAdicional;
|
|
35
|
+
row.UUID =
|
|
36
|
+
rubroItem.Clasificador !== 'DETL'
|
|
37
|
+
? `${rubroItem.RubroId}_${tipoConsolidado}`
|
|
38
|
+
: `${rubroItem.RubroId}_${tipoConsolidado}_${rubroItem.UUID}`;
|
|
39
|
+
row.RubroId = esDetalle
|
|
40
|
+
? `${rubroItem.RubroId}`
|
|
41
|
+
: `${rubroItem.RubroId}.1`;
|
|
42
|
+
const indexExistente = data.FlujoProyectadoAnual.findIndex((el) => el.UUID === row.UUID);
|
|
43
|
+
if (indexExistente >= 0) {
|
|
44
|
+
if (rubroItem.Clasificador === 'HABM') {
|
|
45
|
+
sumarCuentaExistente({
|
|
46
|
+
data: data.FlujoProyectadoAnual,
|
|
47
|
+
fila: row,
|
|
48
|
+
index: indexExistente,
|
|
49
|
+
rango
|
|
50
|
+
});
|
|
33
51
|
}
|
|
52
|
+
else {
|
|
53
|
+
data.FlujoProyectadoAnual[indexExistente] = row;
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
else {
|
|
34
57
|
data.FlujoProyectadoAnual.push(row);
|
|
35
58
|
}
|
|
36
59
|
}
|
|
37
60
|
};
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
61
|
+
function sumarCuentaExistente({ data, index, fila, rango }) {
|
|
62
|
+
for (let i = 1; i <= rango; i++) {
|
|
63
|
+
data[index][`Monto${i}`] =
|
|
64
|
+
(0, utils_1.ourParseFloat)(data[index][`Monto${i}`]) +
|
|
65
|
+
(0, utils_1.ourParseFloat)(fila[`Monto${i}`]);
|
|
42
66
|
}
|
|
43
|
-
}
|
|
44
|
-
|
|
45
|
-
const
|
|
46
|
-
|
|
47
|
-
const detalles = data.FlujoProyectadoAnual.filter((item) => item.RubroId == `${rubroId}.1`);
|
|
48
|
-
for (let detalle of detalles) {
|
|
67
|
+
}
|
|
68
|
+
function resetearSubcuentasSumadas(data, rango) {
|
|
69
|
+
const cuentas = data.filter((el) => el.Subcuenta && ['HABM'].includes(el.ClasificadorOriginal));
|
|
70
|
+
cuentas.forEach((cuenta) => {
|
|
49
71
|
for (let i = 1; i <= rango; i++) {
|
|
50
|
-
cuenta[`Monto${i}`]
|
|
72
|
+
cuenta[`Monto${i}`] = 0;
|
|
51
73
|
}
|
|
74
|
+
});
|
|
75
|
+
}
|
|
76
|
+
function sumarizarCuenta({ data, rubroId, rango }) {
|
|
77
|
+
const cuentaDestino = data.find((el) => el.RubroId === rubroId);
|
|
78
|
+
if (cuentaDestino) {
|
|
79
|
+
const origenes = data.filter((el) => el.Subcuenta && el.RubroId.includes(rubroId));
|
|
80
|
+
for (let i = 1; i <= rango; i++) {
|
|
81
|
+
cuentaDestino[`Monto${i}`] = 0;
|
|
82
|
+
}
|
|
83
|
+
cuentaDestino.MontoCajaPercent = 0;
|
|
84
|
+
origenes.forEach((el) => {
|
|
85
|
+
for (let i = 1; i <= rango; i++) {
|
|
86
|
+
cuentaDestino[`Monto${i}`] += (0, utils_1.ourParseFloat)(el[`Monto${i}`]);
|
|
87
|
+
}
|
|
88
|
+
cuentaDestino.MontoCajaPercent += (0, utils_1.ourParseFloat)(el['MontoCajaPercent']);
|
|
89
|
+
});
|
|
52
90
|
}
|
|
53
|
-
}
|
|
91
|
+
}
|
|
92
|
+
function sumarizarCuentasPadre(data, rango) {
|
|
93
|
+
const rubros = data.filter((item) => ['HM', 'CT'].includes(item.Clasificador));
|
|
94
|
+
rubros.forEach((el) => {
|
|
95
|
+
sumarizarCuenta({ rubroId: el.RubroId, data, rango });
|
|
96
|
+
});
|
|
97
|
+
}
|
|
@@ -1,6 +1,5 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
const lodash_1 = require("lodash");
|
|
4
3
|
const utils_1 = require("../eeff/admFinanciera/utils");
|
|
5
4
|
const gCuentaIngreso = 'ACT_CN_40001';
|
|
6
5
|
const gCuentaCosto = 'ACT_CN_41002';
|
|
@@ -26,7 +25,7 @@ class BalancePecStrategy {
|
|
|
26
25
|
const cuentasIngresosCopy = getCuentasCopy(data, gCuentaIngreso);
|
|
27
26
|
const cuentasCostoCopy = getCuentasCopy(data, gCuentaCosto);
|
|
28
27
|
const cuentaGastoCopy = getCuentasCopy(data, gCuentaGasto);
|
|
29
|
-
const cuentaOtrosIngresosCopy = getCuentasCopy(data, gCuentaOtrosIngresosDet
|
|
28
|
+
const cuentaOtrosIngresosCopy = getCuentasCopy(data, gCuentaOtrosIngresosDet);
|
|
30
29
|
for (const actividad of this.actividades) {
|
|
31
30
|
anadirIngresosAuxPec(actividad, data);
|
|
32
31
|
//anadirIngresoVenta(actividad, data)
|
|
@@ -37,9 +36,8 @@ class BalancePecStrategy {
|
|
|
37
36
|
sumarizarCuentas(`${gCuentaIngreso}.1`, gCuentaIngreso, data, cuentasIngresosCopy);
|
|
38
37
|
sumarizarCuentas(`${gCuentaCosto}.1`, gCuentaCosto, data, cuentasCostoCopy);
|
|
39
38
|
sumarizarCuentas(`${gCuentaGasto}.1`, gCuentaGasto, data, cuentaGastoCopy);
|
|
40
|
-
sumarizarCuentas(`${gCuentaOtrosIngresosDet}.1`, gCuentaOtrosIngresosDet, data, cuentaOtrosIngresosCopy
|
|
39
|
+
sumarizarCuentas(`${gCuentaOtrosIngresosDet}.1`, gCuentaOtrosIngresosDet, data, cuentaOtrosIngresosCopy);
|
|
41
40
|
data.camposCalculadosDefinidos = this.camposCalculadosDefinidos;
|
|
42
|
-
console.log((0, lodash_1.cloneDeep)(data));
|
|
43
41
|
return data;
|
|
44
42
|
}
|
|
45
43
|
}
|
|
@@ -1,16 +1,18 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
const RUBRO_INGRESO =
|
|
4
|
-
const RUBRO_COSTOS =
|
|
5
|
-
const RUBRO_GASTOS =
|
|
6
|
-
const RUBRO_OTROS_INGRESOS =
|
|
7
|
-
const RUBRO_GASTOS_FAMILIARES =
|
|
3
|
+
const RUBRO_INGRESO = "ACT_CNFL_40001";
|
|
4
|
+
const RUBRO_COSTOS = "ACT_CNFL_50001";
|
|
5
|
+
const RUBRO_GASTOS = "ACT_CNFL_60001";
|
|
6
|
+
const RUBRO_OTROS_INGRESOS = "ACT_CNFL_70001";
|
|
7
|
+
const RUBRO_GASTOS_FAMILIARES = "ACT_CNFL_70002";
|
|
8
8
|
class FlujoProyectadoPrdStrategy {
|
|
9
9
|
actividades;
|
|
10
10
|
constructor() {
|
|
11
11
|
this.actividades = [];
|
|
12
12
|
}
|
|
13
13
|
execute(data) {
|
|
14
|
+
if (!this.actividades || this.actividades.length == 0)
|
|
15
|
+
return data;
|
|
14
16
|
const copiaIngreso = getCuentaCopy(RUBRO_INGRESO, data);
|
|
15
17
|
const copiaCostos = getCuentaCopy(RUBRO_COSTOS, data);
|
|
16
18
|
const copiaGastos = getCuentaCopy(RUBRO_GASTOS, data);
|
|
@@ -53,17 +55,24 @@ const addIngresosM = (actividad, data) => {
|
|
|
53
55
|
for (const producto of productos) {
|
|
54
56
|
const ingresos = actividad.Ventas.EstacionalidadCalc.find((item) => item.ProductoId == producto.ProductoId);
|
|
55
57
|
if (!ingresos)
|
|
56
|
-
throw new Error(
|
|
58
|
+
throw new Error("No se encontro la estacionalidad Calc de la actividad");
|
|
57
59
|
let row = { ...rubro };
|
|
58
60
|
row.Descripcion = `Ingresos Actividad ${actividad.ActividadEconomicaId} - Producto ${ingresos.Descripcion}`;
|
|
59
|
-
row.Clasificador =
|
|
61
|
+
row.Clasificador = "CT";
|
|
60
62
|
row.Editable = false;
|
|
61
63
|
row.UUID = `${RUBRO_INGRESO}_${actividad.ActividadEconomicaId}_${producto.ProductoId}`;
|
|
62
64
|
row.RubroId = `${RUBRO_INGRESO}.1`;
|
|
63
65
|
for (let i = 1; i <= 12; i++) {
|
|
64
|
-
row[`Monto${i}`] =
|
|
66
|
+
row[`Monto${i}`] =
|
|
67
|
+
Math.round(parseFloat(ingresos[`C-${i}`]) * 100) / 100;
|
|
68
|
+
}
|
|
69
|
+
const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
|
|
70
|
+
if (existente >= 0) {
|
|
71
|
+
data.FlujoProyectadoMensual[existente] = row;
|
|
72
|
+
}
|
|
73
|
+
else {
|
|
74
|
+
data.FlujoProyectadoMensual.push(row);
|
|
65
75
|
}
|
|
66
|
-
data.FlujoProyectadoMensual.push(row);
|
|
67
76
|
}
|
|
68
77
|
}
|
|
69
78
|
};
|
|
@@ -77,14 +86,21 @@ const addCostosM = (actividad, data) => {
|
|
|
77
86
|
throw new Error(`No se encontro el costo cálculo para el producto ${producto.ProductoId}`);
|
|
78
87
|
let row = { ...rubro };
|
|
79
88
|
row.Descripcion = `(-) Costos de Ventas Actividad: $${actividad.ActividadEconomicaId} Producto ${producto.ProductoId}`;
|
|
80
|
-
row.Clasificador =
|
|
89
|
+
row.Clasificador = "CT";
|
|
81
90
|
row.Editable = false;
|
|
82
91
|
row.UUID = `${RUBRO_COSTOS}_${actividad.ActividadEconomicaId}_${producto.ProductoId}`;
|
|
83
92
|
row.RubroId = `${RUBRO_COSTOS}.1`;
|
|
84
93
|
for (let i = 1; i <= 12; i++) {
|
|
85
|
-
row[`Monto${i}`] =
|
|
94
|
+
row[`Monto${i}`] =
|
|
95
|
+
Math.round(parseFloat(costos[`Monto${i}`]) * 100) / 100;
|
|
96
|
+
}
|
|
97
|
+
const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
|
|
98
|
+
if (existente >= 0) {
|
|
99
|
+
data.FlujoProyectadoMensual[existente] = row;
|
|
100
|
+
}
|
|
101
|
+
else {
|
|
102
|
+
data.FlujoProyectadoMensual.push(row);
|
|
86
103
|
}
|
|
87
|
-
data.FlujoProyectadoMensual.push(row);
|
|
88
104
|
}
|
|
89
105
|
}
|
|
90
106
|
};
|
|
@@ -92,26 +108,33 @@ const addGastosM = (actividad, data) => {
|
|
|
92
108
|
const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_GASTOS}_0`);
|
|
93
109
|
const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
|
|
94
110
|
if (!otrosGastos)
|
|
95
|
-
throw new Error(
|
|
111
|
+
throw new Error("No se encontro los gastos de la actividad");
|
|
96
112
|
let row = { ...rubro };
|
|
97
113
|
row.Descripcion = `(-) Gastos Operativo ActividadId:${actividad.ActividadEconomicaId}`;
|
|
98
|
-
row.Clasificador =
|
|
114
|
+
row.Clasificador = "CT";
|
|
99
115
|
row.Editable = false;
|
|
100
116
|
row.UUID = `${RUBRO_GASTOS}_${actividad.ActividadEconomicaId}`;
|
|
101
117
|
row.RubroId = `${RUBRO_GASTOS}.1`;
|
|
102
118
|
for (let i = 1; i <= 12; i++) {
|
|
103
|
-
row[`Monto${i}`] =
|
|
119
|
+
row[`Monto${i}`] =
|
|
120
|
+
Math.round(parseFloat(otrosGastos.GastosOperativos) * 100) / 100;
|
|
121
|
+
}
|
|
122
|
+
const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
|
|
123
|
+
if (existente >= 0) {
|
|
124
|
+
data.FlujoProyectadoMensual[existente] = row;
|
|
125
|
+
}
|
|
126
|
+
else {
|
|
127
|
+
data.FlujoProyectadoMensual.push(row);
|
|
104
128
|
}
|
|
105
|
-
data.FlujoProyectadoMensual.push(row);
|
|
106
129
|
};
|
|
107
130
|
const otrosIngresoM = (actividad, data) => {
|
|
108
131
|
const rubro = data.FlujoProyectadoMensualMap.get(`${RUBRO_OTROS_INGRESOS}_0`);
|
|
109
132
|
const otrosIngresos = actividad.Ventas.OtrosIngresos;
|
|
110
133
|
if (!otrosIngresos)
|
|
111
|
-
throw new Error(
|
|
134
|
+
throw new Error("No se encontro la estacionalidad Calc de la actividad");
|
|
112
135
|
let row = { ...rubro };
|
|
113
136
|
row.Descripcion = `Otros Ingresos Familiares Actividad: ${actividad.ActividadEconomicaId}`;
|
|
114
|
-
row.Clasificador =
|
|
137
|
+
row.Clasificador = "CT";
|
|
115
138
|
row.Editable = false;
|
|
116
139
|
row.UUID = `${RUBRO_OTROS_INGRESOS}_${actividad.ActividadEconomicaId}`;
|
|
117
140
|
row.RubroId = `${RUBRO_OTROS_INGRESOS}.1`;
|
|
@@ -126,26 +149,40 @@ const otrosIngresoM = (actividad, data) => {
|
|
|
126
149
|
}
|
|
127
150
|
else {
|
|
128
151
|
for (let i = 1; i <= 12; i++) {
|
|
129
|
-
row[`Monto${i}`] =
|
|
152
|
+
row[`Monto${i}`] =
|
|
153
|
+
Math.round(parseFloat(otrosIngresos[`C-${i}`]) * 100) / 100;
|
|
130
154
|
}
|
|
131
155
|
}
|
|
132
|
-
data.FlujoProyectadoMensual.
|
|
156
|
+
const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
|
|
157
|
+
if (existente >= 0) {
|
|
158
|
+
data.FlujoProyectadoMensual[existente] = row;
|
|
159
|
+
}
|
|
160
|
+
else {
|
|
161
|
+
data.FlujoProyectadoMensual.push(row);
|
|
162
|
+
}
|
|
133
163
|
};
|
|
134
164
|
const gastosFamiliaresM = (actividad, data) => {
|
|
135
165
|
const rubro = data.FlujoProyectadoMensualMap.get(`$${RUBRO_GASTOS_FAMILIARES}_0`);
|
|
136
166
|
const otrosGastos = calcularOtrosGastos(actividad.OtrosGastos);
|
|
137
167
|
if (!otrosGastos)
|
|
138
|
-
throw new Error(
|
|
168
|
+
throw new Error("No se encontro los gastos de la actividad");
|
|
139
169
|
let row = { ...rubro };
|
|
140
170
|
row.Descripcion = `(-) Gastos Familiares Actividad ${actividad.ActividadEconomicaId}`;
|
|
141
|
-
row.Clasificador =
|
|
171
|
+
row.Clasificador = "CT";
|
|
142
172
|
row.Editable = false;
|
|
143
173
|
row.UUID = `${RUBRO_GASTOS_FAMILIARES}_${actividad.ActividadEconomicaId}`;
|
|
144
174
|
row.RubroId = `${RUBRO_GASTOS_FAMILIARES}.1`;
|
|
145
175
|
for (let i = 1; i <= 12; i++) {
|
|
146
|
-
row[`Monto${i}`] =
|
|
176
|
+
row[`Monto${i}`] =
|
|
177
|
+
Math.round(parseFloat(otrosGastos.gastosFamiliares) * 100) / 100;
|
|
178
|
+
}
|
|
179
|
+
const existente = data.FlujoProyectadoMensual.findIndex((el) => el.UUID === row.UUID);
|
|
180
|
+
if (existente >= 0) {
|
|
181
|
+
data.FlujoProyectadoMensual[existente] = row;
|
|
182
|
+
}
|
|
183
|
+
else {
|
|
184
|
+
data.FlujoProyectadoMensual.push(row);
|
|
147
185
|
}
|
|
148
|
-
data.FlujoProyectadoMensual.push(row);
|
|
149
186
|
};
|
|
150
187
|
const calcularOtrosGastos = (gastos) => {
|
|
151
188
|
const gastosOperativos = gastos.Operativos.reduce((acc, item) => {
|
|
@@ -158,6 +195,6 @@ const calcularOtrosGastos = (gastos) => {
|
|
|
158
195
|
}, 0);
|
|
159
196
|
return {
|
|
160
197
|
GastosOperativos: Math.round(gastosOperativos * 100) / 100,
|
|
161
|
-
GastosFamiliares: Math.round(gastosFamiliares * 100) / 100
|
|
198
|
+
GastosFamiliares: Math.round(gastosFamiliares * 100) / 100,
|
|
162
199
|
};
|
|
163
200
|
};
|