Checkpoint: Implémentation de l'émargement formateur par QR code avec signature tactile

Modifications principales :
- Ajout des champs typeUtilisateur et formateurId dans la table presences pour distinguer formateurs et apprenants
- Détection automatique du rôle (formateur/apprenant) via l'email lors du scan du QR code
- Interface de signature tactile réutilisée pour les formateurs
- Intégration des signatures tactiles formateur dans la génération PDF de la feuille de présence
- QR code dans l'espace formateur accessible pour l'émargement
- Tests unitaires validés avec succès

Le système permet maintenant aux formateurs d'émarger (matin et après-midi) via le même QR code que les apprenants, avec détection automatique du rôle et intégration des signatures dans le PDF.

.manus/db/db-query-1770056170569.json

@@ -0,0 +1,9 @@
+{
+  "query": "ALTER TABLE `presences` MODIFY COLUMN `inscriptionId` int;\nALTER TABLE `presences` ADD `typeUtilisateur` enum('apprenant','formateur') DEFAULT 'apprenant' NOT NULL;\nALTER TABLE `presences` ADD `formateurId` int;",
+  "command": "mysql --batch --raw --column-names --default-character-set=utf8mb4 --host gateway02.us-east-1.prod.aws.tidbcloud.com --port 4000 --user 4CrrYuB5tme73Qo.root --database 7PAT67UmWoxv8vwp8Bbcv6 --execute ALTER TABLE `presences` MODIFY COLUMN `inscriptionId` int;\nALTER TABLE `presences` ADD `typeUtilisateur` enum('apprenant','formateur') DEFAULT 'apprenant' NOT NULL;\nALTER TABLE `presences` ADD `formateurId` int;",
+  "rows": [],
+  "messages": [],
+  "stdout": "",
+  "stderr": "",
+  "execution_time_ms": 1467
+}

client/src/pages/EmargementScan.tsx

