create-crm-tmp 2.0.0 → 2.1.0

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

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
+import { normalizePhoneNumber } from '@/lib/utils';
 
 const createCompanySchema = z.object({
   name: z.string().trim().min(1, 'Le nom est obligatoire'),
@@ -58,13 +59,35 @@ export async function GET(request: NextRequest) {
     }
 
     if (search) {
+      const trimmedSearch = search.trim();
+      const searchTerms = trimmedSearch.split(/\s+/).filter(Boolean);
+      const firstTerm = searchTerms[0] || '';
+      const remainingTerms = searchTerms.slice(1).join(' ');
+
+      const digitsOnly = trimmedSearch.replace(/\D/g, '');
+      const looksLikePhone = digitsOnly.length >= 4;
+      const normalizedPhone = looksLikePhone ? normalizePhoneNumber(trimmedSearch) : null;
+
       where.AND = where.AND || [];
       where.AND.push({
         OR: [
-          { name: { contains: search, mode: 'insensitive' } },
-          { email: { contains: search, mode: 'insensitive' } },
-          { phone: { contains: search, mode: 'insensitive' } },
-          { siret: { contains: search, mode: 'insensitive' } },
+          { name: { contains: trimmedSearch, mode: 'insensitive' } },
+          { email: { contains: trimmedSearch, mode: 'insensitive' } },
+          { phone: { contains: trimmedSearch, mode: 'insensitive' } },
+          { siret: { contains: trimmedSearch, mode: 'insensitive' } },
+          ...(normalizedPhone
+            ? [{ phone: { contains: normalizedPhone, mode: 'insensitive' as const } }]
+            : []),
+          ...(remainingTerms
+            ? [
+                {
+                  AND: [
+                    { name: { contains: firstTerm, mode: 'insensitive' } },
+                    { name: { contains: remainingTerms, mode: 'insensitive' } },
+                  ],
+                },
+              ]
+            : []),
         ],
       });
     }
@@ -94,15 +117,22 @@ export async function GET(request: NextRequest) {
       prisma.company.count({ where }),
     ]);
 
-    return NextResponse.json({
-      companies,
-      pagination: {
-        total,
-        page,
-        limit,
-        totalPages: Math.ceil(total / limit),
+    return NextResponse.json(
+      {
+        companies,
+        pagination: {
+          total,
+          page,
+          limit,
+          totalPages: Math.ceil(total / limit),
+        },
       },
-    });
+      {
+        headers: {
+          'Cache-Control': 'private, no-store, max-age=0, must-revalidate',
+        },
+      },
+    );
   } catch (error) {
     console.error('Erreur lors de la récupération des entreprises:', error);
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });

package/template/src/app/api/contacts/[id]/files/[fileId]/preview/route.ts

@@ -2,18 +2,15 @@ import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
-import { downloadFileFromDrive } from '@/lib/google-drive';
+import { BUCKETS, createSignedDownloadUrl } from '@/lib/supabase-storage';
 
-// GET /api/contacts/[id]/files/[fileId]/preview - Prévisualiser une image de fichier contact
+// GET /api/contacts/[id]/files/[fileId]/preview — redirect to signed URL
 export async function GET(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; fileId: string }> },
 ) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
-
+    const session = await auth.api.getSession({ headers: request.headers });
     if (!session) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
@@ -29,22 +26,14 @@ export async function GET(
       where: { id: contactId },
       select: { id: true },
     });
-
     if (!contact) {
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
     const file = await prisma.contactFile.findUnique({
       where: { id: fileId },
-      select: {
-        id: true,
-        contactId: true,
-        fileName: true,
-        mimeType: true,
-        googleDriveFileId: true,
-      },
+      select: { id: true, contactId: true, fileName: true, mimeType: true, storagePath: true },
     });
-
     if (!file) {
       return NextResponse.json({ error: 'Fichier non trouvé' }, { status: 404 });
     }
@@ -53,24 +42,13 @@ export async function GET(
       return NextResponse.json({ error: 'Fichier non associé à ce contact' }, { status: 403 });
     }
 
-    if (!file.mimeType.startsWith('image/')) {
-      return NextResponse.json({ error: 'Prévisualisation disponible uniquement pour les images' }, { status: 404 });
-    }
-
-    const downloaded = await downloadFileFromDrive(session.user.id, file.googleDriveFileId);
+    const signedUrl = await createSignedDownloadUrl(BUCKETS.CONTACTS, file.storagePath, 300);
 
-    return new NextResponse(new Uint8Array(downloaded.buffer), {
-      status: 200,
-      headers: {
-        'Content-Type': file.mimeType,
-        'Cache-Control': 'private, max-age=300',
-        'Content-Disposition': `inline; filename="${encodeURIComponent(file.fileName)}"`,
-      },
-    });
-  } catch (error: any) {
-    console.error("Erreur lors de la prévisualisation d'image:", error);
+    return NextResponse.redirect(signedUrl);
+  } catch (error: unknown) {
+    console.error('Erreur lors de la prévisualisation:', error);
     return NextResponse.json(
-      { error: error.message || "Erreur lors de la prévisualisation de l'image" },
+      { error: error instanceof Error ? error.message : 'Erreur lors de la prévisualisation' },
       { status: 500 },
     );
   }

