create-crm-tmp 1.1.2 → 2.0.0

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

@@ -1,6 +1,7 @@
 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 { logFileDeleted } from '@/lib/contact-interactions';
 
@@ -18,9 +19,13 @@ export async function DELETE(
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canDeleteFiles = await checkPermission('contacts.delete_files');
+    if (!canDeleteFiles) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id: contactId, fileId } = await params;
 
-    // Vérifier que le contact existe
     const contact = await prisma.contact.findUnique({
       where: { id: contactId },
     });
@@ -29,7 +34,6 @@ export async function DELETE(
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    // Vérifier que le fichier existe et appartient au contact
     const file = await prisma.contactFile.findUnique({
       where: { id: fileId },
     });
@@ -42,26 +46,12 @@ export async function DELETE(
       return NextResponse.json({ error: 'Fichier non associé à ce contact' }, { status: 403 });
     }
 
-    // Vérifier les permissions (seul l'uploader ou un admin peut supprimer)
-    const user = await prisma.user.findUnique({
-      where: { id: session.user.id },
-      select: { role: true },
-    });
-
-    if (file.uploadedById !== session.user.id && user?.role !== 'ADMIN') {
-      return NextResponse.json(
-        { error: "Vous n'avez pas la permission de supprimer ce fichier" },
-        { 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 (via le compte admin)
+    // Supprimer le fichier de Google Drive
     try {
-      // On passe un userId quelconque car deleteFileFromDrive utilise getAdminGoogleAccount()
       await deleteFileFromDrive(session.user.id, file.googleDriveFileId);
     } catch (error) {
       console.error('Erreur lors de la suppression du fichier de Google Drive:', error);

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

@@ -1,6 +1,7 @@
 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 { logFileUploaded, logFileReplaced } from '@/lib/contact-interactions';
 
@@ -15,6 +16,11 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canUpload = await checkPermission('contacts.upload_files');
+    if (!canUpload) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id: contactId } = await params;
 
     // Vérifier que le contact existe
@@ -31,22 +37,13 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    // Vérifier qu'un administrateur a configuré Google Drive
-    const adminUser = await prisma.user.findFirst({
-      where: { role: 'ADMIN' },
-      include: { googleAccount: true },
-      orderBy: { createdAt: 'asc' },
-    });
+    // 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';
 
-    if (!adminUser || !adminUser.googleAccount) {
-      return NextResponse.json(
-        {
-          error:
-            'Aucun compte Google Drive configuré. Veuillez demander à un administrateur de connecter son compte Google Drive dans les paramètres.',
-        },
-        { status: 400 },
-      );
-    }
+    // 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
 
     // Récupérer le FormData
     const formData = await request.formData();
@@ -80,17 +77,23 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     let contactFile;
 
     if (existingFile) {
-      // Si le fichier existe déjà, supprimer l'ancien fichier de Google Drive (via le compte admin)
+      // Si le fichier existe déjà, supprimer l'ancien fichier de Google Drive
       try {
         const { deleteFileFromDrive } = await import('@/lib/google-drive');
-        await deleteFileFromDrive(adminUser.id, existingFile.googleDriveFileId);
+        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
       }
 
-      // Uploader le nouveau fichier vers Google Drive (via le compte admin)
-      const { fileId } = await uploadFileToDrive(adminUser.id, contactId, contactName, file);
+      // Uploader le nouveau fichier vers Google Drive
+      const { fileId } = await uploadFileToDrive(
+        session.user.id,
+        contactId,
+        contactName,
+        file,
+        isForTransaction,
+      );
 
       // Mettre à jour l'enregistrement existant
       contactFile = await prisma.contactFile.update({
@@ -99,6 +102,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
           fileSize: file.size,
           mimeType: file.type || 'application/octet-stream',
           googleDriveFileId: fileId,
+          isIdentityDocument,
           uploadedById: session.user.id,
           updatedAt: new Date(),
         },
@@ -124,8 +128,14 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
         // On continue même si l'interaction échoue
       }
     } else {
-      // Uploader le fichier vers Google Drive (via le compte admin)
-      const { fileId } = await uploadFileToDrive(adminUser.id, contactId, contactName, file);
+      // Uploader le fichier vers Google Drive
+      const { fileId } = await uploadFileToDrive(
+        session.user.id,
+        contactId,
+        contactName,
+        file,
+        isForTransaction,
+      );
 
       // Créer un nouvel enregistrement dans la base de données
       contactFile = await prisma.contactFile.create({
@@ -135,6 +145,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
           fileSize: file.size,
           mimeType: file.type || 'application/octet-stream',
           googleDriveFileId: fileId,
+          isIdentityDocument,
           uploadedById: session.user.id,
         },
         include: {
@@ -157,15 +168,26 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       }
     }
 
-    // Récupérer le webViewLink pour la réponse (via le compte admin)
-    const fileInfo = await getFileInfo(adminUser.id, contactFile.googleDriveFileId);
+    // 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,
+      isIdentityDocument: contactFile.isIdentityDocument,
       webViewLink,
       uploadedBy: contactFile.uploadedBy,
       createdAt: contactFile.createdAt,
@@ -173,6 +195,24 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     });
   } catch (error: any) {
     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" },
       { status: 500 },
@@ -191,6 +231,11 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canViewFiles = await checkPermission('contacts.view_files');
+    if (!canViewFiles) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id: contactId } = await params;
 
     // Vérifier que le contact existe
@@ -219,30 +264,23 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       },
     });
 