@@ -92,6 +92,7 @@ export default function EmargementScan() {
 
     validerPresence({
       token,
+      email,
       inscriptionId: selectedInscriptionId,
       dateFormationId: selectedDateId,
       periode: selectedPeriode,

client/src/pages/FormateurEmargement.tsx

@@ -457,7 +457,7 @@ export default function FormateurEmargement() {
           <DialogHeader>
             <DialogTitle>QR Code d'émargement</DialogTitle>
             <DialogDescription>
-              Les apprenants doivent scanner ce QR code pour valider leur présence
+              Les apprenants et formateurs doivent scanner ce QR code pour valider leur présence avec signature tactile
             </DialogDescription>
           </DialogHeader>
           {qrData && (

drizzle/meta/_journal.json

@@ -120,6 +120,13 @@
       "when": 1770047974825,
       "tag": "0016_aromatic_king_cobra",
       "breakpoints": true
+    },
+    {
+      "idx": 17,
+      "version": "5",
+      "when": 1770056161269,
+      "tag": "0017_lethal_namor",
+      "breakpoints": true
     }
   ]
 }

drizzle/schema.ts

@@ -414,8 +414,12 @@ export type InsertSupportFormation = typeof supportsFormation.$inferInsert;
  */
 export const presences = mysqlTable("presences", {
   id: int("id").autoincrement().primaryKey(),
-  inscriptionId: int("inscriptionId").notNull(),
+  inscriptionId: int("inscriptionId"),
   dateFormationId: int("dateFormationId").notNull(),
+  /** Type d'utilisateur qui s'émarge (apprenant ou formateur) */
+  typeUtilisateur: mysqlEnum("typeUtilisateur", ["apprenant", "formateur"]).notNull().default("apprenant"),
+  /** ID du formateur (si typeUtilisateur = formateur) */
+  formateurId: int("formateurId"),
   /** Période de la journée (matin ou après-midi) */
   periode: mysqlEnum("periode", ["matin", "apres_midi"]).notNull().default("matin"),
   heurePresence: timestamp("heurePresence").defaultNow().notNull(),
@@ -424,7 +428,7 @@ export const presences = mysqlTable("presences", {
   /** ID de l'utilisateur qui a validé (formateur ou admin) */
   validateurId: int("validateurId"),
   commentaire: text("commentaire"),
-  /** URL de la signature manuscrite de l'apprenant */
+  /** URL de la signature manuscrite (apprenant ou formateur) */
   signatureUrl: varchar("signatureUrl", { length: 500 }),
   /** Clé S3 de la signature manuscrite */
   signatureS3Key: varchar("signatureS3Key", { length: 500 }),

server/__tests__/emargement-formateur.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getDb } from '../db';
+import { validerPresenceFormateur, getPresencesFormateurBySequence } from '../presenceDb';
+import { formateurs, sequences, datesFormation, presences } from '../../drizzle/schema';
+import { eq, and, sql } from 'drizzle-orm';
+
+describe('Émargement formateur par QR code', () => {
+  let testFormateurId: number;
+  let testSequenceId: number;
+  let testDateFormationId: number;
+  const timestamp = Date.now();
+
+  beforeAll(async () => {
+    const db = await getDb();
+    if (!db) throw new Error('Database not available');
+
+    // Créer un formateur de test
+    const formateurResult = await db.insert(formateurs).values({
+      nom: `Test Formateur Émargement ${timestamp}`,
+      email: `test.formateur.emargement.${timestamp}@test.com`,
+    });
+    testFormateurId = Number(formateurResult[0].insertId);
+
+    // Créer une séquence de test
+    const sequenceResult = await db.insert(sequences).values({
+      formationId: 1,
+      nom: 'Test Séquence Émargement',
+      lieu: 'Test Lieu',
+      capaciteMax: 10,
+      statut: 'ouverte',
+      publicCible: 'tous',
+      formateurId: testFormateurId,
+    });
+    testSequenceId = Number(sequenceResult[0].insertId);
+
+    // Créer une date de formation de test
+    const dateResult = await db.insert(datesFormation).values({
+      sequenceId: testSequenceId,
+      ordre: 1,
+      dateDebut: new Date(),
+      dateFin: new Date(Date.now() + 3600000),
+    });
+    testDateFormationId = Number(dateResult[0].insertId);
+  });
+
+  afterAll(async () => {
+    const db = await getDb();
+    if (!db) return;
+
+    // Nettoyer les données de test
+    await db.delete(presences).where(eq(presences.formateurId, testFormateurId));
+    await db.delete(datesFormation).where(eq(datesFormation.sequenceId, testSequenceId));
+    await db.delete(sequences).where(eq(sequences.id, testSequenceId));
+    await db.delete(formateurs).where(eq(formateurs.id, testFormateurId));
+  });
+
+  it('devrait valider la présence du formateur pour le matin', async () => {
+    const result = await validerPresenceFormateur({
+      formateurId: testFormateurId,
+      sequenceId: testSequenceId,
+      dateFormationId: testDateFormationId,
+      periode: 'matin',
+      modeValidation: 'qrcode',
+    });
+
+    expect(result.success).toBe(true);
+
+    // Vérifier que la présence a bien été créée
+    const db = await getDb();
+    if (!db) throw new Error('Database not available');
+
+    const presenceCreated = await db
+      .select()
+      .from(presences)
+      .where(
+        and(
+          eq(presences.formateurId, testFormateurId),
+          eq(presences.dateFormationId, testDateFormationId),
+          sql`${presences}.periode = 'matin'`,
+          sql`${presences}.typeUtilisateur = 'formateur'`
+        )
+      );
+
+    expect(presenceCreated.length).toBe(1);
+    expect(presenceCreated[0].typeUtilisateur).toBe('formateur');
+    expect(presenceCreated[0].modeValidation).toBe('qrcode');
+  });
+
+  it('devrait valider la présence du formateur pour l\'après-midi', async () => {
+    const result = await validerPresenceFormateur({
+      formateurId: testFormateurId,
+      sequenceId: testSequenceId,
+      dateFormationId: testDateFormationId,
+      periode: 'apres_midi',
+      modeValidation: 'qrcode',
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it('devrait empêcher la double validation pour la même période', async () => {
+    await expect(
+      validerPresenceFormateur({
+        formateurId: testFormateurId,
+        sequenceId: testSequenceId,
+        dateFormationId: testDateFormationId,
+        periode: 'matin',
+        modeValidation: 'qrcode',
+      })
+    ).rejects.toThrow('Présence déjà validée');
+  });
+
+  it('devrait récupérer les présences du formateur pour une séquence', async () => {
+    const presencesFormateur = await getPresencesFormateurBySequence(testSequenceId);
+
+    expect(presencesFormateur.length).toBeGreaterThanOrEqual(2); // Matin + Après-midi
+    expect(presencesFormateur.every(p => p.formateurId === testFormateurId)).toBe(true);
+  });
+
+  it('devrait stocker la signature tactile du formateur', async () => {
+    const db = await getDb();
+    if (!db) throw new Error('Database not available');
+
+    // Créer une nouvelle date pour ce test
+    const dateResult = await db.insert(datesFormation).values({
+      sequenceId: testSequenceId,
+      ordre: 2,
+      dateDebut: new Date(),
+      dateFin: new Date(Date.now() + 3600000),
+    });
+    const newDateId = Number(dateResult[0].insertId);
+
+    const signatureUrl = '/uploads/signatures/test-formateur-signature.png';
+    const result = await validerPresenceFormateur({
+      formateurId: testFormateurId,
+      sequenceId: testSequenceId,
+      dateFormationId: newDateId,
+      periode: 'matin',
+      modeValidation: 'qrcode',
+      signatureUrl,
+      signatureS3Key: 'signatures/test-formateur-signature.png',
+    });
+
+    expect(result.success).toBe(true);
+
+    // Vérifier que la signature a été stockée
+    const presenceCreated = await db
+      .select()
+      .from(presences)
+      .where(
+        and(
+          eq(presences.formateurId, testFormateurId),
+          eq(presences.dateFormationId, newDateId),
+          sql`${presences}.periode = 'matin'`
+        )
+      );
+
+    expect(presenceCreated.length).toBe(1);
+    expect(presenceCreated[0].signatureUrl).toBe(signatureUrl);
+
+    // Nettoyer
+    await db.delete(datesFormation).where(eq(datesFormation.id, newDateId));
+  });
+});

server/exportService.ts

@@ -36,9 +36,16 @@ interface ApprenantPresence {
     dateFormationId: number;
     periode: 'matin' | 'apres_midi';
     signatureUrl: string | null;
+    typeUtilisateur?: 'apprenant' | 'formateur';
   }>;
 }
 
+interface FormateurPresence {
+  dateFormationId: number;
+  periode: 'matin' | 'apres_midi';
+  signatureUrl: string | null;
+}
+
 interface FeuillePresenceInfo {
   formationNom: string;
   sequenceNom: string;
@@ -47,6 +54,7 @@ interface FeuillePresenceInfo {
   publicCible: string;
   formateur?: string;
   apprenants: ApprenantPresence[];
+  presencesFormateur?: FormateurPresence[];
 }
 
 /**
@@ -301,14 +309,56 @@ export function generateFeuillePresence(feuilleInfo: FeuillePresenceInfo): Buffe
     doc.text('Signatures du formateur :', 14, signatureY);
     doc.setFont('helvetica', 'normal');
     
+    // Trouver les signatures du formateur pour cette date
+    const presenceFormateurMatin = feuilleInfo.presencesFormateur?.find(
+      p => p.dateFormationId === dateInfo.id && p.periode === 'matin'
+    );
+    const presenceFormateurApresMidi = feuilleInfo.presencesFormateur?.find(
+      p => p.dateFormationId === dateInfo.id && p.periode === 'apres_midi'
+    );
+    
     // Signature Matin
     doc.setFontSize(9);
     doc.text('Matin :', 14, signatureY + 8);
-    doc.line(30, signatureY + 8, 90, signatureY + 8);
+    
+    if (presenceFormateurMatin?.signatureUrl) {
+      try {
+        const signaturePath = path.resolve(process.cwd(), presenceFormateurMatin.signatureUrl.substring(1));
+        if (fs.existsSync(signaturePath)) {
+          const signatureBuffer = fs.readFileSync(signaturePath);
+          const signatureBase64 = `data:image/png;base64,${signatureBuffer.toString('base64')}`;
+          doc.addImage(signatureBase64, 'PNG', 30, signatureY + 2, 55, 10);
+        } else {
+          doc.line(30, signatureY + 8, 90, signatureY + 8);
+        }
+      } catch (error) {
+        console.error('Erreur lors du chargement de la signature formateur matin:', error);
+        doc.line(30, signatureY + 8, 90, signatureY + 8);
+      }
+    } else {
+      doc.line(30, signatureY + 8, 90, signatureY + 8);
+    }
     
     // Signature Après-midi
     doc.text('Après-midi :', 110, signatureY + 8);
-    doc.line(140, signatureY + 8, 200, signatureY + 8);
+    
+    if (presenceFormateurApresMidi?.signatureUrl) {
+      try {
+        const signaturePath = path.resolve(process.cwd(), presenceFormateurApresMidi.signatureUrl.substring(1));
+        if (fs.existsSync(signaturePath)) {
+          const signatureBuffer = fs.readFileSync(signaturePath);
+          const signatureBase64 = `data:image/png;base64,${signatureBuffer.toString('base64')}`;
+          doc.addImage(signatureBase64, 'PNG', 140, signatureY + 2, 55, 10);
+        } else {
+          doc.line(140, signatureY + 8, 200, signatureY + 8);
+        }
+      } catch (error) {
+        console.error('Erreur lors du chargement de la signature formateur après-midi:', error);
+        doc.line(140, signatureY + 8, 200, signatureY + 8);
+      }
+    } else {
+      doc.line(140, signatureY + 8, 200, signatureY + 8);
+    }
   };
 
   // Générer une page pour chaque date

server/presenceDb.ts

@@ -68,7 +68,6 @@ export async function validerPresence(params: {
     commentaire: params.commentaire,
     signatureUrl: params.signatureUrl,
     signatureS3Key: params.signatureS3Key,
-    dateSigned: params.signatureUrl ? new Date() : undefined,
   });
 
   return { success: true };
@@ -93,7 +92,6 @@ export async function getPresencesBySequence(sequenceId: number) {
       commentaire: presences.commentaire,
       signatureUrl: sql<string | null>`${presences}.signatureUrl`,
       signatureS3Key: sql<string | null>`${presences}.signatureS3Key`,
-      dateSigned: sql<Date | null>`${presences}.dateSigned`,
       apprenantId: apprenants.id,
       apprenantNom: apprenants.nom,
       apprenantPrenom: apprenants.prenom,
@@ -128,7 +126,6 @@ export async function getPresencesByInscription(inscriptionId: number) {
       commentaire: presences.commentaire,
       signatureUrl: sql<string | null>`${presences}.signatureUrl`,
       signatureS3Key: sql<string | null>`${presences}.signatureS3Key`,
-      dateSigned: sql<Date | null>`${presences}.dateSigned`,
       dateDebut: datesFormation.dateDebut,
       dateFin: datesFormation.dateFin,
     })
@@ -185,3 +182,106 @@ export async function supprimerPresence(presenceId: number) {
 
   return { success: true };
 }
+
+/**
+ * Valider la présence d'un formateur (par QR code ou manuellement)
+ */
+export async function validerPresenceFormateur(params: {
+  formateurId: number;
+  sequenceId: number;
+  dateFormationId: number;
+  periode: "matin" | "apres_midi";
+  modeValidation: "qrcode" | "manuel";
+  commentaire?: string;
+  signatureUrl?: string;
+  signatureS3Key?: string;
+}) {
+  const db = await getDb();
+  if (!db) throw new Error("Database not available");
+
+  // Récupérer la date de formation
+  const dateFormation = await db
+    .select()
+    .from(datesFormation)
+    .where(eq(datesFormation.id, params.dateFormationId))
+    .limit(1);
+
+  if (dateFormation.length === 0) {
+    throw new Error("Date de formation introuvable");
+  }
+
+  // Vérifier que la date actuelle est le jour de la formation ou après
+  const now = new Date();
+  const dateDebut = new Date(dateFormation[0].dateDebut);
+  
+  // Réinitialiser les heures pour comparer uniquement les dates
+  now.setHours(0, 0, 0, 0);
+  dateDebut.setHours(0, 0, 0, 0);
+  
+  if (now < dateDebut) {
+    throw new Error("Vous ne pouvez pas émarger avant la date de formation");
+  }
+
+  // Vérifier si la présence existe déjà pour cette période
+  const presenceExistante = await db
+    .select()
+    .from(presences)
+    .where(
+      and(
+        eq(presences.formateurId, params.formateurId),
+        eq(presences.dateFormationId, params.dateFormationId),
+        sql`${presences.periode} = ${params.periode}`,
+        sql`${presences.typeUtilisateur} = 'formateur'`
+      )
+    );
+
+  if (presenceExistante.length > 0) {
+    throw new Error(`Présence déjà validée pour ${params.periode === 'matin' ? 'le matin' : 'l\'après-midi'}`);
+  }
+
+  // Créer la présence formateur
+  await db.insert(presences).values({
+    typeUtilisateur: "formateur",
+    formateurId: params.formateurId,
+    dateFormationId: params.dateFormationId,
+    periode: params.periode,
+    heurePresence: new Date(),
+    modeValidation: params.modeValidation,
+    commentaire: params.commentaire,
+    signatureUrl: params.signatureUrl,
+    signatureS3Key: params.signatureS3Key,
+  });
+
+  return { success: true };
+}
+
+/**
+ * Récupérer les présences du formateur pour une séquence
+ */
+export async function getPresencesFormateurBySequence(sequenceId: number) {
+  const db = await getDb();
+  if (!db) throw new Error("Database not available");
+
+  const result = await db
+    .select({
+      presenceId: presences.id,
+      formateurId: presences.formateurId,
+      dateFormationId: presences.dateFormationId,
+      periode: presences.periode,
+      heurePresence: presences.heurePresence,
+      modeValidation: presences.modeValidation,
+      commentaire: presences.commentaire,
+      signatureUrl: sql<string | null>`${presences}.signatureUrl`,
+      signatureS3Key: sql<string | null>`${presences}.signatureS3Key`,
+    })
+    .from(presences)
+    .innerJoin(datesFormation, eq(presences.dateFormationId, datesFormation.id))
+    .where(
+      and(
+        eq(datesFormation.sequenceId, sequenceId),
+        sql`${presences}.typeUtilisateur = 'formateur'`
+      )
+    );
+
+  return result;
+}

server/routers.ts

@@ -1156,7 +1156,7 @@ export const appRouter = router({
       }
 
       // Récupérer toutes les présences avec signatures pour cette séquence
-      const { getPresencesBySequence } = await import("./presenceDb");
+      const { getPresencesBySequence, getPresencesFormateurBySequence } = await import("./presenceDb");
       const presences = await getPresencesBySequence(input.sequenceId);
 
       const data = inscriptions
@@ -1180,6 +1180,9 @@ export const appRouter = router({
           };
         });
 
+      // Récupérer les présences du formateur
+      const presencesFormateur = await getPresencesFormateurBySequence(input.sequenceId);
+
       const buffer = await generateFeuillePresence({
         formationNom: formation.nom,
         sequenceNom: sequence.nom,
@@ -1193,6 +1196,11 @@ export const appRouter = router({
         publicCible: sequence.publicCible,
         formateur: formateurNom,
         apprenants: data,
+        presencesFormateur: presencesFormateur.map(p => ({
+          dateFormationId: p.dateFormationId,
+          periode: p.periode as 'matin' | 'apres_midi',
+          signatureUrl: p.signatureUrl,
+        })),
       });
 
       return {
@@ -2513,7 +2521,8 @@ export const appRouter = router({
     valider: publicProcedure
       .input(z.object({
         token: z.string().optional(),
-        inscriptionId: z.number(),
+        email: z.string().email(),
+        inscriptionId: z.number().optional(),
         dateFormationId: z.number(),
         periode: z.enum(["matin", "apres_midi"]),
         modeValidation: z.enum(["qrcode", "manuel"]),
@@ -2522,57 +2531,77 @@ export const appRouter = router({
         signatureDataUrl: z.string().optional(),
       }))
       .mutation(async ({ input }) => {
-        const { validerPresence } = await import("./presenceDb");
+        const { validerPresence, validerPresenceFormateur } = await import("./presenceDb");
         const { getDb } = await import("./db");
-        const { sequences, inscriptions } = await import("../drizzle/schema");
+        const { sequences, inscriptions, formateurs } = await import("../drizzle/schema");
         const { eq } = await import("drizzle-orm");
 
         const db = await getDb();
         if (!db) throw new Error("Database not available");
 
+        // Détecter si l'utilisateur est un formateur
+        const formateurData = await db.select().from(formateurs).where(eq(formateurs.email, input.email)).limit(1);
+        const isFormateur = formateurData.length > 0;
+
         // Si mode QR code, vérifier le token
+        let sequenceId: number | undefined;
         if (input.modeValidation === "qrcode" && input.token) {
-
+          // Vérifier que le token correspond à une séquence
-          // Récupérer l'inscription pour vérifier la séquence
+          const sequence = await db.select().from(sequences).where(eq(sequences.qrCodeToken, input.token)).limit(1);
-          const inscription = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
+          if (sequence.length === 0) {
-          if (inscription.length === 0) {
-            throw new Error("Inscription introuvable");
-          }
-
-          // Vérifier que le token correspond à la séquence
-          const sequence = await db.select().from(sequences).where(eq(sequences.id, inscription[0].sequenceId)).limit(1);
-          if (sequence.length === 0 || sequence[0].qrCodeToken !== input.token) {
             throw new Error("QR code invalide");
           }
+          sequenceId = sequence[0].id;
+
+          // Si apprenant, vérifier l'inscription
+          if (!isFormateur && input.inscriptionId) {
+            const inscription = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
+            if (inscription.length === 0) {
+              throw new Error("Inscription introuvable");
+            }
+            if (inscription[0].sequenceId !== sequenceId) {
+              throw new Error("QR code invalide pour cette inscription");
+            }
+          }
         }
 
         // Stocker la signature localement si fournie
         let signatureUrl: string | undefined;
         let signatureS3Key: string | undefined;
+        let finalSequenceId = sequenceId;
+        
         if (input.signatureDataUrl) {
           const fs = await import("fs");
           const path = await import("path");
           const crypto = await import("crypto");
           
-          // Récupérer l'inscription pour obtenir la séquence
+          // Déterminer la séquence
-          const inscriptionData = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
+          if (!finalSequenceId) {
-          if (inscriptionData.length === 0) throw new Error("Inscription introuvable");
+            if (input.inscriptionId) {
+              const inscriptionData = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
+              if (inscriptionData.length === 0) throw new Error("Inscription introuvable");
+              finalSequenceId = inscriptionData[0].sequenceId;
+            } else {
+              throw new Error("Impossible de déterminer la séquence");
+            }
+          }
           
-          const sequenceData = await db.select().from(sequences).where(eq(sequences.id, inscriptionData[0].sequenceId)).limit(1);
+          const sequenceData = await db.select().from(sequences).where(eq(sequences.id, finalSequenceId)).limit(1);
           if (sequenceData.length === 0) throw new Error("Séquence introuvable");
           
           const formationId = sequenceData[0].formationId;
-          const sequenceId = sequenceData[0].id;
           
           // Créer la structure de dossiers
-          const uploadsDir = path.resolve(process.cwd(), "uploads", "signatures", `${formationId}-${sequenceId}`);
+          const uploadsDir = path.resolve(process.cwd(), "uploads", "signatures", `${formationId}-${finalSequenceId}`);
           if (!fs.existsSync(uploadsDir)) {
             fs.mkdirSync(uploadsDir, { recursive: true });
           }
           
           // Générer un nom de fichier unique
           const randomSuffix = crypto.randomBytes(8).toString("hex");
-          const fileName = `signature-${input.inscriptionId}-${input.dateFormationId}-${randomSuffix}.png`;
+          const userType = isFormateur ? "formateur" : "apprenant";
+          const userId = isFormateur ? formateurData[0].id : input.inscriptionId;
+          const fileName = `signature-${userType}-${userId}-${input.dateFormationId}-${randomSuffix}.png`;
           const filePath = path.join(uploadsDir, fileName);
           
           // Convertir le data URL en buffer et sauvegarder
@@ -2581,57 +2610,75 @@ export const appRouter = router({
           fs.writeFileSync(filePath, buffer);
           
           // Générer l'URL publique
-          signatureUrl = `/uploads/signatures/${formationId}-${sequenceId}/${fileName}`;
+          signatureUrl = `/uploads/signatures/${formationId}-${finalSequenceId}/${fileName}`;
-          signatureS3Key = `signatures/${formationId}-${sequenceId}/${fileName}`;
+          signatureS3Key = `signatures/${formationId}-${finalSequenceId}/${fileName}`;
         }
 
-        const result = await validerPresence({
+        let result;
-          inscriptionId: input.inscriptionId,
+        if (isFormateur) {
-          dateFormationId: input.dateFormationId,
+          // Valider la présence du formateur
-          periode: input.periode,
+          if (!finalSequenceId) throw new Error("Impossible de déterminer la séquence");
-          modeValidation: input.modeValidation,
+          result = await validerPresenceFormateur({
-          validateurId: input.validateurId,
+            formateurId: formateurData[0].id,
-          commentaire: input.commentaire,
+            sequenceId: finalSequenceId,
-          signatureUrl,
+            dateFormationId: input.dateFormationId,
-          signatureS3Key,
+            periode: input.periode,
-        });
+            modeValidation: input.modeValidation,
+            commentaire: input.commentaire,
+            signatureUrl,
+            signatureS3Key,
+          });
+        } else {
+          // Valider la présence de l'apprenant
+          if (!input.inscriptionId) throw new Error("Inscription requise pour un apprenant");
+          result = await validerPresence({
+            inscriptionId: input.inscriptionId,
+            dateFormationId: input.dateFormationId,
+            periode: input.periode,
+            modeValidation: input.modeValidation,
+            validateurId: input.validateurId,
+            commentaire: input.commentaire,
+            signatureUrl,
+            signatureS3Key,
+          });
 
-        // Vérifier si toutes les présences sont validées
+          // Vérifier si toutes les présences sont validées
-        const { checkAllPresencesValidated } = await import("./presenceDb");
+          const { checkAllPresencesValidated } = await import("./presenceDb");
-        const allValidated = await checkAllPresencesValidated(input.inscriptionId);
+          const allValidated = await checkAllPresencesValidated(input.inscriptionId);
 
-        // Si toutes les présences sont validées, générer l'attestation automatiquement
+          // Si toutes les présences sont validées, générer l'attestation automatiquement
-        if (allValidated) {
+          if (allValidated) {
-          try {
+            try {
-            const { genererAttestationPDF, enregistrerAttestation } = await import("./attestationService");
+              const { genererAttestationPDF, enregistrerAttestation } = await import("./attestationService");
               
-            // Générer le PDF
+              // Générer le PDF
-            const { s3Key, pdfUrl } = await genererAttestationPDF(input.inscriptionId);
+              const { s3Key, pdfUrl } = await genererAttestationPDF(input.inscriptionId);
               
-            // Récupérer les données de l'inscription
+              // Récupérer les données de l'inscription
-            const db = await getDb();
+              const db = await getDb();
-            if (db) {
+              if (db) {
-              const inscriptionData = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
+                const inscriptionData = await db.select().from(inscriptions).where(eq(inscriptions.id, input.inscriptionId)).limit(1);
-              if (inscriptionData.length > 0) {
+                if (inscriptionData.length > 0) {
-                // Enregistrer l'attestation en base
+                  // Enregistrer l'attestation en base
-                await enregistrerAttestation(
+                  await enregistrerAttestation(
-                  input.inscriptionId,
+                    input.inscriptionId,
-                  inscriptionData[0].apprenantId,
+                    inscriptionData[0].apprenantId,
-                  inscriptionData[0].sequenceId,
+                    inscriptionData[0].sequenceId,
-                  s3Key,
+                    s3Key,
-                  pdfUrl
+                    pdfUrl
-                );
+                  );
+                }
               }
-            }
 
-            return {
+              return {
-              ...result,
+                ...result,
-              attestationGenerated: true,
+                attestationGenerated: true,
-              attestationUrl: pdfUrl,
+                attestationUrl: pdfUrl,
-            };
+              };
-          } catch (error) {
+            } catch (error) {
-            console.error("Erreur lors de la génération de l'attestation:", error);
+              console.error("Erreur lors de la génération de l'attestation:", error);
-            // Ne pas bloquer la validation de présence si l'attestation échoue
+              // Ne pas bloquer la validation de présence si l'attestation échoue
+            }
           }
         }
 

todo.md

@@ -1501,4 +1501,12 @@
 
 - [x] Empêcher l'émargement avant la date de formation concernée (vérification backend)
 
-- [ ] Permettre aux formateurs d'émarger par QR code (matin et après-midi) avec signature tactile (en cours - à finaliser lors d'une prochaine session)
+## Émargement formateur par QR code avec signature tactile
+
+- [x] Modifier le schéma de base de données (table presences) pour distinguer formateurs/apprenants et stocker les signatures tactiles
+- [x] Créer une interface de signature tactile pour les formateurs accessible après scan du QR code (interface existante réutilisée)
+- [x] Implémenter la logique backend pour détecter automatiquement si l'utilisateur est formateur ou apprenant (via email)
+- [x] Intégrer les signatures tactiles formateur dans la génération PDF de la feuille de présence
+- [x] Afficher le QR code dans l'espace formateur pour faciliter l'émargement
+- [x] Tester le flux complet (scan QR, signature, intégration PDF)
+- [x] Prêt pour le déploiement sur le VPS de production