699 lines
24 KiB
JavaScript
699 lines
24 KiB
JavaScript
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('setup.json');
|
|
const config = JSON.parse(configFile);
|
|
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('/dashboard', 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 userName = req.userData.name;
|
|
const downloadDir = path.join('cdn-files', userName);
|
|
const domain = config.domain || 'mydomain.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('file_info.json', 'utf8'));
|
|
fileInfoNames = fileInfo.map(file => file.fileName);
|
|
} catch (err) {
|
|
console.error('Error reading file_info.json:', err);
|
|
}
|
|
|
|
try {
|
|
const files = await fs.promises.readdir(downloadDir);
|
|
|
|
const folders = files.filter(file => fs.statSync(path.join(downloadDir, file)).isDirectory());
|
|
|
|
const fileDetails = files.map(file => {
|
|
const filePath = path.join(downloadDir, file);
|
|
const stats = fs.statSync(filePath);
|
|
const fileExtension = path.extname(file).toLowerCase();
|
|
const encodedFileName = encodeURIComponent(file);
|
|
const fileLink = `https://${domain}/attachments/${userId}/${encodedFileName}`;
|
|
|
|
const fileType = stats.isDirectory() ? 'folder' : 'file';
|
|
|
|
return {
|
|
name: file,
|
|
size: stats.size,
|
|
url: fileLink,
|
|
extension: fileExtension,
|
|
type: fileType
|
|
};
|
|
});
|
|
|
|
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 });
|
|
} catch (err) {
|
|
console.error('Error reading directory:', err);
|
|
return res.render('error-recovery-file', { error: err.message });
|
|
}
|
|
});
|
|
|
|
router.get('/dashboard/folder/:folderName', authMiddleware, async (req, res) => {
|
|
const userId = 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 || 'mydomain.com';
|
|
const currentFolderName = folderName || '';
|
|
|
|
const data = await fs.promises.readFile('user.json', 'utf8');
|
|
const users = JSON.parse(data);
|
|
const user = users.find(user => user.name === userId);
|
|
|
|
if (!user) {
|
|
return res.status(500).send('User not found in user.json');
|
|
}
|
|
|
|
const userRealId = user.id;
|
|
|
|
const fileInfoData = await fs.promises.readFile('file_info.json', 'utf8');
|
|
const fileInfo = JSON.parse(fileInfoData);
|
|
|
|
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 });
|
|
})
|
|
.catch(error => {
|
|
console.error('Error processing file details:', error);
|
|
res.status(500).send('Erreur lors du traitement des détails des fichiers.');
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
router.post('/dashboard/newfolder', authMiddleware, (req, res) => {
|
|
try {
|
|
console.log('Received POST request to create a new folder.');
|
|
|
|
const userId = req.userData.name;
|
|
let { folderName } = req.body;
|
|
|
|
console.log('Received folderName:', folderName);
|
|
|
|
if (!folderName || typeof folderName !== 'string') {
|
|
console.log('Invalid folderName:', folderName);
|
|
return res.status(400).json({ message: 'Le nom du dossier ne peut pas être vide.' });
|
|
}
|
|
|
|
folderName = folderName.trim();
|
|
|
|
if (!folderName) {
|
|
console.log('Trimmed folderName is empty.');
|
|
return res.status(400).json({ message: 'Le nom du dossier ne peut pas être vide.' });
|
|
}
|
|
|
|
const folderPath = path.join('cdn-files', userId, folderName);
|
|
|
|
if (fs.existsSync(folderPath)) {
|
|
console.log('Folder already exists:', folderPath);
|
|
return res.status(400).json({ message: 'Le dossier existe déjà.' });
|
|
}
|
|
|
|
fs.mkdir(folderPath, (err) => {
|
|
if (err) {
|
|
console.error(err);
|
|
return res.status(500).json({ message: 'Erreur lors de la création du dossier.', error: err });
|
|
}
|
|
console.log('Folder created successfully:', folderPath);
|
|
res.status(200).json({ message: 'Dossier créé avec succès.' });
|
|
});
|
|
} catch (error) {
|
|
console.error('Error creating folder:', error);
|
|
return res.status(500).json({ message: 'Erreur lors de la création du dossier.', error: error });
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/rename', authMiddleware, async (req, res) => {
|
|
const userId = req.userData.name;
|
|
const { currentName, newName } = req.body;
|
|
|
|
if (!currentName || !newName) {
|
|
return res.status(400).send('Both currentName and newName must be provided.');
|
|
}
|
|
|
|
const currentPath = path.join('cdn-files', userId || '', currentName);
|
|
const newPath = path.join('cdn-files', userId, newName);
|
|
|
|
try {
|
|
await fs.promises.rename(currentPath, newPath);
|
|
|
|
const data = await fs.promises.readFile('file_info.json', 'utf8');
|
|
let fileInfo = JSON.parse(data);
|
|
|
|
let found = false;
|
|
for (let i = 0; i < fileInfo.length; i++) {
|
|
if (fileInfo[i].fileName === currentName) {
|
|
fileInfo[i].fileName = newName;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
await fs.promises.writeFile('file_info.json', JSON.stringify(fileInfo, null, 2), 'utf8');
|
|
}
|
|
|
|
res.status(200).send('L\'opération a été effectuée avec succès.');
|
|
} catch (err) {
|
|
console.error(err);
|
|
return res.status(500).send('Erreur lors du changement de nom du fichier.');
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/rename/:filePath*', authMiddleware, async (req, res) => {
|
|
const userId = req.userData.name;
|
|
const { currentName, newName } = req.body;
|
|
const filePath = path.join(req.params.filePath, req.params[0] || '');
|
|
|
|
if (!currentName || !newName) {
|
|
return res.status(400).send('Both currentName and newName must be provided.');
|
|
}
|
|
|
|
const currentPath = path.join('cdn-files', userId || '', filePath, currentName);
|
|
const newPath = path.join('cdn-files', userId, filePath, newName);
|
|
|
|
try {
|
|
await fs.promises.rename(currentPath, newPath);
|
|
|
|
const data = await fs.promises.readFile('file_info.json', 'utf8');
|
|
let fileInfo = JSON.parse(data);
|
|
|
|
let found = false;
|
|
for (let i = 0; i < fileInfo.length; i++) {
|
|
if (fileInfo[i].fileName === currentName) {
|
|
fileInfo[i].fileName = newName;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
await fs.promises.writeFile('file_info.json', JSON.stringify(fileInfo, null, 2), 'utf8');
|
|
}
|
|
|
|
res.status(200).send('L\'opération a été effectuée avec succès.');
|
|
} catch (err) {
|
|
console.error(err);
|
|
return res.status(500).send('Erreur lors du changement de nom du fichier.');
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/delete', authMiddleware, (req, res) => {
|
|
const userId = req.userData.name;
|
|
const { filename } = req.body;
|
|
|
|
if (!userId || !filename) {
|
|
return res.status(400).json({ message: 'Identifiant d\'utilisateur ou nom de fichier manquant pour la suppression du fichier.' });
|
|
}
|
|
|
|
const userFolderPath = path.join('cdn-files', userId);
|
|
|
|
function findAndDeleteFile(folderPath) {
|
|
const filesInFolder = fs.readdirSync(folderPath);
|
|
|
|
for (const file of filesInFolder) {
|
|
const filePath = path.join(folderPath, file);
|
|
|
|
if (fs.statSync(filePath).isDirectory()) {
|
|
findAndDeleteFile(filePath);
|
|
} else if (file === filename) {
|
|
try {
|
|
fs.unlinkSync(filePath);
|
|
console.log('File deleted:', filePath);
|
|
return true;
|
|
} catch (error) {
|
|
console.error('Error deleting file:', error);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const fileDeleted = findAndDeleteFile(userFolderPath);
|
|
|
|
if (fileDeleted) {
|
|
res.status(200).json({ status: 'success', message: 'Le fichier a été supprimé avec succès.' });
|
|
} else {
|
|
res.status(404).json({ status: 'error', message: 'Le fichier que vous essayez de supprimer n\'existe pas.' });
|
|
}
|
|
});
|
|
|
|
const ncpAsync = (source, destination) => {
|
|
return new Promise((resolve, reject) => {
|
|
ncp(source, destination, (err) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
router.post('/dashboard/movefile', authMiddleware, async (req, res) => {
|
|
const fileName = req.body.fileName;
|
|
const folderName = req.body.folderName;
|
|
|
|
const data = await fs.promises.readFile('user.json', 'utf8');
|
|
const users = JSON.parse(data);
|
|
const user = users.find(user => user.id === req.user.id);
|
|
|
|
if (!user) {
|
|
console.error('User not found in user.json');
|
|
return res.status(500).send('Erreur lors du déplacement du fichier.');
|
|
}
|
|
|
|
const userId = user.name;
|
|
|
|
if (!fileName || !userId) {
|
|
console.error('fileName or userId is undefined');
|
|
return res.status(500).send('Erreur lors du déplacement du fichier.');
|
|
}
|
|
|
|
const sourcePath = path.join('cdn-files', userId, fileName);
|
|
|
|
let destinationDir;
|
|
if (folderName && folderName.trim() !== '') {
|
|
destinationDir = path.join('cdn-files', userId, folderName);
|
|
} else {
|
|
destinationDir = path.join('cdn-files', userId);
|
|
}
|
|
|
|
const destinationPath = path.join(destinationDir, fileName);
|
|
|
|
try {
|
|
const normalizedSourcePath = path.normalize(sourcePath);
|
|
console.log('Full Source Path:', normalizedSourcePath);
|
|
|
|
if (fs.existsSync(normalizedSourcePath)) {
|
|
await fs.promises.access(destinationDir);
|
|
|
|
await ncpAsync(normalizedSourcePath, destinationPath);
|
|
|
|
await fs.promises.unlink(normalizedSourcePath);
|
|
} else {
|
|
console.log('File does not exist');
|
|
}
|
|
|
|
res.redirect('/dpanel/dashboard');
|
|
} catch (err) {
|
|
console.error(err);
|
|
return res.status(500).send('Erreur lors du déplacement du fichier.');
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/movefile/:folderName', authMiddleware, async (req, res) => {
|
|
|
|
const fileName = req.body.fileName;
|
|
const newFolderName = req.body.folderName;
|
|
const oldFolderName = req.params.folderName;
|
|
const userId = req.user && req.user._json ? req.userData.name : undefined;
|
|
|
|
if (!fileName || !userId || !oldFolderName || !newFolderName) {
|
|
console.error('fileName, userId, oldFolderName, or newFolderName is undefined');
|
|
return res.status(500).send('Erreur lors du déplacement du fichier.');
|
|
}
|
|
|
|
const sourcePath = path.join(process.cwd(), 'cdn-files', userId, oldFolderName, fileName);
|
|
const destinationDir = path.join(process.cwd(), 'cdn-files', userId, newFolderName);
|
|
const destinationPath = path.join(destinationDir, fileName);
|
|
|
|
try {
|
|
const normalizedSourcePath = path.normalize(sourcePath);
|
|
console.log('Full Source Path:', normalizedSourcePath);
|
|
|
|
if (fs.existsSync(normalizedSourcePath)) {
|
|
await fs.promises.access(destinationDir, fs.constants.W_OK);
|
|
|
|
await fs.promises.rename(normalizedSourcePath, destinationPath);
|
|
} else {
|
|
console.log('File does not exist');
|
|
}
|
|
|
|
res.redirect('/dpanel/dashboard');
|
|
} catch (err) {
|
|
console.error(err);
|
|
return res.status(500).send('Erreur lors du déplacement du fichier.');
|
|
}
|
|
});
|
|
|
|
router.delete('/dashboard/deletefolder/:folderName', authMiddleware, (req, res) => {
|
|
const userId = req.userData.name;
|
|
const { filename } = req.body;
|
|
|
|
const userFolderPath = path.join('cdn-files', userId || '');
|
|
const folderPath = path.join(userFolderPath, req.params.folderName || '');
|
|
|
|
if (!fs.existsSync(folderPath)) {
|
|
return res.status(404).json({ error: 'Le dossier spécifié n\'existe pas.' });
|
|
}
|
|
|
|
fs.rmdirSync(folderPath, { recursive: true });
|
|
|
|
res.json({ deleted: true, success: 'Dossier supprimé avec succès.' });
|
|
});
|
|
|
|
router.delete('/dashboard/deletefolder/:folderName', authMiddleware, (req, res) => {
|
|
const userId = req.userData.name;
|
|
const folderName = req.params.folderName;
|
|
const folderPath = path.join('cdn-files', userId, folderName);
|
|
|
|
fs.rmdir(folderPath, { recursive: true }, (err) => {
|
|
if (err) {
|
|
console.error(err);
|
|
return res.status(500).json({ error: 'Erreur lors de la suppression du dossier.' });
|
|
}
|
|
res.json({ deleted: true, success: 'Dossier supprimé avec succès.' });
|
|
});
|
|
});
|
|
|
|
router.post('/dashboard/deletefile/:folderName', authMiddleware, (req, res) => {
|
|
const userId = req.userData.name;
|
|
const { filename } = req.body;
|
|
|
|
const userFolderPath = path.join('cdn-files', userId || '');
|
|
const filePath = path.join(userFolderPath, req.params.folderName, filename || '');
|
|
|
|
if (!fs.existsSync(filePath)) {
|
|
return res.status(404).json({ error: 'Le fichier spécifié n\'existe pas.' });
|
|
}
|
|
|
|
fs.unlink(filePath, (err) => {
|
|
if (err) {
|
|
console.error(err);
|
|
return res.status(500).json({ error: 'Erreur lors de la suppression du fichier.' });
|
|
}
|
|
res.json({ deleted: true, success: 'Fichier supprimé avec succès.' });
|
|
});
|
|
});
|
|
|
|
router.get('/upload', authMiddleware, (req, res) => {
|
|
res.render('upload');
|
|
});
|
|
|
|
router.use(fileUpload({
|
|
limits: { fileSize: 15 * 1024 * 1024 * 1024 },
|
|
}));
|
|
|
|
router.post('/upload', authMiddleware, async (req, res) => {
|
|
try {
|
|
if (!req.files || Object.keys(req.files).length === 0) {
|
|
return res.status(400).send('5410 - Erreur de téléchargement, veuillez retenter ultérieurement.');
|
|
}
|
|
|
|
const file = req.files.file;
|
|
const userId = req.userData.name;
|
|
const Id = req.userData.id;
|
|
const uploadDir = path.join('cdn-files', userId);
|
|
const originalFileName = file.name;
|
|
const domain = config.domain || 'mydomain.com';
|
|
let expiryDate = req.body.expiryDate;
|
|
let password = req.body.password;
|
|
|
|
if (!fs.existsSync(uploadDir)) {
|
|
fs.mkdirSync(uploadDir, { recursive: true });
|
|
}
|
|
|
|
file.mv(path.join(uploadDir, originalFileName), async (err) => {
|
|
if (err) {
|
|
console.error(err);
|
|
return res.status(500).send({ message: 'Erreur lors du téléchargement du fichier.' });
|
|
}
|
|
|
|
const fileExtension = path.extname(originalFileName).toLowerCase();
|
|
|
|
let encryptedPassword = '';
|
|
if (password) {
|
|
const algorithm = 'aes-256-cbc';
|
|
const key = crypto.scryptSync(password, 'salt', 32);
|
|
const iv = Buffer.alloc(16, 0);
|
|
const cipher = crypto.createCipheriv(algorithm, key, iv);
|
|
encryptedPassword = cipher.update('', 'utf8', 'hex');
|
|
encryptedPassword += cipher.final('hex');
|
|
}
|
|
|
|
const fileInfo = {
|
|
fileName: originalFileName,
|
|
expiryDate: expiryDate || '',
|
|
password: encryptedPassword,
|
|
Id: Id,
|
|
path: path.join(uploadDir, originalFileName)
|
|
};
|
|
|
|
if (expiryDate || password) {
|
|
let data = [];
|
|
if (fs.existsSync('file_info.json')) {
|
|
const existingData = await fs.promises.readFile('file_info.json', 'utf8');
|
|
data = JSON.parse(existingData);
|
|
}
|
|
data.push(fileInfo);
|
|
await fs.promises.writeFile('file_info.json', JSON.stringify(data, null, 2));
|
|
}
|
|
|
|
res.redirect('/dpanel/dashboard');
|
|
});
|
|
} catch (error) {
|
|
console.error(error);
|
|
return res.status(500).send({ message: 'Erreur lors du téléchargement du fichier.' });
|
|
}
|
|
});
|
|
|
|
const User = require('../user.json');
|
|
const setup = JSON.parse(fs.readFileSync(path.join(__dirname, '../setup.json'), 'utf8'));
|
|
|
|
router.get('/dashboard/admin', authMiddleware, async (req, res) => {
|
|
try {
|
|
res.render('paramAdmin', { users: User, setup: setup });
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
|
|
router.get('/dashboard/admin/users', authMiddleware, async (req, res) => {
|
|
try {
|
|
let currentPage = Number(req.query.page) || 1;
|
|
let limit = Number(req.query.limit) || 10;
|
|
|
|
let rawdata = fs.readFileSync(path.join(__dirname, '../user.json'));
|
|
let users = JSON.parse(rawdata);
|
|
|
|
let totalUsers = users.length;
|
|
let pages = Math.ceil(totalUsers / limit);
|
|
|
|
let start = (currentPage - 1) * limit;
|
|
let end = start + limit;
|
|
let usersForPage = users.slice(start, end);
|
|
|
|
res.render('paramAdminUser', { users: usersForPage, setup: setup, pages: pages, currentPage: currentPage, limit: limit });
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
router.get('/dashboard/admin/settingsetup', authMiddleware, async (req, res) => {
|
|
try {
|
|
res.render('paramAdminSettingSetup', { users: User, setup: setup });
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
const osUtils = require('os-utils');
|
|
|
|
const Convert = require('ansi-to-html');
|
|
const convert = new Convert();
|
|
|
|
router.get('/dashboard/admin/stats&logs', authMiddleware, async (req, res) => {
|
|
try {
|
|
const uptime = os.uptime();
|
|
const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
|
|
|
|
osUtils.cpuUsage(function(cpuUsage) {
|
|
fs.readdir('./logs', (err, files) => {
|
|
if (err) {
|
|
console.error(err);
|
|
res.status(500).send('Error reading logs');
|
|
return;
|
|
}
|
|
|
|
const logs = files.map(file => {
|
|
return fs.promises.readFile(path.join('./logs', file), 'utf8')
|
|
.then(content => {
|
|
content = convert.toHtml(content);
|
|
return { name: file, content: content };
|
|
})
|
|
.catch(err => {
|
|
console.error(err);
|
|
});
|
|
});
|
|
|
|
Promise.all(logs).then(completed => {
|
|
res.render('paramAdminStats&Logs', { users: User, setup: setup, uptime, memoryUsage, cpuUsage, logs: completed });
|
|
});
|
|
});
|
|
});
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
router.get('/dashboard/admin/Privacy&Security', authMiddleware, async (req, res) => {
|
|
try {
|
|
const files = await fs.promises.readdir('./report');
|
|
const reports = files.filter(file => file.endsWith('.json')).map(file => {
|
|
return fs.promises.readFile(path.join('./report', file), 'utf8')
|
|
.then(content => {
|
|
return { name: file, content: content };
|
|
})
|
|
.catch(err => {
|
|
console.error(err);
|
|
});
|
|
});
|
|
|
|
Promise.all([Promise.all(reports)]).then(([completedReports]) => {
|
|
res.render('paramAdminPrivacy&Security', { users: User, reports: completedReports });
|
|
});
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/update-role', authMiddleware, async (req, res) => {
|
|
try {
|
|
const { id, role } = req.body;
|
|
|
|
const user = User.find(user => user.id === id);
|
|
|
|
if (user) {
|
|
user.role = role;
|
|
}
|
|
|
|
fs.writeFileSync(path.join(__dirname, '../user.json'), JSON.stringify(User, null, 2));
|
|
|
|
res.redirect('/dpanel/dashboard/admin');
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
router.post('/dashboard/update-setup', authMiddleware, async (req, res) => {
|
|
try {
|
|
let setup = JSON.parse(fs.readFileSync(path.join(__dirname, '../setup.json')));
|
|
|
|
if (!req.body.ldap || !req.body.ldap.enabled) {
|
|
delete setup.ldap;
|
|
} else {
|
|
setup.ldap = req.body.ldap;
|
|
}
|
|
|
|
if (!req.body.discord || !req.body.discord.enabled) {
|
|
delete setup.discord;
|
|
} else {
|
|
setup.discord = req.body.discord;
|
|
}
|
|
|
|
setup.domain = req.body.domain;
|
|
setup.uptime = req.body.uptime;
|
|
|
|
fs.writeFileSync(path.join(__dirname, '../setup.json'), JSON.stringify(setup, null, 2));
|
|
|
|
res.redirect('/dpanel/dashboard/admin');
|
|
} catch (err) {
|
|
console.error(err);
|
|
res.status(500).send('Server Error');
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|