@programisto/edrm-exams 0.2.4 → 0.2.6

package/dist/modules/edrm-exams/models/candidate.models.d.ts

@@ -1,8 +1,16 @@
 import { EnduranceSchema } from '@programisto/endurance-core';
+import { Types } from 'mongoose';
+export declare enum ExperienceLevel {
+    JUNIOR = "JUNIOR",
+    INTERMEDIATE = "INTERMEDIATE",
+    SENIOR = "SENIOR",
+    EXPERT = "EXPERT"
+}
 declare class Candidate extends EnduranceSchema {
-    firstName: string;
-    lastName: string;
-    email: string;
+    contact: Types.ObjectId;
+    experienceLevel: string;
+    yearsOfExperience: number;
+    skills: string[];
     magicLinkToken?: string;
     magicLinkExpiresAt?: Date;
     authToken?: string;

package/dist/modules/edrm-exams/models/candidate.models.js

@@ -8,10 +8,22 @@ 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';
+import { Types } from 'mongoose';
+// Enum pour les niveaux d'expérience
+/* eslint-disable no-unused-vars */
+export var ExperienceLevel;
+(function (ExperienceLevel) {
+    ExperienceLevel["JUNIOR"] = "JUNIOR";
+    ExperienceLevel["INTERMEDIATE"] = "INTERMEDIATE";
+    ExperienceLevel["SENIOR"] = "SENIOR";
+    ExperienceLevel["EXPERT"] = "EXPERT";
+})(ExperienceLevel || (ExperienceLevel = {}));
+/* eslint-enable no-unused-vars */
 let Candidate = class Candidate extends EnduranceSchema {
-    firstName;
-    lastName;
-    email;
+    contact;
+    experienceLevel;
+    yearsOfExperience;
+    skills;
     magicLinkToken;
     magicLinkExpiresAt;
     authToken;
@@ -21,17 +33,21 @@ let Candidate = class Candidate extends EnduranceSchema {
     }
 };
 __decorate([
-    EnduranceModelType.prop({ required: true }),
-    __metadata("design:type", String)
-], Candidate.prototype, "firstName", void 0);
+    EnduranceModelType.prop({ required: true, ref: 'Contact' }),
+    __metadata("design:type", Types.ObjectId)
+], Candidate.prototype, "contact", void 0);
 __decorate([
-    EnduranceModelType.prop({ required: true }),
+    EnduranceModelType.prop({ required: false, enum: ExperienceLevel, default: ExperienceLevel.JUNIOR }),
     __metadata("design:type", String)
-], Candidate.prototype, "lastName", void 0);
+], Candidate.prototype, "experienceLevel", void 0);
 __decorate([
-    EnduranceModelType.prop({ required: true, unique: true }),
-    __metadata("design:type", String)
-], Candidate.prototype, "email", void 0);
+    EnduranceModelType.prop({ required: false, type: Number, default: 0 }),
+    __metadata("design:type", Number)
+], Candidate.prototype, "yearsOfExperience", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [String], required: true }),
+    __metadata("design:type", Array)
+], Candidate.prototype, "skills", void 0);
 __decorate([
     EnduranceModelType.prop({ required: false, type: String }),
     __metadata("design:type", String)

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

@@ -0,0 +1,14 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+import { Types } from 'mongoose';
+declare class Contact extends EnduranceSchema {
+    firstname: string;
+    lastname: string;
+    email: string;
+    phone?: string;
+    linkedin?: string;
+    city: string;
+    notes: Types.ObjectId[];
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Contact, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const ContactModel: import("@typegoose/typegoose").ReturnModelType<typeof Contact, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default ContactModel;

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

@@ -0,0 +1,60 @@
+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';
+import { Types } from 'mongoose';
+let Contact = class Contact extends EnduranceSchema {
+    firstname;
+    lastname;
+    email;
+    phone;
+    linkedin;
+    city;
+    notes;
+    static getModel() {
+        return ContactModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "firstname", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "lastname", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "email", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", String)
+], Contact.prototype, "phone", void 0);
+__decorate([
+    EnduranceModelType.prop(),
+    __metadata("design:type", String)
+], Contact.prototype, "linkedin", void 0);
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "city", void 0);
+__decorate([
+    EnduranceModelType.prop({ type: [Types.ObjectId], ref: 'Note', default: [] }),
+    __metadata("design:type", Array)
+], Contact.prototype, "notes", void 0);
+Contact = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], Contact);
+const ContactModel = EnduranceModelType.getModelForClass(Contact);
+export default ContactModel;

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

