@programisto/edrm-exams 0.3.16 → 0.3.18

package/dist/modules/edrm-exams/lib/test-invitation-link.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Retourne la base du lien d'invitation au test technique (portail candidat).
+ * Utilise la config de l'entité (testInvitationLink) ou dérive depuis domain/domains.
+ * Fallback : process.env.TEST_INVITATION_LINK (ex. https://app.programisto.fr/magic?email=).
+ */
+export declare function getTestInvitationLinkBase(entity: {
+    config?: Record<string, string>;
+    domain?: string;
+    domains?: string[];
+} | null | undefined): string;

package/dist/modules/edrm-exams/lib/test-invitation-link.js

@@ -0,0 +1,30 @@
+/**
+ * Retourne la base du lien d'invitation au test technique (portail candidat).
+ * Utilise la config de l'entité (testInvitationLink) ou dérive depuis domain/domains.
+ * Fallback : process.env.TEST_INVITATION_LINK (ex. https://app.programisto.fr/magic?email=).
+ */
+export function getTestInvitationLinkBase(entity) {
+    if (!entity) {
+        return process.env.TEST_INVITATION_LINK || '';
+    }
+    const config = entity.config;
+    if (config && typeof config.testInvitationLink === 'string' && config.testInvitationLink.trim() !== '') {
+        const base = config.testInvitationLink.trim();
+        return base.includes('?') ? base : `${base}?email=`;
+    }
+    const domains = entity.domains;
+    if (Array.isArray(domains) && domains.length > 0) {
+        const appHost = domains.find((d) => String(d).toLowerCase().startsWith('app.'));
+        const host = appHost ?? domains[0];
+        const base = String(host).toLowerCase().split(':')[0].trim();
+        if (base)
+            return `https://${base}/magic?email=`;
+    }
+    const domain = entity.domain;
+    if (domain && String(domain).trim() !== '') {
+        const base = String(domain).trim().toLowerCase().replace(/^(my\.|jobs\.|api\.)/, '');
+        if (base)
+            return `https://app.${base}/magic?email=`;
+    }
+    return process.env.TEST_INVITATION_LINK || '';
+}

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

@@ -1,3 +1,4 @@
+import { Types } from 'mongoose';
 import { enduranceListener, enduranceEmitter, enduranceEventTypes } from '@programisto/endurance';
 import Test from '../models/test.model.js';
 import TestResult from '../models/test-result.model.js';
@@ -50,15 +51,22 @@ async function inviteCandidateToTest(payload) {
         console.warn('[INVITE_TO_TECHNICAL_TEST] No email for contact');
         return;
     }
-    const testLink = (process.env.TEST_INVITATION_LINK || '') + email;
+    const linkBase = payload.testInvitationLinkBase ?? process.env.TEST_INVITATION_LINK ?? '';
+    const testLink = linkBase + email;
     const emailUser = process.env.EMAIL_USER;
     const emailPassword = process.env.EMAIL_PASSWORD;
+    const entityIdForMail = payload.entityId != null
+        ? (payload.entityId instanceof Types.ObjectId
+            ? payload.entityId
+            : new Types.ObjectId(String(payload.entityId)))
+        : undefined;
     await enduranceEmitter.emit(enduranceEventTypes.SEND_EMAIL, {
         template: 'test-invitation',
         to: email,
         from: emailUser,
         emailUser,
         emailPassword,
+        ...(entityIdForMail && { entityId: entityIdForMail }),
         data: {
             firstname: contact.firstname,
             testName: test?.title || '',

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

@@ -5,6 +5,7 @@ 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';
+import { Types } from 'mongoose';
 // 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
@@ -23,6 +24,29 @@ async function getJobName(targetJob) {
     }
     return 'Job inconnu';
 }
+/** Entité par défaut : candidats sans entityId lui sont rattachés. */
+function isDefaultEntity(req) {
+    if (!req?.entity)
+        return false;
+    const slug = req.entity.slug;
+    return req.entity.isDefault === true || slug === 'programisto' || slug === 'progamisto';
+}
+/** Filtre MongoDB pour les candidats de l'entité courante (évite les doublons quand un même contact existe sur plusieurs entités). */
+function buildCandidateEntityFilter(req) {
+    if (!req?.entity?._id)
+        return {};
+    const eid = req.entity._id instanceof Types.ObjectId ? req.entity._id : new Types.ObjectId(String(req.entity._id));
+    if (isDefaultEntity(req)) {
+        return {
+            $or: [
+                { entityId: eid },
+                { entityId: null },
+                { entityId: { $exists: false } }
+            ]
+        };
+    }
+    return { entityId: eid };
+}
 class CandidateRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
@@ -204,6 +228,7 @@ class CandidateRouter extends EnduranceRouter {
                 const search = req.query.search || '';
                 const sortBy = req.query.sortBy || 'lastname';
                 const sortOrder = req.query.sortOrder || 'asc';
+                const entityFilter = buildCandidateEntityFilter(req);
                 let contactIds = [];
                 let total = 0;
                 if (search) {
@@ -217,27 +242,27 @@ class CandidateRouter extends EnduranceRouter {
                     };
                     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 } });
+                    // Compter les candidats avec ces contacts (scopé entité : éviter doublons multi-entités)
+                    total = await CandidateModel.countDocuments({ contact: { $in: contactIds }, ...entityFilter });
                 }
                 else {
-                    // Pas de recherche, compter tous les candidats
-                    total = await CandidateModel.countDocuments();
+                    // Pas de recherche, compter tous les candidats (scopé entité)
+                    total = await CandidateModel.countDocuments(entityFilter);
                 }
                 // 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 } })
+                    // Récupérer les candidats avec les contacts trouvés (un seul par contact/entité)
+                    candidates = await CandidateModel.find({ contact: { $in: contactIds }, ...entityFilter })
                         .skip(skip)
                         .limit(limit)
                         .exec();
                 }
                 else if (!search) {
-                    // Récupérer tous les candidats
-                    candidates = await CandidateModel.find()
+                    // Récupérer les candidats de l'entité courante
+                    candidates = await CandidateModel.find(entityFilter)
                         .skip(skip)
                         .limit(limit)
                         .exec();

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

@@ -8,6 +8,7 @@ import Candidate from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
 import { generateLiveMessage } from '../lib/openai.js';
 import { computeScoresByCategory } from '../lib/score-utils.js';
+import { getTestInvitationLinkBase } from '../lib/test-invitation-link.js';
 import { Types } from 'mongoose';
 // Fonction utilitaire pour récupérer le nom du job
 async function getJobName(targetJob) {
@@ -1505,18 +1506,23 @@ class ExamsRouter extends EnduranceRouter {
                 });
                 await newResult.save();
                 const email = contact.email;
-                // Construire le lien d'invitation
-                const testLink = (process.env.TEST_INVITATION_LINK || '') + email;
+                // Construire le lien d'invitation (URL de l'entité ou défaut env)
+                const testLinkBase = getTestInvitationLinkBase(req.entity);
+                const testLink = testLinkBase + email;
                 // Récupérer les credentials d'envoi
                 const emailUser = process.env.EMAIL_USER;
                 const emailPassword = process.env.EMAIL_PASSWORD;
-                // Envoyer l'email via l'event emitter
+                // Envoyer l'email via l'event emitter (entityId pour utiliser le template de l'entité courante, ex. École de Turing)
+                const entityIdForMail = req.entity?._id != null
+                    ? (req.entity._id instanceof Types.ObjectId ? req.entity._id : new Types.ObjectId(String(req.entity._id)))
+                    : undefined;
                 await emitter.emit(eventTypes.SEND_EMAIL, {
                     template: 'test-invitation',
                     to: email,
                     from: emailUser,
                     emailUser,
                     emailPassword,
+                    ...(entityIdForMail && { entityId: entityIdForMail }),
                     data: {
                         firstname: contact.firstname,
                         testName: test?.title || '',
@@ -2298,16 +2304,23 @@ class ExamsRouter extends EnduranceRouter {
                 const email = contact.email;
                 const emailUser = process.env.EMAIL_USER;
                 const emailPassword = process.env.EMAIL_PASSWORD;
-                // Construire le lien d'invitation
-                const testLink = (process.env.TEST_INVITATION_LINK || '') + email;
-                // Envoyer l'email via l'event emitter
+                // Construire le lien d'invitation (URL de l'entité ou défaut env)
+                const testLinkBase = getTestInvitationLinkBase(req.entity);
+                const testLink = testLinkBase + email;
+                // Envoyer l'email via l'event emitter (entityId pour utiliser le template de l'entité courante)
+                const entityIdForReinvite = req.entity?._id != null
+                    ? (req.entity._id instanceof Types.ObjectId ? req.entity._id : new Types.ObjectId(String(req.entity._id)))
+                    : undefined;
                 await emitter.emit(eventTypes.SEND_EMAIL, {
                     template: 'test-invitation',
                     to: email,
                     from: emailUser,
                     emailUser,
                     emailPassword,
+                    ...(entityIdForReinvite && { entityId: entityIdForReinvite }),
                     data: {
+                        firstname: contact.firstname,
+                        testName: test?.title || '',
                         testLink
                     }
                 });

package/package.json

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