Enhancement - APP + API - Nueva página de inicio

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

@@ -14,27 +14,23 @@ const eda_api_config = require('../../../config/eda_api_config');
 export class DashboardController {
   static async getDashboards(req: Request, res: Response, next: NextFunction) {
     try {
-      let admin,
-        privates,
-        group,
-        publics,
-        shared = []
-      const groups = await Group.find({ users: { $in: req.user._id } }).exec()
-      const isAdmin = groups.filter(g => g.role === 'EDA_ADMIN_ROLE').length > 0
-      const isDataSourceCreator = groups.filter(g => g.name === 'EDA_DATASOURCE_CREATOR').length > 0
+      let admin, privates, group, publics, shared = [];
+      const groups = await Group.find({ users: { $in: req.user._id } }).exec();
+      const isAdmin = groups.filter(g => g.role === 'EDA_ADMIN_ROLE').length > 0;
+      const isDataSourceCreator = groups.filter(g => g.name === 'EDA_DATASOURCE_CREATOR').length > 0;
 
       if (isAdmin) {
-        admin = await DashboardController.getAllDashboardToAdmin()
-        publics = admin[0]
-        privates = admin[1]
-        group = admin[2]
-        shared = admin[3]
+        [publics, privates, group, shared] = await DashboardController.getAllDashboardToAdmin();
       } else {
-        privates = await DashboardController.getPrivateDashboards(req)
-        group = await DashboardController.getGroupsDashboards(req)
-        publics = await DashboardController.getPublicsDashboards()
-        shared = await DashboardController.getSharedDashboards()
+        privates = await DashboardController.getPrivateDashboards(req);
+        group = await DashboardController.getGroupsDashboards(req);
+        publics = await DashboardController.getPublicsDashboards();
+        shared = await DashboardController.getSharedDashboards();
       }
+
+      // Asegurarse de que la información del grupo esté incluida para dashboards de tipo "group"
+      group = await DashboardController.addGroupInfo(group);
+
       return res.status(200).json({
         ok: true,
         dashboards: privates,
@@ -43,22 +39,34 @@ export class DashboardController {
         shared,
         isAdmin,
         isDataSourceCreator
-      })
+      });
     } catch (err) {
-      console.log(err)
-      next(new HttpException(400, 'Some error ocurred loading dashboards'))
+      console.log(err);
+      next(new HttpException(400, 'Some error occurred loading dashboards'));
     }
   }
 
