@programisto/edrm-storage 0.3.1

package/dist/modules/edrm-exams/routes/result.router.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceRouter } from '@programisto/endurance-core';
+declare class ResultRouter extends EnduranceRouter {
+    constructor();
+    setupRoutes(): void;
+}
+declare const router: ResultRouter;
+export default router;

package/dist/modules/edrm-exams/routes/result.router.js

@@ -0,0 +1,370 @@
+import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance-core';
+import CandidateModel from '../models/candidate.model.js';
+import TestResult, { TestState } from '../models/test-result.model.js';
+import Test from '../models/test.model.js';
+import TestJob from '../models/test-job.model.js';
+// Fonction utilitaire pour récupérer le nom du job
+async function getJobName(targetJob) {
+    // Si c'est déjà une string (ancien format), on la retourne directement
+    if (typeof targetJob === 'string') {
+        return targetJob;
+    }
+    // Si c'est un ObjectId, on récupère le job
+    if (targetJob && typeof targetJob === 'object' && targetJob._id) {
+        const job = await TestJob.findById(targetJob._id);
+        return job ? job.name : 'Job inconnu';
+    }
+    // Si c'est juste un ObjectId
+    if (targetJob && typeof targetJob === 'object' && targetJob.toString) {
+        const job = await TestJob.findById(targetJob);
+        return job ? job.name : 'Job inconnu';
+    }
+    return 'Job inconnu';
+}
+class ResultRouter extends EnduranceRouter {
+    constructor() {
+        super(EnduranceAuthMiddleware.getInstance());
+    }
+    setupRoutes() {
+        const authenticatedOptions = {
+            requireAuth: false,
+            permissions: []
+        };
+        // Lister tous les résultats de tests d'un candidat
+        this.get('/results/:candidateId', authenticatedOptions, async (req, res) => {
+            try {
+                const { candidateId } = req.params;
+                const page = parseInt(req.query.page) || 1;
+                const limit = parseInt(req.query.limit) || 10;
+                const skip = (page - 1) * limit;
+                const state = req.query.state || 'all';
+                const sortBy = req.query.sortBy || 'invitationDate';
+                const sortOrder = req.query.sortOrder || 'desc';
+                // Vérifier si le candidat existe
+                const candidate = await CandidateModel.findById(candidateId);
+                if (!candidate) {
+                    return res.status(404).json({ message: 'Candidat non trouvé' });
+                }
+                // Construction de la requête
+                const query = { candidateId };
+                if (state !== 'all') {
+                    query.state = state;
+                }
+                // Construction du tri
+                const allowedSortFields = ['invitationDate', 'state', 'score'];
+                const sortField = allowedSortFields.includes(sortBy) ? sortBy : 'invitationDate';
+                const sortOptions = {
+                    [sortField]: sortOrder === 'asc' ? 1 : -1
+                };
+                const [results, total] = await Promise.all([
+                    TestResult.find(query)
+                        .sort(sortOptions)
+                        .skip(skip)
+                        .limit(limit)
+                        .lean()
+                        .exec(),
+                    TestResult.countDocuments(query)
+                ]);
+                // Récupérer les informations des tests associés
+                const testIds = results.map(result => result.testId);
+                const tests = await Test.find({ _id: { $in: testIds } }).lean();
+                const testsMap = new Map(tests.map(test => [test._id.toString(), test]));
+                // Récupérer tous les IDs de catégories utilisés dans les tests
+                const allCategoryIds = Array.from(new Set(tests.flatMap(test => (test.categories || []).map((cat) => cat.categoryId?.toString()))));
+                const TestCategory = (await import('../models/test-category.models.js')).default;
+                const categoriesDocs = await TestCategory.find({ _id: { $in: allCategoryIds } }).lean();
+                const categoriesMap = new Map(categoriesDocs.map(cat => [cat._id.toString(), cat.name]));
+                // Combiner les résultats avec les informations des tests et des catégories
+                const TestQuestion = (await import('../models/test-question.model.js')).default;
+                const resultsWithTests = await Promise.all(results.map(async (result) => {
+                    const test = testsMap.get(result.testId.toString());
+                    let categoriesWithNames = [];
+                    let maxScore = 0;
+                    if (test && test.categories) {
+                        categoriesWithNames = test.categories.map((cat) => ({
+                            ...cat,
+                            categoryName: categoriesMap.get(cat.categoryId?.toString()) || 'Catégorie inconnue'
+                        }));
+                    }
+                    if (test && test.questions && test.questions.length > 0) {
+                        const questionIds = test.questions.map((q) => q.questionId || q);
+                        const questions = await TestQuestion.find({ _id: { $in: questionIds } }).lean();
+                        maxScore = questions.reduce((sum, q) => sum + (q.maxScore || 0), 0);
+                    }
+                    const { responses, ...resultWithoutResponses } = result;
+                    return {
+                        ...resultWithoutResponses,
+                        testResultId: result._id,
+                        maxScore,
+                        test: test
+                            ? {
+                                title: test.title,
+                                description: test.description,
+                                targetJob: await getJobName(test.targetJob),
+                                seniorityLevel: test.seniorityLevel,
+                                categories: categoriesWithNames
+                            }
+                            : null
+                    };
+                }));
+                const totalPages = Math.ceil(total / limit);
+                return res.json({
+                    data: resultsWithTests,
+                    pagination: {
+                        currentPage: page,
+                        totalPages,
+                        totalItems: total,
+                        itemsPerPage: limit,
+                        hasNextPage: page < totalPages,
+                        hasPreviousPage: page > 1
+                    }
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération des résultats :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Obtenir les infos de base d'un test (sans les questions), avec categoryName et maxTime
+        this.get('/test/:id', authenticatedOptions, async (req, res) => {
+            try {
+                const { id } = req.params;
+                const TestCategory = (await import('../models/test-category.models.js')).default;
+                const TestQuestion = (await import('../models/test-question.model.js')).default;
+                // Récupérer le test sans les questions
+                const test = await Test.findById(id).lean();
+                if (!test) {
+                    return res.status(404).json({ message: 'Test non trouvé' });
+                }
+                // Récupérer les noms des catégories
+                const categoryIds = (test.categories || []).map((cat) => cat.categoryId?.toString());
+                const categoriesDocs = await TestCategory.find({ _id: { $in: categoryIds } }).lean();
+                const categoriesMap = new Map(categoriesDocs.map(cat => [cat._id.toString(), cat.name]));
+                const categoriesWithNames = (test.categories || []).map((cat) => ({
+                    ...cat,
+                    categoryName: categoriesMap.get(cat.categoryId?.toString()) || 'Catégorie inconnue'
+                }));
+                // Calculer la somme du temps de toutes les questions
+                const questions = await TestQuestion.find({ _id: { $in: (test.questions || []).map((q) => q.questionId) } }).lean();
+                const maxTime = questions.reduce((sum, q) => sum + (q.time || 0), 0);
+                const numberOfQuestions = questions.length;
+                // Récupérer le nom du job
+                const targetJobName = await getJobName(test.targetJob);
+                // Construire la réponse sans les questions
+                const { questions: _questions, // on retire les questions
+                ...testWithoutQuestions } = test;
+                return res.json({
+                    ...testWithoutQuestions,
+                    targetJobName,
+                    categories: categoriesWithNames,
+                    maxTime,
+                    numberOfQuestions
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération du test :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Obtenir l'ID de la prochaine question non répondue pour un résultat de test
+        this.get('/:id/nextQuestion', authenticatedOptions, async (req, res) => {
+            try {
+                const { id } = req.params;
+                const { currentQuestionId } = req.query;
+                // Récupérer le résultat de test
+                const result = await TestResult.findById(id);
+                if (!result) {
+                    return res.status(404).json({ message: 'Résultat non trouvé' });
+                }
+                // Récupérer le test associé
+                const test = await Test.findById(result.testId).lean();
+                if (!test) {
+                    return res.status(404).json({ message: 'Test non trouvé' });
+                }
+                // Liste des questions du test dans l'ordre
+                const questions = test.questions || [];
+                if (currentQuestionId) {
+                    // Si on a un currentQuestionId, on cherche la question suivante dans l'ordre
+                    const currentIndex = questions.findIndex(q => (q.questionId ? q.questionId.toString() : q.toString()) === currentQuestionId);
+                    if (currentIndex === -1) {
+                        return res.status(404).json({ message: 'Question courante non trouvée' });
+                    }
+                    // Si c'est la dernière question
+                    if (currentIndex === questions.length - 1) {
+                        // On est sur la dernière réponse, on met à jour la date de fin
+                        result.endTime = new Date();
+                        await result.save();
+                        return res.json({ nextQuestionId: 'result' });
+                    }
+                    // Retourner la question suivante
+                    const nextQuestion = questions[currentIndex + 1];
+                    // Si c'est la première question (currentIndex === -1 avant), on met à jour la date de début
+                    if (currentIndex === 0 && !result.startTime) {
+                        result.startTime = new Date();
+                        await result.save();
+                    }
+                    return res.json({
+                        nextQuestionId: nextQuestion.questionId
+                            ? nextQuestion.questionId.toString()
+                            : nextQuestion.toString()
+                    });
+                }
+                else {
+                    // Comportement original : chercher la première question non répondue
+                    const answeredIds = (result.responses || []).map((r) => r.questionId.toString());
+                    let nextQuestionId = null;
+                    for (const q of questions) {
+                        const qid = (q.questionId ? q.questionId.toString() : q.toString());
+                        if (!answeredIds.includes(qid)) {
+                            nextQuestionId = qid;
+                            break;
+                        }
+                    }
+                    if (!nextQuestionId) {
+                        // Plus de question à répondre, on met à jour la date de fin
+                        result.endTime = new Date();
+                        await result.save();
+                        nextQuestionId = 'result';
+                    }
+                    else if (questions.length > 0 && nextQuestionId === (questions[0].questionId ? questions[0].questionId.toString() : questions[0].toString()) && !result.startTime) {
+                        // Si c'est la première question, on met à jour la date de début
+                        result.startTime = new Date();
+                        await result.save();
+                    }
+                    return res.json({ nextQuestionId });
+                }
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération de la prochaine question :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Afficher une question par son ID (optionnellement vérifier la session)
+        this.get('/question/:idQuestion', authenticatedOptions, async (req, res) => {
+            try {
+                const { idQuestion } = req.params;
+                const { sessionId } = req.query;
+                const TestQuestion = (await import('../models/test-question.model.js')).default;
+                // Récupérer la question
+                const question = await TestQuestion.findById(idQuestion).lean();
+                if (!question) {
+                    return res.status(404).json({ message: 'Question non trouvée' });
+                }
+                // Optionnel : vérifier que la question appartient bien au test de la session et n'a pas déjà été répondue
+                let test = null;
+                let questionPosition = -1;
+                let numberOfQuestions = 0;
+                if (sessionId) {
+                    const result = await TestResult.findById(sessionId).lean();
+                    if (!result) {
+                        return res.status(404).json({ message: 'Session (résultat) non trouvée' });
+                    }
+                    test = await Test.findById(result.testId).lean();
+                    if (!test) {
+                        return res.status(404).json({ message: 'Test non trouvé' });
+                    }
+                    const questionIds = (test.questions || []).map((q) => q.questionId?.toString());
+                    if (!questionIds.includes(idQuestion)) {
+                        return res.status(403).json({ message: 'Question non autorisée pour cette session' });
+                    }
+                    // Vérifier que la question n'a pas déjà été répondue
+                    const alreadyAnswered = (result.responses || []).some((r) => r.questionId?.toString() === idQuestion);
+                    if (alreadyAnswered) {
+                        return res.status(403).json({ message: 'Question déjà répondue pour cette session' });
+                    }
+                }
+                else {
+                    // Si pas de sessionId, on doit quand même récupérer le test pour avoir les infos
+                    // Chercher dans tous les tests pour trouver celui qui contient cette question
+                    const allTests = await Test.find({}).lean();
+                    for (const t of allTests) {
+                        const questionIds = (t.questions || []).map((q) => q.questionId?.toString());
+                        if (questionIds.includes(idQuestion)) {
+                            test = t;
+                            break;
+                        }
+                    }
+                }
+                // Calculer la position de la question et le nombre total de questions
+                if (test) {
+                    numberOfQuestions = test.questions?.length || 0;
+                    const questionIndex = test.questions?.findIndex((q) => q.questionId?.toString() === idQuestion);
+                    questionPosition = questionIndex !== -1 ? questionIndex + 1 : -1; // +1 car les positions commencent à 1
+                }
+                return res.json({
+                    question,
+                    numberOfQuestions,
+                    questionPosition
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de la récupération de la question :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+        // Enregistrer la réponse à une question pour un résultat de test
+        this.post('/response', authenticatedOptions, async (req, res) => {
+            try {
+                const { response, questionId, testResultId } = req.body;
+                // Récupérer le résultat de test
+                const result = await TestResult.findById(testResultId);
+                if (!result) {
+                    return res.status(404).json({ message: 'Résultat non trouvé' });
+                }
+                // Récupérer le test associé
+                const test = await Test.findById(result.testId);
+                if (!test) {
+                    return res.status(404).json({ message: 'Test non trouvé' });
+                }
+                // Vérifier que la question appartient bien au test
+                const questionIds = (test.questions || []).map((q) => q.questionId?.toString());
+                if (!questionIds.includes(questionId)) {
+                    return res.status(403).json({ message: 'Question non autorisée pour ce test' });
+                }
+                // Vérifier que la question n'a pas déjà été répondue
+                const alreadyAnswered = (result.responses || []).some((r) => r.questionId?.toString() === questionId);
+                if (alreadyAnswered) {
+                    return res.status(403).json({ message: 'Question déjà répondue pour cette session' });
+                }
+                // Enregistrer la réponse
+                result.responses = result.responses || [];
+                result.responses.push({
+                    questionId,
+                    response,
+                    score: 0,
+                    comment: ''
+                });
+                // Marquer explicitement le champ responses comme modifié
+                result.markModified('responses');
+                console.log('Avant sauvegarde - Responses:', result.responses);
+                // Vérifier si c'était la dernière question
+                const totalQuestions = test.questions.length;
+                const answeredQuestions = result.responses.length;
+                if (answeredQuestions === totalQuestions) {
+                    result.state = TestState.Finish;
+                }
+                else {
+                    result.state = TestState.InProgress;
+                }
+                // Sauvegarder d'abord la réponse
+                const savedResult = await result.save();
+                console.log('Après sauvegarde - Responses:', savedResult.responses);
+                // Déclencher la correction automatique seulement après la sauvegarde
+                if (answeredQuestions === totalQuestions) {
+                    await enduranceEmitter.emit(enduranceEventTypes.CORRECT_TEST, savedResult);
+                }
+                return res.status(200).json({
+                    message: 'Réponse enregistrée',
+                    response,
+                    isLastQuestion: answeredQuestions === totalQuestions
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de l\'enregistrement de la réponse :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
+    }
+}
+const router = new ResultRouter();
+export default router;

package/dist/modules/edrm-exams/routes/user.router.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceRouter } from '@programisto/endurance-core';
+declare class UserRouter extends EnduranceRouter {
+    constructor();
+    setupRoutes(): void;
+}
+declare const router: UserRouter;
+export default router;

package/dist/modules/edrm-exams/routes/user.router.js

@@ -0,0 +1,96 @@
+import { EnduranceRouter, EnduranceAuthMiddleware } from '@programisto/endurance-core';
+import UserExam from '../models/user.model.js';
+class UserRouter extends EnduranceRouter {
+    constructor() {
+        super(EnduranceAuthMiddleware.getInstance());
+    }
+    setupRoutes() {
+        const authenticatedOptions = {
+            requireAuth: false,
+            permissions: []
+        };
+        // Lister tous les utilisateurs
+        this.get('/', authenticatedOptions, async (req, res) => {
+            try {
+                const users = await UserExam.find();
+                res.status(200).json({ array: users });
+            }
+            catch (err) {
+                console.error('Error when retrieving users: ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Créer un utilisateur
+        this.post('/create', authenticatedOptions, async (req, res) => {
+            const { firstName, lastName, email, companyId } = req.body;
+            if (!firstName || !lastName || !email || !companyId) {
+                return res.status(400).json({ message: 'Error, firstName, lastName, email and companyId are required' });
+            }
+            try {
+                const newUser = new UserExam({ firstName, lastName, email, companyId });
+                await newUser.save();
+                res.status(201).json({ message: 'user created with sucess', user: newUser });
+            }
+            catch (err) {
+                console.error('error when creating user : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Obtenir un utilisateur par son ID
+        this.get('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const user = await UserExam.findById(id);
+                if (!user) {
+                    return res.status(404).json({ message: 'no user founded with this id' });
+                }
+                res.status(200).json({ data: user });
+            }
+            catch (err) {
+                console.error('error when geting user : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Mettre à jour un utilisateur
+        this.put('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            const { firstName, lastName, email, companyId } = req.body;
+            try {
+                const user = await UserExam.findById(id);
+                if (!user) {
+                    return res.status(404).json({ message: 'no user founded with this id' });
+                }
+                const updateData = {
+                    firstName: firstName || user.firstName,
+                    lastName: lastName || user.lastName,
+                    email: email || user.email,
+                    companyId: companyId || user.companyId
+                };
+                await UserExam.findByIdAndUpdate(id, updateData, { new: true });
+                const updatedUser = await UserExam.findById(id);
+                res.status(200).json({ message: 'user updated', user: updatedUser });
+            }
+            catch (err) {
+                console.error('error when updating user : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Supprimer un utilisateur
+        this.delete('/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const user = await UserExam.findByIdAndDelete(id);
+                if (!user) {
+                    return res.status(404).json({ message: 'no user founded with this id' });
+                }
+                res.status(200).json({ message: 'user deleted', user });
+            }
+            catch (err) {
+                console.error('error when deleting user : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+    }
+}
+const router = new UserRouter();
+export default router;

package/dist/modules/edrm-storage/config/edrm-storage.config.d.ts

@@ -0,0 +1,29 @@
+export interface EdrmStorageConfig {
+    aws: {
+        region: string;
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        bucket: string;
+    };
+    minio?: {
+        endpoint: string;
+        accessKey: string;
+        secretKey: string;
+        bucket: string;
+        useSSL: boolean;
+    };
+    general: {
+        defaultProvider: 'S3' | 'MINIO' | 'LOCAL';
+        maxFileSize: number;
+        allowedMimeTypes: string[];
+        uploadExpiresIn: number;
+        downloadExpiresIn: number;
+    };
+    events: {
+        enabled: boolean;
+        emitFileStored: boolean;
+        emitFileDeleted: boolean;
+        emitFileAccessed: boolean;
+    };
+}
+export declare const defaultConfig: EdrmStorageConfig;

package/dist/modules/edrm-storage/config/edrm-storage.config.js

@@ -0,0 +1,31 @@
+export const defaultConfig = {
+    aws: {
+        region: process.env.AWS_REGION || 'us-east-1',
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        bucket: process.env.S3_BUCKET || 'edrm-storage'
+    },
+    general: {
+        defaultProvider: 'S3',
+        maxFileSize: 100 * 1024 * 1024, // 100MB
+        allowedMimeTypes: [
+            'application/pdf',
+            'application/msword',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'image/jpeg',
+            'image/png',
+            'image/gif',
+            'text/plain',
+            'application/zip',
+            'application/x-zip-compressed'
+        ],
+        uploadExpiresIn: 3600, // 1 heure
+        downloadExpiresIn: 3600 // 1 heure
+    },
+    events: {
+        enabled: true,
+        emitFileStored: true,
+        emitFileDeleted: true,
+        emitFileAccessed: true
+    }
+};

package/dist/modules/edrm-storage/config/environment.example.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Configuration d'environnement pour le module EDRM Storage
+ * Copiez ce fichier vers .env et configurez vos valeurs
+ */
+export declare const EdrmStorageEnvironment: {
+    AWS: {
+        REGION: string;
+        ACCESS_KEY_ID: string;
+        SECRET_ACCESS_KEY: string;
+        BUCKET: string;
+    };
+    MINIO: {
+        ENDPOINT: string;
+        ACCESS_KEY: string;
+        SECRET_KEY: string;
+        BUCKET: string;
+        USE_SSL: boolean;
+    };
+    GENERAL: {
+        DEFAULT_PROVIDER: string;
+        MAX_FILE_SIZE: number;
+        UPLOAD_EXPIRES_IN: number;
+        DOWNLOAD_EXPIRES_IN: number;
+        ALLOWED_MIME_TYPES: string[];
+    };
+    EVENTS: {
+        ENABLED: boolean;
+        EMIT_FILE_STORED: boolean;
+        EMIT_FILE_DELETED: boolean;
+        EMIT_FILE_ACCESSED: boolean;
+    };
+    SECURITY: {
+        PRESIGNED_URL_EXPIRES_IN: number;
+        MAX_CONCURRENT_UPLOADS: number;
+        ENABLE_ANTIVIRUS: boolean;
+        ENABLE_WATERMARKING: boolean;
+    };
+    MONITORING: {
+        ENABLE_METRICS: boolean;
+        LOG_LEVEL: string;
+        ENABLE_AUDIT_LOG: boolean;
+    };
+};
+/**
+ * Validation de la configuration
+ */
+export declare function validateEdrmStorageConfig(): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Exemple de fichier .env
+ */
+export declare const ENV_EXAMPLE = "\n# Configuration AWS S3\nAWS_REGION=us-east-1\nAWS_ACCESS_KEY_ID=your_access_key_here\nAWS_SECRET_ACCESS_KEY=your_secret_key_here\nS3_BUCKET=edrm-storage\n\n# Configuration MinIO (optionnel)\nMINIO_ENDPOINT=http://localhost:9000\nMINIO_ACCESS_KEY=your_minio_key\nMINIO_SECRET_KEY=your_minio_secret\nMINIO_BUCKET=edrm-storage\nMINIO_USE_SSL=false\n\n# Configuration g\u00E9n\u00E9rale\nEDRM_STORAGE_PROVIDER=S3\nEDRM_MAX_FILE_SIZE=104857600\nEDRM_UPLOAD_EXPIRES_IN=3600\nEDRM_DOWNLOAD_EXPIRES_IN=3600\nEDRM_ALLOWED_MIME_TYPES=application/pdf,image/jpeg,image/png\n\n# Configuration des \u00E9v\u00E9nements\nEDRM_EVENTS_ENABLED=true\nEDRM_EMIT_FILE_STORED=true\nEDRM_EMIT_FILE_DELETED=true\nEDRM_EMIT_FILE_ACCESSED=true\n\n# Configuration de s\u00E9curit\u00E9\nEDRM_PRESIGNED_URL_EXPIRES_IN=3600\nEDRM_MAX_CONCURRENT_UPLOADS=100\nEDRM_ENABLE_ANTIVIRUS=false\nEDRM_ENABLE_WATERMARKING=false\n\n# Configuration de monitoring\nEDRM_ENABLE_METRICS=true\nEDRM_LOG_LEVEL=info\nEDRM_ENABLE_AUDIT_LOG=false\n";