@programisto/edrm-exams 0.2.12 → 0.3.0

package/dist/modules/edrm-exams/lib/openai/correctQuestion.txt

@@ -1,10 +1,6 @@
-Tu est un correcteur de question de concours.
-Tu doit donner un score à cette question : ${instruction} dont la réponse donnée par le candidat est : ${response}.
-Il s'agissait d'une question de type ${questionType} (et si la question est de type MCQ alors les réponses possibles étaient les suivantes : ${possibleResponses})
-le score maximum pour cette question est ${maxScore}
-Tu doit donner un score entre 0 et ${maxScore} et un commentaire de correction.
-Tu dois répondre au format JSON : la reponse envoyer doit correspondre exactement à ce model json : 
-{
-    "score": score,
-    "comment": commentaire
-}
+Question : ${instruction}
+Type de question : ${questionType} 
+- si MCQ les réponses possibles étaient : ${possibleResponses}
+
+Réponse du candidat : ${response}
+Score à donner : De 0 à ${maxScore} avec un commentaire de correction

package/dist/modules/edrm-exams/lib/openai/createQuestion.txt

@@ -1,68 +1,6 @@
-Tu es un assistant qui crée des questions pour un test.
-    créer une question en fonction de du métier : ${job}, du niveau de seniorité : ${seniority}, de la categorie de question : ${category} et le niveau d'expertise de cette categorie : ${expertiseLevel} (allant de 1 à 10, de 1 à 3 = 'beginner', de 3 à 6 = 'intermediate', de 6 à 10 = 'advanced').
-    - la question doit être de type : ${questionType}.
-    - la question doit être dans la langue suivante : Français
-    - voici le model pour une question : 
-    const questionModel = new mongoose.Schema(
-    {
-        instruction:
-        {
-            type: String,
-            required: true
-        },
-        questionType:
-        {
-            type: String,
-            enum: 
-            ["MCQ", "free question", "exercice"],
-            required: true,
-        },
-        maxScore:
-        {
-            type: Number,
-            required: true,
-        },
-        possibleResponses: // only on MCQ (multiple choice responses)
-        {
-            type: 
-            [{
-                possibleResponse:
-                {
-                    type: String,
-                    required: true,
-                },
-                valid:
-                {
-                    type: Boolean,
-                    required: true
-                }
-            }],
-        },
-        time: // in secondes
-        {
-            type: Number,
-            required: true,
-        },
-        textType: //type d'input demandé à l'utilisateur 
-        {
-            type: String,
-            enum:
-            ["text", "code"],
-            required: false
-        }
-    });
-    - toutes les instruction et les réponses doivent toujours être compatible avec LaTeX pour être afficher dans des balises <MathJax>
-        voici un exemple : Voici une formule mathématique : \\( \\frac{a}{b} = c \\)
-    - voici des containtes pour chaque type de question : 
-    - MCQ
-        (il ne peut y avoir qu'une seule réponse juste sur quatre au total) le temps pour ces questions vont de 30 secondes à 1 minute
-    - free question ( ne rien mettre dans possibleResponses)
-        le temps pour ces questions vont de 30 secondes à 5 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
-    - exercice ( ne rien mettre dans possibleResponses )
-        le temps pour ces questions vont de 3 à 20 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
-    - les instruction et la difficulté doivent être en rapport avec targetJob et seniorityLevel de ${test}
-    - le temps pour répondre à la question dans time doit laisser le temps aux utilisateur d'y répondre, sans non plus lui laisser trop de temps pour qu'il triche (surtout sur les QCM).
-    - le format de la réponses doit être en json avec seulement les elements présent dans le model ci dessus et pas besoin d'ajouter d"_id".
-    - si la réponse attendue à une question de type free question ou exercice est un bout de code, alors remplit textType en "code", sinon laisse "text"
+Métier ciblé : ${job}
+Catégorie de la question : ${category} niveau ${expertiseLevel} 
+Type de question : ${questionType}
+Format : json
 
-    Pour ne pas faire de doublon, voici la liste des questions déjà présentes dans le test : ${otherQuestions}
+Voici la liste des questions déjà présentes dans le test (pour éviter les doublons) : ${otherQuestions}

package/dist/modules/edrm-exams/lib/openai.d.ts

@@ -33,4 +33,5 @@ interface ContextBuilder {
     }>;
 }
 export declare function generateLiveMessage(messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
+export declare function generateLiveMessageAssistant(assistantId: string, messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
 export {};

package/dist/modules/edrm-exams/lib/openai.js

@@ -74,6 +74,59 @@ export async function generateLiveMessage(messageType, params, json) {
     }
     return 'Brain freezed, I cannot generate a live message right now.';
 }
+export async function generateLiveMessageAssistant(assistantId, messageType, params, json) {
+    const MAX_RETRY = 2;
+    let retryCount = 0;
+    // Construire le contexte pour le message
+    const context = await contextBuilder[messageType](params);
+    const text = fs.readFileSync(path.join(__dirname, 'openai', `${messageType}.txt`), 'utf8');
+    const message = text.replace(/\${(.*?)}/g, (_, v) => context[v]);
+    while (retryCount <= MAX_RETRY) {
+        try {
+            // Créer un thread avec l'assistant
+            const thread = await openai.beta.threads.create();
+            // Ajouter le message avec le contexte
+            await openai.beta.threads.messages.create(thread.id, {
+                role: 'user',
+                content: message
+            });
+            // Exécuter l'assistant
+            const run = await openai.beta.threads.runs.create(thread.id, {
+                assistant_id: assistantId
+            });
+            // Attendre que l'exécution soit terminée
+            let runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            while (runStatus.status === 'in_progress' || runStatus.status === 'queued') {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            }
+            if (runStatus.status === 'failed') {
+                throw new Error('Assistant execution failed');
+            }
+            // Récupérer les messages de réponse
+            const messages = await openai.beta.threads.messages.list(thread.id);
+            const lastMessage = messages.data[0]; // Le premier message est le plus récent
+            if (!lastMessage || !lastMessage.content || lastMessage.content.length === 0) {
+                throw new Error('No content in response');
+            }
+            const content = lastMessage.content[0];
+            if (content.type === 'text') {
+                return removeQuotes(content.text.value);
+            }
+            else {
+                throw new Error('Unexpected content type');
+            }
+        }
+        catch (error) {
+            retryCount++;
+            console.log(error);
+            if (retryCount > MAX_RETRY) {
+                return 'Brain freezed, I cannot generate a live message right now.';
+            }
+        }
+    }
+    return 'Brain freezed, I cannot generate a live message right now.';
+}
 function removeQuotes(str) {
     if (str.startsWith('"') && str.endsWith('"')) {
         return str.substring(1, str.length - 1);

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

@@ -1,6 +1,6 @@
 import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance-core';
 import TestQuestion from '../models/test-question.model.js';
-import { generateLiveMessage } from '../lib/openai.js';
+import { generateLiveMessageAssistant } 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';
@@ -31,7 +31,7 @@ async function correctTest(options) {
                 continue;
             }
             maxScore += question.maxScore;
-            const scoreResponse = await generateLiveMessage('correctQuestion', {
+            const scoreResponse = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
                 question: {
                     _id: question._id.toString(),
                     instruction: question.instruction,
@@ -48,16 +48,49 @@ async function correctTest(options) {
             }, true);
             console.log('Correction result:', { scoreResponse });
             const parsedResult = JSON.parse(scoreResponse);
-            finalscore += parsedResult.score;
-            dbResponse.score = parsedResult.score;
+            // Valider le score retourné par l'IA
+            let validScore = 0;
+            if (parsedResult.score !== undefined && parsedResult.score !== null) {
+                const score = parseFloat(parsedResult.score.toString());
+                if (!isNaN(score) && isFinite(score) && score >= 0) {
+                    validScore = score;
+                }
+                else {
+                    console.warn('Invalid score returned by AI:', parsedResult.score);
+                }
+            }
+            finalscore += validScore;
+            dbResponse.score = validScore;
             dbResponse.comment = parsedResult.comment || '';
         }
+        // S'assurer que finalscore est un nombre valide
+        if (isNaN(finalscore) || !isFinite(finalscore)) {
+            console.warn('Invalid finalscore calculated, setting to 0:', finalscore);
+            finalscore = 0;
+        }
+        // S'assurer que maxScore est un nombre valide
+        if (isNaN(maxScore) || !isFinite(maxScore)) {
+            console.warn('Invalid maxScore calculated, setting to 0:', maxScore);
+            maxScore = 0;
+        }
         // Mettre à jour le score final et l'état
         result.score = finalscore;
         result.state = TestState.Finish;
         // Forcer la sauvegarde des sous-documents responses
         result.markModified('responses');
-        const scorePercentage = Math.ceil((finalscore / maxScore) * 100);
+        // Calculer le pourcentage de score en évitant la division par zéro
+        let scorePercentage = 0;
+        if (maxScore > 0) {
+            scorePercentage = Math.ceil((finalscore / maxScore) * 100);
+        }
+        else if (finalscore > 0) {
+            // Si maxScore est 0 mais qu'il y a un score, on met 100%
+            scorePercentage = 100;
+        }
+        // S'assurer que le score est un nombre valide
+        if (isNaN(scorePercentage) || !isFinite(scorePercentage)) {
+            scorePercentage = 0;
+        }
         // Sauvegarder les modifications avec findByIdAndUpdate pour éviter les conflits de version
         await TestResult.findByIdAndUpdate(result._id, {
             $set: {
@@ -80,7 +113,7 @@ async function correctTest(options) {
                         lastname: contact.lastname,
                         score: result.score,
                         testName: test?.title || '',
-                        testLink: testLink
+                        testLink
                     }
                 });
             }

package/dist/modules/edrm-exams/models/test-job.model.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+declare class TestJob extends EnduranceSchema {
+    name: string;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestJob, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const TestJobModel: import("@typegoose/typegoose").ReturnModelType<typeof TestJob, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default TestJobModel;

package/dist/modules/edrm-exams/models/test-job.model.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
+let TestJob = class TestJob extends EnduranceSchema {
+    name;
+    static getModel() {
+        return TestJobModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], TestJob.prototype, "name", void 0);
+TestJob = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], TestJob);
+const TestJobModel = EnduranceModelType.getModelForClass(TestJob);
+export default TestJobModel;

package/dist/modules/edrm-exams/models/test.model.d.ts

@@ -2,19 +2,13 @@ import { EnduranceSchema } from '@programisto/endurance-core';
 import Company from './company.model.js';
 import TestQuestion from './test-question.model.js';
 import TestCategory from './test-category.models.js';
+import TestJob from './test-job.model.js';
 import User from './user.model.js';
 declare enum TestState {
     Draft = "draft",
     Published = "published",
     Archived = "archived"
 }
-declare enum JobType {
-    FrontEnd = "front-end",
-    BackEnd = "back-end",
-    Fullstack = "fullstack",
-    DevOps = "devops",
-    Data = "data"
-}
 declare enum SeniorityLevel {
     Student = "student",
     Junior = "junior",
@@ -44,9 +38,10 @@ declare class Test extends EnduranceSchema {
     duration?: number;
     passingScore?: number;
     categories?: TestCategoryWithExpertise[];
-    targetJob: JobType;
+    targetJob: typeof TestJob;
     seniorityLevel: SeniorityLevel;
     static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+    migrateTargetJob(): Promise<void>;
 }
 declare const TestModel: import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
 export default TestModel;

package/dist/modules/edrm-exams/models/test.model.js

@@ -9,6 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
 import Company from './company.model.js';
+import TestJob from './test-job.model.js';
 import User from './user.model.js';
 var TestState;
 (function (TestState) {
@@ -19,19 +20,6 @@ var TestState;
     // eslint-disable-next-line no-unused-vars
     TestState["Archived"] = "archived";
 })(TestState || (TestState = {}));
-var JobType;
-(function (JobType) {
-    // eslint-disable-next-line no-unused-vars
-    JobType["FrontEnd"] = "front-end";
-    // eslint-disable-next-line no-unused-vars
-    JobType["BackEnd"] = "back-end";
-    // eslint-disable-next-line no-unused-vars
-    JobType["Fullstack"] = "fullstack";
-    // eslint-disable-next-line no-unused-vars
-    JobType["DevOps"] = "devops";
-    // eslint-disable-next-line no-unused-vars
-    JobType["Data"] = "data";
-})(JobType || (JobType = {}));
 var SeniorityLevel;
 (function (SeniorityLevel) {
     // eslint-disable-next-line no-unused-vars
@@ -67,6 +55,28 @@ let Test = class Test extends EnduranceSchema {
     static getModel() {
         return TestModel;
     }
+    // Méthode pour migrer automatiquement les anciennes données
+    async migrateTargetJob() {
+        const testData = this;
+        // Si targetJob est une string (ancien format), on la migre
+        if (typeof testData.targetJob === 'string') {
+            try {
+                // Chercher si le job existe déjà
+                let jobType = await TestJob.findOne({ name: testData.targetJob });
+                // Si pas trouvé, on le crée
+                if (!jobType) {
+                    jobType = new TestJob({ name: testData.targetJob });
+                    await jobType.save();
+                }
+                // Mettre à jour la référence
+                this.targetJob = jobType._id;
+                await this.save();
+            }
+            catch (error) {
+                console.error('Erreur lors de la migration du targetJob:', error);
+            }
+        }
+    }
 };
 __decorate([
     EnduranceModelType.prop({ required: true }),
@@ -105,8 +115,8 @@ __decorate([
     __metadata("design:type", Array)
 ], Test.prototype, "categories", void 0);
 __decorate([
-    EnduranceModelType.prop({ required: true, enum: JobType }),
-    __metadata("design:type", String)
+    EnduranceModelType.prop({ ref: () => TestJob, required: true }),
+    __metadata("design:type", Object)
 ], Test.prototype, "targetJob", void 0);
 __decorate([
     EnduranceModelType.prop({ required: true, enum: SeniorityLevel }),

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

@@ -3,7 +3,26 @@ 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';
+import TestJob from '../models/test-job.model.js';
 import jwt from 'jsonwebtoken';
+// 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 CandidateRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
@@ -383,7 +402,7 @@ class CandidateRouter extends EnduranceRouter {
                 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 resultsWithTests = results.map(result => {
+                const resultsWithTests = await Promise.all(results.map(async (result) => {
                     const test = testsMap.get(result.testId.toString());
                     let categoriesWithNames = [];
                     if (test && test.categories) {
@@ -398,13 +417,13 @@ class CandidateRouter extends EnduranceRouter {
                             ? {
                                 title: test.title,
                                 description: test.description,
-                                targetJob: test.targetJob,
+                                targetJob: await getJobName(test.targetJob),
                                 seniorityLevel: test.seniorityLevel,
                                 categories: categoriesWithNames
                             }
                             : null
                     };
-                });
+                }));
                 const totalPages = Math.ceil(total / limit);
                 return res.json({
                     data: resultsWithTests,

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

@@ -1,6 +1,7 @@
 import { EnduranceRouter } from '@programisto/endurance-core';
 declare class ExamsRouter extends EnduranceRouter {
     constructor();
+    private generateAndSaveQuestion;
     setupRoutes(): void;
 }
 declare const router: ExamsRouter;

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

@@ -3,13 +3,80 @@ 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 TestJob from '../models/test-job.model.js';
 import Candidate from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
-import { generateLiveMessage } from '../lib/openai.js';
+import { generateLiveMessage, generateLiveMessageAssistant } from '../lib/openai.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';
+}
+// Fonction pour migrer automatiquement un test si nécessaire
+async function migrateTestIfNeeded(test) {
+    if (typeof test.targetJob === 'string') {
+        await test.migrateTargetJob();
+    }
+}
 class ExamsRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
     }
+    async generateAndSaveQuestion(test, categoryInfo, useAssistant = false) {
+        try {
+            const categoryDoc = await TestCategory.findById(categoryInfo.categoryId);
+            if (!categoryDoc) {
+                console.error('Catégorie non trouvée:', categoryInfo.categoryId);
+                return null;
+            }
+            // Récupérer les questions existantes pour éviter les doublons
+            const otherQuestionsIds = test.questions.map(question => question.questionId);
+            const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
+            const jobName = await getJobName(test.targetJob);
+            const questionParams = {
+                job: jobName,
+                seniority: test.seniorityLevel,
+                category: categoryDoc.name,
+                questionType: ['MCQ', 'free question', 'exercice'][Math.floor(Math.random() * 3)],
+                expertiseLevel: categoryInfo.expertiseLevel,
+                otherQuestions: otherQuestions.map(question => question.instruction).join('\n')
+            };
+            let generatedQuestion;
+            if (useAssistant) {
+                generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', questionParams, true);
+            }
+            else {
+                generatedQuestion = await generateLiveMessage('createQuestion', questionParams, true);
+            }
+            if (generatedQuestion === 'Brain freezed, I cannot generate a live message right now.') {
+                console.error('Échec de génération de question pour la catégorie:', categoryDoc.name);
+                return null;
+            }
+            const question = new TestQuestion(JSON.parse(generatedQuestion));
+            await question.save();
+            // Ajouter la question au test et sauvegarder immédiatement
+            test.questions.push({ questionId: question._id, order: test.questions.length });
+            await test.save();
+            return question;
+        }
+        catch (error) {
+            console.error('Erreur lors de la génération/sauvegarde de la question:', error);
+            return null;
+        }
+    }
     setupRoutes() {
         const authenticatedOptions = {
             requireAuth: false,
@@ -57,6 +124,78 @@ class ExamsRouter extends EnduranceRouter {
                 res.status(500).json({ message: 'Internal server error' });
             }
         });
+        // Créer un job type
+        this.post('/jobs', authenticatedOptions, async (req, res) => {
+            const { name } = req.body;
+            if (!name) {
+                return res.status(400).json({ message: 'Error, name is required' });
+            }
+            try {
+                const newJob = new TestJob({ name });
+                await newJob.save();
+                res.status(201).json({ message: 'job created with success', job: newJob });
+            }
+            catch (err) {
+                console.error('error when creating job : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Lister tous les jobs
+        this.get('/jobs', authenticatedOptions, async (req, res) => {
+            try {
+                const jobs = await TestJob.find();
+                res.status(200).json({ array: jobs });
+            }
+            catch (err) {
+                console.error('error when getting jobs : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Obtenir un job par son ID
+        this.get('/jobs/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const job = await TestJob.findById(id);
+                if (!job) {
+                    return res.status(404).json({ message: 'no job founded with this id' });
+                }
+                res.status(200).json({ array: job });
+            }
+            catch (err) {
+                console.error('error when getting job : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Migrer tous les tests avec l'ancien format targetJob
+        this.post('/migrate-targetjobs', authenticatedOptions, async (req, res) => {
+            try {
+                const tests = await Test.find();
+                let migratedCount = 0;
+                let errorCount = 0;
+                for (const test of tests) {
+                    try {
+                        // Vérifier si le test a besoin de migration
+                        if (typeof test.targetJob === 'string') {
+                            await test.migrateTargetJob();
+                            migratedCount++;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Erreur lors de la migration du test ${test._id}:`, error);
+                        errorCount++;
+                    }
+                }
+                res.status(200).json({
+                    message: `Migration terminée. ${migratedCount} tests migrés, ${errorCount} erreurs.`,
+                    migratedCount,
+                    errorCount
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de la migration :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
         // Créer un test
         this.post('/test', authenticatedOptions, async (req, res) => {
             const { title, description, targetJob, seniorityLevel, categories, state = 'draft' } = req.body;
@@ -67,6 +206,19 @@ class ExamsRouter extends EnduranceRouter {
             try {
                 const companyId = user?.companyId;
                 const userId = user?._id;
+                // Traiter le targetJob - si c'est une string, on cherche ou crée le TestJob
+                let targetJobId;
+                if (typeof targetJob === 'string') {
+                    let existingJob = await TestJob.findOne({ name: targetJob });
+                    if (!existingJob) {
+                        existingJob = new TestJob({ name: targetJob });
+                        await existingJob.save();
+                    }
+                    targetJobId = existingJob._id;
+                }
+                else {
+                    targetJobId = targetJob;
+                }
                 const processedCategories = await Promise.all(categories?.map(async (category) => {
                     let existingCategory = await TestCategory.findOne({ name: category.name });
                     if (!existingCategory) {
@@ -82,7 +234,7 @@ class ExamsRouter extends EnduranceRouter {
                     userId,
                     title,
                     description,
-                    targetJob,
+                    targetJob: targetJobId,
                     seniorityLevel,
                     state,
                     categories: processedCategories
@@ -108,8 +260,20 @@ class ExamsRouter extends EnduranceRouter {
                     test.title = title;
                 if (description)
                     test.description = description;
-                if (targetJob)
-                    test.targetJob = targetJob;
+                if (targetJob) {
+                    // Traiter le targetJob - si c'est une string, on cherche ou crée le TestJob
+                    if (typeof targetJob === 'string') {
+                        let existingJob = await TestJob.findOne({ name: targetJob });
+                        if (!existingJob) {
+                            existingJob = new TestJob({ name: targetJob });
+                            await existingJob.save();
+                        }
+                        test.targetJob = existingJob._id;
+                    }
+                    else {
+                        test.targetJob = targetJob;
+                    }
+                }
                 if (seniorityLevel)
                     test.seniorityLevel = seniorityLevel;
                 if (state)
@@ -163,6 +327,8 @@ class ExamsRouter extends EnduranceRouter {
                 if (!test) {
                     return res.status(404).json({ message: 'no test founded with this id' });
                 }
+                // Migration automatique si nécessaire
+                await migrateTestIfNeeded(test);
                 const questions = [];
                 for (const questionRef of test.questions) {
                     console.log(questionRef);
@@ -172,7 +338,10 @@ class ExamsRouter extends EnduranceRouter {
                         questions.push(question);
                     }
                 }
-                res.status(200).json({ test, questions });
+                // Récupérer le nom du job pour l'affichage
+                const testObj = test.toObject();
+                testObj.targetJobName = await getJobName(testObj.targetJob);
+                res.status(200).json({ test: testObj, questions });
             }
             catch (err) {
                 console.error('error when geting test : ', err);
@@ -195,7 +364,15 @@ class ExamsRouter extends EnduranceRouter {
                 const query = {};
                 // Filtres
                 if (targetJob !== 'all') {
-                    query.targetJob = targetJob;
+                    // Si on filtre par targetJob, on cherche d'abord le TestJob correspondant
+                    const jobType = await TestJob.findOne({ name: targetJob });
+                    if (jobType) {
+                        query.targetJob = jobType._id;
+                    }
+                    else {
+                        // Si le job n'existe pas, on ne retourne aucun résultat
+                        query.targetJob = null;
+                    }
                 }
                 if (seniorityLevel !== 'all') {
                     query.seniorityLevel = seniorityLevel;
@@ -205,10 +382,13 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 // Recherche sur testName et targetJob
                 if (search) {
+                    // Pour la recherche sur targetJob, on cherche d'abord les jobs qui correspondent
+                    const matchingJobs = await TestJob.find({ name: { $regex: search, $options: 'i' } });
+                    const jobIds = matchingJobs.map(job => job._id);
                     query.$or = [
                         { title: { $regex: search, $options: 'i' } },
                         { description: { $regex: search, $options: 'i' } },
-                        { targetJob: { $regex: search, $options: 'i' } },
+                        { targetJob: { $in: jobIds } },
                         { seniorityLevel: { $regex: search, $options: 'i' } }
                     ];
                 }
@@ -226,9 +406,13 @@ class ExamsRouter extends EnduranceRouter {
                         .exec(),
                     Test.countDocuments(query)
                 ]);
-                // Récupérer les noms des catégories pour chaque test
+                // Récupérer les noms des catégories et des jobs pour chaque test
                 const testsWithCategories = await Promise.all(tests.map(async (test) => {
+                    // Migration automatique si nécessaire
+                    await migrateTestIfNeeded(test);
                     const testObj = test.toObject();
+                    // Récupérer le nom du job
+                    testObj.targetJobName = await getJobName(testObj.targetJob);
                     if (testObj.categories && testObj.categories.length > 0) {
                         const categoriesWithNames = await Promise.all(testObj.categories.map(async (category) => {
                             const categoryDoc = await TestCategory.findById(category.categoryId);
@@ -437,8 +621,9 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 const otherQuestionsIds = test.questions.map(question => question.questionId);
                 const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
-                const generatedQuestion = await generateLiveMessage('createQuestion', {
-                    job: test.targetJob,
+                const jobName = await getJobName(test.targetJob);
+                const generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', {
+                    job: jobName,
                     seniority: test.seniorityLevel,
                     questionType,
                     category,
@@ -715,7 +900,7 @@ class ExamsRouter extends EnduranceRouter {
                     const question = await TestQuestion.findById(response.questionId);
                     if (!question)
                         continue;
-                    const score = await generateLiveMessage('correctQuestion', {
+                    const score = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
                         question: {
                             _id: question._id.toString(),
                             instruction: question.instruction,
@@ -819,45 +1004,32 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 const generatedQuestions = [];
                 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 } });
-                    // Calculer combien de questions générer pour cette catégorie
-                    const remainingQuestions = numberOfQuestions - questionsGenerated;
-                    const questionsForThisCategory = Math.min(remainingQuestions, Math.ceil(numberOfQuestions / categoriesToUse.length));
-                    for (let i = 0; i < questionsForThisCategory; i++) {
-                        const generatedQuestion = await generateLiveMessage('createQuestion', {
-                            job: test.targetJob,
-                            seniority: test.seniorityLevel,
-                            category: categoryDoc.name,
-                            questionType: ['MCQ', 'free question', 'exercice'][Math.floor(Math.random() * 3)],
-                            expertiseLevel: categoryInfo.expertiseLevel,
-                            otherQuestions: otherQuestions.map(question => question.instruction).join('\n')
-                        }, true);
-                        // Vérifier si la réponse est un JSON valide
-                        if (generatedQuestion === 'Brain freezed, I cannot generate a live message right now.') {
-                            console.error('Échec de génération de question pour la catégorie:', categoryDoc.name);
-                            continue; // Passer à la question suivante
-                        }
-                        try {
-                            const question = new TestQuestion(JSON.parse(generatedQuestion));
-                            await question.save();
+                let attempts = 0;
+                const maxAttempts = numberOfQuestions * 3; // Limite pour éviter les boucles infinies
+                // Si on spécifie une catégorie, on génère toutes les questions pour cette catégorie
+                if (category && category !== 'ALL') {
+                    const categoryInfo = categoriesToUse[0];
+                    while (questionsGenerated < numberOfQuestions && attempts < maxAttempts) {
+                        attempts++;
+                        const question = await this.generateAndSaveQuestion(test, categoryInfo, true);
+                        if (question) {
                             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);
-                            console.error('Réponse reçue:', generatedQuestion);
-                            continue; // Passer à la question suivante
+                    }
+                }
+                else {
+                    // Pour ALL, répartition aléatoire sur toutes les catégories
+                    const shuffledCategories = [...categoriesToUse].sort(() => Math.random() - 0.5);
+                    while (questionsGenerated < numberOfQuestions && attempts < maxAttempts) {
+                        attempts++;
+                        // Sélectionner une catégorie aléatoire
+                        const randomCategoryIndex = Math.floor(Math.random() * shuffledCategories.length);
+                        const categoryInfo = shuffledCategories[randomCategoryIndex];
+                        const question = await this.generateAndSaveQuestion(test, categoryInfo, true);
+                        if (question) {
+                            generatedQuestions.push(question);
+                            questionsGenerated++;
                         }
                     }
                 }
@@ -867,7 +1039,6 @@ class ExamsRouter extends EnduranceRouter {
                         message: 'Aucune question n\'a pu être générée. Veuillez réessayer plus tard.'
                     });
                 }
-                await test.save();
                 res.status(200).json({
                     message: `${generatedQuestions.length} question(s) générée(s) avec succès`,
                     questions: generatedQuestions,

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

@@ -2,6 +2,25 @@ import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEv
 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());
@@ -81,7 +100,7 @@ class ResultRouter extends EnduranceRouter {
                             ? {
                                 title: test.title,
                                 description: test.description,
-                                targetJob: test.targetJob,
+                                targetJob: await getJobName(test.targetJob),
                                 seniorityLevel: test.seniorityLevel,
                                 categories: categoriesWithNames
                             }
@@ -129,11 +148,14 @@ class ResultRouter extends EnduranceRouter {
                 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
@@ -312,18 +334,25 @@ class ResultRouter extends EnduranceRouter {
                     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;
-                    // Déclencher la correction automatique
-                    await enduranceEmitter.emit(enduranceEventTypes.CORRECT_TEST, result);
                 }
                 else {
                     result.state = TestState.InProgress;
                 }
-                await result.save();
+                // 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,

package/package.json

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