@programisto/edrm-exams 0.3.12 → 0.3.14

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

@@ -1,9 +1,20 @@
+Tu es un correcteur de question de concours / test en ligne.
+Tu dois donner un score à la question et à la réponse fournie par le candidat.
+Tu dois répondre au format JSON, en français pour les explications de correction.
+Modèle JSON attendu :
+{
+    "score": score,
+    "comment": commentaire
+}
+
+---
+
 Question : ${instruction}
-Type de question : ${questionType} 
+Type de question : ${questionType}
 - si MCQ les réponses possibles étaient : ${possibleResponses}
 
 Réponse du candidat à corriger :
 --------------------------------
- ${response}
+${response}
 --------------------------------
-Score à donner : De 0 point (tout faux ou réponse vide) à ${maxScore} points (réponse correcte), avec un commentaire de correction
+Score à donner : de 0 point (tout faux ou réponse vide) à ${maxScore} points (réponse correcte), avec un commentaire de correction.

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

@@ -1,6 +1,35 @@
-Métier ciblé : ${job}
-Catégorie de la question : ${category} niveau ${expertiseLevel} 
-Type de question : ${questionType}
-Format : json
+Tu es un assistant qui crée des questions pour un outil de test en ligne.
+L'utilisateur te demande de générer une question avec les critères suivants :
+- Métier ciblé : ${job}
+- Séniorité ciblée : ${seniority}
+- Catégorie (domaine) : ${category}
+- Niveau d'expertise sur cette catégorie : ${expertiseLevel} (sur une échelle : 'beginner' = 1 à 3, 'intermediate' = 3 à 6, 'advanced' = 6 à 10)
+- Type de question demandé : ${questionType}
 
-Voici la liste des questions déjà présentes dans le test (pour éviter les doublons) : ${otherQuestions}
+Contraintes :
+- La question doit obligatoirement être en français.
+- Les instructions et réponses doivent être compatibles avec LaTeX pour affichage dans des balises <MathJax>. Exemple : \\( \\frac{a}{b} = c \\)
+- Le format de réponse doit être un JSON avec uniquement les champs du schéma ci-dessous, sans "_id".
+
+Schéma JSON à produire :
+{
+    "instruction": "string, required",
+    "questionType": "MCQ" | "free question" | "exercice",
+    "maxScore": "number, required",
+    "possibleResponses": [{"possibleResponse": "string", "valid": "boolean"}] // uniquement pour MCQ, 4 réponses dont une seule juste
+    "time": "number, en secondes, required",
+    "textType": "text" | "code" // "code" si la réponse attendue est du code, sinon "text"
+}
+
+Contraintes par type :
+- MCQ : une seule réponse juste sur quatre au total ; time entre 30 s et 1 min.
+- Free Question : ne rien mettre dans possibleResponses ; time entre 30 s et 5 min selon complexité.
+- Exercice : ne rien mettre dans possibleResponses ; time entre 3 et 20 min selon complexité.
+
+- Les instructions et la difficulté doivent être en rapport avec le métier et la séniorité.
+- Le temps (time) doit laisser le temps de répondre sans favoriser la triche (surtout pour les MCQ).
+
+Questions déjà présentes dans le test (éviter les doublons) :
+${otherQuestions}
+
+Génère une question au format JSON correspondant à la demande et au schéma ci-dessus.

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

@@ -32,6 +32,9 @@ interface ContextBuilder {
         maxScore: number;
     }>;
 }
+/**
+ * Génère une réponse via l'API Responses (gpt-5-mini).
+ * Pour forcer le JSON : text.format = { type: 'json_object' }.
+ */
 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

@@ -2,6 +2,7 @@ import OpenAI from 'openai';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
 import path from 'path';
