create-crm-tmp 1.1.3 → 2.1.0

package/template/src/app/api/reminders/state/route.ts

@@ -0,0 +1,164 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { REMINDERS_CLEAR_ALL_ID } from '@/lib/reminder-state';
+import {
+  computeExpiresAtForUpsert,
+  getRequestId,
+  isMissingReminderStateTableError,
+  logReminderEvent,
+  reminderStateNotExpired,
+} from '@/lib/reminder-state-server';
+
+export async function GET(request: NextRequest) {
+  const started = Date.now();
+  const requestId = getRequestId(request);
+  let degraded = false;
+
+  try {
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const now = new Date();
+    let states: Array<{ reminderId: string; status: string; updatedAt: Date }> = [];
+    let clearAllState: { status: string; updatedAt: Date; clearedCutoffAt: Date | null } | undefined;
+
+    try {
+      const rows = await prisma.userReminderState.findMany({
+        where: {
+          userId: session.user.id,
+          AND: [reminderStateNotExpired(now)],
+        },
+        select: {
+          reminderId: true,
+          status: true,
+          updatedAt: true,
+          clearedCutoffAt: true,
+        },
+      });
+      states = rows;
+      clearAllState = rows.find((state) => state.reminderId === REMINDERS_CLEAR_ALL_ID);
+    } catch (err) {
+      if (isMissingReminderStateTableError(err)) {
+        degraded = true;
+        logReminderEvent({
+          event: 'reminders_fallback_missing_table',
+          requestId,
+          userId: session.user.id,
+          degraded: true,
+          durationMs: Date.now() - started,
+        });
+      } else {
+        throw err;
+      }
+    }
+
+    const clearedAtIso =
+      clearAllState?.status === 'CLEARED'
+        ? (clearAllState.clearedCutoffAt ?? clearAllState.updatedAt).toISOString()
+        : null;
+
+    logReminderEvent({
+      event: 'reminder_state_read',
+      requestId,
+      userId: session.user.id,
+      countReturned: states.filter((s) => s.reminderId !== REMINDERS_CLEAR_ALL_ID).length,
+      degraded,
+      durationMs: Date.now() - started,
+    });
+
+    return NextResponse.json({
+      states: states.filter((state) => state.reminderId !== REMINDERS_CLEAR_ALL_ID),
+      clearedAt: clearedAtIso,
+      degraded,
+    });
+  } catch (error: unknown) {
+    const msg = error instanceof Error ? error.message : 'Erreur serveur';
+    console.error("Erreur lors de la récupération de l'état des rappels:", error);
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const started = Date.now();
+  const requestId = getRequestId(request);
+
+  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().catch(() => ({}));
+    const reminderId = typeof body.reminderId === 'string' ? body.reminderId.trim() : '';
+    const status = typeof body.status === 'string' ? body.status.trim().toUpperCase() : '';
+    if (!reminderId) {
+      return NextResponse.json({ error: 'reminderId requis.' }, { status: 400 });
+    }
+    if (!['READ', 'DISMISSED'].includes(status)) {
+      return NextResponse.json({ error: 'status invalide.' }, { status: 400 });
+    }
+
+    const now = new Date();
+    const expiresAt = computeExpiresAtForUpsert(reminderId, status as 'READ' | 'DISMISSED', now);
+
+    try {
+      const state = await prisma.userReminderState.upsert({
+        where: {
+          userId_reminderId: {
+            userId: session.user.id,
+            reminderId,
+          },
+        },
+        update: {
+          status: status as 'READ' | 'DISMISSED',
+          expiresAt,
+        },
+        create: {
+          userId: session.user.id,
+          reminderId,
+          status: status as 'READ' | 'DISMISSED',
+          expiresAt,
+        },
+        select: {
+          reminderId: true,
+          status: true,
+          updatedAt: true,
+        },
+      });
+
+      logReminderEvent({
+        event: 'reminder_state_upsert',
+        requestId,
+        userId: session.user.id,
+        degraded: false,
+        durationMs: Date.now() - started,
+        extra: { reminderId, status },
+      });
+
+      return NextResponse.json({ success: true, state, degraded: false });
+    } catch (err) {
+      if (isMissingReminderStateTableError(err)) {
+        logReminderEvent({
+          event: 'reminders_fallback_missing_table',
+          requestId,
+          userId: session.user.id,
+          degraded: true,
+          durationMs: Date.now() - started,
+        });
+        return NextResponse.json({
+          success: true,
+          state: { reminderId, status, updatedAt: now.toISOString() },
+          degraded: true,
+        });
+      }
+      throw err;
+    }
+  } catch (error: unknown) {
+    const msg = error instanceof Error ? error.message : 'Erreur serveur';
+    console.error("Erreur lors de la mise à jour de l'état rappel:", error);
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/template/src/app/api/reset-password/complete/route.ts

@@ -46,21 +46,19 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
     }
 
-    // Hasher le nouveau mot de passe
     const hashedPassword = await hashPassword(password);
 
-    // Mettre à jour le mot de passe dans l'Account
-    await prisma.account.update({
-      where: { id: user.accounts[0].id },
-      data: {
-        password: hashedPassword,
-      },
-    });
-
-    // Supprimer le token de vérification
-    await prisma.verification.delete({
-      where: { id: verification.id },
-    });
+    await prisma.$transaction([
+      prisma.account.update({
+        where: { id: user.accounts[0].id },
+        data: {
+          password: hashedPassword,
+        },
+      }),
+      prisma.verification.delete({
+        where: { id: verification.id },
+      }),
+    ]);
 
     return NextResponse.json({
       success: true,

package/template/src/app/api/reset-password/request/route.ts

@@ -31,7 +31,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Générer un code à 6 chiffres
-    const code = Math.floor(100000 + Math.random() * 900000).toString();
+    const code = String(crypto.getRandomValues(new Uint32Array(1))[0] % 900000 + 100000);
 
     // Créer ou mettre à jour le token de vérification
     const expiresAt = new Date();

package/template/src/app/api/reset-password/verify/route.ts

@@ -46,7 +46,7 @@ export async function POST(request: NextRequest) {
     // Générer un token pour la réinitialisation (différent du code)
     const resetToken = crypto.randomUUID();
     const expiresAt = new Date();
-    expiresAt.setHours(expiresAt.getHours() + 1); // Valide 1 heure
+    expiresAt.setMinutes(expiresAt.getMinutes() + 30); // Valide 30 minutes
 
     // Supprimer l'ancien token de code
     await prisma.verification.delete({

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

@@ -4,12 +4,10 @@ import { ResetPasswordEmailTemplate } from '@/components/reset-password-email-te
 import { prisma } from '@/lib/prisma';
 import { decrypt } from '@/lib/encryption';
 import { auth } from '@/lib/auth';
+import { checkPermission } from '@/lib/check-permission';
 import nodemailer from 'nodemailer';
-import { render } from '@react-email/render';
 import React from 'react';
 
-
-
 function htmlToText(html: string): string {
   if (!html) return '';
   return html
@@ -22,7 +20,6 @@ function htmlToText(html: string): string {
 
 async function getAdminSmtpConfig(userId: string) {
   try {
-    // Récupérer la configuration SMTP de l'administrateur connecté
     const user = await prisma.user.findUnique({
       where: { id: userId },
       include: {
@@ -31,12 +28,10 @@ async function getAdminSmtpConfig(userId: string) {
     });
 
     if (!user) {
-      console.error('❌ Utilisateur non trouvé:', userId);
       return { config: null, error: 'Utilisateur non trouvé' };
     }
 
     if (!user.smtpConfig) {
-      console.error("❌ Aucune configuration SMTP trouvée pour l'utilisateur:", user.email);
       return {
         config: null,
         error:
@@ -56,8 +51,6 @@ async function getAdminSmtpConfig(userId: string) {
 
 async function getAnyAdminSmtpConfig() {
   try {
-    // Récupérer la première configuration SMTP d'un administrateur
-    // On cherche directement dans SmtpConfig et on joint avec User pour vérifier le rôle
     const smtpConfig = await prisma.smtpConfig.findFirst({
       where: {
         user: {
@@ -78,15 +71,6 @@ async function getAnyAdminSmtpConfig() {
     });
 
     if (!smtpConfig) {
-      console.error('❌ Aucune configuration SMTP trouvée pour un administrateur');
-
-      // Log supplémentaire pour debug : vérifier s'il y a des admins
-      const adminCount = await prisma.user.count({
-        where: { role: 'ADMIN' },
-      });
-      const smtpConfigCount = await prisma.smtpConfig.count();
-      console.error('Debug - Admins:', adminCount, 'Configs SMTP:', smtpConfigCount);
-
       return {
         config: null,
         error: 'Aucune configuration SMTP trouvée. Veuillez configurer SMTP dans les paramètres.',
@@ -108,28 +92,29 @@ export async function POST(request: Request) {
     const body = await request.json();
     const { to, subject, template, ...emailData } = body;
 
-    // Récupérer la session de l'utilisateur connecté (optionnel pour reset-password)
     const session = await auth.api.getSession({
       headers: request.headers,
     });
 
-    // Pour le reset password, on n'a pas besoin de session
     const isResetPassword = template === 'reset-password';
 
     if (!isResetPassword && (!session || !session.user?.id)) {
-      console.error('❌ Utilisateur non authentifié');
       return Response.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    // Récupérer la configuration SMTP
+    if (!isResetPassword) {
+      const canSendEmail = await checkPermission('contacts.send_email');
+      if (!canSendEmail) {
+        return Response.json({ error: 'Accès refusé' }, { status: 403 });
+      }
+    }
+
     let smtpConfig, smtpError;
     if (isResetPassword) {
-      // Pour le reset password, utiliser n'importe quelle config SMTP d'admin
       const result = await getAnyAdminSmtpConfig();
       smtpConfig = result.config;
       smtpError = result.error;
     } else {
-      // Pour les autres emails, utiliser la config de l'utilisateur connecté
       const result = await getAdminSmtpConfig(session!.user.id);
       smtpConfig = result.config;
       smtpError = result.error;
@@ -138,12 +123,13 @@ export async function POST(request: Request) {
     if (!smtpConfig) {
       const errorMsg =
         smtpError ||
-        'Aucune configuration SMTP trouvée. Veuillez configurer SMTP dans les paramètres.';
-      console.error('❌', errorMsg);
-      return Response.json({ error: errorMsg }, { status: 400 });
+        'Aucune configuration SMTP trouvée. Veuillez configurer SMTP dans les paramètres pour finaliser votre action.';
+      return Response.json(
+        { error: errorMsg, configLink: '/settings?section=system' },
+        { status: 400 },
+      );
     }
 
-    // Sélectionner le template approprié et le rendre en HTML
     let emailComponent: React.ReactElement;
     if (template === 'invitation') {
       emailComponent = React.createElement(InvitationEmailTemplate, {
@@ -163,23 +149,17 @@ export async function POST(request: Request) {
       });
     }
 
-    // Rendre le composant React en HTML avec @react-email/render
+    const { render } = await import('@react-email/render');
     const emailHtml = await render(emailComponent);
     const emailText = htmlToText(emailHtml);
 
-    // Déchiffrer le mot de passe SMTP
     let password: string;
     try {
       password = decrypt(smtpConfig.password);
-    } catch (error) {
-      // Si le déchiffrement échoue, utiliser le mot de passe tel quel (ancien format non chiffré)
-      console.warn(
-        '⚠️ Impossible de déchiffrer le mot de passe SMTP, utilisation du mot de passe brut',
-      );
+    } catch {
       password = smtpConfig.password;
     }
 
-    // Créer le transporteur SMTP
     const transporter = nodemailer.createTransport({
       host: smtpConfig.host,
       port: smtpConfig.port,
@@ -190,7 +170,6 @@ export async function POST(request: Request) {
       },
     });
 
-    // Envoyer l'email
     const recipients = Array.isArray(to) ? to : [to];
     const mailOptions = {
       from: smtpConfig.fromName
@@ -209,21 +188,15 @@ export async function POST(request: Request) {
       message: 'Email envoyé avec succès',
     });
   } catch (error: any) {
-    console.error("❌ Erreur lors de l'envoi de l'email:", error);
-    console.error("Détails de l'erreur:", {
-      message: error.message,
-      code: error.code,
-      command: error.command,
-      response: error.response,
-    });
+    console.error("Erreur lors de l'envoi de l'email:", error);
 
-    // Gérer les erreurs spécifiques de nodemailer
     if (error.code === 'EAUTH' || error.code === 'ECONNECTION') {
       return Response.json(
         {
           error:
-            "Erreur d'authentification SMTP. Vérifiez votre configuration SMTP dans les paramètres.",
+            "Erreur d'authentification SMTP. Veuillez vérifier votre configuration SMTP pour finaliser votre action.",
           details: error.message,
+          configLink: '/settings?section=system',
         },
         { status: 400 },
       );
@@ -231,8 +204,13 @@ export async function POST(request: Request) {
 
     return Response.json(
       {
-        error: error.message || "Erreur lors de l'envoi de l'email",
-        details: error.code || 'UNKNOWN_ERROR',
+        error:
+          process.env.NODE_ENV === 'development'
+            ? error.message || "Erreur lors de l'envoi de l'email"
+            : "Erreur lors de l'envoi de l'email",
+        ...(process.env.NODE_ENV === 'development' && {
+          details: error.code || 'UNKNOWN_ERROR',
+        }),
       },
       { status: 500 },
     );

package/template/src/app/api/settings/closing-reasons/[id]/route.ts

@@ -1,11 +1,15 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 
 // PUT /api/settings/closing-reasons/[id] - Mettre à jour un motif de fermeture (admin)
 export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.closing_reasons.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const { id } = await params;
     const body = await request.json();
@@ -32,15 +36,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
     });
   } catch (error: any) {
     console.error('Erreur lors de la mise à jour du motif de fermeture:', 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 });
   }
 }
@@ -51,7 +46,10 @@ export async function DELETE(
   { params }: { params: Promise<{ id: string }> },
 ) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.closing_reasons.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const { id } = await params;
 
@@ -65,15 +63,6 @@ export async function DELETE(
     });
   } catch (error: any) {
     console.error('Erreur lors de la suppression du motif de fermeture:', 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/closing-reasons/route.ts

@@ -1,11 +1,15 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 
 // GET /api/settings/closing-reasons - Récupérer tous les motifs de fermeture (admin)
 export async function GET(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.closing_reasons.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const reasons = await prisma.closingReason.findMany({
       orderBy: { name: 'asc' },
@@ -14,15 +18,6 @@ export async function GET(request: NextRequest) {
     return NextResponse.json(reasons);
   } catch (error: any) {
     console.error('Erreur lors de la récupération des motifs de fermeture:', 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 });
   }
 }
@@ -30,7 +25,10 @@ export async function GET(request: NextRequest) {
 // POST /api/settings/closing-reasons - Créer un motif de fermeture (admin)
 export async function POST(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const canManage = await checkPermission('settings.closing_reasons.manage');
+    if (!canManage) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const body = await request.json();
     const { name } = body;
@@ -58,15 +56,6 @@ export async function POST(request: NextRequest) {
     );
   } catch (error: any) {
     console.error('Erreur lors de la création du motif de fermeture:', 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/company/route.ts

@@ -1,20 +1,24 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { prisma } from '@/lib/prisma';
-import { requireAdmin } from '@/lib/roles';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
 
 // GET /api/settings/company - Récupérer les informations de l'entreprise
 export async function GET(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const hasPermission = await checkPermission('settings.view');
+    if (!hasPermission) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     // Récupérer ou créer l'enregistrement de l'entreprise
-    let company = await prisma.company.findUnique({
+    let company = await prisma.organization.findUnique({
       where: { id: 'company' },
     });
 
     // Si l'entreprise n'existe pas, la créer
     if (!company) {
-      company = await prisma.company.create({
+      company = await prisma.organization.create({
         data: {
           id: 'company',
         },
@@ -24,15 +28,6 @@ export async function GET(request: NextRequest) {
     return NextResponse.json(company);
   } catch (error: any) {
     console.error("Erreur lors de la récupération des informations de l'entreprise:", 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 });
   }
 }
@@ -40,11 +35,15 @@ export async function GET(request: NextRequest) {
 // PUT /api/settings/company - Mettre à jour les informations de l'entreprise
 export async function PUT(request: NextRequest) {
   try {
-    await requireAdmin(request.headers);
+    const session = await auth.api.getSession({ headers: request.headers });
+    if (!session) return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    const hasPermission = await checkPermission('settings.company.edit');
+    if (!hasPermission) return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
 
     const body = await request.json();
     const {
       name,
+      legalRepresentative,
       address,
       city,
       postalCode,
@@ -58,16 +57,17 @@ export async function PUT(request: NextRequest) {
     } = body;
 
     // Vérifier si l'entreprise existe
-    let company = await prisma.company.findUnique({
+    let company = await prisma.organization.findUnique({
       where: { id: 'company' },
     });
 
     // Si l'entreprise n'existe pas, la créer
     if (!company) {
-      company = await prisma.company.create({
+      company = await prisma.organization.create({
         data: {
           id: 'company',
           name,
+          legalRepresentative,
           address,
           city,
           postalCode,
@@ -82,10 +82,12 @@ export async function PUT(request: NextRequest) {
       });
     } else {
       // Mettre à jour l'entreprise
-      company = await prisma.company.update({
+      company = await prisma.organization.update({
         where: { id: 'company' },
         data: {
           name: name !== undefined ? name : company.name,
+          legalRepresentative:
+            legalRepresentative !== undefined ? legalRepresentative : company.legalRepresentative,
           address: address !== undefined ? address : company.address,
           city: city !== undefined ? city : company.city,
           postalCode: postalCode !== undefined ? postalCode : company.postalCode,
@@ -107,15 +109,6 @@ export async function PUT(request: NextRequest) {
     });
   } catch (error: any) {
     console.error("Erreur lors de la mise à jour des informations de l'entreprise:", 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 });
   }
 }