Added few configurations & mores

lib/pages.ts

@@ -0,0 +1,55 @@
+// Liste des pages disponibles dans l'application avec leurs permissions
+export const AVAILABLE_PAGES = [
+  {
+    route: '/dashboard',
+    label: 'Tableau de Board',
+    description: 'Page principale du tableau de bord',
+  },
+  {
+    route: '/dashboard/calendrier',
+    label: 'Calendrier',
+    description: 'Gestion des trajets et planning',
+  },
+  {
+    route: '/dashboard/chauffeurs',
+    label: 'Chauffeurs',
+    description: 'Gestion des chauffeurs',
+  },
+  {
+    route: '/dashboard/adherents',
+    label: 'Adhérents',
+    description: 'Gestion des adhérents',
+  },
+  {
+    route: '/dashboard/univers-pro',
+    label: 'Univers Pro',
+    description: 'Base de données des contacts professionnels',
+  },
+  {
+    route: '/dashboard/messagerie',
+    label: 'Messagerie',
+    description: 'Système de messagerie',
+  },
+  {
+    route: '/dashboard/factures',
+    label: 'Factures',
+    description: 'Gestion des factures',
+  },
+  {
+    route: '/dashboard/archives',
+    label: 'Archives',
+    description: 'Archives des trajets',
+  },
+  {
+    route: '/dashboard/parametres',
+    label: 'Paramètres',
+    description: 'Paramètres utilisateur',
+  },
+  {
+    route: '/dashboard/parametres/configuration',
+    label: 'Configuration',
+    description: 'Configuration de la plateforme',
+  },
+] as const;
+
+export type PageRoute = typeof AVAILABLE_PAGES[number]['route'];

lib/permissions.ts

@@ -0,0 +1,88 @@
+import { prisma } from './prisma';
+import { AVAILABLE_PAGES } from './pages';
+
+/**
+ * Vérifie si un utilisateur a accès à une page donnée
+ */
+export async function hasPageAccess(userId: string, pageRoute: string): Promise<boolean> {
+  try {
+    // La page Paramètres est toujours accessible à tous les utilisateurs
+    if (pageRoute === '/dashboard/parametres') {
+      return true;
+    }
+
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        role: {
+          include: {
+            permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    // Si l'utilisateur n'a pas de rôle, permettre l'accès à toutes les pages
+    // (pour permettre la transition et la configuration initiale)
+    if (!user || !user.role) {
+      return true;
+    }
+
+    // Vérifier si le rôle a la permission pour cette page
+    const hasPermission = user.role.permissions.some(
+      (rp) => rp.permission.name === pageRoute
+    );
+
+    return hasPermission;
+  } catch (error) {
+    console.error('Erreur lors de la vérification des permissions:', error);
+    // En cas d'erreur, permettre l'accès pour éviter de bloquer l'utilisateur
+    return true;
+  }
+}
+
+/**
+ * Récupère toutes les pages accessibles pour un utilisateur
+ */
+export async function getUserAccessiblePages(userId: string): Promise<string[]> {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        role: {
+          include: {
+            permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    // Si l'utilisateur n'a pas de rôle, retourner toutes les pages disponibles
+    // (pour permettre la transition et la configuration initiale)
+    if (!user || !user.role) {
+      return AVAILABLE_PAGES.map(page => page.route);
+    }
+
+    // La page Paramètres est toujours accessible
+    const pages: string[] = ['/dashboard/parametres'];
+
+    // Ajouter les pages accessibles via le rôle
+    const rolePages = user.role.permissions
+      .map((rp) => rp.permission.name)
+      .filter((route) => AVAILABLE_PAGES.some((page) => page.route === route));
+
+    return [...pages, ...rolePages];
+  } catch (error) {
+    console.error('Erreur lors de la récupération des pages accessibles:', error);
+    // En cas d'erreur, retourner toutes les pages pour éviter de bloquer l'utilisateur
+    return AVAILABLE_PAGES.map(page => page.route);
+  }
+}

lib/withPageAccess.tsx

@@ -0,0 +1,27 @@
+import { redirect } from 'next/navigation';
+import { getCurrentUser } from '@/lib/auth';
+import { hasPageAccess } from '@/lib/permissions';
+
+/**
+ * HOC pour protéger une page avec vérification des permissions
+ */
+export async function withPageAccess(
+  pageRoute: string,
+  PageComponent: React.ComponentType<any>
+) {
+  return async function ProtectedPage(props: any) {
+    const user = await getCurrentUser();
+
+    if (!user) {
+      redirect('/login');
+    }
+
+    const hasAccess = await hasPageAccess(user.id, pageRoute);
+    if (!hasAccess) {
+      // Rediriger vers la première page accessible ou paramètres
+      redirect('/dashboard/parametres');
+    }
+
+    return <PageComponent {...props} />;
+  };
+}