-    // Vérifier qu'un administrateur a configuré Google Drive
-    const adminUser = await prisma.user.findFirst({
-      where: { role: 'ADMIN' },
-      include: { googleAccount: true },
-      orderBy: { createdAt: 'asc' },
-    });
-
-    // Pour chaque fichier, récupérer le lien de visualisation depuis Google Drive (via le compte admin)
+    // Pour chaque fichier, récupérer le lien de visualisation depuis Google Drive
     const filesWithLinks = await Promise.all(
       files.map(async (file) => {
         try {
-          if (adminUser && adminUser.googleAccount) {
-            const fileInfo = await getFileInfo(adminUser.id, file.googleDriveFileId);
-            return {
-              id: file.id,
-              fileName: file.fileName,
-              fileSize: file.fileSize,
-              mimeType: file.mimeType,
-              webViewLink: fileInfo.webViewLink,
-              uploadedBy: file.uploadedBy,
-              createdAt: file.createdAt,
-              updatedAt: file.updatedAt,
-            };
-          }
+          // 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}:`,
@@ -255,6 +293,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`,
           uploadedBy: file.uploadedBy,
           createdAt: file.createdAt,

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

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
 
 // GET /api/contacts/[id]/interactions - Récupérer les interactions d'un contact
 export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
@@ -24,6 +25,24 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
+    // Vérifier les permissions
+    const canViewAll = await checkPermission('contacts.view_all');
+    const canViewOwn = await checkPermission('contacts.view_own');
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    // Si l'utilisateur ne peut voir que ses propres contacts, vérifier l'assignation
+    if (!canViewAll && canViewOwn) {
+      const isAssigned =
+        contact.assignedCommercialId === session.user.id ||
+        contact.assignedTeleproId === session.user.id;
+      if (!isAssigned) {
+        return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+      }
+    }
+
     const interactions = await prisma.interaction.findMany({
       where: { contactId: id },
       include: {
@@ -78,6 +97,24 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
+    // Vérifier les permissions d'édition
+    const canEditAll = await checkPermission('contacts.edit_all');
+    const canEditOwn = await checkPermission('contacts.edit_own');
+
+    if (!canEditAll && !canEditOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    // Si l'utilisateur ne peut éditer que ses propres contacts, vérifier l'assignation
+    if (!canEditAll && canEditOwn) {
+      const isAssigned =
+        contact.assignedCommercialId === session.user.id ||
+        contact.assignedTeleproId === session.user.id;
+      if (!isAssigned) {
+        return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+      }
+    }
+
     const interaction = await prisma.interaction.create({
       data: {
         contactId: id,

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

@@ -0,0 +1,71 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// PUT /api/contacts/[id]/kyc - Mettre à jour les informations KYC d'un contact
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+    const body = await request.json();
+
+    const { placeOfBirth, dateOfBirth, idType, idNumber, idExpiryDate, idDocumentUrl } = body;
+
+    // Vérifier que le contact existe
+    const contact = await prisma.contact.findUnique({
+      where: { id },
+    });
+
+    if (!contact) {
+      return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
+    }
+
+    // Mettre à jour les informations KYC
+    const updatedContact = await prisma.contact.update({
+      where: { id },
+      data: {
+        placeOfBirth: placeOfBirth || null,
+        dateOfBirth: dateOfBirth ? new Date(dateOfBirth) : null,
+        idType: idType || null,
+        idNumber: idNumber || null,
+        idExpiryDate: idExpiryDate ? new Date(idExpiryDate) : null,
+        idDocumentUrl: idDocumentUrl || null,
+        // Réinitialiser la vérification si les informations changent
+        idVerifiedByAdmin: false,
+      },
+      include: {
+        status: true,
+        assignedCommercial: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+    });
+
+    // Mettre à jour le statut des transactions en attente de vérification
+    await prisma.transaction.updateMany({
+      where: {
+        contactId: id,
+        status: 'PENDING_ID_VERIFICATION',
+      },
+      data: {
+        status: 'PENDING_ID_VERIFICATION', // Reste en attente jusqu'à vérification admin
+      },
+    });
+
+    return NextResponse.json(updatedContact);
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour des informations KYC:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -7,7 +7,7 @@ import {
   extractMeetLink,
 } from '@/lib/google-calendar';
 import nodemailer from 'nodemailer';
-import { decrypt } from '@/lib/encryption';
+import { decrypt, encrypt } from '@/lib/encryption';
 import { render } from '@react-email/render';
 import { MeetConfirmationEmailTemplate } from '@/components/meet-confirmation-email-template';
 import React from 'react';
@@ -63,14 +63,18 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Contact non trouvé' }, { status: 404 });
     }
 
-    // Vérifier que l'utilisateur a un compte Google connecté
-    const googleAccount = await prisma.userGoogleAccount.findUnique({
-      where: { userId: session.user.id },
-    });
-
-    if (!googleAccount) {
+    // 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: 'Veuillez connecter votre compte Google dans les paramètres' },
+        {
+          error:
+            error.message ||
+            'Veuillez connecter votre compte Google dans les paramètres pour utiliser Google Calendar.',
+        },
         { status: 400 },
       );
     }
@@ -89,7 +93,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       await prisma.userGoogleAccount.update({
         where: { userId: session.user.id },
         data: {
-          accessToken,
+          accessToken: encrypt(accessToken),
           tokenExpiresAt,
         },
       });
@@ -112,28 +116,33 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     });
 
     // Créer l'évènement Google Calendar avec Meet
-    const googleEvent = await createGoogleCalendarEvent(accessToken, {
-      summary: title,
-      description: description || '',
-      start: {
-        dateTime: startDate.toISOString(),
-        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      },
-      end: {
-        dateTime: endDate.toISOString(),
-        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      },
-      attendees: allAttendees.length > 0 ? allAttendees : undefined,
-      conferenceData: {
-        createRequest: {
-          requestId: `meet-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-          conferenceSolutionKey: {
-            type: 'hangoutsMeet',
+    let googleEvent;
+    try {
+      googleEvent = await createGoogleCalendarEvent(accessToken, {
+        summary: title,
+        description: description || '',
+        start: {
+          dateTime: startDate.toISOString(),
+          timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        },
+        end: {
+          dateTime: endDate.toISOString(),
+          timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        },
+        attendees: allAttendees.length > 0 ? allAttendees : undefined,
+        conferenceData: {
+          createRequest: {
+            requestId: `meet-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            conferenceSolutionKey: {
+              type: 'hangoutsMeet',
+            },
           },
         },
-      },
-      conferenceDataVersion: 1,
-    });
+        conferenceDataVersion: 1,
+      });
+    } catch (error: any) {
+      throw error;
+    }
 
     const meetLink = extractMeetLink(googleEvent);