@@ -1,5 +1,6 @@
 import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance-core';
 import CandidateModel from '../models/candidate.models.js';
+import ContactModel from '../models/contact.model.js';
 import TestResult from '../models/test-result.model.js';
 import Test from '../models/test.model.js';
 import jwt from 'jsonwebtoken';
@@ -14,16 +15,79 @@ class CandidateRouter extends EnduranceRouter {
         };
         // Créer un nouveau candidat
         this.post('/', authenticatedOptions, async (req, res) => {
-            const { firstName, lastName, email } = req.body;
+            const { firstname, lastname, email, phone, linkedin, city, experienceLevel, yearsOfExperience, skills } = req.body;
             console.log(req.body);
-            console.log(firstName, lastName, email);
-            if (!firstName || !lastName || !email) {
-                return res.status(400).json({ message: 'Error, firstName, lastName and email are required' });
+            if (!firstname || !lastname || !email || !city || !skills || skills.length === 0) {
+                return res.status(400).json({ message: 'Error, firstname, lastname, email, city and skills are required' });
             }
             try {
-                const newCandidate = new CandidateModel({ firstName, lastName, email });
+                // Vérifier si un contact existe déjà avec cette adresse email
+                const existingContact = await ContactModel.findOne({ email });
+                if (existingContact) {
+                    // Vérifier si un candidat existe déjà avec ce contact
+                    const existingCandidate = await CandidateModel.findOne({ contact: existingContact._id });
+                    if (existingCandidate) {
+                        // Contact et candidat existent déjà
+                        return res.status(200).json({
+                            message: 'Contact et candidat existent déjà avec cette adresse email',
+                            status: 'EXISTING',
+                            candidate: {
+                                ...existingCandidate.toObject(),
+                                contact: existingContact.toObject()
+                            }
+                        });
+                    }
+                    else {
+                        // Le contact existe mais pas de candidat, créer le candidat
+                        const newCandidate = new CandidateModel({
+                            contact: existingContact._id,
+                            experienceLevel: experienceLevel || 'JUNIOR',
+                            yearsOfExperience: yearsOfExperience || 0,
+                            skills
+                        });
+                        await newCandidate.save();
+                        return res.status(201).json({
+                            message: 'Candidat créé avec succès en utilisant le contact existant',
+                            status: 'CREATED_WITH_EXISTING_CONTACT',
+                            candidate: {
+                                ...newCandidate.toObject(),
+                                contact: existingContact.toObject()
+                            }
+                        });
+                    }
+                }
+                // Aucun contact existant, créer le contact et le candidat
+                const newContact = new ContactModel({
+                    firstname,
+                    lastname,
+                    email,
+                    phone,
+                    linkedin,
+                    city
+                });
+                await newContact.save();
+                // Créer ensuite le candidat avec la référence au contact
+                const newCandidate = new CandidateModel({
+                    contact: newContact._id,
+                    experienceLevel: experienceLevel || 'JUNIOR',
+                    yearsOfExperience: yearsOfExperience || 0,
+                    skills
+                });
                 await newCandidate.save();
-                res.status(201).json({ message: 'candidate created with success', candidate: newCandidate });
+                // Récupérer le candidat et le contact séparément
+                const candidate = await CandidateModel.findById(newCandidate._id);
+                const contact = await ContactModel.findById(newContact._id);
+                if (!candidate || !contact) {
+                    return res.status(500).json({ message: 'Erreur lors de la récupération des données' });
+                }
+                res.status(201).json({
+                    message: 'Contact et candidat créés avec succès',
+                    status: 'CREATED',
+                    candidate: {
+                        ...candidate.toObject(),
+                        contact: contact.toObject()
+                    }
+                });
             }
             catch (err) {
                 console.error('error when creating candidate : ', err);
@@ -37,35 +101,78 @@ class CandidateRouter extends EnduranceRouter {
                 const limit = parseInt(req.query.limit) || 10;
                 const skip = (page - 1) * limit;
                 const search = req.query.search || '';
-                const sortBy = req.query.sortBy || 'lastName';
+                const sortBy = req.query.sortBy || 'lastname';
                 const sortOrder = req.query.sortOrder || 'asc';
-                // Construction de la requête de recherche
-                const query = {};
-                // Recherche sur firstName, lastName et email
+                let contactIds = [];
+                let total = 0;
                 if (search) {
-                    query.$or = [
-                        { firstName: { $regex: search, $options: 'i' } },
-                        { lastName: { $regex: search, $options: 'i' } },
-                        { email: { $regex: search, $options: 'i' } }
-                    ];
+                    // Recherche dans les contacts
+                    const contactQuery = {
+                        $or: [
+                            { firstname: { $regex: search, $options: 'i' } },
+                            { lastname: { $regex: search, $options: 'i' } },
+                            { email: { $regex: search, $options: 'i' } }
+                        ]
+                    };
+                    const contacts = await ContactModel.find(contactQuery);
+                    contactIds = contacts.map(contact => contact._id);
+                    // Compter les candidats avec ces contacts
+                    total = await CandidateModel.countDocuments({ contact: { $in: contactIds } });
                 }
-                // Construction du tri
-                const allowedSortFields = ['firstName', 'lastName', 'email'];
-                const sortField = allowedSortFields.includes(sortBy) ? sortBy : 'lastName';
-                const sortOptions = {
-                    [sortField]: sortOrder === 'asc' ? 1 : -1
-                };
-                const [candidates, total] = await Promise.all([
-                    CandidateModel.find(query)
-                        .sort(sortOptions)
+                else {
+                    // Pas de recherche, compter tous les candidats
+                    total = await CandidateModel.countDocuments();
+                }
+                // Construction du tri pour les contacts
+                const allowedSortFields = ['firstname', 'lastname', 'email'];
+                const sortField = allowedSortFields.includes(sortBy) ? sortBy : 'lastname';
+                let candidates;
+                if (search && contactIds.length > 0) {
+                    // Récupérer les candidats avec les contacts trouvés
+                    candidates = await CandidateModel.find({ contact: { $in: contactIds } })
                         .skip(skip)
                         .limit(limit)
-                        .exec(),
-                    CandidateModel.countDocuments(query)
-                ]);
+                        .exec();
+                }
+                else if (!search) {
+                    // Récupérer tous les candidats
+                    candidates = await CandidateModel.find()
+                        .skip(skip)
+                        .limit(limit)
+                        .exec();
+                }
+                else {
+                    // Aucun contact trouvé pour la recherche
+                    candidates = [];
+                }
+                // Récupérer les contacts pour tous les candidats
+                const candidateContactIds = candidates.map(candidate => candidate.contact);
+                const contacts = await ContactModel.find({ _id: { $in: candidateContactIds } });
+                const contactsMap = new Map(contacts.map(contact => [contact._id.toString(), contact]));
+                // Combiner les candidats avec leurs contacts et trier
+                const candidatesWithContacts = candidates.map(candidate => {
+                    const contact = contactsMap.get(candidate.contact.toString());
+                    return {
+                        ...candidate.toObject(),
+                        contact: contact ? contact.toObject() : null
+                    };
+                });
+                // Trier les résultats côté serveur si nécessaire
+                if (sortField && candidatesWithContacts.length > 0) {
+                    candidatesWithContacts.sort((a, b) => {
+                        const aValue = a.contact ? a.contact[sortField] : '';
+                        const bValue = b.contact ? b.contact[sortField] : '';
+                        if (sortOrder === 'asc') {
+                            return aValue.localeCompare(bValue);
+                        }
+                        else {
+                            return bValue.localeCompare(aValue);
+                        }
+                    });
+                }
                 const totalPages = Math.ceil(total / limit);
                 return res.json({
-                    data: candidates,
+                    data: candidatesWithContacts,
                     pagination: {
                         currentPage: page,
                         totalPages,
@@ -89,7 +196,18 @@ class CandidateRouter extends EnduranceRouter {
                 if (!candidate) {
                     return res.status(404).json({ message: 'no candidate found with this id' });
                 }
-                res.status(200).json({ message: 'candidate : ', data: candidate });
+                // Récupérer le contact associé
+                const contact = await ContactModel.findById(candidate.contact);
+                if (!contact) {
+                    return res.status(404).json({ message: 'contact not found for this candidate' });
+                }
+                res.status(200).json({
+                    message: 'candidate : ',
+                    data: {
+                        ...candidate.toObject(),
+                        contact: contact.toObject()
+                    }
+                });
             }
             catch (err) {
                 console.error('error when getting candidate : ', err);
@@ -100,12 +218,19 @@ class CandidateRouter extends EnduranceRouter {
         this.get('/email/:email', authenticatedOptions, async (req, res) => {
             try {
                 const email = req.params.email;
-                const candidate = await CandidateModel.findOne({ email });
+                // Chercher d'abord le contact par email
+                const contact = await ContactModel.findOne({ email });
+                if (!contact) {
+                    return res.status(404).json({ message: 'Contact non trouvé' });
+                }
+                // Puis chercher le candidat avec ce contact
+                const candidate = await CandidateModel.findOne({ contact: contact._id });
                 if (!candidate) {
                     return res.status(404).json({ message: 'Candidat non trouvé' });
                 }
                 return res.json({
-                    ...candidate.toObject()
+                    ...candidate.toObject(),
+                    contact: contact.toObject()
                 });
             }
             catch (error) {
@@ -120,7 +245,13 @@ class CandidateRouter extends EnduranceRouter {
                 if (!email) {
                     return res.status(400).json({ message: 'Email requis' });
                 }
-                const candidate = await CandidateModel.findOne({ email });
+                // Chercher d'abord le contact par email
+                const contact = await ContactModel.findOne({ email });
+                if (!contact) {
+                    return res.status(404).json({ message: 'Contact non trouvé' });
+                }
+                // Puis chercher le candidat avec ce contact
+                const candidate = await CandidateModel.findOne({ contact: contact._id });
                 if (!candidate) {
                     return res.status(404).json({ message: 'Candidat non trouvé' });
                 }
@@ -195,8 +326,7 @@ class CandidateRouter extends EnduranceRouter {
                     candidate: {
                         id: candidate._id,
                         email: decoded.email,
-                        firstName: candidate.firstName,
-                        lastName: candidate.lastName
+                        contact: candidate.contact
                     }
                 });
             }

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

@@ -4,6 +4,7 @@ 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 ContactModel from '../models/contact.model.js';
 import { generateLiveMessage } from '../lib/openai.js';
 class ExamsRouter extends EnduranceRouter {
     constructor() {
@@ -545,7 +546,12 @@ class ExamsRouter extends EnduranceRouter {
                 if (!candidate) {
                     return res.status(404).json({ message: 'Candidate not found' });
                 }
-                const email = candidate.email;
+                // Récupérer le contact pour obtenir l'email
+                const contact = await ContactModel.findById(candidate.contact);
+                if (!contact) {
+                    return res.status(404).json({ message: 'Contact not found' });
+                }
+                const email = contact.email;
                 // Construire le lien d'invitation
                 const testLink = process.env.TEST_INVITATION_LINK || '';
                 // Récupérer les credentials d'envoi
@@ -865,6 +871,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) {
@@ -875,30 +883,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) {
@@ -906,21 +968,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 = results.map(result => {
-                    const candidate = candidatesMap.get(result.candidateId.toString());
-                    return {
-                        ...result.toObject(),
-                        candidate: candidate
-                            ? {
-                                firstName: candidate.firstName,
-                                lastName: candidate.lastName,
-                                email: candidate.email
-                            }
-                            : null,
+                // 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: contact
+                                ? {
+                                    firstName: contact.firstname,
+                                    lastName: contact.lastname,
+                                    email: contact.email
+                                }
+                                : null,
+                            maxScore
+                        };
+                    }));
+                }
                 const totalPages = Math.ceil(total / limit);
                 return res.json({
                     data: resultsWithCandidates,
@@ -947,17 +1033,22 @@ class ExamsRouter extends EnduranceRouter {
                 if (!result) {
                     return res.status(404).json({ message: 'Result not found' });
                 }
-                // Récupérer l'email du candidat
+                // Récupérer le candidat et son contact
                 const candidate = await Candidate.findById(result.candidateId);
                 if (!candidate) {
                     return res.status(404).json({ message: 'Candidate not found' });
                 }
+                // Récupérer le contact pour obtenir l'email
+                const contact = await ContactModel.findById(candidate.contact);
+                if (!contact) {
+                    return res.status(404).json({ message: 'Contact not found' });
+                }
                 // Récupérer les informations du test
                 const test = await Test.findById(result.testId);
                 if (!test) {
                     return res.status(404).json({ message: 'Test not found' });
                 }
-                const email = candidate.email;
+                const email = contact.email;
                 const emailUser = process.env.EMAIL_USER;
                 const emailPassword = process.env.EMAIL_PASSWORD;
                 // Construire le lien d'invitation

package/package.json

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