package/template/src/app/api/contacts/[id]/files/[fileId]/route.ts

@@ -2,19 +2,16 @@ import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
-import { deleteFileFromDrive } from '@/lib/google-drive';
+import { BUCKETS, deleteFile } from '@/lib/supabase-storage';
 import { logFileDeleted } from '@/lib/contact-interactions';
 
-// DELETE /api/contacts/[id]/files/[fileId] - Supprimer un fichier
+// DELETE /api/contacts/[id]/files/[fileId]
 export async function DELETE(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; fileId: string }> },
 ) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
-
+    const session = await auth.api.getSession({ headers: request.headers });
     if (!session) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
@@ -26,18 +23,12 @@ export async function DELETE(
 
     const { id: contactId, fileId } = await params;
 
-    const contact = await prisma.contact.findUnique({
-      where: { id: contactId },
-    });
-
+    const contact = await prisma.contact.findUnique({ where: { id: contactId } });
     if (!contact) {
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    const file = await prisma.contactFile.findUnique({
-      where: { id: fileId },
-    });
-
+    const file = await prisma.contactFile.findUnique({ where: { id: fileId } });
     if (!file) {
       return NextResponse.json({ error: 'Fichier non trouvé' }, { status: 404 });
     }
@@ -46,39 +37,30 @@ export async function DELETE(
       return NextResponse.json({ error: 'Fichier non associé à ce contact' }, { status: 403 });
     }
 
-    // Sauvegarder les informations du fichier avant suppression pour l'interaction
     const fileName = file.fileName;
     const fileSize = file.fileSize;
 
-    // Supprimer le fichier de Google Drive
     try {
-      await deleteFileFromDrive(session.user.id, file.googleDriveFileId);
+      await deleteFile(BUCKETS.CONTACTS, file.storagePath);
     } catch (error) {
-      console.error('Erreur lors de la suppression du fichier de Google Drive:', error);
-      // On continue quand même pour supprimer l'enregistrement en base
+      console.error('Erreur lors de la suppression du fichier du stockage:', error);
     }
 
-    // Supprimer l'enregistrement de la base de données
-    await prisma.contactFile.delete({
-      where: { id: fileId },
-    });
+    await prisma.contactFile.delete({ where: { id: fileId } });
 
-    // Créer une interaction pour la suppression du fichier
     try {
       await logFileDeleted(contactId, fileName, fileSize, session.user.id);
-    } catch (interactionError: any) {
-      console.error(
-        "Erreur lors de la création de l'interaction de suppression:",
-        interactionError,
-      );
-      // On continue même si l'interaction échoue
+    } catch (e) {
+      console.error('Erreur interaction suppression:', e);
     }
 
     return NextResponse.json({ success: true });
-  } catch (error: any) {
+  } catch (error: unknown) {
     console.error('Erreur lors de la suppression du fichier:', error);
     return NextResponse.json(
-      { error: error.message || 'Erreur lors de la suppression du fichier' },
+      {
+        error: error instanceof Error ? error.message : 'Erreur lors de la suppression du fichier',
+      },
       { status: 500 },
     );
   }

package/template/src/app/api/contacts/[id]/files/route.ts

@@ -2,16 +2,20 @@ import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
-import { uploadFileToDrive, getFileInfo } from '@/lib/google-drive';
+import {
+  BUCKETS,
+  buildContactFilePath,
+  createSignedUploadUrl,
+  createSignedDownloadUrl,
+} from '@/lib/supabase-storage';
 import { logFileUploaded, logFileReplaced } from '@/lib/contact-interactions';
 
-// POST /api/contacts/[id]/files - Uploader un fichier
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100 MB
+
+// POST /api/contacts/[id]/files — create-upload-url | finalize
 export async function POST(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
-
+    const session = await auth.api.getSession({ headers: request.headers });
     if (!session) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
@@ -23,210 +27,132 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
 
     const { id: contactId } = await params;
 
-    // Vérifier que le contact existe
     const contact = await prisma.contact.findUnique({
       where: { id: contactId },
-      select: {
-        id: true,
-        firstName: true,
-        lastName: true,
-      },
+      select: { id: true },
     });
 
     if (!contact) {
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    // Vérifier si c'est pour une transaction (via query param)
-    const { searchParams } = new URL(request.url);
-    const isForTransaction = searchParams.get('transaction') === 'true';
-    const isIdentityDocument = searchParams.get('isIdentityDocument') === 'true';
+    const body = await request.json();
 
-    // Récupérer le compte Google de l'admin (tous les utilisateurs utilisent la config admin)
-    // Note: uploadFileToDrive utilise déjà getAdminGoogleAccount, donc pas besoin de vérifier ici
+    // ── Step 1 : generate a signed upload URL ─────────────────────────
+    if (body.action === 'create-upload-url') {
+      const { fileName, fileSize, mimeType } = body;
 
-    // Récupérer le FormData
-    const formData = await request.formData();
-    const file = formData.get('file') as File;
+      if (!fileName || typeof fileSize !== 'number' || !mimeType) {
+        return NextResponse.json(
+          { error: 'Champs requis: fileName, fileSize (number), mimeType' },
+          { status: 400 },
+        );
+      }
 
-    if (!file) {
-      return NextResponse.json({ error: 'Aucun fichier fourni' }, { status: 400 });
-    }
+      if (fileSize > MAX_FILE_SIZE) {
+        return NextResponse.json(
+          { error: 'Le fichier est trop volumineux. Taille maximale: 100 MB' },
+          { status: 400 },
+        );
+      }
 
-    // Vérifier la taille du fichier (max 100MB)
-    const maxSize = 100 * 1024 * 1024; // 100MB
-    if (file.size > maxSize) {
-      return NextResponse.json(
-        { error: 'Le fichier est trop volumineux. Taille maximale: 100MB' },
-        { status: 400 },
-      );
+      const storagePath = buildContactFilePath(contactId, fileName);
+      const result = await createSignedUploadUrl(BUCKETS.CONTACTS, storagePath);
+      return NextResponse.json(result);
     }
 
-    // Nom du contact pour le dossier
-    const contactName =
-      `${contact.firstName || ''} ${contact.lastName || ''}`.trim() || `Contact ${contactId}`;
-
-    // Vérifier si un fichier avec le même nom existe déjà pour ce contact
-    const existingFile = await prisma.contactFile.findFirst({
-      where: {
-        contactId,
-        fileName: file.name,
-      },
-    });
-
-    let contactFile;
+    // ── Step 2 : finalize after client PUT ────────────────────────────
+    if (body.action === 'finalize') {
+      const { storagePath, fileName, fileSize, mimeType } = body;
 
-    if (existingFile) {
-      // Si le fichier existe déjà, supprimer l'ancien fichier de Google Drive
-      try {
-        const { deleteFileFromDrive } = await import('@/lib/google-drive');
-        await deleteFileFromDrive(session.user.id, existingFile.googleDriveFileId);
-      } catch (error) {
-        console.error("Erreur lors de la suppression de l'ancien fichier:", error);
-        // On continue même si la suppression échoue
+      if (!storagePath || !fileName || typeof fileSize !== 'number' || !mimeType) {
+        return NextResponse.json(
+          { error: 'Champs requis: storagePath, fileName, fileSize (number), mimeType' },
+          { status: 400 },
+        );
       }
 
-      // Uploader le nouveau fichier vers Google Drive
-      const { fileId } = await uploadFileToDrive(
-        session.user.id,
-        contactId,
-        contactName,
-        file,
-        isForTransaction,
-      );
+      if (!storagePath.startsWith(`files/${contactId}/`)) {
+        return NextResponse.json({ error: 'Chemin de stockage invalide' }, { status: 400 });
+      }
 
-      // Mettre à jour l'enregistrement existant
-      contactFile = await prisma.contactFile.update({
-        where: { id: existingFile.id },
-        data: {
-          fileSize: file.size,
-          mimeType: file.type || 'application/octet-stream',
-          googleDriveFileId: fileId,
-          isIdentityDocument,
-          uploadedById: session.user.id,
-          updatedAt: new Date(),
-        },
-        include: {
-          uploadedBy: {
-            select: {
-              id: true,
-              name: true,
-              email: true,
-            },
-          },
-        },
+      const existingFile = await prisma.contactFile.findFirst({
+        where: { contactId, fileName },
       });
 
-      // Créer une interaction pour le remplacement du fichier
-      try {
-        await logFileReplaced(contactId, contactFile.id, file.name, file.size, session.user.id);
-      } catch (interactionError: any) {
-        console.error(
-          "Erreur lors de la création de l'interaction de remplacement:",
-          interactionError,
-        );
-        // On continue même si l'interaction échoue
-      }
-    } else {
-      // Uploader le fichier vers Google Drive
-      const { fileId } = await uploadFileToDrive(
-        session.user.id,
-        contactId,
-        contactName,
-        file,
-        isForTransaction,
-      );
+      let contactFile;
+
+      if (existingFile) {
+        contactFile = await prisma.contactFile.update({
+          where: { id: existingFile.id },
+          data: {
+            fileSize,
+            mimeType,
+            storagePath,
+            uploadedById: session.user.id,
+            updatedAt: new Date(),
+          },
+          include: {
+            uploadedBy: { select: { id: true, name: true, email: true } },
+          },
+        });
 
-      // Créer un nouvel enregistrement dans la base de données
-      contactFile = await prisma.contactFile.create({
-        data: {
-          contactId,
-          fileName: file.name,
-          fileSize: file.size,
-          mimeType: file.type || 'application/octet-stream',
-          googleDriveFileId: fileId,
-          isIdentityDocument,
-          uploadedById: session.user.id,
-        },
-        include: {
-          uploadedBy: {
-            select: {
-              id: true,
-              name: true,
-              email: true,
-            },
+        try {
+          await logFileReplaced(contactId, contactFile.id, fileName, fileSize, session.user.id);
+        } catch (e) {
+          console.error('Erreur interaction remplacement:', e);
+        }
+      } else {
+        contactFile = await prisma.contactFile.create({
+          data: {
+            contactId,
+            fileName,
+            fileSize,
+            mimeType,
+            storagePath,
+            uploadedById: session.user.id,
           },
-        },
-      });
+          include: {
+            uploadedBy: { select: { id: true, name: true, email: true } },
+          },
+        });
 
-      // Créer une interaction pour l'upload du fichier (seulement si c'est un nouveau fichier)
-      try {
-        await logFileUploaded(contactId, contactFile.id, file.name, file.size, session.user.id);
-      } catch (interactionError: any) {
-        console.error("Erreur lors de la création de l'interaction d'upload:", interactionError);
-        // On continue même si l'interaction échoue
+        try {
+          await logFileUploaded(contactId, contactFile.id, fileName, fileSize, session.user.id);
+        } catch (e) {
+          console.error('Erreur interaction upload:', e);
+        }
       }
-    }
-
-    // Récupérer le webViewLink pour la réponse
-    const fileInfo = await getFileInfo(session.user.id, contactFile.googleDriveFileId);
-    const webViewLink = fileInfo.webViewLink;
 
-    // Si c'est pour une transaction, mettre à jour automatiquement idDocumentUrl du contact
-    if (isForTransaction) {
-      await prisma.contact.update({
-        where: { id: contactId },
-        data: {
-          idDocumentUrl: webViewLink,
-        },
+      return NextResponse.json({
+        id: contactFile.id,
+        fileName: contactFile.fileName,
+        fileSize: contactFile.fileSize,
+        mimeType: contactFile.mimeType,
+        storagePath: contactFile.storagePath,
+        uploadedBy: contactFile.uploadedBy,
+        createdAt: contactFile.createdAt,
+        updatedAt: contactFile.updatedAt,
       });
     }
 
-    return NextResponse.json({
-      id: contactFile.id,
-      fileName: contactFile.fileName,
-      fileSize: contactFile.fileSize,
-      mimeType: contactFile.mimeType,
-      isIdentityDocument: contactFile.isIdentityDocument,
-      webViewLink,
-      uploadedBy: contactFile.uploadedBy,
-      createdAt: contactFile.createdAt,
-      updatedAt: contactFile.updatedAt,
-    });
-  } catch (error: any) {
+    return NextResponse.json(
+      { error: 'Action invalide. Utilisez "create-upload-url" ou "finalize".' },
+      { status: 400 },
+    );
+  } catch (error: unknown) {
     console.error("Erreur lors de l'upload du fichier:", error);
-
-    // Détecter les erreurs d'authentification Google (token expiré/révoqué)
-    if (
-      error.message?.includes('401') ||
-      error.message?.includes('UNAUTHENTICATED') ||
-      error.message?.includes('Invalid Credentials') ||
-      error.message?.includes('invalid_grant')
-    ) {
-      return NextResponse.json(
-        {
-          error:
-            '🔒 La connexion Google Drive a expiré. Veuillez demander à un administrateur de reconnecter son compte Google dans Paramètres > Intégrations > Google Drive.',
-        },
-        { status: 401 },
-      );
-    }
-
-    // Autres erreurs
     return NextResponse.json(
-      { error: error.message || "Erreur lors de l'upload du fichier" },
+      { error: error instanceof Error ? error.message : "Erreur lors de l'upload du fichier" },
       { status: 500 },
     );
   }
 }
 
-// GET /api/contacts/[id]/files - Lister les fichiers d'un contact
+// GET /api/contacts/[id]/files — lister les fichiers d'un contact
 export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
-
+    const session = await auth.api.getSession({ headers: request.headers });
     if (!session) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
@@ -238,54 +164,26 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
 
     const { id: contactId } = await params;
 
-    // Vérifier que le contact existe
-    const contact = await prisma.contact.findUnique({
-      where: { id: contactId },
-    });
-
+    const contact = await prisma.contact.findUnique({ where: { id: contactId } });
     if (!contact) {
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    // Récupérer tous les fichiers du contact
     const files = await prisma.contactFile.findMany({
       where: { contactId },
       include: {
-        uploadedBy: {
-          select: {
-            id: true,
-            name: true,
-            email: true,
-          },
-        },
-      },
-      orderBy: {
-        createdAt: 'desc',
+        uploadedBy: { select: { id: true, name: true, email: true } },
       },
+      orderBy: { createdAt: 'desc' },
     });
 
-    // Pour chaque fichier, récupérer le lien de visualisation depuis Google Drive
     const filesWithLinks = await Promise.all(
       files.map(async (file) => {
+        let downloadUrl: string | null = null;
         try {
-          // getFileInfo utilise déjà le compte admin
-          const fileInfo = await getFileInfo(session.user.id, file.googleDriveFileId);
-          return {
-            id: file.id,
-            fileName: file.fileName,
-            fileSize: file.fileSize,
-            mimeType: file.mimeType,
-            isIdentityDocument: file.isIdentityDocument,
-            webViewLink: fileInfo.webViewLink,
-            uploadedBy: file.uploadedBy,
-            createdAt: file.createdAt,
-            updatedAt: file.updatedAt,
-          };
-        } catch (error) {
-          console.error(
-            `Erreur lors de la récupération du lien pour le fichier ${file.id}:`,
-            error,
-          );
+          downloadUrl = await createSignedDownloadUrl(BUCKETS.CONTACTS, file.storagePath);
+        } catch (err) {
+          console.error(`Erreur signed URL pour fichier ${file.id}:`, err);
         }
 
         return {
@@ -293,8 +191,7 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
           fileName: file.fileName,
           fileSize: file.fileSize,
           mimeType: file.mimeType,
-          isIdentityDocument: file.isIdentityDocument,
-          webViewLink: `https://drive.google.com/file/d/${file.googleDriveFileId}/view`,
+          downloadUrl,
           uploadedBy: file.uploadedBy,
           createdAt: file.createdAt,
           updatedAt: file.updatedAt,
@@ -303,10 +200,13 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     );
 
     return NextResponse.json(filesWithLinks);
-  } catch (error: any) {
+  } catch (error: unknown) {
     console.error('Erreur lors de la récupération des fichiers:', error);
     return NextResponse.json(
-      { error: error.message || 'Erreur lors de la récupération des fichiers' },
+      {
+        error:
+          error instanceof Error ? error.message : 'Erreur lors de la récupération des fichiers',
+      },
       { status: 500 },
     );
   }