@programisto/edrm-exams 0.2.5 → 0.2.7

package/dist/modules/edrm-exams/listeners/correct.listener.js

@@ -1,9 +1,11 @@
-import { enduranceListener, enduranceEventTypes } from '@programisto/endurance-core';
+import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance-core';
 import TestQuestion from '../models/test-question.model.js';
 import { generateLiveMessage } from '../lib/openai.js';
 import TestResult, { TestState } from '../models/test-result.model.js';
+import CandidateModel from '../models/candidate.model.js';
+import ContactModel from '../models/contact.model.js';
+import TestModel from '../models/test.model.js';
 async function correctTest(options) {
-    console.log('Correcting test', { options });
     if (!options.testId)
         throw new Error('TestId is required');
     if (!options.responses)
@@ -17,6 +19,7 @@ async function correctTest(options) {
             throw new Error('Test result not found');
         }
         let finalscore = 0;
+        let maxScore = 0;
         // Pour chaque réponse enregistrée en base, on cherche la correction correspondante
         for (const dbResponse of result.responses) {
             const correction = options.responses.find(r => r.questionId.toString() === dbResponse.questionId.toString());
@@ -27,6 +30,7 @@ async function correctTest(options) {
                 console.error('Question not found', { questionId: dbResponse.questionId });
                 continue;
             }
+            maxScore += question.maxScore;
             const scoreResponse = await generateLiveMessage('correctQuestion', {
                 question: {
                     _id: question._id.toString(),
@@ -53,15 +57,33 @@ async function correctTest(options) {
         result.state = TestState.Finish;
         // Forcer la sauvegarde des sous-documents responses
         result.markModified('responses');
+        const scorePercentage = (finalscore / maxScore) * 100;
         // Sauvegarder les modifications avec findByIdAndUpdate pour éviter les conflits de version
         await TestResult.findByIdAndUpdate(result._id, {
             $set: {
                 responses: result.responses,
-                score: result.score,
+                score: scorePercentage,
                 state: result.state
             }
         });
-        console.log('Test correction completed and saved', { finalScore: finalscore });
+        const test = await TestModel.findById(result.testId);
+        const candidate = await CandidateModel.findById(result.candidateId);
+        if (candidate) {
+            const contact = await ContactModel.findById(candidate.contact);
+            if (contact) {
+                enduranceEmitter.emit(enduranceEventTypes.SEND_EMAIL, {
+                    template: 'test-result',
+                    to: contact.email,
+                    data: {
+                        firstname: contact.firstname,
+                        lastname: contact.lastname,
+                        score: result.score,
+                        testName: test?.title || '',
+                        testLink: process.env.TEST_INVITATION_LINK || ''
+                    }
+                });
+            }
+        }
     }
     catch (err) {
         if (err instanceof Error) {

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

@@ -1,5 +1,5 @@
 import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance-core';
-import CandidateModel from '../models/candidate.models.js';
+import CandidateModel from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
 import TestResult from '../models/test-result.model.js';
 import Test from '../models/test.model.js';

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

@@ -3,7 +3,7 @@ import Test from '../models/test.model.js';
 import TestQuestion from '../models/test-question.model.js';
 import TestResult from '../models/test-result.model.js';
 import TestCategory from '../models/test-category.models.js';
-import Candidate from '../models/candidate.models.js';
+import Candidate from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
 import { generateLiveMessage } from '../lib/openai.js';
 class ExamsRouter extends EnduranceRouter {
@@ -565,6 +565,8 @@ class ExamsRouter extends EnduranceRouter {
                     emailUser,
                     emailPassword,
                     data: {
+                        firstname: contact.firstname,
+                        testName: test?.title || '',
                         testLink
                     }
                 });
@@ -810,15 +812,23 @@ class ExamsRouter extends EnduranceRouter {
                 if (categoriesToUse.length === 0) {
                     return res.status(400).json({ message: 'Aucune catégorie disponible pour générer des questions' });
                 }
-                const questionsPerCategory = Math.ceil(numberOfQuestions / categoriesToUse.length);
                 const generatedQuestions = [];
-                for (const categoryInfo of categoriesToUse) {
+                let questionsGenerated = 0;
+                // Mélanger les catégories pour une répartition aléatoire
+                const shuffledCategories = [...categoriesToUse].sort(() => Math.random() - 0.5);
+                for (const categoryInfo of shuffledCategories) {
+                    // Arrêter si on a déjà généré le nombre de questions demandé
+                    if (questionsGenerated >= numberOfQuestions)
+                        break;
                     const categoryDoc = await TestCategory.findById(categoryInfo.categoryId);
                     if (!categoryDoc)
                         continue;
                     const otherQuestionsIds = test.questions.map(question => question.questionId);
                     const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
-                    for (let i = 0; i < questionsPerCategory; i++) {
+                    // Calculer combien de questions générer pour cette catégorie
+                    const remainingQuestions = numberOfQuestions - questionsGenerated;
+                    const questionsForThisCategory = Math.min(remainingQuestions, 1); // Au maximum 1 question par catégorie
+                    for (let i = 0; i < questionsForThisCategory; i++) {
                         const generatedQuestion = await generateLiveMessage('createQuestion', {
                             job: test.targetJob,
                             seniority: test.seniorityLevel,
@@ -837,6 +847,7 @@ class ExamsRouter extends EnduranceRouter {
                             await question.save();
                             generatedQuestions.push(question);
                             test.questions.push({ questionId: question._id, order: test.questions.length });
+                            questionsGenerated++;
                         }
                         catch (parseError) {
                             console.error('Erreur lors du parsing de la question générée:', parseError);
@@ -871,6 +882,8 @@ class ExamsRouter extends EnduranceRouter {
             const skip = (page - 1) * limit;
             const search = req.query.search || '';
             const state = req.query.state || 'all';
+            const sortBy = req.query.sortBy || 'invitationDate';
+            const sortOrder = req.query.sortOrder || 'desc';
             try {
                 const test = await Test.findById(testId);
                 if (!test) {
@@ -881,30 +894,84 @@ class ExamsRouter extends EnduranceRouter {
                 if (state !== 'all') {
                     query.state = state;
                 }
-                // Recherche sur les candidats
+                // Recherche sur les candidats via leurs contacts
                 if (search) {
-                    const candidates = await Candidate.find({
+                    // D'abord, rechercher dans les contacts
+                    const contacts = await ContactModel.find({
                         $or: [
-                            { firstName: { $regex: search, $options: 'i' } },
-                            { lastName: { $regex: search, $options: 'i' } },
+                            { firstname: { $regex: search, $options: 'i' } },
+                            { lastname: { $regex: search, $options: 'i' } },
                             { email: { $regex: search, $options: 'i' } }
                         ]
                     });
+                    // Ensuite, récupérer les candidats qui ont ces contacts
+                    const contactIds = contacts.map(c => c._id);
+                    const candidates = await Candidate.find({
+                        contact: { $in: contactIds }
+                    });
                     const candidateIds = candidates.map(c => c._id);
                     query.candidateId = { $in: candidateIds };
                 }
-                const [results, total] = await Promise.all([
-                    TestResult.find(query)
-                        .sort({ invitationDate: -1 })
-                        .skip(skip)
-                        .limit(limit)
-                        .exec(),
-                    TestResult.countDocuments(query)
-                ]);
-                // Récupérer les données des candidats
-                const candidateIds = results.map(result => result.candidateId);
-                const candidates = await Candidate.find({ _id: { $in: candidateIds } });
-                const candidatesMap = new Map(candidates.map(c => [c._id.toString(), c]));
+                // Déterminer l'ordre de tri
+                const sortDirection = sortOrder === 'asc' ? 1 : -1;
+                // Si on trie par lastName, on récupère tous les résultats puis on trie après
+                // Sinon on peut trier directement dans la requête MongoDB
+                let results, total;
+                if (sortBy === 'lastName') {
+                    // Récupérer tous les résultats sans pagination pour pouvoir trier par lastName
+                    const allResults = await TestResult.find(query).exec();
+                    total = allResults.length;
+                    // Récupérer les données des candidats pour le tri
+                    const candidateIds = allResults.map(result => result.candidateId);
+                    const candidates = await Candidate.find({ _id: { $in: candidateIds } });
+                    const candidatesMap = new Map(candidates.map(c => [c._id.toString(), c]));
+                    // Combiner les résultats avec les données des candidats et trier
+                    const resultsWithCandidates = await Promise.all(allResults.map(async (result) => {
+                        const candidate = candidatesMap.get(result.candidateId.toString());
+                        if (!candidate) {
+                            return {
+                                ...result.toObject(),
+                                candidate: null,
+                                lastName: ''
+                            };
+                        }
+                        const contact = await ContactModel.findById(candidate.contact);
+                        return {
+                            ...result.toObject(),
+                            candidate: contact
+                                ? {
+                                    firstName: contact.firstname,
+                                    lastName: contact.lastname,
+                                    email: contact.email
+                                }
+                                : null,
+                            lastName: contact ? contact.lastname : ''
+                        };
+                    }));
+                    // Trier par lastName
+                    resultsWithCandidates.sort((a, b) => {
+                        const lastNameA = (a.lastName || '').toLowerCase();
+                        const lastNameB = (b.lastName || '').toLowerCase();
+                        return sortDirection === 1
+                            ? lastNameA.localeCompare(lastNameB)
+                            : lastNameB.localeCompare(lastNameA);
+                    });
+                    // Appliquer la pagination
+                    results = resultsWithCandidates.slice(skip, skip + limit);
+                }
+                else {
+                    // Tri direct dans MongoDB pour invitationDate
+                    const sortObject = {};
+                    sortObject[sortBy] = sortDirection;
+                    [results, total] = await Promise.all([
+                        TestResult.find(query)
+                            .sort(sortObject)
+                            .skip(skip)
+                            .limit(limit)
+                            .exec(),
+                        TestResult.countDocuments(query)
+                    ]);
+                }
                 // Calculer le maxScore du test
                 let maxScore = 0;
                 if (test.questions && test.questions.length > 0) {
@@ -912,30 +979,45 @@ class ExamsRouter extends EnduranceRouter {
                     const questions = await TestQuestion.find({ _id: { $in: questionIds } }).lean();
                     maxScore = questions.reduce((sum, q) => sum + (q.maxScore || 0), 0);
                 }
-                // Combiner les résultats avec les données des candidats
-                const resultsWithCandidates = await Promise.all(results.map(async (result) => {
-                    const candidate = candidatesMap.get(result.candidateId.toString());
-                    if (!candidate) {
+                // Si on a déjà traité les candidats pour le tri par lastName, on utilise directement les résultats
+                let resultsWithCandidates;
+                if (sortBy === 'lastName') {
+                    // Les résultats sont déjà traités avec les données des candidats
+                    resultsWithCandidates = results.map(result => ({
+                        ...result,
+                        maxScore
+                    }));
+                }
+                else {
+                    // Récupérer les données des candidats
+                    const candidateIds = results.map(result => result.candidateId);
+                    const candidates = await Candidate.find({ _id: { $in: candidateIds } });
+                    const candidatesMap = new Map(candidates.map(c => [c._id.toString(), c]));
+                    // Combiner les résultats avec les données des candidats
+                    resultsWithCandidates = await Promise.all(results.map(async (result) => {
+                        const candidate = candidatesMap.get(result.candidateId.toString());
+                        if (!candidate) {
+                            return {
+                                ...result.toObject(),
+                                candidate: null,
+                                maxScore
+                            };
+                        }
+                        // Récupérer le contact pour obtenir les informations personnelles
+                        const contact = await ContactModel.findById(candidate.contact);
                         return {
                             ...result.toObject(),
-                            candidate: null,
+                            candidate: contact
+                                ? {
+                                    firstName: contact.firstname,
+                                    lastName: contact.lastname,
+                                    email: contact.email
+                                }
+                                : null,
                             maxScore
                         };
-                    }
-                    // Récupérer le contact pour obtenir les informations personnelles
-                    const contact = await ContactModel.findById(candidate.contact);
-                    return {
-                        ...result.toObject(),
-                        candidate: contact
-                            ? {
-                                firstName: contact.firstname,
-                                lastName: contact.lastname,
-                                email: contact.email
-                            }
-                            : null,
-                        maxScore
-                    };
-                }));
+                    }));
+                }
                 const totalPages = Math.ceil(total / limit);
                 return res.json({
                     data: resultsWithCandidates,

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

@@ -1,5 +1,5 @@
 import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance-core';
-import CandidateModel from '../models/candidate.models.js';
+import CandidateModel from '../models/candidate.model.js';
 import TestResult, { TestState } from '../models/test-result.model.js';
 import Test from '../models/test.model.js';
 class ResultRouter extends EnduranceRouter {

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@programisto/edrm-exams",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "publishConfig": {
     "access": "public"
   },