@programisto/edrm-exams 0.3.11 → 0.3.13

package/dist/modules/edrm-exams/lib/score-utils.d.ts

@@ -0,0 +1,18 @@
+import type { CategoryScore } from '../models/test-result.model.js';
+export interface ComputeScoresResult {
+    score: number;
+    scoresByCategory: CategoryScore[];
+}
+/** Objet ayant au minimum testId et responses (document TestResult ou équivalent). */
+export interface ResultWithResponses {
+    testId: unknown;
+    responses?: Array<{
+        questionId: unknown;
+        score?: number;
+    }>;
+}
+/**
+ * Calcule le score global et les sous-scores par catégorie à partir des réponses d'un TestResult.
+ * Les questions sans categoryId contribuent au score global uniquement (pas d'entrée dans scoresByCategory).
+ */
+export declare function computeScoresByCategory(result: ResultWithResponses): Promise<ComputeScoresResult>;

package/dist/modules/edrm-exams/lib/score-utils.js

@@ -0,0 +1,48 @@
+import Test from '../models/test.model.js';
+import TestQuestion from '../models/test-question.model.js';
+/**
+ * Calcule le score global et les sous-scores par catégorie à partir des réponses d'un TestResult.
+ * Les questions sans categoryId contribuent au score global uniquement (pas d'entrée dans scoresByCategory).
+ */
+export async function computeScoresByCategory(result) {
+    const responses = result.responses || [];
+    let score = 0;
+    const categoryMap = new Map();
+    const test = await Test.findById(result.testId).lean();
+    if (!test) {
+        return { score: 0, scoresByCategory: [] };
+    }
+    for (const res of responses) {
+        const questionId = res.questionId?.toString?.() ?? res.questionId;
+        if (!questionId)
+            continue;
+        const question = await TestQuestion.findById(questionId).lean();
+        if (!question)
+            continue;
+        const responseScore = typeof res.score === 'number' && !isNaN(res.score) ? res.score : 0;
+        const questionMaxScore = typeof question.maxScore === 'number' && !isNaN(question.maxScore) ? question.maxScore : 0;
+        score += responseScore;
+        const catId = question.categoryId;
+        if (catId) {
+            const key = catId.toString?.() ?? String(catId);
+            const existing = categoryMap.get(key);
+            if (existing) {
+                existing.score += responseScore;
+                existing.maxScore += questionMaxScore;
+            }
+            else {
+                categoryMap.set(key, {
+                    categoryId: catId,
+                    score: responseScore,
+                    maxScore: questionMaxScore
+                });
+            }
+        }
+    }
+    const scoresByCategory = Array.from(categoryMap.values()).map(({ categoryId, score: catScore, maxScore: catMax }) => ({
+        categoryId: categoryId,
+        score: catScore,
+        maxScore: catMax
+    }));
+    return { score, scoresByCategory };
+}

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

@@ -1,6 +1,7 @@
 import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance';
 import TestQuestion from '../models/test-question.model.js';
 import { generateLiveMessageAssistant } 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';
