@programisto/edrm-exams 0.1.4 → 0.1.5

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

@@ -0,0 +1,7 @@
+import { EnduranceRouter } from '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,314 @@
+import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEventTypes } from 'endurance-core';
+import CandidateModel from '../models/candidate.models.js';
+import TestResult, { TestState } from '../models/test-result.model.js';
+import Test from '../models/test.model.js';
+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: 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);
+                // Construire la réponse sans les questions
+                const { questions: _questions, // on retire les questions
+                ...testWithoutQuestions } = test;
+                return res.json({
+                    ...testWithoutQuestions,
+                    categories: categoriesWithNames,
+                    maxTime
+                });
+            }
+            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
+                if (sessionId) {
+                    const result = await TestResult.findById(sessionId).lean();
+                    if (!result) {
+                        return res.status(404).json({ message: 'Session (résultat) non trouvée' });
+                    }
+                    const 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' });
+                    }
+                }
+                return res.json({ question });
+            }
+            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: ''
+                });
+                // 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;
+                    // Déclencher la correction automatique
+                    await enduranceEmitter.emit(enduranceEventTypes.CORRECT_TEST, result);
+                }
+                else {
+                    result.state = TestState.InProgress;
+                }
+                await result.save();
+                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 '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 'endurance-core';
+import User 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 User.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 User({ 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 User.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 User.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 User.findByIdAndUpdate(id, updateData, { new: true });
+                const updatedUser = await User.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 User.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/package.json

@@ -1,15 +1,80 @@
 {
+  "type": "module",
   "name": "@programisto/edrm-exams",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "publishConfig": {
     "access": "public"
   },
-  "description": "endurance module with basic exams route",
-  "license": "ISC",
-  "author": "",
-  "type": "commonjs",
-  "main": "index.js",
+  "description": "an api for online exams",
+  "main": "app.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  }
+    "start": "node ./dist/bin/www",
+    "dev": "tsc-watch --onSuccess \"node ./dist/bin/www\"",
+    "test": "mocha",
+    "build": "tsc && npm run copy-files",
+    "copy-files": "copyfiles -u 1 'src/**/*.txt' dist",
+    "lint": "eslint \"**/*.{ts,tsx}\"",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "aws-sdk": "^2.1692.0",
+    "debug": "^4.3.7",
+    "edrm-mailer": "^0.4.5",
+    "edrm-user": "^0.4.9",
+    "endurance-core": "^0.4.25",
+    "fs": "^0.0.1-security",
+    "http": "^0.0.1-security",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.8.3",
+    "multer": "^1.4.5-lts.2",
+    "multer-s3": "^3.0.1",
+    "mustache": "^4.2.0",
+    "nodemailer": "^6.10.1",
+    "openai": "^4.100.0",
+    "path": "^0.12.7",
+    "to-regex-range": "^5.0.1",
+    "tsc-watch": "^6.2.1",
+    "url": "^0.11.4",
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.3",
+    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "@types/node": "^22.15.3",
+    "commitlint": "^19.8.1",
+    "copyfiles": "^2.4.1",
+    "@typescript-eslint/eslint-plugin": "^8.26.0",
+    "@typescript-eslint/parser": "^8.26.0",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "husky": "^9.1.7",
+    "mocha": "^11.0.1",
+    "nodemon": "^3.1.4",
+    "semantic-release": "^24.2.5",
+    "supertest": "^3.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/programisto-labs/edrm-exams.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/programisto-labs/edrm-exams/issues"
+  },
+  "homepage": "https://github.com/programisto-labs/edrm-exams#readme",
+  "files": [
+    "dist",
+    "README.md"
+  ]
 }