CDN-APP-INSIDER/routes/Dpanel/Folder/index.js

const express = require('express');
const fs = require('fs');
const path = require('path');
const router = express.Router();
const fileUpload = require('express-fileupload');
const authMiddleware = require('../../../Middlewares/authMiddleware');
const { loggers } = require('winston');
const ncp = require('ncp').ncp;
const configFile = fs.readFileSync(path.join(__dirname, '../../../data', 'setup.json'), 'utf-8')
const 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 setupData = getSetupData();
let userData = getUserData();
router.use(bodyParser.json());

router.get('/:folderName', authMiddleware, async (req, res) => {
    const userId = req.userData.name;
    const userName = req.userData.name;
    const folderName = req.params.folderName || '';    
    const folderPath = path.join('cdn-files', userId, folderName);
    const userFolderPath = path.join('cdn-files', userId);
    const domain = config.domain || 'swiftlogic-labs.com';
    const currentFolderName = folderName || '';

    const data = await fs.readFileSync(path.join(__dirname, '../../../data', 'user.json'), 'utf-8')
    let users;
    try {
        users = JSON.parse(data);
    } catch (error) {
        console.error('Error parsing user.json:', error);
        users = [];
    }

    if (!Array.isArray(users)) {
        console.error('Error: users is not an array. Check the contents of setup.json');
        users = [];
    }

    const user = users.find(user => user.name === userId);

    if (!user) {
        console.error(`User with ID ${userId} not found in user.json`);
        return res.status(500).send(`User with ID ${userId} not found in user.json`);
    }

    const userRealId = user.id;

    const fileInfoData = await fs.readFileSync(path.join(__dirname, '../../../data', 'file_info.json'), 'utf-8')
    let fileInfo;
    try {
        fileInfo = JSON.parse(fileInfoData);
    } catch (error) {
        console.error('Error parsing file_info.json:', error);
        fileInfo = [];
    }

    if (!Array.isArray(fileInfo)) {
        console.error('Error: fileInfo is not an array. Check the contents of file_info.json');
        fileInfo = []; 
    }

    const fileInfoNames = fileInfo.map(file => file.fileName);

    fs.readdir(folderPath, { withFileTypes: true }, (err, entries) => {
        if (err) {
            console.error('Error reading directory:', err);
            return res.render('error-recovery-file');
        }

        const folders = entries
            .filter(entry => entry.isDirectory())
            .map(entry => entry.name);

        fs.readdir(userFolderPath, { withFileTypes: true }, (err, allEntries) => {
            if (err) {
                console.error('Error reading user directory:', err);
                return res.render('error-recovery-file');
            }

            const allFolders = allEntries
                .filter(entry => entry.isDirectory())
                .map(entry => entry.name);

            const fileDetailsPromises = entries.map(entry => {
                const filePath = path.join(folderPath, entry.name);

                return new Promise((resolve, reject) => {
                    fs.stat(filePath, (err, stats) => {
                        if (err) {
                            console.error('Error getting file stats:', err);
                            return reject(err);
                        }

                        const encodedFileName = encodeURIComponent(entry.name);
                        const fileLink = `https://${domain}/attachments/${userRealId}/${encodedFileName}`;

                        const fileType = entry.isDirectory() ? 'folder' : 'file';

                        resolve({
                            name: entry.name,
                            size: stats.size,
                            url: fileLink,
                            extension: path.extname(entry.name).toLowerCase(),
                            type: fileType
                        });
                    });
                });
            });

            Promise.all(fileDetailsPromises)
                .then(fileDetails => {
                    const availableExtensions = Array.from(new Set(fileDetails.map(file => file.extension)));

                    res.render('folder', { files: fileDetails, folders, allFolders, extensions: availableExtensions, currentFolder: currentFolderName, folderName: folderName, fileInfoNames, userName });                
                })
                .catch(error => {
                    console.error('Error processing file details:', error);
                    res.status(500).send('Erreur lors du traitement des détails des fichiers.');
                });
        });
    });
});

module.exports = router;