data-primals-engine 1.2.1 → 1.2.3

package/src/modules/data.js

@@ -3,35 +3,30 @@ import {BSON, ObjectId} from "mongodb";
 import * as util from 'node:util';
 import {promisify} from 'node:util';
 import crypto from "node:crypto";
-import {exec,execFile} from 'node:child_process';
+import {exec, execFile} from 'node:child_process';
 import sanitizeHtml from 'sanitize-html';
 import * as tar from "tar";
 import process from "node:process";
 import {randomColor} from "randomcolor";
 import cronstrue from 'cronstrue/i18n.js';
-import { setTimeoutMiddleware } from '../middlewares/timeout.js';
-import { mkdir } from 'node:fs/promises';
+import {setTimeoutMiddleware} from '../middlewares/timeout.js';
+import {mkdir} from 'node:fs/promises';
+import {anonymizeText, getDefaultForType, getFieldValueHash, getUserId, isDemoUser, isLocalUser} from "../data.js";
 import {
-    anonymizeText,
-    encryptValue,
-    getDefaultForType,
-    getFieldValueHash,
-    getUserId, isDemoUser,
-    isLocalUser
-} from "../data.js";
-import {
-    allowedFields, availableLangs,
+    allowedFields,
     dbName,
-    install, maxAlertsPerUser,
+    install,
+    maxAlertsPerUser,
     maxBytesPerSecondThrottleData,
     maxExportCount,
     maxFileSize,
-    maxFilterDepth, maxMagnetsDataPerModel, maxMagnetsModels,
+    maxFilterDepth,
+    maxMagnetsDataPerModel,
+    maxMagnetsModels,
     maxModelNameLength,
     maxModelsPerUser,
     maxPasswordLength,
     maxPostData,
-    maxPrivateFileSize,
     maxRelationsPerData,
     maxRequestData,
     maxRichTextLength,
@@ -39,7 +34,8 @@ import {
     maxTotalDataPerUser,
     megabytes,
     optionsSanitizer,
-    searchRequestTimeout, storageSafetyMargin
+    searchRequestTimeout,
+    storageSafetyMargin
 } from "../constants.js";
 import {
     getCollection,
@@ -51,22 +47,14 @@ import {
 } from "./mongodb.js";
 import {dbUrl, MongoClient, MongoDatabase} from "../engine.js";
 import path from "node:path";
-import {
-    event_trigger,
-    getFileExtension,
-    getObjectHash,
-    getRandom,
-    isGUID,
-    isPlainObject,
-    randomDate,
-    uuidv4
-} from "../core.js";
+import {getFileExtension, getObjectHash, getRandom, isGUID, isPlainObject, randomDate, sleep, uuidv4} from "../core.js";
+import {Event} from "../events.js";
 import fs from "node:fs";
 import schedule from "node-schedule";
 import {middleware} from "../middlewares/middleware-mongodb.js";
 import i18n from "../i18n.js";
 import {
-    executeSafeJavascript,
+    executeSafeJavascript, processWorkflowRun,
     runScheduledJobWithDbLock,
     scheduleWorkflowTriggers,
     triggerWorkflows
@@ -75,12 +63,14 @@ import NodeCache from "node-cache";
 import AWS from 'aws-sdk';
 import {openaiJobModel} from "../openai.jobs.js";
 import checkDiskSpace from "check-disk-space";
-import { fileURLToPath } from 'url';
-import { Worker } from 'worker_threads';
+import {fileURLToPath} from 'url';
+import {Worker} from 'worker_threads';
 import {addFile, encryptFile, removeFile} from "./file.js";
-import {listS3Backups, uploadToS3} from "./bucket.js";
+import {downloadFromS3, getS3Stream, getUserS3Config, listS3Backups, uploadToS3} from "./bucket.js";
 import {
-    calculateTotalUserStorageUsage, generateLimiter, hasPermission,
+    calculateTotalUserStorageUsage,
+    generateLimiter,
+    hasPermission,
     middlewareAuthenticator,
     userInitiator
 } from "./user.js";
@@ -104,7 +94,6 @@ const sseConnections = new Map();
 const delay = ms => new Promise(res => setTimeout(res, ms));
 
 const getBackupDir = () => process.env.BACKUP_DIR || './backups'; // Répertoire de stockage des sauvegardes
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
 let importJobs = {};
@@ -132,6 +121,7 @@ export function sendSseToUser(username, data) {
     const res = sseConnections.get(username);
     if (res) {
         res.write(`data: ${JSON.stringify(data)}\n\n`);
+        Event.Trigger("sendSseToUser", "system", "calls");
         return true;
     }
     logger.warn(`[SSE] Attempted to send event to disconnected user: ${username}`);
@@ -155,12 +145,13 @@ export const jobDumpUserData = async () => {
                 return;
             try {
                 dumpUserData(user).catch(e => {
-
+                    Event.Trigger("OnUserDataDumped", "event", "system", engine);
                 })
             } catch (ignored) {
 
             }
         });
+
     }catch (e) {
         console.error(e);
     }
@@ -1210,7 +1201,11 @@ export const editModel = async (user, id, data) => {
             logger.error(`Erreur asynchrone lors du déclenchement des workflows pour ${model._model} ID ${model._id}:`, workflowError);
         });
 
-        return ({ success: true, data: await modelsCollection.findOne({_id : oid}) });
+        const newModel = await modelsCollection.findOne({_id : oid});
+        const res = ({ success: true, data: newModel });
+        const plugin = Event.Trigger("OnModelEdited", "event", "system", engine, newModel);
+        Event.Trigger("OnModelEdited", "event", "user", plugin?.data || newModel);
+        return plugin || res
     } catch (e) {
         logger.error(e);
         return ({ success: false, error: e.message, statusCode: 500 });
@@ -1390,6 +1385,7 @@ export async function onInit(defaultEngine) {
     schedule.scheduleJob("0 2 * * *", jobDumpUserData);
     //await jobDumpUserData();
 
+
     schedule.scheduleJob("0 0 * * *", async () => {
         const dt = new Date();
         dt.setTime(dt.getTime()-1000*3600*24*14);
@@ -1971,7 +1967,7 @@ export async function onInit(defaultEngine) {
             const filter = req.fields.filter;
             const hash = req.params.id; // Récupérer l'identifiant de la ressource à modifier
             const data = req.fields.data || (req.fields._data && JSON.parse(req.fields._data));
-            const r = await editData(req.fields.model, filter || hash, data, req.files, req.me)
+            const r = await editData(req.fields.model, filter || { "$eq": ["$_id", { "$toObjectId": hash}]}, data, req.files, req.me)
             if (r.error)
                 res.status(400).json(r);
             else
@@ -2111,7 +2107,7 @@ export async function onInit(defaultEngine) {
                 await cancelAlerts(req.me);
 
                 await getPromise();
-                event_trigger('jobAddUserData', req.me.username);
+                Event.Trigger('jobAddUserData', req.me.username);
             }else{
                 await getPromise();
             }
@@ -2850,12 +2846,24 @@ export async function onInit(defaultEngine) {
             const resourceInfo = await getResource(guid, user); // Passez l'objet utilisateur
             res.setHeader('Content-Type', resourceInfo.mimeType);
 
-            const fileStream = fs.createReadStream(resourceInfo.filepath);
-            fileStream.on('error', (streamError) => {
-                console.error(`Stream error for resource ${guid}:`, streamError); // ou logger.error
-                res.status(404).json({ error: 'Resource file not found on server.' });
-            });
-            fileStream.pipe(res);
+            if (resourceInfo.storage === 's3') {
+                const s3Config = await getUserS3Config(user);
+                const s3Stream = getS3Stream(s3Config, resourceInfo.s3Key);
+
+                s3Stream.on('error', (s3Error) => {
+                    logger.error(`S3 stream error for resource ${guid}:`, s3Error);
+                    res.status(404).json({ error: 'Resource file not found in storage.' });
+                });
+
+                s3Stream.pipe(res);
+            } else { // Stockage 'local'
+                const fileStream = fs.createReadStream(resourceInfo.filepath);
+                fileStream.on('error', (streamError) => {
+                    console.error(`Stream error for resource ${guid}:`, streamError); // ou logger.error
+                    res.status(404).json({error: 'Resource file not found on server.'});
+                });
+                fileStream.pipe(res);
+            }
 
         } catch (error) {
             console.error(`Error serving resource ${req.params.guid}:`, error); // ou logger.error
@@ -2881,18 +2889,18 @@ export const deleteModels = async (filter) => {
 }
 
 export const getModel = async (modelName, user) => {
-    const modelInCache = modelsCache.get(user.username+"@@"+modelName);
+    const modelInCache = modelsCache.get((user?.username||'')+"@@"+modelName);
     if(modelInCache)
         return modelInCache;
-    const model = await getCollection('models').findOne({name: modelName, $and: [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}]});
+    const model = await getCollection('models').findOne({name: modelName, $and: user ? [{_user: {$exists: true}}, {$or: [{_user: user._user}, {_user: user.username}]}] : [{_user: { $exists: false}}]});
     if (!model) {
         throw new Error(i18n.t('api.model.notFound', {model: modelName}));
     }
-    modelsCache.set(user.username+"@@"+modelName, model);
+    modelsCache.set((user?.username||'')+"@@"+modelName, model);
     return model;
 }
 export const getModels = async ()  => {
-    return await getCollection('models').find({'$or': [{_user: { $exists: false}}]}).toArray();
+    return await getCollection('models')?.find({'$or': [{_user: { $exists: false}}]}).toArray() || [];
 }
 
 
@@ -3119,9 +3127,10 @@ export const insertData = async (modelName, data, files, user, triggerWorkflow =
             // Attendre que toutes les opérations post-insertion (workflows, planification) soient tentées
             await Promise.allSettled(postInsertionPromises);
         }
-
-        // --- Retourner succès car l'insertion principale a réussi ---
-        return { success: true, insertedIds: insertedIds.map(id => id.toString()) }; // Convertir les IDs en string pour la réponse
+        const res = { success: true, insertedIds: insertedIds.map(id => id.toString()) }; // Convertir les IDs en string pour la réponse
+        const plugin = Event.Trigger("OnDataAdded", "event", "system", engine, insertedIds);
+        Event.Trigger("OnDataAdded", "event", "user", plugin?.insertedIds || insertedIds);
+        return plugin || res;
 
     } catch (error) { // Attrape les erreurs de permission ou de pushDataUnsecure
         logger.error(`[insertData] Main error during insertion process for model ${modelName}: ${error.message}`, error.stack);
@@ -3633,27 +3642,48 @@ const checkHash = async (me, model, hash, excludeId = null) => {
     return count > 0;
 };
 
+
 export const getResource = async (guid, user) => {
     if (!guid) throw new Error("Le GUID du fichier est requis.");
     if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
 
     const collection = getCollection("files");
-
-    // Trouver le fichier et vérifier l'autorisation (propriétaire, admin ou utilisateur principal)
     const file = await collection.findOne({ guid });
-    if (!file) throw new Error("Fichier non trouvé."+guid);
 
+    if (!file) {
+        throw new Error("Fichier non trouvé.");
+    }
+
+    // La vérification des permissions reste la même...
     if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_READ_FILE", `API_READ_FILE_privateFile_${guid}`], user)) {
-        if (file._user !== (user._user || user.username)) { // Vérifier si l'utilisateur est le propriétaire
+        if (file.user !== (user._user || user.username)) {
             throw new Error("Vous n'êtes pas autorisé à accéder à ce fichier.");
         }
     }
-    // Construire le chemin vers le fichier
-    const filepath = path.join(process.cwd(), 'uploads', 'private', guid)+'.'+getFileExtension(file.filename);
-    if (!fs.existsSync(filepath)) throw new Error("Fichier non trouvé sur le serveur.");
 
-
-    return { success: true, filepath, filename: file.filename, mimeType: file.mimeType }; // Retourner des informations utiles
+    // On retourne des informations différentes selon le type de stockage
+    if (file.storage === 's3') {
+        return {
+            success: true,
+            storage: 's3',
+            s3Key: file.filename, // 'filename' contient la clé S3
+            mimeType: file.mimeType
+            // Idlement, on aurait aussi le nom de fichier original ici
+        };
+    } else { // Par défaut, on considère le stockage local
+        // On utilise le chemin stocké en base de données
+        const filepath = file.path;
+        if (!filepath || !fs.existsSync(filepath)) {
+            throw new Error("Fichier non trouvé sur le serveur.");
+        }
+        return {
+            success: true,
+            storage: 'local',
+            filepath: filepath,
+            filename: file.filename,
+            mimeType: file.mimeType
+        };
+    }
 };
 
 export const patchData = async (modelName, filter, data, files, user, triggerWorkflow = true, waitForWorkflow = false) => {
@@ -4088,7 +4118,10 @@ export const deleteData = async (modelName, filter, user ={}, triggerWorkflow, w
             logger.info(`[deleteData] No documents to delete for user ${user?.username} after permission checks or matching criteria.`);
         }
 
-        return ({ success: true, deletedCount });
+        const res = { success: true, deletedCount }
+        const plugin = Event.Trigger("OnDataDeleted", "event", "system", engine, {model:modelName, filter});
+        Event.Trigger("OnDataDeleted", "event", "user", {model:modelName, filter});
+        return plugin || res;
 
     } catch (error) {
         logger.error(`[deleteData] Error during deletion process for user ${user?.username}:`, error);
@@ -4102,7 +4135,7 @@ export const deleteData = async (modelName, filter, user ={}, triggerWorkflow, w
 export const searchData = async (query, user) => {
     const { page, limit, sort, model, ids, timeout, pack } = query; // Les filtres de la requête (attention aux injections MongoDB !)
 
-    if( user.username !== 'demo' && isLocalUser(user) && (
+    if( user && user.username !== 'demo' && isLocalUser(user) && (
         !await hasPermission(["API_ADMIN", "API_SEARCH_DATA", "API_SEARCH_DATA_"+model], user) ||
         await hasPermission(["API_SEARCH_DATA_NOT_"+model], user))){
         throw new Error(i18n.t('api.permission.searchData'));
@@ -4598,7 +4631,10 @@ export const searchData = async (query, user) => {
     let data = await prom.toArray();
     data = await handleFields(modelElement, data, user);
 
-    return {data, count: count[0]?.count || 0};
+    const res = {data, count: count[0]?.count || 0};
+    const plugin = Event.Trigger("OnDataSearched", "event", "system", engine, {data, count: count[0]?.count});
+    Event.Trigger("OnDataSearched", "event", "user", plugin || {data, count: count[0]?.count});
+    return plugin || res;
 }
 
 export const importData = async(options, files, user) => {
@@ -4909,8 +4945,7 @@ export const importData = async(options, files, user) => {
             importJobs[importJobId].errors.push(error.message || "An unhandled error occurred in background process.");
         }
     });
-
-    return ({ success: true, message: "Import initiated. Check progress via SSE.", job: importJob });
+    return ({success: true, message: "Import initiated. Check progress via SSE.", job: importJob});
 }
 
 export const exportData= async (options, user) =>{
@@ -5025,7 +5060,10 @@ export const exportData= async (options, user) =>{
         exportResults._exportErrors = errors;
     }
 
-    return { success: true, data: exportResults, models: modelsToExport };
+    const res = { success: true, data: exportResults, models: modelsToExport };
+    const plugin = Event.Trigger("OnDataExported", "event", "system", engine, exportResults, modelsToExport);
+    Event.Trigger("OnDataExported", "event", "user", plugin?.exportResults || exportResults, plugin?.modelsToExport || modelsToExport);
+    return plugin || res;
 }
 
 function handleCalculationExpression(calcExpression, fi, modelElement, calculationName) {
@@ -5270,43 +5308,68 @@ export const loadFromDump = async (user, options = {}) => {
     const action = modelsOnly ? 'restore-models' : 'full-restore';
     logger.info(`[${action}] Starting for user: ${user.username}`);
 
-    let encryptedKey = readKeyFromFile(user);
+    const encryptedKey = readKeyFromFile(user);
     if (!encryptedKey) {
         throw new Error("No encryption key found for this user. Cannot restore.");
     }
 
-    const userId = getObjectHash({user: user.username});
-    // --- La logique pour trouver le fichier de backup (local ou S3) reste la même ---
-    // (le code existant pour trouver/télécharger le backupFilePath va ici)
-    // ...
-    let backupFilePath; // Assurez-vous que cette variable est bien définie avec le chemin du fichier .tar.gz
-    // Exemple simplifié :
+    const userId = getObjectHash({ user: user.username });
     const backupDir = getBackupDir();
-    const backupFilenameRegex = new RegExp(`^backup_${userId}_(\\d+)\\.tar\\.gz$`);
-    const backupFiles = fs.readdirSync(backupDir).filter(filename => backupFilenameRegex.test(filename));
-    if (backupFiles.length === 0) throw new Error(`Aucun fichier de sauvegarde local trouvé pour l'utilisateur ${user.username}.`);
-    const latestBackupFile = backupFiles.sort((a, b) => parseInt(b.match(backupFilenameRegex)[1], 10) - parseInt(a.match(backupFilenameRegex)[1], 10))[0];
-    backupFilePath = path.join(backupDir, latestBackupFile);
-    // --- Fin de la logique de recherche de fichier ---
+    let backupFilePath = ''; // Will hold the path to the archive to be restored
+    let isTempFile = false; // Flag to know if we need to delete the file later
 
     const tmpRestoreDir = path.join(backupDir, `tmp_restore_${userId}_${Date.now()}`);
 
     try {
+        const s3Config = await getUserS3Config(user);
+        // --- NEW LOGIC: Check for S3 config first ---
+        if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
+            logger.info(`[${action}] S3 config found for user. Searching for backups in bucket: ${s3Config.bucketName}`);
+
+            const s3Backups = await listS3Backups(s3Config);
+            const userBackups = s3Backups
+                .filter(f => f.filename.startsWith(`backup_${userId}_`))
+                .sort((a, b) => b.timestamp - a.timestamp);
+
+            if (userBackups.length === 0) {
+                throw new Error(`No S3 backups found for user ${user.username} in bucket ${s3Config.bucketName}.`);
+            }
+
+            const latestBackup = userBackups[0];
+            logger.info(`[${action}] Found latest S3 backup: ${latestBackup.key}. Downloading...`);
+
+            // Download the file to a temporary location
+            backupFilePath = path.join(backupDir, latestBackup.filename);
+            isTempFile = true;
+            await downloadFromS3(s3Config, latestBackup.key, backupFilePath);
+            logger.info(`[${action}] S3 backup downloaded to ${backupFilePath}.`);
+
+        } else {
+            // --- FALLBACK LOGIC: Look for local backups ---
+            logger.info(`[${action}] No S3 config. Searching for local backups.`);
+            const backupFilenameRegex = new RegExp(`^backup_${userId}_(\\d+)\\.tar\\.gz$`);
+            const backupFiles = fs.readdirSync(backupDir).filter(filename => backupFilenameRegex.test(filename));
+            if (backupFiles.length === 0) {
+                throw new Error(`No local backup files found for user ${user.username}.`);
+            }
+            const latestBackupFile = backupFiles.sort((a, b) => parseInt(b.match(backupFilenameRegex)[1], 10) - parseInt(a.match(backupFilenameRegex)[1], 10))[0];
+            backupFilePath = path.join(backupDir, latestBackupFile);
+        }
+
+        // --- The rest of the logic remains the same, operating on backupFilePath ---
+
         await runCryptoWorkerTask('decrypt', { filePath: backupFilePath, password: encryptedKey });
+
         if (!fs.existsSync(tmpRestoreDir)) {
             fs.mkdirSync(tmpRestoreDir, { recursive: true });
         }
         await tar.extract({ file: backupFilePath, gzip: true, C: tmpRestoreDir, sync: true });
 
-        // --- NETTOYAGE SÉCURISÉ AVANT RESTAURATION ---
+        // ... (Cleaning logic: deleteMany, removeFile, cancelAlerts) ...
         const datasCollection = getCollection("datas");
-
         if (modelsOnly) {
-            // Supprime uniquement les modèles de l'utilisateur
             await modelsCollection.deleteMany({ _user: user.username });
-            logger.info(`[${action}] Deleted existing models for user ${user.username}.`);
         } else {
-            // Restauration complète : supprime les données, modèles, fichiers et alertes de l'utilisateur
             await datasCollection.deleteMany({ _user: user.username });
             await modelsCollection.deleteMany({ _user: user.username });
 
@@ -5344,23 +5407,31 @@ export const loadFromDump = async (user, options = {}) => {
 
         logger.info(`[${action}] Executing restore command: ${command}`);
         await execFileAsync('mongorestore', args);
-        
-        // --- Tâches Post-Restauration ---
+
+        // ... (Post-restore tasks) ...
         await scheduleAlerts();
         await scheduleWorkflowTriggers();
-        modelsCache.flushAll(); // Vider le cache des modèles
+        modelsCache.flushAll();
 
         logger.info(`[${action}] Restore successful for user ${user.username}.`);
+        Event.Trigger("OnDataRestored", "event", "system");
 
     } finally {
-        // --- Nettoyage final ---
+        // --- GUARANTEED CLEANUP ---
         if (fs.existsSync(tmpRestoreDir)) {
             await fs.promises.rm(tmpRestoreDir, { recursive: true, force: true });
         }
-        // Il est préférable de rechiffrer le fichier de backup après l'avoir utilisé
-        if (fs.existsSync(backupFilePath)) {
+
+        // Re-encrypt the original file if it's not a temporary one
+        if (fs.existsSync(backupFilePath) && !isTempFile) {
             await runCryptoWorkerTask('encrypt', { filePath: backupFilePath, password: encryptedKey });
         }
+
+        // If we downloaded a temp file from S3, delete it
+        if (fs.existsSync(backupFilePath) && isTempFile) {
+            fs.unlinkSync(backupFilePath);
+            logger.info(`[${action}] Deleted temporary downloaded backup file: ${backupFilePath}`);
+        }
     }
 };
 
@@ -5384,7 +5455,7 @@ const readKeyFromFile = (user) => {
 };
 
 export const dumpUserData = async (user) => {
-    const s3Config = user.configS3;
+    const s3Config = await getUserS3Config(user);
     const backupDir = getBackupDir();
     const userId = getObjectHash({ user: user.username });
     const backupFilename = `backup_${userId}`;
@@ -5420,28 +5491,28 @@ export const dumpUserData = async (user) => {
                 await execFileAsync('mongodump', args);
             }
         }
-
         const dumpSourceDir = path.join(localTempDumpDir, dbName);
         if (fs.existsSync(dumpSourceDir)) {
             await tar.create({ gzip: true, file: localArchivePath, C: localTempDumpDir }, [dbName]);
             logger.info(`Archive de sauvegarde locale créée : ${localArchivePath}`);
         } else {
-            logger.warn(`Le répertoire de dump ${dumpSourceDir} était vide. Aucune archive n'a été créée.`);
-            // On s'arrête ici car il n'y a rien à traiter
+            logger.warn(`Le répertoire de dump ${dumpSourceDir} était vide. Aucune archive n'a créée.`);
             return Promise.resolve();
         }
 
-        await encryptFile(localArchivePath, encryptedKey);
+        await runCryptoWorkerTask('encrypt', { filePath: localArchivePath, password: encryptedKey });
 
-        if (s3Config && s3Config.bucketName) {
+        try {
+            // Attempt the S3 upload
             await uploadToS3(s3Config, localArchivePath, finalArchiveName);
-            fs.unlinkSync(localArchivePath); // Supprime l'archive locale après l'upload
-        } else {
-            logger.info(`Aucune configuration S3 trouvée. La sauvegarde reste locale : ${localArchivePath}.`);
+            // ONLY if the upload succeeds, delete the local file.
+            fs.unlinkSync(localArchivePath);
+            logger.info(`Local archive ${finalArchiveName} deleted after successful S3 upload.`);
+        } catch (e) {
         }
 
         logger.info(`Sauvegarde réussie pour l'utilisateur ${user.username}.`);
-        await manageBackupRotation(user, backupFrequency, s3Config);
+        await manageBackupRotation(user, await engine.userProvider.getBackupFrequency(user), s3Config);
 
     } catch (error) {
         logger.error(`Erreur lors de la sauvegarde pour l'utilisateur ${user.username}:`, error);
@@ -5463,8 +5534,8 @@ async function manageBackupRotation(user, backupFrequency, s3Config = null) { //
     const userId = getObjectHash({user:user.username});
     let filesToManage = [];
 
-    if (s3Config && s3Config.bucketName) {
-        logger.info(`Gestion de la rotation des sauvegardes S3 pour ${userid}.`);
+    if (s3Config && s3Config.bucketName && s3Config.accessKeyId && s3Config.secretAccessKey) {
+        logger.info(`Gestion de la rotation des sauvegardes S3 pour ${userId}.`);
         const s3Backups = await listS3Backups(s3Config);
         // Filtrer pour ne garder que les backups de cet utilisateur et trier
         filesToManage = s3Backups
@@ -5841,6 +5912,8 @@ export async function installPack(packId, user, lang) {
         }
     }
 
+    Event.Trigger("OnPackInstalled", "event", "system", pack);
+
     const modifiedCount = summary.datas.inserted + summary.datas.updated;
     logger.info(`--- Installation of pack '${pack.name}' finished. ---`);
     return { success: errors.length === 0, summary, errors, modifiedCount };
@@ -5915,4 +5988,4 @@ export async function handleDemoInitialization(req, res) {
         logger.error(`[Demo Init] Critical error during initialization for user '${user.username}':`, error);
         res.status(500).json({ success: false, error: 'An internal server error occurred during initialization.' });
     }
-}
+}