+const DEFAULT_MODEL = 'gpt-5-mini';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const openai = new OpenAI({
@@ -41,6 +42,10 @@ const contextBuilder = {
         return context;
     }
 };
+/**
+ * Génère une réponse via l'API Responses (gpt-5-mini).
+ * Pour forcer le JSON : text.format = { type: 'json_object' }.
+ */
 export async function generateLiveMessage(messageType, params, json) {
     const MAX_RETRY = 2;
     let retryCount = 0;
@@ -49,17 +54,17 @@ export async function generateLiveMessage(messageType, params, json) {
     const message = text.replace(/\${(.*?)}/g, (_, v) => context[v]);
     while (retryCount <= MAX_RETRY) {
         try {
-            const openAIParams = {
-                model: 'gpt-4-1106-preview',
-                temperature: 0.7,
-                messages: [{ role: 'system', content: message }]
+            const createParams = {
+                model: DEFAULT_MODEL,
+                instructions: message,
+                input: json ? 'Réponds en JSON uniquement. Traite la demande.' : 'Traite la demande.'
             };
             if (json) {
-                openAIParams.response_format = { type: 'json_object' };
+                createParams.text = { format: { type: 'json_object' } };
             }
-            const result = await openai.chat.completions.create(openAIParams);
-            const content = result.choices[0].message.content;
-            if (!content) {
+            const result = await openai.responses.create(createParams);
+            const content = result.output_text;
+            if (!content || typeof content !== 'string') {
                 throw new Error('No content in response');
             }
             return removeQuotes(content);
@@ -74,59 +79,6 @@ 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,11 +1,36 @@
 import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance';
 import TestQuestion from '../models/test-question.model.js';
-import { generateLiveMessageAssistant } from '../lib/openai.js';
+import { generateLiveMessage } from '../lib/openai.js';
 import { computeScoresByCategory } from '../lib/score-utils.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';
+const QUESTION_TYPE_MCQ = 'MCQ';
+/**
+ * Pour un QCM avec bonne réponse enregistrée (possibleResponses avec valid: true),
+ * retourne { score, comment } sans appeler OpenAI.
+ * Retourne null si la question n'est pas un QCM corrigeable automatiquement.
+ */
+function correctMcqIfPossible(question, candidateResponse) {
+    if (question.questionType !== QUESTION_TYPE_MCQ)
+        return null;
+    const possibleResponses = question.possibleResponses;
+    if (!Array.isArray(possibleResponses) || possibleResponses.length === 0)
+        return null;
+    const validIndex = possibleResponses.findIndex((r) => r.valid === true);
+    if (validIndex === -1)
+        return null;
+    const normalizedCandidate = String(candidateResponse ?? '').trim();
+    const validChoice = possibleResponses[validIndex];
+    const validText = (validChoice?.possibleResponse ?? '').trim();
+    const isCorrect = normalizedCandidate === validText ||
+        normalizedCandidate === String(validIndex);
+    return {
+        score: isCorrect ? question.maxScore : 0,
+        comment: ''
+    };
+}
 async function sendDiscordNotification(message) {
     const discordWebhook = process.env.TEST_CORRECTION_DISCORD_WEBHOOKS;
     if (discordWebhook) {
@@ -51,37 +76,46 @@ async function correctTest(options) {
                 continue;
             }
             maxScore += question.maxScore;
-            const scoreResponse = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
-                question: {
-                    _id: question._id.toString(),
-                    instruction: question.instruction,
-                    possibleResponses: question.possibleResponses,
-                    questionType: question.questionType,
-                    maxScore: question.maxScore
-                },
-                result: {
-                    responses: [{
-                            questionId: dbResponse.questionId.toString(),
-                            response: dbResponse.response
-                        }]
-                }
-            }, true);
-            console.log('Correction result:', { scoreResponse });
-            const parsedResult = JSON.parse(scoreResponse);
-            // 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);
+            const mcqResult = correctMcqIfPossible(question, dbResponse.response ?? '');
+            let validScore;
+            let comment;
+            if (mcqResult !== null) {
+                validScore = mcqResult.score;
+                comment = mcqResult.comment;
+            }
+            else {
+                const scoreResponse = await generateLiveMessage('correctQuestion', {
+                    question: {
+                        _id: question._id.toString(),
+                        instruction: question.instruction,
+                        possibleResponses: question.possibleResponses,
+                        questionType: question.questionType,
+                        maxScore: question.maxScore
+                    },
+                    result: {
+                        responses: [{
+                                questionId: dbResponse.questionId.toString(),
+                                response: dbResponse.response
+                            }]
+                    }
+                }, true);
+                console.log('Correction result:', { scoreResponse });
+                const parsedResult = JSON.parse(scoreResponse);
+                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);
+                    }
                 }
+                comment = parsedResult.comment || '';
             }
             finalscore += validScore;
             dbResponse.score = validScore;
-            dbResponse.comment = parsedResult.comment || '';
+            dbResponse.comment = comment;
         }
         // S'assurer que finalscore est un nombre valide
         if (isNaN(finalscore) || !isFinite(finalscore)) {

package/dist/modules/edrm-exams/listeners/invite-from-job.listener.d.ts

@@ -0,0 +1,2 @@
+import { enduranceListener } from '@programisto/endurance';
+export default enduranceListener;

package/dist/modules/edrm-exams/listeners/invite-from-job.listener.js

@@ -0,0 +1,79 @@
+import { enduranceListener, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance';
+import Test from '../models/test.model.js';
+import TestResult from '../models/test-result.model.js';
+import Candidate from '../models/candidate.model.js';
+import ContactModel from '../models/contact.model.js';
+const EVENT_INVITE_TO_TECHNICAL_TEST = 'INVITE_TO_TECHNICAL_TEST';
+/**
+ * Même logique que POST /exams/invite : crée un TestResult et envoie l'email d'invitation.
+ * Déclenché quand une candidature est créée sur une offre avec un test lié (internal-portal).
+ */
+async function inviteCandidateToTest(payload) {
+    const candidateId = typeof payload.candidateId === 'object' && payload.candidateId?.toString
+        ? payload.candidateId.toString()
+        : String(payload.candidateId ?? '');
+    const testId = typeof payload.testId === 'object' && payload.testId?.toString
+        ? payload.testId.toString()
+        : String(payload.testId ?? '');
+    if (!candidateId || !testId)
+        return;
+    const existing = await TestResult.findOne({ candidateId, testId });
+    if (existing) {
+        return;
+    }
+    const test = await Test.findById(testId);
+    if (!test) {
+        console.warn('[INVITE_TO_TECHNICAL_TEST] Test not found:', testId);
+        return;
+    }
+    const categories = test.categories?.map((cat) => ({ categoryId: cat.categoryId })) ?? [];
+    const newResult = new TestResult({
+        candidateId,
+        testId,
+        categories,
+        state: 'pending',
+        invitationDate: Date.now()
+    });
+    await newResult.save();
+    const candidate = await Candidate.findById(candidateId);
+    if (!candidate) {
+        console.warn('[INVITE_TO_TECHNICAL_TEST] Candidate not found:', candidateId);
+        return;
+    }
+    const contact = await ContactModel.findById(candidate.contact);
+    if (!contact) {
+        console.warn('[INVITE_TO_TECHNICAL_TEST] Contact not found for candidate:', candidateId);
+        return;
+    }
+    const email = contact.email;
+    if (!email) {
+        console.warn('[INVITE_TO_TECHNICAL_TEST] No email for contact');
+        return;
+    }
+    const testLink = (process.env.TEST_INVITATION_LINK || '') + email;
+    const emailUser = process.env.EMAIL_USER;
+    const emailPassword = process.env.EMAIL_PASSWORD;
+    await enduranceEmitter.emit(enduranceEventTypes.SEND_EMAIL, {
+        template: 'test-invitation',
+        to: email,
+        from: emailUser,
+        emailUser,
+        emailPassword,
+        data: {
+            firstname: contact.firstname,
+            testName: test?.title || '',
+            testLink
+        }
+    });
+}
+enduranceListener.createListener(EVENT_INVITE_TO_TECHNICAL_TEST, async (args) => {
+    try {
+        if (typeof args === 'object' && args !== null) {
+            await inviteCandidateToTest(args);
+        }
+    }
+    catch (err) {
+        console.error('[INVITE_TO_TECHNICAL_TEST] Error inviting candidate to test:', err);
+    }
+});
+export default enduranceListener;

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

@@ -6,7 +6,7 @@ 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, generateLiveMessageAssistant } from '../lib/openai.js';
+import { generateLiveMessage } from '../lib/openai.js';
 import { computeScoresByCategory } from '../lib/score-utils.js';
 // Fonction utilitaire pour récupérer le nom du job
 async function getJobName(targetJob) {
@@ -53,7 +53,7 @@ class ExamsRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
     }
-    async generateAndSaveQuestion(test, categoryInfo, useAssistant = false, questionTypeOverride) {
+    async generateAndSaveQuestion(test, categoryInfo, _useAssistant = false, questionTypeOverride) {
         try {
             const categoryDoc = await TestCategory.findById(categoryInfo.categoryId);
             if (!categoryDoc) {
@@ -74,13 +74,7 @@ class ExamsRouter extends EnduranceRouter {
                 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);
-            }
+            const 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;
@@ -1252,7 +1246,7 @@ class ExamsRouter extends EnduranceRouter {
                 const otherQuestionsIds = test.questions.map(question => question.questionId);
                 const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
                 const jobName = await getJobName(test.targetJob);
-                const generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', {
+                const generatedQuestion = await generateLiveMessage('createQuestion', {
                     job: jobName,
                     seniority: test.seniorityLevel,
                     questionType,
@@ -1791,7 +1785,7 @@ class ExamsRouter extends EnduranceRouter {
                     const question = await TestQuestion.findById(response.questionId);
                     if (!question)
                         continue;
-                    const score = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
+                    const score = await generateLiveMessage('correctQuestion', {
                         question: {
                             _id: question._id.toString(),
                             instruction: question.instruction,

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@programisto/edrm-exams",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "publishConfig": {
     "access": "public"
   },
@@ -11,6 +11,7 @@
     "start": "node ./dist/bin/www",
     "dev": "tsc-watch --onSuccess \"node ./dist/bin/www\"",
     "test": "mocha",
+    "test:openai": "node -r dotenv/config node_modules/.bin/mocha",
     "build": "tsc && npm run copy-files",
     "copy-files": "copyfiles -u 1 'src/**/*.txt' dist",
     "lint": "eslint \"**/*.{ts,tsx}\"",
@@ -48,6 +49,7 @@
     "@typescript-eslint/parser": "^8.26.0",
     "commitlint": "^19.8.1",
     "copyfiles": "^2.4.1",
+    "dotenv": "^16.6.1",
     "eslint": "^8.57.1",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.31.0",