CDN-APP-INSIDER/routes/Dpanel/API/RenameFolder.js

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;