create-crm-tmp 1.0.0

package/template/src/app/api/settings/smtp/test/route.ts

@@ -0,0 +1,121 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import nodemailer from 'nodemailer';
+
+function htmlToText(html: string): string {
+  if (!html) return '';
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// POST /api/settings/smtp/test - Tester la connexion SMTP
+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 body = await request.json();
+    const { host, port, secure, username, password, fromEmail, fromName, signature } = body;
+
+    // Validation
+    if (!host || !port || !username || !password || !fromEmail) {
+      return NextResponse.json(
+        { error: 'Tous les champs sont requis pour tester la connexion' },
+        { status: 400 },
+      );
+    }
+
+    // Créer un transporteur SMTP de test
+    const transporter = nodemailer.createTransport({
+      host,
+      port: parseInt(port),
+      secure: secure === true || secure === 'true', // true pour 465, false pour les autres ports
+      auth: {
+        user: username,
+        pass: password,
+      },
+      // Options de test
+      connectionTimeout: 10000, // 10 secondes
+      greetingTimeout: 10000,
+    });
+
+    // Tester la connexion
+    try {
+      await transporter.verify();
+
+      // Construire le contenu de test avec la signature éventuelle
+      const baseHtml = `
+        <div style="font-family: Arial, sans-serif;">
+          <h2 style="color: #4F46E5;">Test de configuration SMTP</h2>
+          <p>Ceci est un email de test pour vérifier que votre configuration SMTP fonctionne correctement.</p>
+          <p style="color: #10B981; font-weight: bold;">✅ Votre configuration SMTP est opérationnelle !</p>
+        </div>
+      `;
+
+      const baseText =
+        'Test de configuration SMTP\n\nCeci est un email de test pour vérifier que votre configuration SMTP fonctionne correctement.\n\n✅ Votre configuration SMTP est opérationnelle !';
+
+      const signatureHtml = signature ? `<br><br>${signature}` : '';
+      const signatureText = signature ? `\n\n${htmlToText(signature)}` : '';
+
+      const finalHtml = `${baseHtml}${signatureHtml}`;
+      const finalText = `${baseText}${signatureText}`;
+
+      // Si la vérification réussit, essayer d'envoyer un email de test
+      try {
+        const testEmail = await transporter.sendMail({
+          from: `"${fromName}" <${fromEmail}>`,
+          to: session.user.email, // Envoyer à l'utilisateur connecté
+          subject: 'Test de configuration SMTP - CRM',
+          text: finalText,
+          html: finalHtml,
+        });
+
+        return NextResponse.json({
+          success: true,
+          message: 'Connexion SMTP réussie ! Un email de test a été envoyé à votre adresse.',
+          messageId: testEmail.messageId,
+        });
+      } catch (sendError: any) {
+        // La connexion fonctionne mais l'envoi a échoué
+        return NextResponse.json(
+          {
+            success: false,
+            message: "Connexion SMTP réussie, mais l'envoi de l'email de test a échoué",
+            error: sendError.message,
+          },
+          { status: 200 },
+        ); // On retourne 200 car la connexion fonctionne
+      }
+    } catch (verifyError: any) {
+      // La connexion a échoué
+      return NextResponse.json(
+        {
+          success: false,
+          message: 'Échec de la connexion SMTP',
+          error: verifyError.message || 'Impossible de se connecter au serveur SMTP',
+        },
+        { status: 400 },
+      );
+    }
+  } catch (error: any) {
+    console.error('Erreur lors du test SMTP:', error);
+    return NextResponse.json(
+      {
+        success: false,
+        message: 'Erreur lors du test de connexion',
+        error: error.message || 'Erreur serveur',
+      },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,101 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+
+// 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 { id } = await params;
+
+    const body = await request.json();
+    const { name, color, order } = body;
+
+    // Validation
+    if (!name || !color) {
+      return NextResponse.json({ error: 'Le nom et la couleur sont requis' }, { status: 400 });
+    }
+
+    // Vérifier si le statut existe
+    const existing = await prisma.status.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Statut non trouvé' }, { status: 404 });
+    }
+
+    // Vérifier si le nom existe déjà pour un autre statut
+    const nameConflict = await prisma.status.findFirst({
+      where: {
+        name,
+        NOT: { id },
+      },
+    });
+
+    if (nameConflict) {
+      return NextResponse.json({ error: 'Un statut avec ce nom existe déjà' }, { status: 400 });
+    }
+
+    const updatedStatus = await prisma.status.update({
+      where: { id },
+      data: {
+        name,
+        color,
+        ...(order !== undefined && { order }),
+      },
+    });
+
+    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 });
+  }
+}
+
+// DELETE /api/settings/statuses/[id] - Supprimer un statut
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    await requireAdmin(request.headers);
+    const { id } = await params;
+
+    // Vérifier si le statut existe
+    const existing = await prisma.status.findUnique({
+      where: { id },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Statut non trouvé' }, { status: 404 });
+    }
+
+    await prisma.status.delete({
+      where: { id },
+    });
+
+    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

@@ -0,0 +1,83 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { requireAdmin } from '@/lib/roles';
+
+// GET /api/settings/statuses - Récupérer tous les statuts
+export async function GET(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const statuses = await prisma.status.findMany({
+      orderBy: { order: 'asc' },
+    });
+
+    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 });
+  }
+}
+
+// POST /api/settings/statuses - Créer un nouveau statut
+export async function POST(request: NextRequest) {
+  try {
+    await requireAdmin(request.headers);
+
+    const body = await request.json();
+    const { name, color, order } = body;
+
+    // Validation
+    if (!name || !color) {
+      return NextResponse.json({ error: 'Le nom et la couleur sont requis' }, { status: 400 });
+    }
+
+    // Vérifier si le nom existe déjà
+    const existing = await prisma.status.findUnique({
+      where: { name },
+    });
+
+    if (existing) {
+      return NextResponse.json({ error: 'Un statut avec ce nom existe déjà' }, { status: 400 });
+    }
+
+    // Récupérer le dernier ordre si non fourni
+    let statusOrder = order;
+    if (statusOrder === undefined || statusOrder === null) {
+      const lastStatus = await prisma.status.findFirst({
+        orderBy: { order: 'desc' },
+      });
+      statusOrder = lastStatus ? lastStatus.order + 1 : 0;
+    }
+
+    const status = await prisma.status.create({
+      data: {
+        name,
+        color,
+        order: statusOrder,
+      },
+    });
+
+    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 });
+  }
+}

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

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// 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({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const statuses = await prisma.status.findMany({
+      orderBy: { order: 'asc' },
+    });
+
+    return NextResponse.json(statuses);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des statuts:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,76 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { getValidAccessToken, getGoogleCalendarEvent } from '@/lib/google-calendar';
+
+// GET /api/tasks/[id]/attendees - Récupérer les invités d'un Google Meet
+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;
+
+    const task = await prisma.task.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        googleEventId: true,
+        contactId: true,
+        contact: {
+          select: {
+            email: true,
+          },
+        },
+        assignedUserId: true,
+      },
+    });
+
+    if (!task || !task.googleEventId) {
+      return NextResponse.json({ error: 'Tâche ou Google Event non trouvé' }, { status: 404 });
+    }
+
+    // Vérifier les permissions
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true },
+    });
+
+    if (task.assignedUserId !== session.user.id && user?.role !== 'ADMIN') {
+      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 });
+    }
+
+    // Obtenir un token valide
+    const accessToken = await getValidAccessToken(
+      googleAccount.accessToken,
+      googleAccount.refreshToken,
+      googleAccount.tokenExpiresAt,
+    );
+
+    // Récupérer l'événement Google Calendar
+    const googleEvent = await getGoogleCalendarEvent(accessToken, task.googleEventId);
+
+    // Extraire les emails des invités (inclure tous les invités, y compris le contact)
+    const attendees =
+      googleEvent.attendees?.map((attendee) => attendee.email).filter(Boolean) || [];
+
+    return NextResponse.json({ attendees });
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des invités:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}