+  static async addGroupInfo(dashboards) {
+    for (const dashboard of dashboards) {
+      if (dashboard.group && Array.isArray(dashboard.group)) {
+        dashboard.group = await Group.find({ _id: { $in: dashboard.group } }, 'name').exec();
+      }
+    }
+    return dashboards;
+  }
+
   static async getPrivateDashboards(req: Request) {
     try {
       const dashboards = await Dashboard.find(
         { user: req.user._id },
-        'config.title config.visible config.tag config.onlyIcanEdit'
-      ).exec()
+        'config.title config.visible config.tag config.onlyIcanEdit config.description config.createdAt config.modifiedAt config.ds user'
+      ).populate('user','name').exec()
       const privates = []
       for (const dashboard of dashboards) {
         if (dashboard.config.visible === 'private') {
+          // Obtain the name of the data source
+          dashboard.config.ds.name = (await DataSource.findById(dashboard.config.ds._id, 'ds.metadata.model_name').exec())?.ds?.metadata?.model_name ?? 'N/A';
+
           privates.push(dashboard)
         }
       }
@@ -72,42 +80,33 @@ export class DashboardController {
     try {
       const userGroups = await Group.find({
         users: { $in: req.user._id }
-      }).exec()
+      }).exec();
       const dashboards = await Dashboard.find(
         { group: { $in: userGroups.map(g => g._id) } },
-        'config.title config.visible group config.tag config.onlyIcanEdit'
-      ).exec()
-      const groupDashboards = []
-      for (let i = 0, n = dashboards.length; i < n; i += 1) {
-        const dashboard = dashboards[i]
-        for (const dashboardGroup of dashboard.group) {
-          //dashboard.group = groups.filter(g => JSON.stringify(g._id) === JSON.stringify(group));
-          for (const userGroup of userGroups) {
-            if (
-              JSON.stringify(userGroup._id) === JSON.stringify(dashboardGroup)
-            ) {
-              groupDashboards.push(dashboard)
-            }
-          }
-        }
-      }
-      return groupDashboards
+        'config.title config.visible group config.tag config.onlyIcanEdit config.description config.createdAt config.ds user'
+      ).populate('user','name').exec()
+
+      // Añadir información de grupo aquí también
+      return DashboardController.addGroupInfo(dashboards);
     } catch (err) {
-      console.log(err)
-      throw new HttpException(400, 'Error loading groups dashboards')
+      console.log(err);
+      throw new HttpException(400, 'Error loading groups dashboards');
     }
   }
 
   static async getPublicsDashboards() {
     try {
       const dashboards = await Dashboard.find(
         {},
-        'config.title config.visible config.tag config.onlyIcanEdit'
-      ).exec()
+        'config.title config.visible config.tag config.onlyIcanEdit config.description config.createdAt config.modifiedAt config.ds user'
+      ).populate('user','name').exec()
       const publics = []
 
       for (const dashboard of dashboards) {
         if (dashboard.config.visible === 'public') {
+          // Obtain the name of the data source
+          dashboard.config.ds.name = (await DataSource.findById(dashboard.config.ds._id, 'ds.metadata.model_name').exec())?.ds?.metadata?.model_name ?? 'N/A';
+
           publics.push(dashboard)
         }
       }
@@ -121,11 +120,14 @@ export class DashboardController {
     try {
       const dashboards = await Dashboard.find(
         {},
-        'config.title config.visible config.tag config.onlyIcanEdit'
-      ).exec()
+        'config.title config.visible config.tag config.onlyIcanEdit config.description config.createdAt config.modifiedAt config.ds user'
+      ).populate('user','name').exec()
       const shared = []
       for (const dashboard of dashboards) {
         if (dashboard.config.visible === 'shared') {
+          // Obtain the name of the data source
+          dashboard.config.ds.name = (await DataSource.findById(dashboard.config.ds._id, 'ds.metadata.model_name').exec())?.ds?.metadata?.model_name ?? 'N/A';
+
           shared.push(dashboard)
         }
       }
@@ -137,36 +139,68 @@ export class DashboardController {
 
   static async getAllDashboardToAdmin() {
     try {
+
+
+      // Define the default date to be used for both createdAt and modifiedAt fields
+      const defaultDate = new Date('2024-01-01T00:00:00.000Z');
+
+      // First, update all documents that don't have a createdAt field
+      // This operation sets a default createdAt date for all dashboards missing this field
+      const createdAtUpdateResult = await Dashboard.updateMany(
+        { 'config.createdAt': { $exists: false } },
+        { $set: { 'config.createdAt': defaultDate } }
+      );
+
+      // Then, update all documents that don't have a modifiedAt field
+      // If createdAt exists, use its value; otherwise, use the default date
+      const modifiedAtUpdateResult = await Dashboard.updateMany(
+        { 'config.modifiedAt': { $exists: false } },
+        [
+          { 
+            $set: { 
+              'config.modifiedAt': { 
+                $ifNull: ['$config.createdAt', defaultDate] 
+              } 
+            } 
+          }
+        ]
+      );
+
+
+
       const dashboards = await Dashboard.find(
         {},
-        'user config.title config.visible group config.tag config.onlyIcanEdit'
+        'user config.title config.visible group config.tag config.onlyIcanEdit config.description config.createdAt config.modifiedAt config.ds'
       ).exec()
       const publics = []
       const privates = []
       const groups = []
       const shared = []
-
+  
       for (const dashboard of dashboards) {
+        // Buscar información del usuario para todos los dashboards
+        dashboard.user = await User.findById(
+          { _id: dashboard.user },
+          'name'
+        ).exec()
+        if (dashboard.user == null) {
+          dashboard.user = new User({
+            name: 'N/A',
+            email: '',
+            password: '',
+            img: '',
+            role: '',
+            active: ''
+          })
+        }
+
+          // Obtain the name of the data source
+          dashboard.config.ds.name = (await DataSource.findById(dashboard.config.ds._id, 'ds.metadata.model_name').exec())?.ds?.metadata?.model_name ?? 'N/A';
         switch (dashboard.config.visible) {
           case 'public':
             publics.push(dashboard)
             break
           case 'private':
-            dashboard.user = await User.findById(
-              { _id: dashboard.user },
-              'name'
-            ).exec()
-            if (dashboard.user == null) {
-              dashboard.user = new User(
-                {
-                  name: 'N/A',
-                  email: '',
-                  password: '',
-                  img: '',
-                  role: '',
-                  active: ''
-                })
-            };
             privates.push(dashboard)
             break
           case 'group':
@@ -178,7 +212,7 @@ export class DashboardController {
             break
         }
       }
-
+  
       return [publics, privates, groups, shared]
     } catch (err) {
       throw new HttpException(400, 'Error loading dashboards for admin')
@@ -395,12 +429,17 @@ export class DashboardController {
             new HttpException(400, 'Dashboard not exist with this id')
           )
         }
-
+        const createdAt=dashboard.config.createdAt
         dashboard.config = body.config
+        dashboard.config.createdAt = createdAt
         dashboard.group = body.group
         /**avoid dashboards without name */
         if (dashboard.config.title === null) { dashboard.config.title = '-' };
-
+
+        // Update modifiedAt with current date and time
+        dashboard.config.modifiedAt = new Date();
+
+
         dashboard.save((err, dashboard) => {
           if (err) {
             return next(new HttpException(500, 'Error updating dashboard'))
@@ -413,6 +452,62 @@ export class DashboardController {
       next(err)
     }
   }
+
+    /**
+     * Updates a specific field of a dashboard.
+     * 
+     * @param {Request} req - Express request object
+     * @param {Response} res - Express response object
+     * @param {NextFunction} next - Express next middleware function
+     * 
+     * @description
+     * Expects 'id' in req.params and 'data' (containing 'key' and 'newValue') in req.body.
+     * If 'config.visible' is updated to a value other than 'group', 'group' is set to an empty array.
+     * 
+     * @throws {HttpException} 400 for update errors, 404 if dashboard not found
+     */
+    static async updateSpecific(req: Request, res: Response, next: NextFunction) {
+      try {
+        const { id } = req.params;
+        const { data } = req.body;
+        const { key, newValue } = data;
+
+        let updateObj: any = { [key]: newValue };
+
+        if (key === 'config.visible' && newValue !== 'group') {
+          updateObj = {
+            ...updateObj,
+            group: []
+          };
+        }
+
+        Dashboard.findByIdAndUpdate(
+          id,
+          { $set: updateObj },
+          { new: true, runValidators: true },
+          (err, dashboard) => {
+            if (err) {
+              return next(
+                new HttpException(
+                  400,
+                  'Some error occurred while updating the dashboard'
+                )
+              );
+            }
+
+            if (!dashboard) {
+              return next(
+                new HttpException(404, 'Dashboard not found with this id')
+              );
+            }
+
+            return res.status(200).json({ ok: true, dashboard });
+          }
+        );
+      } catch (err) {
+        next(err);
+      }
+  }
 
   static async delete(req: Request, res: Response, next: NextFunction) {
     let options: QueryOptions = {}
@@ -1410,6 +1505,52 @@ export class DashboardController {
       data[1] = newRows
     }
   }
+
+  /**
+   * Clones an existing dashboard.
+   * 
+   * @param req - Express request object containing the dashboard ID to clone
+   * @param res - Express response object
+   * @param next - Express next function
+   * @returns A Promise that resolves with the cloned dashboard or rejects with an error
+   */
+  static async clone(req: Request, res: Response, next: NextFunction) {
+    try {
+      const dashboardId = req.params.id;
+      console.log('Attempting to clone dashboard with ID:', dashboardId);
+
+      // Find the original dashboard by ID
+      const originalDashboard = await Dashboard.findById(dashboardId).exec();
+
+      if (!originalDashboard) {
+        console.log('Original dashboard not found');
+        return next(new HttpException(404, 'Dashboard not found'));
+      }
+
+      // Create a new dashboard object with cloned properties
+      const clonedDashboard: IDashboard = new Dashboard({
+        config: {
+          ...originalDashboard.config,
+          title: `${originalDashboard.config.title} copy`, // Append 'copy' to the title
+          createdAt: new Date(),
+          modifiedAt: new Date()
+        },
+        user: req.user._id, // Set the current user as the owner of the cloned dashboard
+        group: originalDashboard.group // Maintain the same group permissions
+      });
+
+
+      // Save the cloned dashboard to the database
+      const savedDashboard = await clonedDashboard.save();
+      console.log('Cloned dashboard saved:', savedDashboard);
+
+      // Return the saved cloned dashboard with a 201 (Created) status
+      return res.status(201).json({ ok: true, dashboard: savedDashboard });
+    } catch (err) {
+      console.error('Error cloning dashboard:', err);
+      next(new HttpException(500, 'Error cloning dashboard'));
+    }
+}
 
   static async cleanDashboardCache(
     req: Request,

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

@@ -24,4 +24,8 @@ router.put('/:id', authGuard, DashboardController.update);
 
 router.delete('/:id', authGuard, DashboardController.delete);
 
+/*SDA CUSTOM*/ router.put('/:id/updateSpecific', authGuard, DashboardController.updateSpecific);
+
+/*SDA CUSTOM*/ router.post('/:id/clone', authGuard, DashboardController.clone);
+
 export default router;