create-crm-tmp 1.1.2 → 2.0.0

package/template/src/app/api/settings/google-sheet/auto-map/route.ts

@@ -1,12 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { auth } from '@/lib/auth';
+import { checkPermission } from '@/lib/check-permission';
 import { getValidAccessToken } from '@/lib/google-calendar';
+import { indexToColumn } from '@/lib/utils';
+import { googleFetch } from '@/lib/google-fetch';
 
 function extractSpreadsheetId(sheetUrlOrId: string): string {
   if (!sheetUrlOrId) return sheetUrlOrId;
 
-  // Si c'est déjà un ID simple, on le renvoie
   if (!sheetUrlOrId.includes('https://')) {
     return sheetUrlOrId;
   }
@@ -19,21 +20,18 @@ function extractSpreadsheetId(sheetUrlOrId: string): string {
   return sheetUrlOrId;
 }
 
-function indexToColumn(index: number): string {
-  let col = '';
-  let n = index + 1;
-  while (n > 0) {
-    const rem = (n - 1) % 26;
-    col = String.fromCharCode(65 + rem) + col;
-    n = Math.floor((n - 1) / 26);
-  }
-  return col;
-}
-
 // POST /api/settings/google-sheet/auto-map - Proposer un mapping automatique des colonnes
 export async function POST(request: NextRequest) {
   try {
-    const session = await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const hasPermission = await checkPermission('integrations.google_sheets.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const body = await request.json();
     const { sheetUrl, sheetName, headerRow } = body || {};
@@ -58,16 +56,18 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    // Récupérer le compte Google de l'utilisateur admin courant
-    const googleAccount = await prisma.userGoogleAccount.findUnique({
-      where: { userId: session.user.id },
-    });
-
-    if (!googleAccount) {
+    // Récupérer le compte Google de l'admin pour Google Sheets (utilise Drive)
+    // Note: Cette fonction n'existe plus dans google-calendar, utiliser celle de google-drive
+    const { getAdminGoogleAccount } = await import('@/lib/google-drive');
+    let googleAccount;
+    try {
+      googleAccount = await getAdminGoogleAccount();
+    } catch (error: any) {
       return NextResponse.json(
         {
           error:
-            'Aucun compte Google connecté. Veuillez connecter votre compte Google dans les paramètres avant de configurer Google Sheets.',
+            error.message ||
+            'Aucun compte Google configuré. Veuillez demander à un administrateur de connecter son compte Google dans les paramètres.',
         },
         { status: 400 },
       );
@@ -80,7 +80,7 @@ export async function POST(request: NextRequest) {
     );
 
     const range = encodeURIComponent(sheetName);
-    const response = await fetch(
+    const response = await googleFetch(
       `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${range}`,
       {
         headers: {
@@ -184,15 +184,6 @@ export async function POST(request: NextRequest) {
     });
   } catch (error: any) {
     console.error('Erreur lors du mapping automatique Google Sheets:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json(
       { error: error.message || 'Erreur serveur lors du mapping automatique' },
       { status: 500 },

package/template/src/app/api/settings/google-sheet/preview/route.ts

@@ -0,0 +1,104 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { checkPermission } from '@/lib/check-permission';
+import { getValidAccessToken } from '@/lib/google-calendar';
+import { googleFetch } from '@/lib/google-fetch';
+
+function extractSpreadsheetId(sheetUrlOrId: string): string {
+  if (!sheetUrlOrId) return sheetUrlOrId;
+  if (!sheetUrlOrId.includes('https://')) return sheetUrlOrId;
+  const match = sheetUrlOrId.match(/spreadsheets\/d\/([a-zA-Z0-9-_]+)/);
+  return match?.[1] ?? sheetUrlOrId;
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const hasPermission = await checkPermission('integrations.google_sheets.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const body = await request.json();
+    const { sheetUrl, sheetName } = body || {};
+
+    if (!sheetUrl) {
+      return NextResponse.json(
+        { error: 'Le lien du Google Sheet est obligatoire.' },
+        { status: 400 },
+      );
+    }
+
+    const spreadsheetId = extractSpreadsheetId(sheetUrl);
+
+    const { getAdminGoogleAccount } = await import('@/lib/google-drive');
+    let googleAccount;
+    try {
+      googleAccount = await getAdminGoogleAccount();
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : 'Aucun compte Google configuré.';
+      return NextResponse.json({ error: message }, { status: 400 });
+    }
+
+    const accessToken = await getValidAccessToken(
+      googleAccount.accessToken,
+      googleAccount.refreshToken,
+      googleAccount.tokenExpiresAt,
+    );
+
+    // Fetch spreadsheet metadata to get all sheet names
+    const metaResponse = await googleFetch(
+      `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}?fields=sheets.properties.title`,
+      { headers: { Authorization: `Bearer ${accessToken}` } },
+    );
+
+    if (!metaResponse.ok) {
+      return NextResponse.json(
+        { error: 'Impossible de lire les métadonnées du Google Sheet.' },
+        { status: 400 },
+      );
+    }
+
+    const metaData = await metaResponse.json();
+    const sheetNames: string[] = (metaData.sheets || []).map(
+      (s: { properties: { title: string } }) => s.properties.title,
+    );
+
+    if (sheetNames.length === 0) {
+      return NextResponse.json(
+        { error: 'Le Google Sheet ne contient aucune feuille.' },
+        { status: 400 },
+      );
+    }
+
+    const targetSheet = sheetName && sheetNames.includes(sheetName) ? sheetName : sheetNames[0];
+
+    const range = encodeURIComponent(targetSheet);
+    const dataResponse = await googleFetch(
+      `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${range}`,
+      { headers: { Authorization: `Bearer ${accessToken}` } },
+    );
+
+    if (!dataResponse.ok) {
+      return NextResponse.json(
+        { error: 'Impossible de lire les données de la feuille.' },
+        { status: 400 },
+      );
+    }
+
+    const data = await dataResponse.json();
+    const values: string[][] = data.values || [];
+
+    const rawRows = values.slice(0, 20).map((row) => row.map((cell) => String(cell ?? '')));
+
+    return NextResponse.json({ sheetNames, rawRows });
+  } catch (error: unknown) {
+    console.error('Erreur google-sheet preview:', error);
+    const message = error instanceof Error ? error.message : 'Erreur serveur';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/google-sheet/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 
 function extractSpreadsheetId(sheetUrlOrId: string): string {
   if (!sheetUrlOrId) return sheetUrlOrId;
@@ -18,10 +19,17 @@ function extractSpreadsheetId(sheetUrlOrId: string): string {
   return sheetUrlOrId;
 }
 
-// GET /api/settings/google-sheet - Récupérer toutes les configurations Google Sheets (admin uniquement)
+// GET /api/settings/google-sheet - Récupérer toutes les configurations Google Sheets
 export async function GET(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.google_sheets.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const client = prisma as any;
 
@@ -76,23 +84,21 @@ export async function GET(request: NextRequest) {
     );
   } catch (error: any) {
     console.error('Erreur lors de la récupération des configurations Google Sheets:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
   }
 }
 
-// POST /api/settings/google-sheet - Créer une nouvelle configuration (admin uniquement)
+// POST /api/settings/google-sheet - Créer une nouvelle configuration
 export async function POST(request: NextRequest) {
   try {
-    const session = await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.google_sheets.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const body = await request.json();
     const {
@@ -240,15 +246,6 @@ export async function POST(request: NextRequest) {
     });
   } catch (error: any) {
     console.error('Erreur lors de la création de la configuration Google Sheets:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }

package/template/src/app/api/settings/meta-leads/[id]/route.ts

@@ -1,12 +1,20 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 import { encrypt } from '@/lib/encryption';
 
-// PUT /api/settings/meta-leads/[id] - Mettre à jour une configuration (admin uniquement)
+// PUT /api/settings/meta-leads/[id] - Mettre à jour une configuration
 export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.meta.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const { id } = await params;
     const body = await request.json();
@@ -68,26 +76,24 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
     });
   } catch (error: any) {
     console.error('Erreur lors de la mise à jour de la configuration Meta Lead Ads:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }
 
-// DELETE /api/settings/meta-leads/[id] - Supprimer une configuration (admin uniquement)
+// DELETE /api/settings/meta-leads/[id] - Supprimer une configuration
 export async function DELETE(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.meta.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const { id } = await params;
 
@@ -109,15 +115,6 @@ export async function DELETE(
     });
   } catch (error: any) {
     console.error('Erreur lors de la suppression de la configuration Meta Lead Ads:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }

package/template/src/app/api/settings/meta-leads/route.ts

@@ -1,12 +1,20 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 import { encrypt } from '@/lib/encryption';
 
-// GET /api/settings/meta-leads - Récupérer toutes les configurations Meta Lead Ads (admin uniquement)
+// GET /api/settings/meta-leads - Récupérer toutes les configurations Meta Lead Ads
 export async function GET(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.meta.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const configs = await prisma.metaLeadConfig.findMany({
       include: {
@@ -41,23 +49,21 @@ export async function GET(request: NextRequest) {
     );
   } catch (error: any) {
     console.error('Erreur lors de la récupération des configurations Meta Lead Ads:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
   }
 }
 
-// POST /api/settings/meta-leads - Créer une nouvelle configuration (admin uniquement)
+// POST /api/settings/meta-leads - Créer une nouvelle configuration
 export async function POST(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+    const hasPermission = await checkPermission('integrations.meta.manage');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
 
     const body = await request.json();
     const {
@@ -118,15 +124,6 @@ export async function POST(request: NextRequest) {
     });
   } catch (error: any) {
     console.error('Erreur lors de la création de la configuration Meta Lead Ads:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }

package/template/src/app/api/settings/statuses/[id]/route.ts

@@ -1,15 +1,21 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+import { invalidateCachePrefix } from '@/lib/cache';
 
 // PUT /api/settings/statuses/[id] - Mettre à jour un statut
 export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.status.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+
     const { id } = await params;
 
     const body = await request.json();
-    const { name, color, order } = body;
+    const { name, color, order, requiresClosingReason } = body;
 
     // Validation
     if (!name || !color) {
@@ -25,6 +31,13 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Statut non trouvé' }, { status: 404 });
     }
 
+    if (existing.isSystem && name !== existing.name) {
+      return NextResponse.json(
+        { error: 'Ce statut est utilisé par le système et ne peut pas être renommé' },
+        { status: 403 },
+      );
+    }
+
     // Vérifier si le nom existe déjà pour un autre statut
     const nameConflict = await prisma.status.findFirst({
       where: {
@@ -43,21 +56,15 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
         name,
         color,
         ...(order !== undefined && { order }),
+        ...(requiresClosingReason !== undefined && { requiresClosingReason }),
       },
     });
 
+    invalidateCachePrefix('status');
+
     return NextResponse.json(updatedStatus);
   } catch (error: any) {
     console.error('Erreur lors de la mise à jour du statut:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }
@@ -68,10 +75,13 @@ export async function DELETE(
   { params }: { params: Promise<{ id: string }> },
 ) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.status.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+
     const { id } = await params;
 
-    // Vérifier si le statut existe
     const existing = await prisma.status.findUnique({
       where: { id },
     });
@@ -80,22 +90,22 @@ export async function DELETE(
       return NextResponse.json({ error: 'Statut non trouvé' }, { status: 404 });
     }
 
+    if (existing.isSystem) {
+      return NextResponse.json(
+        { error: 'Ce statut est utilisé par le système et ne peut pas être supprimé' },
+        { status: 403 },
+      );
+    }
+
     await prisma.status.delete({
       where: { id },
     });
 
+    invalidateCachePrefix('status');
+
     return NextResponse.json({ success: true, message: 'Statut supprimé avec succès' });
   } catch (error: any) {
     console.error('Erreur lors de la suppression du statut:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
   }
 }

package/template/src/app/api/settings/statuses/route.ts

@@ -1,11 +1,16 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+import { invalidateCachePrefix } from '@/lib/cache';
 
 // GET /api/settings/statuses - Récupérer tous les statuts
 export async function GET(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.status.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const statuses = await prisma.status.findMany({
       orderBy: { order: 'asc' },
@@ -14,15 +19,6 @@ export async function GET(request: NextRequest) {
     return NextResponse.json(statuses);
   } catch (error: any) {
     console.error('Erreur lors de la récupération des statuts:', error);
-
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
   }
 }
@@ -30,10 +26,13 @@ export async function GET(request: NextRequest) {
 // POST /api/settings/statuses - Créer un nouveau statut
 export async function POST(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.status.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const body = await request.json();
-    const { name, color, order } = body;
+    const { name, color, order, requiresClosingReason } = body;
 
     // Validation
     if (!name || !color) {
@@ -63,21 +62,24 @@ export async function POST(request: NextRequest) {
         name,
         color,
         order: statusOrder,
+        ...(requiresClosingReason !== undefined && { requiresClosingReason }),
       },
     });
 
+    invalidateCachePrefix('status');
+
     return NextResponse.json(status, { status: 201 });
   } catch (error: any) {
     console.error('Erreur lors de la création du statut:', error);
 
-    if (error.message === 'Non authentifié') {
-      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
-    }
-
-    if (error.message === 'Permissions insuffisantes') {
-      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
-    }
-
-    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+    return NextResponse.json(
+      {
+        error:
+          process.env.NODE_ENV === 'development'
+            ? error.message || 'Erreur serveur'
+            : 'Erreur serveur',
+      },
+      { status: 500 },
+    );
   }
 }

package/template/src/app/api/statuses/route.ts

@@ -1,8 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
-import { prisma } from '@/lib/prisma';
+import { getCachedStatuses } from '@/lib/cache';
 
-// GET /api/statuses - Récupérer tous les statuts (accessible à tous les utilisateurs authentifiés)
 export async function GET(request: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -13,9 +12,7 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    const statuses = await prisma.status.findMany({
-      orderBy: { order: 'asc' },
-    });
+    const statuses = await getCachedStatuses();
 
     return NextResponse.json(statuses);
   } catch (error: any) {

package/template/src/app/api/tasks/[id]/attendees/route.ts

@@ -45,13 +45,20 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    // Récupérer le compte Google
-    const googleAccount = await prisma.userGoogleAccount.findUnique({
-      where: { userId: session.user.id },
-    });
-
-    if (!googleAccount) {
-      return NextResponse.json({ error: 'Compte Google non connecté' }, { status: 400 });
+    // Récupérer le compte Google de l'utilisateur courant
+    const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+    let googleAccount;
+    try {
+      googleAccount = await getUserGoogleAccount(session.user.id);
+    } catch (error: any) {
+      return NextResponse.json(
+        {
+          error:
+            error.message ||
+            'Veuillez connecter votre compte Google dans les paramètres pour utiliser Google Calendar.',
+        },
+        { status: 400 },
+      );
     }
 
     // Obtenir un token valide