create-crm-tmp 1.0.0

package/template/src/app/api/auth/google/status/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+/**
+ * GET /api/auth/google/status
+ * Récupère le statut de connexion Google de l'utilisateur
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const googleAccount = await prisma.userGoogleAccount.findUnique({
+      where: { userId: session.user.id },
+      select: { email: true },
+    });
+
+    return NextResponse.json({
+      connected: !!googleAccount,
+      email: googleAccount?.email || null,
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération du statut Google:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/closing-reasons/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { auth } from '@/lib/auth';
+
+// GET /api/closing-reasons - Liste des motifs de fermeture (tout utilisateur authentifié)
+export async function GET(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const reasons = await prisma.closingReason.findMany({
+      orderBy: { name: 'asc' },
+    });
+
+    return NextResponse.json(reasons);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des motifs de fermeture:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+

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

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { deleteFileFromDrive } from '@/lib/google-drive';
+import { logFileDeleted } from '@/lib/contact-interactions';
+
+// DELETE /api/contacts/[id]/files/[fileId] - Supprimer un fichier
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; fileId: string }> },
+) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id: contactId, fileId } = await params;
+
+    // Vérifier que le contact existe
+    const contact = await prisma.contact.findUnique({
+      where: { id: contactId },
+    });
+
+    if (!contact) {
+      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 },
+    });
+
+    if (!file) {
+      return NextResponse.json({ error: 'Fichier non trouvé' }, { status: 404 });
+    }
+
+    if (file.contactId !== contactId) {
+      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
+    try {
+      await deleteFileFromDrive(session.user.id, file.googleDriveFileId);
+    } 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
+    }
+
+    // Supprimer l'enregistrement de la base de données
+    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
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    console.error('Erreur lors de la suppression du fichier:', error);
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la suppression du fichier' },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,269 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { uploadFileToDrive, getFileInfo } from '@/lib/google-drive';
+import { logFileUploaded, logFileReplaced } from '@/lib/contact-interactions';
+
+// POST /api/contacts/[id]/files - Uploader un fichier
+export async function POST(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: 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,
+      },
+    });
+
+    if (!contact) {
+      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) {
+      return NextResponse.json(
+        {
+          error:
+            'Aucun compte Google connecté. Veuillez connecter votre compte Google dans les paramètres.',
+        },
+        { status: 400 },
+      );
+    }
+
+    // Récupérer le FormData
+    const formData = await request.formData();
+    const file = formData.get('file') as File;
+
+    if (!file) {
+      return NextResponse.json({ error: 'Aucun fichier fourni' }, { 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 },
+      );
+    }
+
+    // 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;
+
+    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
+      }
+
+      // Uploader le nouveau fichier vers Google Drive
+      const { fileId } = await uploadFileToDrive(session.user.id, contactId, contactName, file);
+
+      // 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,
+          uploadedById: session.user.id,
+          updatedAt: new Date(),
+        },
+        include: {
+          uploadedBy: {
+            select: {
+              id: true,
+              name: true,
+              email: true,
+            },
+          },
+        },
+      });
+
+      // 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);
+
+      // 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,
+          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
+      }
+    }
+
+    // Récupérer le webViewLink pour la réponse
+    const fileInfo = await getFileInfo(session.user.id, contactFile.googleDriveFileId);
+    const webViewLink = fileInfo.webViewLink;
+
+    return NextResponse.json({
+      id: contactFile.id,
+      fileName: contactFile.fileName,
+      fileSize: contactFile.fileSize,
+      mimeType: contactFile.mimeType,
+      webViewLink,
+      uploadedBy: contactFile.uploadedBy,
+      createdAt: contactFile.createdAt,
+      updatedAt: contactFile.updatedAt,
+    });
+  } catch (error: any) {
+    console.error("Erreur lors de l'upload du fichier:", error);
+    return NextResponse.json(
+      { error: error.message || "Erreur lors de l'upload du fichier" },
+      { status: 500 },
+    );
+  }
+}
+
+// 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,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id: contactId } = await params;
+
+    // Vérifier que le contact existe
+    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',
+      },
+    });
+
+    // Pour chaque fichier, récupérer le lien de visualisation depuis Google Drive
+    const filesWithLinks = await Promise.all(
+      files.map(async (file) => {
+        try {
+          const googleAccount = await prisma.userGoogleAccount.findUnique({
+            where: { userId: session.user.id },
+          });
+
+          if (googleAccount) {
+            const fileInfo = await getFileInfo(session.user.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,
+            };
+          }
+        } catch (error) {
+          console.error(
+            `Erreur lors de la récupération du lien pour le fichier ${file.id}:`,
+            error,
+          );
+        }
+
+        return {
+          id: file.id,
+          fileName: file.fileName,
+          fileSize: file.fileSize,
+          mimeType: file.mimeType,
+          webViewLink: `https://drive.google.com/file/d/${file.googleDriveFileId}/view`,
+          uploadedBy: file.uploadedBy,
+          createdAt: file.createdAt,
+          updatedAt: file.updatedAt,
+        };
+      }),
+    );
+
+    return NextResponse.json(filesWithLinks);
+  } catch (error: any) {
+    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' },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// PUT /api/contacts/[id]/interactions/[interactionId] - Mettre à jour une interaction
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; interactionId: string }> },
+) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { interactionId } = await params;
+    const body = await request.json();
+    const { type, title, content, date } = body;
+
+    // Vérifier que l'interaction existe
+    const existing = await prisma.interaction.findUnique({
+      where: { id: interactionId },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Interaction non trouvée' }, { status: 404 });
+    }
+
+    const interaction = await prisma.interaction.update({
+      where: { id: interactionId },
+      data: {
+        type: type || existing.type,
+        title: title !== undefined ? title : existing.title,
+        content: content || existing.content,
+        date: date ? new Date(date) : existing.date,
+      },
+      include: {
+        user: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    return NextResponse.json(interaction);
+  } catch (error: any) {
+    console.error("Erreur lors de la mise à jour de l'interaction:", error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/contacts/[id]/interactions/[interactionId] - Supprimer une interaction
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; interactionId: string }> },
+) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { interactionId } = await params;
+
+    // Vérifier que l'interaction existe
+    const existing = await prisma.interaction.findUnique({
+      where: { id: interactionId },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Interaction non trouvée' }, { status: 404 });
+    }
+
+    await prisma.interaction.delete({
+      where: { id: interactionId },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Interaction supprimée avec succès',
+    });
+  } catch (error: any) {
+    console.error("Erreur lors de la suppression de l'interaction:", error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,103 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/contacts/[id]/interactions - Récupérer les interactions d'un contact
+export async function GET(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;
+
+    // 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 });
+    }
+
+    const interactions = await prisma.interaction.findMany({
+      where: { contactId: id },
+      include: {
+        user: {
+          select: { id: true, name: true, email: true },
+        },
+        emailTracking: {
+          select: {
+            id: true,
+            openCount: true,
+            firstOpenedAt: true,
+            lastOpenedAt: true,
+          },
+        },
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+
+    return NextResponse.json(interactions);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des interactions:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/contacts/[id]/interactions - Créer une nouvelle interaction
+export async function POST(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 { type, title, content, date, metadata } = body;
+
+    // Validation
+    if (!type || !content) {
+      return NextResponse.json({ error: 'Le type et le contenu sont requis' }, { status: 400 });
+    }
+
+    // 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 });
+    }
+
+    const interaction = await prisma.interaction.create({
+      data: {
+        contactId: id,
+        type,
+        title: title || null,
+        content,
+        date: date ? new Date(date) : null,
+        userId: session.user.id,
+        metadata: metadata || undefined,
+      },
+      include: {
+        user: {
+          select: { id: true, name: true, email: true },
+        },
+      },
+    });
+
+    return NextResponse.json(interaction, { status: 201 });
+  } catch (error: any) {
+    console.error("Erreur lors de la création de l'interaction:", error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}