create-crm-tmp 1.1.2 → 2.0.0

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

@@ -1,9 +1,9 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { getAuthUser } from '@/lib/get-auth-user';
 import { logAppointmentCreated, createInteraction } from '@/lib/contact-interactions';
 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';
@@ -22,62 +22,81 @@ function htmlToText(html: string): string {
 // GET /api/tasks - Récupérer les tâches de l'utilisateur
 export async function GET(request: NextRequest) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
+    const authUser = await getAuthUser();
 
-    if (!session) {
+    if (!authUser) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const { session, permissions } = authUser;
+    const canViewAll = permissions.includes('tasks.view_all');
+    const canViewOwn = permissions.includes('tasks.view_own');
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { searchParams } = new URL(request.url);
     const startDate = searchParams.get('startDate');
     const endDate = searchParams.get('endDate');
-    const assignedTo = searchParams.get('assignedTo'); // Pour les admins
-    const contactId = searchParams.get('contactId'); // Filtrer par contact
+    const assignedTo = searchParams.get('assignedTo');
+    const contactId = searchParams.get('contactId');
     const showOtherUsers = searchParams.get('showOtherUsers') === 'true';
 
-    // Construire les filtres
-    const where: any = {
-      scheduledAt: {
-        gte: startDate ? new Date(startDate) : new Date(),
+    // Construire les filtres de base
+    // Pour les événements multi-jours, on récupère les tâches avec une marge
+    // Les tâches qui commencent jusqu'à 30 jours avant le début de la période
+    // peuvent potentiellement être affichées (événements longs)
+    const baseFilters: any = {};
+
+    if (startDate) {
+      const startDateObj = new Date(startDate);
+      // Marge de 30 jours avant pour capturer les événements longs
+      const marginStart = new Date(startDateObj);
+      marginStart.setDate(marginStart.getDate() - 30);
+
+      baseFilters.scheduledAt = {
+        gte: marginStart,
         lte: endDate ? new Date(endDate) : undefined,
-      },
-    };
+      };
+
+      if (!endDate) {
+        delete baseFilters.scheduledAt.lte;
+      }
+    } else {
+      baseFilters.scheduledAt = {
+        gte: new Date(),
+        lte: endDate ? new Date(endDate) : undefined,
+      };
+
+      if (!endDate) {
+        delete baseFilters.scheduledAt.lte;
+      }
+    }
 
     // Filtrer par contact si fourni
     if (contactId) {
-      where.contactId = contactId;
+      baseFilters.contactId = contactId;
     }
 
-    // Vérifier la permission pour voir les événements des autres utilisateurs
-    if (showOtherUsers) {
-      const { checkPermission } = await import('@/lib/check-permission');
-      const hasPermission = await checkPermission('tasks.view_other_users_events');
-      if (hasPermission) {
-        // Ne pas filtrer par utilisateur, voir tous les événements
-        delete where.assignedUserId;
-      } else {
-        // Pas de permission, voir uniquement ses propres tâches
-        where.assignedUserId = session.user.id;
-      }
-    } else if (assignedTo && assignedTo !== session.user.id) {
-      const { checkPermission } = await import('@/lib/check-permission');
-      const canViewOthers = await checkPermission('tasks.view_other_users_events');
-      if (canViewOthers) {
-        where.assignedUserId = assignedTo;
-      } else {
-        // Pas de permission, voir uniquement ses propres tâches
-        where.assignedUserId = session.user.id;
+    // Construire les filtres d'utilisateur basés sur les permissions
+    let userFilters: any = {};
+
+    if (showOtherUsers && permissions.includes('tasks.view_other_users_events')) {
+      userFilters = {};
+    } else if (canViewAll) {
+      if (assignedTo) {
+        userFilters = { assignedUserId: assignedTo };
       }
     } else {
-      // Par défaut, voir ses propres tâches
-      where.assignedUserId = session.user.id;
+      userFilters = { assignedUserId: session.user.id };
     }
 
-    if (!endDate) {
-      delete where.scheduledAt.lte;
-    }
+    // Combiner tous les filtres
+    const where: any = {
+      ...baseFilters,
+      ...userFilters,
+    };
 
     const tasks = await prisma.task.findMany({
       where,
@@ -96,7 +115,6 @@ export async function GET(request: NextRequest) {
             id: true,
             name: true,
             email: true,
-            eventColor: true,
           },
         },
         createdBy: {
@@ -115,22 +133,32 @@ export async function GET(request: NextRequest) {
     return NextResponse.json(tasks);
   } catch (error: any) {
     console.error('Erreur lors de la récupération des tâches:', error);
-    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 },
+    );
   }
 }
 
 // POST /api/tasks - Créer une nouvelle tâche
 export async function POST(request: NextRequest) {
   try {
-    const session = await auth.api.getSession({
-      headers: request.headers,
-    });
+    const [authUser, body] = await Promise.all([getAuthUser(), request.json()]);
 
-    if (!session) {
+    if (!authUser) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    const body = await request.json();
+    const { session } = authUser;
+
+    if (!authUser.permissions.includes('tasks.create')) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
     const {
       type,
       title,
@@ -143,6 +171,12 @@ export async function POST(request: NextRequest) {
       internalNote,
       attendees = [],
       addToGoogleCalendar = true,
+      // Champs pour les rendez-vous physiques
+      location,
+      locationAddress,
+      locationCity,
+      locationPostalCode,
+      isAtHome = false,
     } = body;
 
     // Validation
@@ -153,20 +187,20 @@ export async function POST(request: NextRequest) {
       );
     }
 
+    // Vérifier si l'utilisateur est admin
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { role: true },
+    });
+
     // Déterminer l'utilisateur assigné
     let finalAssignedUserId: string;
-    if (assignedUserId && assignedUserId !== session.user.id) {
-      const { checkPermission: checkPerm } = await import('@/lib/check-permission');
-      const canAssignOthers = await checkPerm('tasks.view_other_users_events');
-      if (canAssignOthers) {
-        // Utilisateur avec permission peut assigner à n'importe qui
-        finalAssignedUserId = assignedUserId;
-      } else {
-        // Pas de permission, s'assigne automatiquement
-        finalAssignedUserId = session.user.id;
-      }
+    if (assignedUserId && user?.role === 'ADMIN') {
+      // Admin peut assigner à n'importe qui
+      finalAssignedUserId = assignedUserId;
     } else {
-      finalAssignedUserId = assignedUserId || session.user.id;
+      // Utilisateur normal s'assigne automatiquement
+      finalAssignedUserId = session.user.id;
     }
 
     // Vérifier que le contact existe si fourni
@@ -193,6 +227,12 @@ export async function POST(request: NextRequest) {
           typeof reminderMinutesBefore === 'number' ? reminderMinutesBefore : null,
         notifyContact: notifyContact === true,
         internalNote: internalNote || null,
+        // Champs d'adresse pour les rendez-vous physiques
+        location: location || null,
+        locationAddress: locationAddress || null,
+        locationCity: locationCity || null,
+        locationPostalCode: locationPostalCode || null,
+        isAtHome: isAtHome === true,
       },
       include: {
         contact: {
@@ -209,7 +249,6 @@ export async function POST(request: NextRequest) {
             id: true,
             name: true,
             email: true,
-            eventColor: true,
           },
         },
         createdBy: {
@@ -241,44 +280,55 @@ export async function POST(request: NextRequest) {
     // Si c'est un rendez-vous (physique) ou une tâche et que l'utilisateur veut l'ajouter à Google Calendar
     if ((type === 'MEETING' || type === 'TASK') && addToGoogleCalendar) {
       try {
-        const googleAccount = await prisma.userGoogleAccount.findUnique({
-          where: { userId: session.user.id },
-        });
-
-        if (googleAccount) {
-          const accessToken = await getValidAccessToken(
-            googleAccount.accessToken,
-            googleAccount.refreshToken,
-            googleAccount.tokenExpiresAt,
-          );
-
-          // Durée par défaut de 60 minutes pour les rendez-vous physiques, 30 minutes pour les tâches
-          const startDate = new Date(scheduledAt);
-          const duration = type === 'MEETING' ? 60 : 30;
-          const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
-
-          const googleEvent = await createGoogleCalendarEvent(accessToken, {
-            summary: title || (type === 'MEETING' ? 'Rendez-vous' : 'Tâche'),
-            description: htmlToText(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,
-          });
-
-          // Sauvegarder l'ID de l'évènement pour synchroniser les modifications/suppressions
-          await prisma.task.update({
-            where: { id: task.id },
+        const { getUserGoogleAccount } = await import('@/lib/google-calendar');
+        const googleAccount = await getUserGoogleAccount(session.user.id);
+
+        const accessToken = await getValidAccessToken(
+          googleAccount.accessToken,
+          googleAccount.refreshToken,
+          googleAccount.tokenExpiresAt,
+        );
+
+        // Mettre à jour le token si nécessaire
+        if (accessToken !== googleAccount.accessToken) {
+          const tokenExpiresAt = new Date();
+          tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+          await prisma.userGoogleAccount.update({
+            where: { userId: session.user.id },
             data: {
-              googleEventId: googleEvent.id,
+              accessToken: encrypt(accessToken),
+              tokenExpiresAt,
             },
           });
         }
+
+        // Durée par défaut de 60 minutes pour les rendez-vous physiques, 30 minutes pour les tâches
+        const startDate = new Date(scheduledAt);
+        const duration = type === 'MEETING' ? 60 : 30;
+        const endDate = new Date(startDate.getTime() + duration * 60 * 1000);
+
+        const googleEvent = await createGoogleCalendarEvent(accessToken, {
+          summary: title || (type === 'MEETING' ? 'Rendez-vous' : 'Tâche'),
+          description: htmlToText(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,
+          location: location || undefined, // Ajouter l'adresse du rendez-vous
+        });
+
+        // Sauvegarder l'ID de l'évènement pour synchroniser les modifications/suppressions
+        await prisma.task.update({
+          where: { id: task.id },
+          data: {
+            googleEventId: googleEvent.id,
+          },
+        });
       } catch (googleError: any) {
         console.error('Erreur lors de la création de lévènement Google Calendar:', googleError);
         // On ne bloque pas la création de la tâche si Google Calendar échoue
@@ -299,7 +349,8 @@ export async function POST(request: NextRequest) {
           );
 
           // Envoyer un email de notification si demandé (contact ou invités)
-          if (notifyContact) {
+          // Vérifier explicitement que notifyContact est true
+          if (notifyContact === true) {
             try {
               // Récupérer la configuration SMTP
               const smtpConfig = await prisma.smtpConfig.findUnique({
@@ -312,6 +363,7 @@ export async function POST(request: NextRequest) {
                 try {
                   password = decrypt(smtpConfig.password);
                 } catch (error) {
+                  console.error(error);
                   password = smtpConfig.password;
                 }
 
@@ -378,7 +430,7 @@ export async function POST(request: NextRequest) {
                         ? `"${smtpConfig.fromName}" <${smtpConfig.fromEmail}>`
                         : smtpConfig.fromEmail,
                       to: recipient.email,
-                      subject: `Confirmation de rendez-vous${title ? ` : ${title}` : ''}`,
+                      subject: `Confirmation de rendez-vous ${title ? `: ${title}` : ''}`,
                       text: emailText,
                       html: emailHtml,
                     });
@@ -416,6 +468,14 @@ export async function POST(request: NextRequest) {
     return NextResponse.json(task, { status: 201 });
   } catch (error: any) {
     console.error('Erreur lors de la création de la tâche:', error);
-    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/templates/[id]/route.ts

@@ -1,8 +1,9 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
 
-// GET /api/templates/[id] - Récupérer un template spécifique
+// GET /api/templates/[id] - Récupérer un template spécifique (commun à tous les utilisateurs)
 export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
     const session = await auth.api.getSession({
@@ -13,12 +14,16 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canView = await checkPermission('templates.view');
+    if (!canView) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
 
-    const template = await prisma.template.findFirst({
+    const template = await prisma.template.findUnique({
       where: {
         id,
-        userId: session.user.id,
       },
     });
 
@@ -33,7 +38,7 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
   }
 }
 
-// PUT /api/templates/[id] - Mettre à jour un template
+// PUT /api/templates/[id] - Mettre à jour un template (commun à tous les utilisateurs)
 export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
     const session = await auth.api.getSession({
@@ -44,15 +49,18 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canEdit = await checkPermission('templates.edit');
+    if (!canEdit) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
     const body = await request.json();
     const { name, type, subject, content } = body;
 
-    // Vérifier que le template existe et appartient à l'utilisateur
-    const existing = await prisma.template.findFirst({
+    const existing = await prisma.template.findUnique({
       where: {
         id,
-        userId: session.user.id,
       },
     });
 
@@ -60,7 +68,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Template non trouvé' }, { status: 404 });
     }
 
-    // Validation
     if (!name || !type || !content) {
       return NextResponse.json(
         { error: 'Le nom, le type et le contenu sont requis' },
@@ -75,7 +82,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       );
     }
 
-    // Pour EMAIL, le sujet est requis
     if (type === 'EMAIL' && !subject) {
       return NextResponse.json(
         { error: 'Le sujet est requis pour les templates EMAIL' },
@@ -100,7 +106,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
   }
 }
 
-// DELETE /api/templates/[id] - Supprimer un template
+// DELETE /api/templates/[id] - Supprimer un template (commun à tous les utilisateurs)
 export async function DELETE(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
@@ -114,13 +120,16 @@ export async function DELETE(
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canDelete = await checkPermission('templates.delete');
+    if (!canDelete) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { id } = await params;
 
-    // Vérifier que le template existe et appartient à l'utilisateur
-    const existing = await prisma.template.findFirst({
+    const existing = await prisma.template.findUnique({
       where: {
         id,
-        userId: session.user.id,
       },
     });
 

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

@@ -1,8 +1,9 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
 
-// GET /api/templates - Récupérer tous les templates de l'utilisateur
+// GET /api/templates - Récupérer tous les templates (communs à tous les utilisateurs)
 export async function GET(request: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -13,12 +14,15 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canView = await checkPermission('templates.view');
+    if (!canView) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const { searchParams } = new URL(request.url);
     const type = searchParams.get('type'); // EMAIL, SMS, NOTE
 
-    const where: any = {
-      userId: session.user.id,
-    };
+    const where: any = {};
 
     if (type) {
       where.type = type;
@@ -47,6 +51,11 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    const canCreate = await checkPermission('templates.create');
+    if (!canCreate) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
     const body = await request.json();
     const { name, type, subject, content } = body;
 
@@ -86,6 +95,14 @@ export async function POST(request: NextRequest) {
     return NextResponse.json(template, { status: 201 });
   } catch (error: any) {
     console.error('Erreur lors de la création du template:', error);
-    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/users/[id]/resend-invite/route.ts

@@ -0,0 +1,95 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const [session, { id }] = await Promise.all([
+      auth.api.getSession({ headers: request.headers }),
+      params,
+    ]);
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const hasPermission = await checkPermission('users.create');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const user = await prisma.user.findUnique({
+      where: { id },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+          select: { id: true },
+        },
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    if (user.accounts.length > 0 || user.emailVerified) {
+      return NextResponse.json(
+        { error: 'Cet utilisateur a déjà complété son inscription' },
+        { status: 400 },
+      );
+    }
+
+    const token = crypto.randomUUID();
+    const expiresAt = new Date();
+    expiresAt.setDate(expiresAt.getDate() + 1);
+
+    await prisma.$transaction([
+      prisma.verification.deleteMany({
+        where: { identifier: user.email },
+      }),
+      prisma.verification.create({
+        data: {
+          id: crypto.randomUUID(),
+          identifier: user.email,
+          value: token,
+          expiresAt,
+        },
+      }),
+    ]);
+
+    const baseUrl = process.env.BETTER_AUTH_URL || 'http://localhost:3000';
+    const invitationUrl = `${baseUrl}/invite/${token}`;
+
+    const cookieHeader = request.headers.get('cookie') || '';
+    const emailResponse = await fetch(`${baseUrl}/api/send`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Cookie: cookieHeader,
+      },
+      body: JSON.stringify({
+        to: user.email,
+        subject: 'Invitation à rejoindre le CRM',
+        template: 'invitation',
+        invitationUrl,
+        name: user.name,
+      }),
+    });
+
+    if (!emailResponse.ok) {
+      const errorData = await emailResponse.json().catch(() => ({}));
+      console.error("Erreur lors de l'envoi de l'email de réinvitation:", errorData);
+      return NextResponse.json(
+        { error: errorData.error || "Erreur lors de l'envoi de l'email" },
+        { status: 500 },
+      );
+    }
+
+    return NextResponse.json({
+      message: "Email d'invitation renvoyé avec succès",
+    });
+  } catch (error: any) {
+    console.error("Erreur lors du renvoi de l'invitation:", error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -3,6 +3,7 @@ import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 import { auth } from '@/lib/auth';
 import { logAudit } from '@/lib/audit-log';
+import { resolveRoleFromCustomRoleName } from '@/lib/roles';
 
 // GET /api/users/[id] - Récupérer un utilisateur spécifique
 export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
@@ -86,12 +87,26 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
     }
 
-    // Mettre à jour l'utilisateur
+    // Résoudre le rôle enum si le profil change
+    let resolvedRole: string | undefined;
+    if (customRoleId !== undefined) {
+      if (customRoleId) {
+        const customRole = await prisma.customRole.findUnique({
+          where: { id: customRoleId },
+          select: { name: true },
+        });
+        resolvedRole = resolveRoleFromCustomRoleName(customRole?.name);
+      } else {
+        resolvedRole = 'USER';
+      }
+    }
+
     const updatedUser = await prisma.user.update({
       where: { id },
       data: {
         ...(name && { name }),
         ...(customRoleId !== undefined && { customRoleId: customRoleId || null }),
+        ...(resolvedRole && { role: resolvedRole as any }),
         ...(typeof active === 'boolean' && { active }),
       },
       include: {