Merge branch 'master' of https://github.com/jortilles/EDA

Author: ronaldchavezjortilles

eda/eda_api/lib/module/dashboard/dashboard.controller.ts

@@ -8,6 +8,7 @@ import Group from '../admin/groups/model/group.model'
 import formatDate from '../../services/date-format/date-format.service'
 import { CachedQueryService } from '../../services/cache-service/cached-query.service'
 import { ArimaService } from '../../services/prediction/arima.service'
+import { TensorflowService } from '../../services/prediction/tensorflow.service'
 import { TimeFormatService } from '../../services/time-format/time-format.service'
 import { QueryOptions } from 'mongoose'
 import ServerLogService from '../../services/server-log/server-log.service'
@@ -483,7 +484,6 @@ export class DashboardController {
         // Obtener el dashboard
         const dashboard = await Dashboard.findById(req.params.id);
         if (!dashboard) {
-          console.log('Dashboard not found with this id:' + req.params.id);
           return next(new HttpException(500, 'Dashboard not found with this id'));
         }
 
@@ -499,7 +499,6 @@ export class DashboardController {
           dashboard.user.toString() !== user;
 
         if (visibilityCheck && roleCheck) {
-          console.log("You don't have permission " + user + ' for dashboard ' + req.params.id);
           return next(new HttpException(500, "You don't have permission"));
         }
 
@@ -1797,8 +1796,10 @@ export class DashboardController {
   // Suma acumulativa
   DashboardController.cumulativeSum(output, req.body.query);
 
-  // ARIMA (si aplica)
-  DashboardController.applyArimaIfNeeded(output, req.body, myQuery );
+  // Revisar si hay predicción y el tipo
+  if(req.body.query?.prediction && req.body.query?.prediction !== 'None' && req.body.output?.config?.chartType === 'line'){
+    await DashboardController.setupPrediction(output, req.body, myQuery, connection, dataModelObject, req.user)
+  }
 
   console.log(
     '\x1b[32m%s\x1b[0m',
@@ -1814,55 +1815,180 @@ export class DashboardController {
     }
   }
 
-  // Formula de arima
-  static applyArimaIfNeeded(output: any, body: any, myQuery: any) {
-    // Si no tenemos arima o no estamos en linea, salimos
-    if (body.query?.prediction !== 'Arima' || body.output.config.chartType !== 'line' ) {
-      return;
-    }
 
-    // Número de fechas a predecir
-    const steps = 3;
+  static async setupPrediction(output: any, body: any, myQuery: any, connection?: any, dataModelObject?: any, user?: any){
+    // Leer configuración de predicción del body
+    const predictionConfig = body.query?.predictionConfig || {};
+    const steps = predictionConfig.steps || 3;
 
-    // Buscamos campo de la fecha, su formato y su último valor
+    // Buscamos campo de la fecha — sin él no podemos generar fechas futuras
     const dateField = myQuery.fields.find(field => field.column_type === 'date');
     if (!dateField){
       return;
-    } 
-    
+    }
+
     const timeFormat = dateField.format;
     const lastDate = output[1][output[1].length - 1][0];
 
-    // A partir de los datos anteriores generamos las proximas fechas
+    // Generamos las próximas fechas en el mismo formato que las existentes (mes, semana, día...)
     const nextLabels = TimeFormatService.nextInSequenceGeneric( timeFormat, lastDate, steps );
 
     const rows = output[1];
     const lastIndex = rows.length - 1;
+    // Dataset numérico: solo la columna de valores (índice 1), descartando nulos/infinitos
     const originalDataset = rows.map(row => row[1]).filter(val => Number.isFinite(val));
 
     let predictions: number[] = [];
+    const setup = {steps: steps, rows: rows, lastIndex: lastIndex, nextLabels: nextLabels}
+
+    switch(body.query?.prediction){
+        case 'Arima':
+          // arimaParams puede ser undefined (usará configs automáticas) o {p,d,q} manual
+          await DashboardController.applyArimaPredicction(
+            predictions, originalDataset, setup, predictionConfig.arimaParams);
+          break;
+        case 'Tensorflow':
+          // Construir datasets de referencia para predicción multivariante
+          // referenceColumns ahora es [{table_name, column_name, display_name}]
+          const referenceColumns: {table_name: string, column_name: string, display_name: string}[] =
+            predictionConfig.tensorflowParams?.referenceColumns || [];
+          let referenceDatasets: number[][] = [];
+
+          if (referenceColumns.length > 0 && connection && dataModelObject) {
+            try {
+              // Para cada columna de referencia lanzamos una query auxiliar
+              // alineada con el mismo campo de fecha
+              referenceDatasets = await DashboardController.fetchReferenceDatasets(
+                referenceColumns, dateField, myQuery, connection, dataModelObject, user, body.query?.queryLimit
+              );
+            } catch (err) {
+              console.warn('[Prediction] Error fetching reference datasets, falling back to univariate:', err.message);
+              referenceDatasets = [];
+            }
+          }
+
+          // tfParams puede ser undefined o {epochs, lookback, learningRate}
+          await DashboardController.applyTensorflowPredicction(
+            predictions, originalDataset, setup, predictionConfig.tensorflowParams, referenceDatasets);
+          break;
+      }
+  }
+
+  // encontrar los datasets de las columnas de referencia para la predicción multivariante con TensorFlow. Cada dataset es un array de números alineado con el campo de fecha.
+  static async fetchReferenceDatasets(referenceColumns: {table_name: string, column_name: string}[],
+    dateField: any, myQuery: any, connection: any, dataModelObject: any, user: any, queryLimit?: number ): Promise<number[][]> {
+    const referenceDatasets: number[][] = [];
+
+    for (const refCol of referenceColumns) {
+      // Encontrar tablas
+      const table = dataModelObject.ds?.model?.tables?.find(t => t.table_name === refCol.table_name);
+      if (!table) {
+        console.warn(`[Prediction] Reference table not found: ${refCol.table_name}`);
+        continue;
+      }
+      // Encontrar columnas
+      const colDef = table.columns?.find(c => c.column_name === refCol.column_name);
+      if (!colDef) {
+        console.warn(`[Prediction] Reference column not found: ${refCol.column_name} in ${refCol.table_name}`);
+        continue;
+      }
+
+      // Build a query with the same date field + this reference column
+      const refQuery = {
+        fields: [
+          { ...dateField },  // Same date field as main query for alignment
+          {
+            column_name: colDef.column_name,
+            column_type: colDef.column_type || 'numeric',
+            table_id: refCol.table_name,
+            display_name: colDef.display_name?.default || colDef.column_name,
+            order: 0,
+            aggregation_type: 'sum',
+          }
+        ],
+        filters: myQuery.filters || [],
+        queryMode: myQuery.queryMode || 'EDA',
+        simple: myQuery.simple,
+        joinType: myQuery.joinType || 'inner',
+      };
+
+      try {
+        const refQueryBuilt = await connection.getQueryBuilded(refQuery, dataModelObject, user, queryLimit);
+        connection.client = await connection.getclient();
+        const refResults = await connection.execQuery(refQueryBuilt);
+
+        // Extract numeric values from results (column index 1 = the reference column)
+        let dataset: number[];
+        if (Array.isArray(refResults) && refResults.length > 0) {
+          if (Array.isArray(refResults[0])) {
+            // MongoDB format: already arrays
+            dataset = refResults.map(row => row[1]).filter(val => Number.isFinite(val));
+          } else {
+            // SQL format: objects
+            const keys = Object.keys(refResults[0]);
+            const valueKey = keys[1]; // Second column is the numeric value
+            dataset = refResults.map(row => {
+              const val = parseFloat(row[valueKey]);
+              return isNaN(val) ? null : val;
+            }).filter(val => val !== null && Number.isFinite(val));
+          }
+        }
 
+        if (dataset && dataset.length > 0) {
+          referenceDatasets.push(dataset);
+        } else {
+          console.warn(`[Prediction] No data for reference column ${refCol.table_name}.${refCol.column_name}`);
+        }
+      } catch (err) {
+        console.warn(`[Prediction] Failed to fetch reference column ${refCol.table_name}.${refCol.column_name}:`, err.message);
+      }
+    }
+
+    return referenceDatasets;
+  }
+
+  // Formula de arima
+  static applyArimaPredicction(predictions: number[], originalDataset: any, setup: {steps,rows,lastIndex,nextLabels}, arimaParams?: {p: number, d: number, q: number}) {
     try {
-      // Calculamos las predicciones a través del servicio ARIMA
-      predictions = ArimaService.forecast(originalDataset, steps);
+      predictions = ArimaService.forecast(originalDataset, setup.steps, arimaParams);
     } catch (err) {
       console.error('Error ARIMA:', err);
       return;
     }
 
-    // Añadir columna predictionet
-    rows.forEach((row, index) => {
-      row.push(index === lastIndex ? row[1] : null);
+    // Añadir columna predicción a las filas existentes
+    // Solo el último punto real tiene valor para "unir" visualmente ambas líneas
+    setup.rows.forEach((row, index) => {
+      row.push(index === setup.lastIndex ? row[1] : null);
     });
 
-    // Añadir fila de fechas
-    nextLabels.forEach((label, index) => {
-      rows.push([label, null, predictions[index] ?? null]);
+    // Añadir filas de fechas futuras con los valores predichos
+    setup.nextLabels.forEach((label, index) => {
+      setup.rows.push([label, null, predictions[index] ?? null]);
     });
 
-    console.log('Predicción ARIMA aplicada');
   }
 
+  // Predicción con TensorFlow
+  static async applyTensorflowPredicction(predictions: number[], originalDataset: any, setup: {steps,rows,lastIndex,nextLabels}, tfParams?: any, referenceDatasets?: number[][]) {
+    try {
+      predictions = await TensorflowService.forecast(originalDataset, setup.steps, tfParams, referenceDatasets);
+    } catch (err) {
+      console.error('Error TensorFlow:', err);
+      return;
+    }
+
+    // Añadir columna predicción a las filas existentes
+    setup.rows.forEach((row, index) => {
+      row.push(index === setup.lastIndex ? row[1] : null);
+    });
+
+    // Añadir filas de fechas futuras con los valores predichos
+    setup.nextLabels.forEach((label, index) => {
+      setup.rows.push([label, null, predictions[index] ?? null]);
+    });
+
+  }
 
   /**
    * Executa una consulta SQL  per un dashboard

eda/eda_api/lib/module/predictions/predictions.controller.ts

@@ -1,10 +1,13 @@
 import { NextFunction, Request, Response } from 'express';
 import { HttpException } from '../global/model/index';
 import { ArimaService as ArimaLogic} from '../../services/prediction/arima.service';
+import { TensorflowService } from '../../services/prediction/tensorflow.service';
 
-export class ArimaController {
+export class PredictionsController {
+    // Listado de todas las llamadas a la API para las predicciones
 
-    static async predict(req: Request, res: Response, next: NextFunction) {
+    // LLamada a Arima
+    static async predictArima(req: Request, res: Response, next: NextFunction) {
         try {
             const { dataset, steps } = req.body;
 
@@ -21,9 +24,28 @@ export class ArimaController {
             });
 
         } catch (err) {
-            console.error(err);
             next(new HttpException(500, 'Error generando predicción ARIMA'));
         }
     }
 
+    // LLamada a TensorFlow
+    static async predictTensorflow(req: Request, res: Response, next: NextFunction) {
+        try {
+            const { dataset, steps } = req.body;
+
+            if (!dataset || !Array.isArray(dataset)) {
+                return res.status(400).json({ ok: false, message: 'Dataset inválido' });
+            }
+
+            const predictions = await TensorflowService.forecast(dataset, steps || 1);
+
+            res.status(200).json({
+                ok: true,
+                predictions
+            });
+
+        } catch (err) {
+            next(new HttpException(500, 'Error generando predicción TensorFlow'));
+        }
+    }
 }

eda/eda_api/lib/module/predictions/predictions.router.ts

@@ -1,9 +1,10 @@
 import * as express from 'express';
-import { ArimaController } from './predictions.controller';
+import { PredictionsController } from './predictions.controller';
 import { authGuard } from '../../guards/auth-guard'; // opcional
 
 const router = express.Router();
 
-router.post('/predict', authGuard, ArimaController.predict);
+router.post('/predict', authGuard, PredictionsController.predictArima);
+router.post('/tensorflow/predict', authGuard, PredictionsController.predictTensorflow);
 
 export default router;