@@ -97,6 +98,9 @@ async function correctTest(options) {
         result.state = TestState.Finish;
         // Forcer la sauvegarde des sous-documents responses
         result.markModified('responses');
+        // Calculer les sous-scores par catégorie
+        const { scoresByCategory } = await computeScoresByCategory(result);
+        result.scoresByCategory = scoresByCategory;
         // Calculer le pourcentage de score en évitant la division par zéro
         let scorePercentage = 0;
         if (maxScore > 0) {
@@ -115,6 +119,7 @@ async function correctTest(options) {
             $set: {
                 responses: result.responses,
                 score: finalscore,
+                scoresByCategory: result.scoresByCategory,
                 state: result.state
             }
         });

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/models/test-question.model.d.ts

@@ -1,4 +1,5 @@
 import { EnduranceSchema } from '@programisto/endurance';
+import TestCategory from './test-category.models.js';
 declare enum QuestionType {
     MCQ = "MCQ",
     FreeQuestion = "free question",
@@ -19,7 +20,8 @@ declare class TestQuestion extends EnduranceSchema {
     possibleResponses: PossibleResponse[];
     time: number;
     textType: TextType;
-    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types").BeAnObject>;
+    categoryId?: typeof TestCategory;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
 }
-declare const TestQuestionModel: import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types").BeAnObject>;
+declare const TestQuestionModel: import("@typegoose/typegoose").ReturnModelType<typeof TestQuestion, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
 export default TestQuestionModel;

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

@@ -8,6 +8,7 @@ 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';
+import TestCategory from './test-category.models.js';
 var QuestionType;
 (function (QuestionType) {
     // eslint-disable-next-line no-unused-vars
@@ -31,6 +32,7 @@ let TestQuestion = class TestQuestion extends EnduranceSchema {
     possibleResponses;
     time;
     textType;
+    categoryId;
     static getModel() {
         return TestQuestionModel;
     }
@@ -59,6 +61,10 @@ __decorate([
     EnduranceModelType.prop({ required: false, enum: TextType, default: TextType.Text }),
     __metadata("design:type", String)
 ], TestQuestion.prototype, "textType", void 0);
+__decorate([
+    EnduranceModelType.prop({ ref: () => TestCategory, required: false }),
+    __metadata("design:type", Object)
+], TestQuestion.prototype, "categoryId", void 0);
 TestQuestion = __decorate([
     EnduranceModelType.modelOptions({
         options: {

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

@@ -12,12 +12,18 @@ interface Response {
     score?: number;
     comment?: string;
 }
+export interface CategoryScore {
+    categoryId: ObjectId;
+    score: number;
+    maxScore: number;
+}
 declare class TestResult extends EnduranceSchema {
     testId: typeof Test;
     candidateId: typeof User;
     state: TestState;
     responses: Response[];
     score?: number;
+    scoresByCategory?: CategoryScore[];
     startTime?: Date;
     endTime?: Date;
     static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestResult, import("@typegoose/typegoose/lib/types.js").BeAnObject>;

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

@@ -25,6 +25,7 @@ let TestResult = class TestResult extends EnduranceSchema {
     state;
     responses;
     score;
+    scoresByCategory;
     startTime;
     endTime;
     static getModel() {
@@ -51,6 +52,10 @@ __decorate([
     EnduranceModelType.prop(),
     __metadata("design:type", Number)
 ], TestResult.prototype, "score", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Object], required: false }),
+    __metadata("design:type", Array)
+], TestResult.prototype, "scoresByCategory", void 0);
 __decorate([
     EnduranceModelType.prop(),
     __metadata("design:type", Date)

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

@@ -7,6 +7,7 @@ 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 { computeScoresByCategory } from '../lib/score-utils.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
@@ -1092,7 +1093,7 @@ class ExamsRouter extends EnduranceRouter {
          */
         this.put('/test/modifyQuestion/:id', authenticatedOptions, async (req, res) => {
             const { id } = req.params;
-            const { instruction, maxScore, time, possibleResponses, textType } = req.body;
+            const { instruction, maxScore, time, possibleResponses, textType, categoryId } = req.body;
             try {
                 const question = await TestQuestion.findById(id);
                 if (!question) {
@@ -1113,6 +1114,18 @@ class ExamsRouter extends EnduranceRouter {
                 if (possibleResponses) {
                     question.possibleResponses = possibleResponses;
                 }
+                if (categoryId !== undefined) {
+                    if (categoryId === null || categoryId === '') {
+                        question.categoryId = undefined;
+                    }
+                    else {
+                        const category = await TestCategory.findById(categoryId);
+                        if (!category) {
+                            return res.status(400).json({ message: 'Catégorie non trouvée' });
+                        }
+                        question.categoryId = categoryId;
+                    }
+                }
                 await question.save();
                 res.status(200).json({ message: 'question modified with sucess' });
             }
@@ -1159,7 +1172,7 @@ class ExamsRouter extends EnduranceRouter {
          */
         this.put('/test/addCustomQuestion/:id', authenticatedOptions, async (req, res) => {
             const { id } = req.params;
-            const { questionType, instruction, maxScore, time } = req.body;
+            const { questionType, instruction, maxScore, time, categoryId } = req.body;
             try {
                 const test = await Test.findById(id);
                 if (!test) {
@@ -1168,11 +1181,18 @@ class ExamsRouter extends EnduranceRouter {
                 if (!testBelongsToEntity(test, req)) {
                     return res.status(404).json({ message: 'no test founded with this id' });
                 }
+                if (categoryId != null && categoryId !== '') {
+                    const category = await TestCategory.findById(categoryId);
+                    if (!category) {
+                        return res.status(400).json({ message: 'Catégorie non trouvée' });
+                    }
+                }
                 const question = new TestQuestion({
                     questionType,
                     instruction,
                     maxScore,
-                    time
+                    time,
+                    ...(categoryId != null && categoryId !== '' ? { categoryId } : {})
                 });
                 await question.save();
                 test.questions.push({ questionId: question._id, order: test.questions.length });
@@ -1792,6 +1812,8 @@ class ExamsRouter extends EnduranceRouter {
                     response.comment = parsedResult.comment;
                 }
                 result.score = finalscore;
+                const { scoresByCategory } = await computeScoresByCategory(result);
+                result.scoresByCategory = scoresByCategory;
                 await result.save();
                 res.status(200).json({ data: finalscore });
             }
@@ -2350,8 +2372,10 @@ class ExamsRouter extends EnduranceRouter {
                     response.score = score;
                 if (typeof comment === 'string')
                     response.comment = comment;
-                // Recalculer le score global
-                result.score = (result.responses || []).reduce((sum, r) => sum + (r.score || 0), 0);
+                // Recalculer le score global et les sous-scores par catégorie
+                const { score: globalScore, scoresByCategory } = await computeScoresByCategory(result);
+                result.score = globalScore;
+                result.scoresByCategory = scoresByCategory;
                 await result.save();
                 return res.status(200).json({
                     message: 'Correction manuelle enregistrée',

package/package.json

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