Update v1.1.1-beta1

routes/Dpanel/API/Collaboration.js

@@ -0,0 +1,358 @@
+const express = require('express');
+const router = express.Router();
+const path = require('path');
+const fs = require('fs').promises;
+const { logger } = require('../../../config/logs');
+
+const collaborationFilePath = path.join(__dirname, '../../../data', 'collaboration.json');
+
+// Fonction utilitaire pour lire le fichier de collaboration
+async function readCollaborationFile() {
+    try {
+        const exists = await fs.access(collaborationFilePath)
+            .then(() => true)
+            .catch(() => false);
+
+        if (!exists) {
+            await fs.writeFile(collaborationFilePath, JSON.stringify({ activeFiles: {} }));
+            return { activeFiles: {} };
+        }
+
+        const data = await fs.readFile(collaborationFilePath, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        logger.error('Error reading collaboration file:', error);
+        return { activeFiles: {} };
+    }
+}
+
+// Fonction utilitaire pour écrire dans le fichier de collaboration
+async function writeCollaborationFile(data) {
+    try {
+        await fs.writeFile(collaborationFilePath, JSON.stringify(data, null, 2));
+        return true;
+    } catch (error) {
+        logger.error('Error writing collaboration file:', error);
+        return false;
+    }
+}
+
+router.post('/toggle', async (req, res) => {
+    try {
+        const { itemName, itemType, enable } = req.body;
+        
+        // Lire ou créer le fichier de collaboration
+        let collaborationData = await readCollaborationFile();
+
+        // S'assurer que la structure est correcte
+        if (!collaborationData.activeFiles) {
+            collaborationData.activeFiles = {};
+        }
+
+        // Mettre à jour le statut de collaboration
+        const itemId = `${itemType}-${itemName}`;
+        if (enable) {
+            collaborationData.activeFiles[itemId] = {
+                name: itemName,
+                type: itemType,
+                isCollaborative: true,
+                activeUsers: [],
+                lastModified: new Date().toISOString()
+            };
+        } else {
+            delete collaborationData.activeFiles[itemId];
+        }
+
+        // Sauvegarder les changements
+        await writeCollaborationFile(collaborationData);
+
+        // Notifier via WebSocket si disponible
+        if (req.app.get('wsManager')) {
+            req.app.get('wsManager').broadcast({
+                type: 'collaborationStatus',
+                itemName,
+                itemType,
+                isCollaborative: enable,
+                activeUsers: collaborationData.activeFiles[itemId]?.activeUsers || []
+            });
+        }
+
+        res.json({ 
+            success: true, 
+            isCollaborative: enable,
+            activeUsers: collaborationData.activeFiles[itemId]?.activeUsers || []
+        });
+
+    } catch (error) {
+        logger.error('Error in collaboration toggle:', error);
+        res.status(500).json({ 
+            success: false, 
+            error: 'Internal server error' 
+        });
+    }
+});
+
+// Route pour obtenir le statut d'un fichier
+router.get('/file-status/:fileId', async (req, res) => {
+    try {
+        const { fileId } = req.params;
+        const collaboration = await readCollaborationFile();
+        
+        res.json({
+            fileId,
+            isCollaborative: true,
+            activeUsers: collaboration.activeFiles[fileId]?.activeUsers || [],
+            lastModified: collaboration.activeFiles[fileId]?.lastModified || null
+        });
+    } catch (error) {
+        logger.error('Error getting file status:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+router.get('/searchuser', async (req, res) => {
+    try {
+        const { username } = req.query;
+        const userFilePath = path.join(__dirname, '../../../data', 'user.json');
+        const users = JSON.parse(await fs.readFile(userFilePath, 'utf8'));
+        
+        const user = users.find(u => u.name.toLowerCase() === username.toLowerCase());
+        
+        if (user) {
+            res.json({
+                found: true,
+                user: {
+                    id: user.id,
+                    name: user.name,
+                    profilePicture: user.profilePicture
+                }
+            });
+        } else {
+            res.json({ found: false });
+        }
+    } catch (error) {
+        logger.error('Error searching user:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour rejoindre un fichier
+router.post('/join', async (req, res) => {
+    try {
+        const { itemName, itemType, userId } = req.body;
+        const collaboration = await readCollaborationFile();
+        
+        const itemId = `${itemType}-${itemName}`;
+        
+        if (!collaboration.activeFiles[itemId]) {
+            collaboration.activeFiles[itemId] = {
+                name: itemName,
+                type: itemType,
+                isCollaborative: true,
+                activeUsers: [],
+                lastModified: new Date().toISOString()
+            };
+        }
+
+        // Ajouter l'utilisateur si pas déjà présent
+        if (!collaboration.activeFiles[itemId].activeUsers.find(u => u.id === userId)) {
+            // Récupérer les infos de l'utilisateur
+            const userFilePath = path.join(__dirname, '../../../data', 'user.json');
+            const users = JSON.parse(await fs.readFile(userFilePath, 'utf8'));
+            const user = users.find(u => u.id === userId);
+
+            if (user) {
+                collaboration.activeFiles[itemId].activeUsers.push({
+                    id: user.id,
+                    name: user.name,
+                    profilePicture: user.profilePicture,
+                    lastActive: new Date().toISOString()
+                });
+
+                await writeCollaborationFile(collaboration);
+
+                // Notifier via WebSocket
+                if (req.app.get('wsManager')) {
+                    req.app.get('wsManager').broadcast({
+                        type: 'collaborationStatus',
+                        itemName,
+                        itemType,
+                        isCollaborative: true,
+                        activeUsers: collaboration.activeFiles[itemId].activeUsers
+                    });
+                }
+            }
+        }
+
+        res.json({ success: true });
+    } catch (error) {
+        logger.error('Error in join collaboration:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour ajouter un collaborateur
+router.post('/add', async (req, res) => {
+    try {
+        const { itemName, itemType, userId } = req.body;
+        const collaboration = await readCollaborationFile();
+        
+        const itemId = `${itemType}-${itemName}`;
+        
+        if (!collaboration.activeFiles[itemId]) {
+            return res.status(404).json({ error: 'Item not found in collaboration' });
+        }
+
+        // Vérifier si l'utilisateur n'est pas déjà dans la liste
+        if (!collaboration.activeFiles[itemId].activeUsers.find(u => u.id === userId)) {
+            // Récupérer les infos de l'utilisateur
+            const userFilePath = path.join(__dirname, '../../../data', 'user.json');
+            const users = JSON.parse(await fs.readFile(userFilePath, 'utf8'));
+            const user = users.find(u => u.id === userId);
+
+            if (user) {
+                collaboration.activeFiles[itemId].activeUsers.push({
+                    id: user.id,
+                    name: user.name,
+                    profilePicture: user.profilePicture,
+                    lastActive: new Date().toISOString()
+                });
+
+                await writeCollaborationFile(collaboration);
+
+                // Notifier via WebSocket
+                if (req.app.get('wsManager')) {
+                    req.app.get('wsManager').broadcast({
+                        type: 'collaborationStatus',
+                        itemName,
+                        itemType,
+                        isCollaborative: true,
+                        activeUsers: collaboration.activeFiles[itemId].activeUsers
+                    });
+                }
+
+                res.json({ success: true });
+            } else {
+                res.status(404).json({ error: 'User not found' });
+            }
+        } else {
+            res.status(400).json({ error: 'User already in collaboration' });
+        }
+    } catch (error) {
+        logger.error('Error adding collaborator:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour retirer un collaborateur
+router.post('/remove', async (req, res) => {
+    try {
+        const { itemName, itemType, userId } = req.body;
+        const collaboration = await readCollaborationFile();
+        
+        const itemId = `${itemType}-${itemName}`;
+        
+        if (!collaboration.activeFiles[itemId]) {
+            return res.status(404).json({ error: 'Item not found in collaboration' });
+        }
+
+        // Retirer l'utilisateur de la liste
+        collaboration.activeFiles[itemId].activeUsers = 
+            collaboration.activeFiles[itemId].activeUsers.filter(user => user.id !== userId);
+
+        await writeCollaborationFile(collaboration);
+
+        // Notifier via WebSocket
+        if (req.app.get('wsManager')) {
+            req.app.get('wsManager').broadcast({
+                type: 'collaborationStatus',
+                itemName,
+                itemType,
+                isCollaborative: true,
+                activeUsers: collaboration.activeFiles[itemId].activeUsers
+            });
+        }
+
+        res.json({ success: true });
+    } catch (error) {
+        logger.error('Error removing collaborator:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour quitter un fichier
+router.post('/leave', async (req, res) => {
+    try {
+        const { fileId } = req.body;
+        const userId = req.user.id;
+
+        if (!fileId || !userId) {
+            return res.status(400).json({ error: 'FileId and userId are required' });
+        }
+
+        const collaboration = await readCollaborationFile();
+        
+        if (collaboration.activeFiles[fileId]) {
+            collaboration.activeFiles[fileId].activeUsers = 
+                collaboration.activeFiles[fileId].activeUsers.filter(user => user.id !== userId);
+            
+            if (collaboration.activeFiles[fileId].activeUsers.length === 0) {
+                delete collaboration.activeFiles[fileId];
+            }
+
+            await writeCollaborationFile(collaboration);
+            if (req.app.get('wsManager')) {
+                req.app.get('wsManager').broadcastFileStatus(fileId);
+            }
+        }
+
+        res.json({ success: true });
+    } catch (error) {
+        logger.error('Error leaving file:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+router.get('/status', async (req, res) => {
+    try {
+        const collaboration = await readCollaborationFile();
+        res.json({ items: collaboration.activeFiles });
+    } catch (error) {
+        logger.error('Error getting collaboration status:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour obtenir les détails d'un élément collaboratif
+router.get('/details/:type/:name', async (req, res) => {
+    try {
+        const { type, name } = req.params;
+        const collaboration = await readCollaborationFile();
+        const itemId = `${type}-${name}`;
+        
+        res.json(collaboration.activeFiles[itemId] || { 
+            isCollaborative: false, 
+            activeUsers: [] 
+        });
+    } catch (error) {
+        logger.error('Error getting collaboration details:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// Route pour obtenir les utilisateurs actifs d'un élément
+router.get('/users/:type/:name', async (req, res) => {
+    try {
+        const { type, name } = req.params;
+        const collaboration = await readCollaborationFile();
+        const itemId = `${type}-${name}`;
+        
+        const activeUsers = collaboration.activeFiles[itemId]?.activeUsers || [];
+        res.json({ users: activeUsers });
+    } catch (error) {
+        logger.error('Error getting active users:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+module.exports = router;

routes/Dpanel/API/MoveFile.js

@@ -141,13 +141,48 @@ router.get('/', (req, res) => {
 });
 
 router.post('/', authenticateToken, async (req, res) => {
+    console.log('MoveFile API - Raw request body:', req.body);
+    console.log('MoveFile API - Request body keys:', Object.keys(req.body));
+    
     const fileName = req.body.fileName;
     const folderName = req.body.folderName;
 
-    if (!fileName || fileName.trim() === '') {
+    console.log('MoveFile API - Received data:', {
+        fileName: fileName,
+        folderName: folderName,
+        typeOfFileName: typeof fileName,
+        typeOfFolderName: typeof folderName,
+        fileNameStringified: JSON.stringify(fileName),
+        folderNameStringified: JSON.stringify(folderName),
+        fullBody: req.body
+    });
+
+    // Forcer la conversion en string si ce sont des objets
+    let finalFileName = fileName;
+    let finalFolderName = folderName;
+    
+    if (typeof fileName === 'object' && fileName !== null) {
+        console.log('fileName is an object, attempting conversion:', fileName);
+        finalFileName = String(fileName);
+        console.log('Converted fileName to:', finalFileName, typeof finalFileName);
+    }
+    
+    if (typeof folderName === 'object' && folderName !== null) {
+        console.log('folderName is an object, attempting conversion:', folderName);
+        finalFolderName = String(folderName);
+        console.log('Converted folderName to:', finalFolderName, typeof finalFolderName);
+    }
+
+    if (!finalFileName || (typeof finalFileName === 'string' && finalFileName.trim() === '')) {
         return res.status(400).json({ error: 'No file selected for moving.' });
     }
 
+    // Vérifier que folderName est une chaîne de caractères
+    if (finalFolderName && typeof finalFolderName !== 'string') {
+        console.error('folderName is not a string after conversion:', finalFolderName, typeof finalFolderName);
+        return res.status(400).json({ error: 'Invalid folder name format.' });
+    }
+
     try {
         const data = await fs.promises.readFile(path.join(__dirname, '../../../data', 'user.json'), 'utf-8');
         const users = JSON.parse(data);
@@ -160,21 +195,21 @@ router.post('/', authenticateToken, async (req, res) => {
 
         const userId = user.name;
 
-        if (!fileName || !userId) {
-            console.error('fileName or userId is undefined');
+        if (!finalFileName || !userId) {
+            console.error('finalFileName or userId is undefined');
             return res.status(500).json({ error: 'Error moving the file.' });
         }
 
-        const sourcePath = path.join('cdn-files', userId, fileName);
+        const sourcePath = path.join('cdn-files', userId, finalFileName);
 
         let destinationDir;
-        if (folderName && folderName.trim() !== '') {
-            destinationDir = path.join('cdn-files', userId, folderName);
+        if (finalFolderName && finalFolderName.trim() !== '') {
+            destinationDir = path.join('cdn-files', userId, finalFolderName);
         } else {
             destinationDir = path.join('cdn-files', userId);
         }
 
-        const destinationPath = path.join(destinationDir, fileName);
+        const destinationPath = path.join(destinationDir, finalFileName);
 
         if (!destinationPath.startsWith(path.join('cdn-files', userId))) {
             return res.status(403).json({ error: 'Unauthorized: Cannot move file outside of user directory.' });

routes/Dpanel/API/RenameFolder.js

@@ -0,0 +1,205 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+const authMiddleware = require('../../../Middlewares/authMiddleware');
+const { logger, logRequestInfo, ErrorLogger, authLogger } = require('../../../config/logs');
+const bodyParser = require('body-parser');
+
+router.use(bodyParser.json());
+
+/**
+ * @swagger
+ * /folders/rename:
+ *   post:
+ *     security:
+ *       - bearerAuth: []
+ *     tags:
+ *       - Folder
+ *     summary: Rename a folder
+ *     description: This route allows you to rename a folder. It requires authentication.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               oldName:
+ *                 type: string
+ *                 description: The current name of the folder
+ *               newName:
+ *                 type: string
+ *                 description: The new name for the folder
+ *     responses:
+ *       200:
+ *         description: Success
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 message:
+ *                   type: string
+ *       400:
+ *         description: Bad Request
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 message:
+ *                   type: string
+ *       401:
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *       403:
+ *         description: Forbidden
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 message:
+ *                   type: string
+ *       404:
+ *         description: Folder not found
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 message:
+ *                   type: string
+ *       500:
+ *         description: Internal server error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 message:
+ *                   type: string
+ */
+
+router.post('/', authMiddleware, async (req, res) => {
+    try {
+        const userId = req.userData.name;
+        const { oldName, newName } = req.body;
+
+        // Validation des paramètres
+        if (!oldName || !newName) {
+            return res.status(400).json({
+                success: false,
+                message: 'Les noms de dossier ancien et nouveau sont requis.'
+            });
+        }
+
+        if (typeof oldName !== 'string' || typeof newName !== 'string') {
+            return res.status(400).json({
+                success: false,
+                message: 'Les noms de dossier doivent être des chaînes de caractères.'
+            });
+        }
+
+        // Nettoyer les noms (éviter les traversées de répertoire)
+        const sanitizedOldName = path.basename(oldName.trim());
+        const sanitizedNewName = path.basename(newName.trim());
+
+        if (!sanitizedOldName || !sanitizedNewName) {
+            return res.status(400).json({
+                success: false,
+                message: 'Les noms de dossier ne peuvent pas être vides.'
+            });
+        }
+
+        // Construire les chemins
+        const userDir = path.join('cdn-files', userId);
+        const oldFolderPath = path.join(userDir, sanitizedOldName);
+        const newFolderPath = path.join(userDir, sanitizedNewName);
+
+        // Vérifier que les chemins sont dans le répertoire de l'utilisateur
+        if (!oldFolderPath.startsWith(userDir) || !newFolderPath.startsWith(userDir)) {
+            ErrorLogger.error(`Unauthorized directory access attempt by user ${userId}`);
+            return res.status(403).json({
+                success: false,
+                message: 'Accès non autorisé.'
+            });
+        }
+
+        // Vérifier que le dossier source existe
+        if (!fs.existsSync(oldFolderPath)) {
+            return res.status(404).json({
+                success: false,
+                message: 'Le dossier à renommer n\'existe pas.'
+            });
+        }
+
+        // Vérifier que c'est bien un dossier
+        const stats = await fs.promises.stat(oldFolderPath);
+        if (!stats.isDirectory()) {
+            return res.status(400).json({
+                success: false,
+                message: 'Le chemin spécifié n\'est pas un dossier.'
+            });
+        }
+
+        // Vérifier que le nouveau nom n'existe pas déjà
+        if (fs.existsSync(newFolderPath)) {
+            return res.status(400).json({
+                success: false,
+                message: 'Un dossier avec ce nom existe déjà.'
+            });
+        }
+
+        // Renommer le dossier
+        await fs.promises.rename(oldFolderPath, newFolderPath);
+
+        logger.info(`Folder renamed successfully by user ${userId}: ${sanitizedOldName} -> ${sanitizedNewName}`);
+
+        res.status(200).json({
+            success: true,
+            message: 'Dossier renommé avec succès.'
+        });
+
+    } catch (error) {
+        ErrorLogger.error('Error renaming folder:', error);
+        
+        if (error.code === 'ENOENT') {
+            return res.status(404).json({
+                success: false,
+                message: 'Le dossier spécifié n\'existe pas.'
+            });
+        }
+        
+        if (error.code === 'EACCES') {
+            return res.status(403).json({
+                success: false,
+                message: 'Permission refusée pour renommer ce dossier.'
+            });
+        }
+
+        return res.status(500).json({
+            success: false,
+            message: 'Erreur lors du renommage du dossier.'
+        });
+    }
+});
+
+module.exports = router;

routes/Dpanel/API/RevokeToken.js

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const path = require('path');
+const router = require('express').Router();
+
+router.post('/', (req, res) => {
+  if (!req.body.userId) {
+    return res.status(400).json({ 
+      error: 'Bad Request. User ID is required.' 
+    });
+  }
+
+  fs.readFile(path.join(__dirname, '../../../data', 'user.json'), 'utf8', (err, data) => {
+    if (err) {
+      console.error('Error reading user.json:', err);
+      return res.status(500).json({ 
+        error: 'Internal server error while reading user data.' 
+      });
+    }
+
+    try {
+      const users = JSON.parse(data);
+
+      // Trouver l'utilisateur par ID
+      const userIndex = users.findIndex(u => u.id === req.body.userId);
+
+      if (userIndex === -1) {
+        return res.status(404).json({ 
+          error: 'User not found.' 
+        });
+      }
+
+      // Supprimer le token de l'utilisateur
+      if (users[userIndex].token) {
+        delete users[userIndex].token;
+      } else {
+        return res.status(404).json({ 
+          error: 'No API key found for this user.' 
+        });
+      }
+
+      // Sauvegarder les modifications
+      fs.writeFile(path.join(__dirname, '../../../data', 'user.json'), JSON.stringify(users, null, 2), (err) => {
+        if (err) {
+          console.error('Error writing user.json:', err);
+          return res.status(500).json({ 
+            error: 'Internal server error while saving user data.' 
+          });
+        }
+
+        res.json({ 
+          success: true,
+          message: 'API key successfully revoked.' 
+        });
+      });
+    } catch (parseErr) {
+      console.error('Error parsing user.json:', parseErr);
+      return res.status(500).json({ 
+        error: 'Internal server error while parsing user data.' 
+      });
+    }
+  });
+});
+
+module.exports = router;

routes/Dpanel/API/UserSearch.js

@@ -0,0 +1,98 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const router = express.Router();
+const authMiddleware = require('../../../Middlewares/authMiddleware');
+const { logger } = require('../../../config/logs');
+
+/**
+ * @swagger
+ * /api/dpanel/users/search:
+ *   get:
+ *     tags:
+ *       - Users
+ *     summary: Search for users by name or ID
+ *     parameters:
+ *       - in: query
+ *         name: term
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Search term (name or ID)
+ *       - in: query
+ *         name: username
+ *         required: false
+ *         schema:
+ *           type: string
+ *         description: Exact username to search for
+ *     responses:
+ *       200:
+ *         description: Search results
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 users:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       name:
+ *                         type: string
+ *                       profilePicture:
+ *                         type: string
+ *                 found:
+ *                   type: boolean
+ *                 user:
+ *                   type: object
+ *       500:
+ *         description: Internal server error
+ */
+
+router.get('/', authMiddleware, async (req, res) => {
+    try {
+        const { term, username } = req.query;
+        const userFilePath = path.join(__dirname, '../../../data', 'user.json');
+        const users = JSON.parse(fs.readFileSync(userFilePath, 'utf8'));
+
+        if (username) {
+            // Search for exact username match (for collaboration search)
+            const user = users.find(u => u.name.toLowerCase() === username.toLowerCase());
+            if (user) {
+                res.json({
+                    found: true,
+                    user: {
+                        id: user.id,
+                        name: user.name,
+                        profilePicture: user.profilePicture
+                    }
+                });
+            } else {
+                res.json({ found: false });
+            }
+        } else if (term) {
+            // Search for users by term (for general user search)
+            const searchTerm = term.toLowerCase();
+            const filteredUsers = users.filter(user => 
+                user.name.toLowerCase().includes(searchTerm) || 
+                user.id.toLowerCase().includes(searchTerm)
+            ).map(user => ({
+                id: user.id,
+                name: user.name,
+                profilePicture: user.profilePicture
+            }));
+
+            res.json({ users: filteredUsers });
+        } else {
+            res.status(400).json({ error: 'Search term or username required' });
+        }
+    } catch (error) {
+        logger.error('Error searching users:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+module.exports = router;

routes/Dpanel/Dashboard/index.js

@@ -6,95 +6,146 @@ const fileUpload = require('express-fileupload');
 const authMiddleware = require('../../../Middlewares/authMiddleware');
 const { loggers } = require('winston');
 const ncp = require('ncp').ncp;
-let configFile = fs.readFileSync(path.join(__dirname, '../../../data', 'setup.json'), 'utf-8')
-let config = JSON.parse(configFile)[0];
 const bodyParser = require('body-parser');
 const crypto = require('crypto');
 const os = require('os');
 const { getUserData, getSetupData } = require('../../../Middlewares/watcherMiddleware');
 
+let configFile = fs.readFileSync(path.join(__dirname, '../../../data', 'setup.json'), 'utf-8');
+let config = JSON.parse(configFile)[0];
 let setupData = getSetupData();
 let userData = getUserData();
+
+// Fonction utilitaire pour lire le fichier de collaboration
+async function getCollaborativeAccess(userId) {
+    try {
+        const collaborationFilePath = path.join(__dirname, '../../../data', 'collaboration.json');
+        if (!fs.existsSync(collaborationFilePath)) {
+            return [];
+        }
+        const data = JSON.parse(await fs.promises.readFile(collaborationFilePath, 'utf8'));
+        
+        const sharedFolders = [];
+
+        for (const [itemId, item] of Object.entries(data.activeFiles)) {
+            // Ne chercher que les utilisateurs qui ne sont pas le propriétaire
+            if (item.type === 'folder' && 
+                item.isCollaborative && 
+                item.activeUsers.some(u => u.id === userId)) {
+                
+                // Extraire le nom du propriétaire du dossier depuis cdn-files
+                const folderPath = item.name;
+                const ownerFolder = path.join(__dirname, '../../../cdn-files');
+                
+                // Parcourir tous les dossiers utilisateurs
+                const users = await fs.promises.readdir(ownerFolder);
+                for (const user of users) {
+                    const userFolderPath = path.join(ownerFolder, user, folderPath);
+                    if (fs.existsSync(userFolderPath)) {
+                        sharedFolders.push({
+                            originalPath: `${user}/${folderPath}`,
+                            displayName: `${user}/${folderPath}`,
+                            owner: user,
+                            folderName: folderPath,
+                            activeUsers: item.activeUsers
+                        });
+                        break; // On a trouvé le propriétaire, on peut arrêter
+                    }
+                }
+            }
+        }
+        return sharedFolders;
+    } catch (error) {
+        console.error('Error getting collaborative access:', error);
+        return [];
+    }
+}
+
 router.use(bodyParser.json());
 
 router.get('/', authMiddleware, async (req, res) => {
     const folderName = req.params.folderName || '';  
-    
+   
     if (!req.userData || !req.userData.name) {
         return res.render('error-recovery-file', { error: 'User data is undefined or incomplete' });
     }
 
-    const userId = req.userData.id; 
+    const userId = req.userData.id;
     const userName = req.userData.name;
     const downloadDir = path.join('cdn-files', userName);
     const domain = config.domain || 'swiftlogic-labs.com';
 
-    if (!config.domain) {
-        console.error('Domain is not defined in setup.json');
-        config.domain = 'swiftlogic-labs.com';
-    }
-
     if (!fs.existsSync(downloadDir)) {
         fs.mkdirSync(downloadDir, { recursive: true });
     }
 
     try {
-        fs.accessSync(downloadDir, fs.constants.R_OK | fs.constants.W_OK);
-    } catch (err) {
-        console.error('No access!', err);
-        return res.render('error-recovery-file', { error: 'No access to directory' });
-    }
-
-    let fileInfoNames = [];
-    try {
-        const fileInfo = JSON.parse(fs.readFileSync(path.join(__dirname, '../../../data', 'setup.json'), 'utf-8'))
-        
-        if (!Array.isArray(fileInfo)) {
-            console.error('fileInfo is not an array. Check the contents of file_info.json');
-        } else {
-            fileInfoNames = fileInfo.map(file => file.fileName);
-        }
-    } catch (err) {
-        console.error('Error reading file_info.json:', err);
-    }
-
-    try {
+        // Lire les fichiers du répertoire de l'utilisateur
         const files = await fs.promises.readdir(downloadDir);
-
-        const folders = files.filter(file => fs.statSync(path.join(downloadDir, file)).isDirectory());
-
-        const fileDetails = files.map(file => {
+        
+        // Séparer les fichiers et les dossiers
+        const fileDetails = await Promise.all(files.map(async file => {
             const filePath = path.join(downloadDir, file);
-            const stats = fs.statSync(filePath);
-            const fileExtension = path.extname(file).toLowerCase();
+            const stats = await fs.promises.stat(filePath);
+            const isDirectory = stats.isDirectory();
+            const fileExtension = isDirectory ? null : path.extname(file).toLowerCase();
             const encodedFileName = encodeURIComponent(file);
-            const fileLink = `https://${domain}/attachments/${userId}/${encodedFileName}`;
-
-            const fileType = stats.isDirectory() ? 'folder' : 'file';
-
+            const fileLink = isDirectory ? null : `https://${domain}/attachments/${userId}/${encodedFileName}`;
+            
             return {
                 name: file,
                 size: stats.size,
                 url: fileLink,
                 extension: fileExtension,
-                type: fileType
+                type: isDirectory ? 'folder' : 'file',
+                isPersonal: true,
+                owner: userName,
+                isCollaborative: false,
+                activeUsers: []
             };
+        }));
+
+        // Séparer les dossiers personnels et les fichiers
+        const personalFolders = fileDetails.filter(item => item.type === 'folder');
+        const personalFiles = fileDetails.filter(item => item.type === 'file');
+        
+        // Obtenir les dossiers partagés
+        const sharedFolders = await getCollaborativeAccess(userId);
+
+        // Formater les dossiers partagés
+        const sharedFolderDetails = sharedFolders.map(folder => ({
+            name: folder.displayName,
+            type: 'shared-folder',
+            isCollaborative: true,
+            originalPath: folder.originalPath,
+            owner: folder.owner,
+            folderName: folder.folderName,
+            activeUsers: folder.activeUsers
+        }));
+
+        // Combiner tous les éléments dans l'ordre souhaité
+        const allItems = [
+            ...personalFolders,     // Dossiers personnels en premier
+            ...sharedFolderDetails, // Puis les dossiers partagés
+            ...personalFiles        // Et enfin les fichiers
+        ];
+
+        const availableExtensions = Array.from(new Set(
+            allItems
+                .filter(item => item.type === 'file')
+                .map(file => file.extension)
+        ));
+
+        res.render('dashboard', {
+            files: allItems,            // Liste complète pour la compatibilité
+            folders: personalFolders,   // Uniquement les dossiers personnels
+            extensions: availableExtensions,
+            allFolders: personalFolders,
+            folderName: folderName,
+            fileInfoNames: [],
+            userData: userData,
+            sharedFolders: sharedFolderDetails  // Les dossiers partagés séparément
         });
-
-        function formatFileSize(fileSizeInBytes) {
-            if (fileSizeInBytes < 1024 * 1024) {
-                return `${(fileSizeInBytes / 1024).toFixed(2)} Ko`;
-            } else if (fileSizeInBytes < 1024 * 1024 * 1024) {
-                return `${(fileSizeInBytes / (1024 * 1024)).toFixed(2)} Mo`;
-            } else {
-                return `${(fileSizeInBytes / (1024 * 1024 * 1024)).toFixed(2)} Go`;
-            }
-        }
-
-
-        const availableExtensions = Array.from(new Set(fileDetails.map(file => file.extension)));
-
-        res.render('dashboard', { files: fileDetails, folders, extensions: availableExtensions, allFolders: folders, folderName: folderName, fileInfoNames: fileInfoNames, userData: userData });
     } catch (err) {
         console.error('Error reading directory:', err);
         return res.render('error-recovery-file', { error: err.message });

routes/Dpanel/Folder/index.js

@@ -17,6 +17,90 @@ let setupData = getSetupData();
 let userData = getUserData();
 router.use(bodyParser.json());
 
+router.get('/shared/:ownerName/:folderName', authMiddleware, async (req, res) => {
+    const { ownerName, folderName } = req.params;
+    const userId = req.userData.id;
+    const userName = req.userData.name;
+
+    try {
+        // Vérifier l'accès collaboratif
+        const collaborationFilePath = path.join(__dirname, '../../../data', 'collaboration.json');
+        const collaborationData = JSON.parse(await fs.promises.readFile(collaborationFilePath, 'utf8'));
+        
+        const itemId = `folder-${folderName}`;
+        const folderInfo = collaborationData.activeFiles[itemId];
+        
+        if (!folderInfo || !folderInfo.isCollaborative || 
+            !folderInfo.activeUsers.some(u => u.id === userId)) {
+            return res.status(403).render('error-recovery-file', { 
+                error: 'Vous n\'avez pas accès à ce dossier.'
+            });
+        }
+
+        // Accès au dossier partagé
+        const folderPath = path.join('cdn-files', ownerName, folderName);
+        const userFolderPath = path.join('cdn-files', ownerName);
+        const domain = config.domain || 'swiftlogic-labs.com';
+
+        // Lecture des fichiers
+        const entries = await fs.promises.readdir(folderPath, { withFileTypes: true });
+        const allEntries = await fs.promises.readdir(userFolderPath, { withFileTypes: true });
+
+        const folders = entries
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+
+        const allFolders = allEntries
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+
+        // Lecture des informations de fichiers
+        const fileInfoData = await fs.promises.readFile(
+            path.join(__dirname, '../../../data', 'file_info.json'), 
+            'utf-8'
+        );
+        const fileInfo = JSON.parse(fileInfoData);
+        const fileInfoNames = fileInfo.map(file => file.fileName);
+
+        // Récupération des détails des fichiers
+        const fileDetails = await Promise.all(entries.map(async entry => {
+            const filePath = path.join(folderPath, entry.name);
+            const stats = await fs.promises.stat(filePath);
+            const encodedFileName = encodeURIComponent(entry.name);
+            const fileLink = `https://${domain}/attachments/${ownerName}/${encodedFileName}`;
+
+            return {
+                name: entry.name,
+                size: stats.size,
+                url: fileLink,
+                extension: path.extname(entry.name).toLowerCase(),
+                type: entry.isDirectory() ? 'folder' : 'file'
+            };
+        }));
+
+        const availableExtensions = Array.from(new Set(fileDetails.map(file => file.extension)));
+
+        res.render('folder', {
+            files: fileDetails,
+            folders,
+            allFolders,
+            extensions: availableExtensions,
+            currentFolder: folderName,
+            folderName,
+            fileInfoNames,
+            userName,
+            isSharedFolder: true,
+            ownerName
+        });
+
+    } catch (error) {
+        console.error('Error accessing shared folder:', error);
+        res.status(500).render('error-recovery-file', { 
+            error: 'Erreur lors de l\'accès au dossier partagé'
+        });
+    }
+});
+
 router.get('/:folderName', authMiddleware, async (req, res) => {
     const userId = req.userData.name;
     const userName = req.userData.name;