Checkpoint: Implémentation complète des restrictions d'accès pour les formateurs : (1) Ajout du rôle "formateur" dans le schéma de base de données avec champ formateurId pour lier un utilisateur à un formateur. (2) Modification du menu de navigation DashboardLayout pour masquer automatiquement les sections "Configuration", "Traçabilité" et "Analyses" aux utilisateurs ayant le rôle formateur. (3) Filtrage backend des données : création de getSequencesByFormateur, getFormationsByFormateur et getApprenantsByFormateur dans db.ts pour ne retourner que les données pertinentes. (4) Modification des procédures tRPC formations.list, sequences.list et apprenants.list pour utiliser protectedProcedure au lieu de adminProcedure et appliquer le filtrage selon le rôle (formateur vs admin). Les formateurs ne voient désormais que leurs propres formations (celles pour lesquelles ils ont des séquences), leurs propres séquences (où ils sont assignés comme formateur) et uniquement les apprenants inscrits à leurs séquences. Les administrateurs conservent l'accès complet à toutes les données. Cette implémentation garantit une séparation claire des accès et protège les données sensibles tout en permettant aux formateurs de gérer efficacement leurs formations.

server/db.ts

@@ -137,6 +137,27 @@ export async function getFormations() {
   return await db.select().from(formations);
 }
 
+export async function getFormationsByFormateur(formateurId: number) {
+  const db = await getDb();
+  if (!db) return [];
+  
+  // Récupérer les IDs de formations uniques pour lesquelles le formateur a des séquences
+  const seqs = await db.select({ formationId: sequences.formationId })
+    .from(sequences)
+    .where(eq(sequences.formateurId, formateurId));
+  
+  const formationIds = Array.from(new Set(seqs.map(s => s.formationId)));
+  
+  if (formationIds.length === 0) return [];
+  
+  // Récupérer les formations correspondantes
+  const result = await db.select().from(formations).where(
+    sql`${formations.id} IN (${sql.join(formationIds.map(id => sql`${id}`), sql`, `)})`
+  );
+  
+  return result;
+}
+
 export async function getFormationById(id: number) {
   const db = await getDb();
   if (!db) return undefined;
@@ -212,6 +233,35 @@ export async function getSequencesWithFormation() {
   );
 }
 
+export async function getSequencesByFormateur(formateurId: number) {
+  const db = await getDb();
+  if (!db) return [];
+  
+  // Récupérer uniquement les séquences de ce formateur
+  const seqs = await db.select().from(sequences).where(eq(sequences.formateurId, formateurId));
+  
+  // Récupérer les informations de formation et de formateur pour chaque séquence
+  return await Promise.all(
+    seqs.map(async (seq) => {
+      const formation = await db.select().from(formations).where(eq(formations.id, seq.formationId)).limit(1);
+      
+      let formateur = null;
+      if (seq.formateurId) {
+        const formateurResult = await db.select().from(formateurs).where(eq(formateurs.id, seq.formateurId)).limit(1);
+        if (formateurResult.length > 0) {
+          formateur = { id: formateurResult[0].id, nom: formateurResult[0].nom };
+        }
+      }
+      
+      return {
+        ...seq,
+        formation: formation.length > 0 ? { id: formation[0].id, nom: formation[0].nom } : null,
+        formateur,
+      };
+    })
+  );
+}
+
 export async function getSequenceById(id: number): Promise<Sequence | undefined> {
   const db = await getDb();
   if (!db) return undefined;
@@ -304,6 +354,58 @@ export async function getApprenants() {
   return apprenantsWithInscriptions;
 }
 
+export async function getApprenantsByFormateur(formateurId: number) {
+  const db = await getDb();
+  if (!db) return [];
+  
+  // Récupérer les IDs de séquences du formateur
+  const seqs = await db.select({ id: sequences.id })
+    .from(sequences)
+    .where(eq(sequences.formateurId, formateurId));
+  
+  const sequenceIds = seqs.map(s => s.id);
+  
+  if (sequenceIds.length === 0) return [];
+  
+  // Récupérer les IDs d'apprenants inscrits à ces séquences
+  const inscriptionsData = await db.select({ apprenantId: inscriptions.apprenantId })
+    .from(inscriptions)
+    .where(
+      sql`${inscriptions.sequenceId} IN (${sql.join(sequenceIds.map(id => sql`${id}`), sql`, `)})`
+    );
+  
+  const apprenantIds = Array.from(new Set(inscriptionsData.map(i => i.apprenantId)));
+  
+  if (apprenantIds.length === 0) return [];
+  
+  // Récupérer les apprenants correspondants
+  const apprenantsData = await db.select().from(apprenants).where(
+    sql`${apprenants.id} IN (${sql.join(apprenantIds.map(id => sql`${id}`), sql`, `)})`
+  );
+  
+  // Pour chaque apprenant, récupérer ses inscriptions (filtrées par les séquences du formateur)
+  const apprenantsWithInscriptions = await Promise.all(
+    apprenantsData.map(async (apprenant) => {
+      const inscriptionsFiltered = await db
+        .select()
+        .from(inscriptions)
+        .where(
+          and(
+            eq(inscriptions.apprenantId, apprenant.id),
+            sql`${inscriptions.sequenceId} IN (${sql.join(sequenceIds.map(id => sql`${id}`), sql`, `)})`
+          )
+        );
+      
+      return {
+        ...apprenant,
+        inscriptions: inscriptionsFiltered,
+      };
+    })
+  );
+  
+  return apprenantsWithInscriptions;
+}
+
 export async function getApprenantById(id: number): Promise<Apprenant | undefined> {
   const db = await getDb();
   if (!db) return undefined;