create-crm-tmp 1.0.0

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

@@ -0,0 +1,95 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/reminders - Récupérer tous les rappels 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 now = new Date();
+    const future = new Date(now);
+    future.setDate(future.getDate() + 7); // 7 jours à venir
+
+    // Récupérer toutes les tâches non complétées de l'utilisateur avec rappels
+    const tasks = await prisma.task.findMany({
+      where: {
+        assignedUserId: session.user.id,
+        completed: false,
+        scheduledAt: {
+          gte: now,
+          lte: future,
+        },
+        reminderMinutesBefore: {
+          not: null,
+        },
+      },
+      include: {
+        contact: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            email: true,
+            phone: true,
+          },
+        },
+        assignedUser: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+      orderBy: {
+        scheduledAt: 'asc',
+      },
+    });
+
+    // Formater les rappels - inclure toutes les tâches avec rappels
+    const reminders = tasks
+      .filter((task) => {
+        if (!task.reminderMinutesBefore) return false;
+        const scheduled = new Date(task.scheduledAt);
+        const reminderTime = new Date(scheduled.getTime() - task.reminderMinutesBefore * 60 * 1000);
+        // Inclure les rappels qui sont passés mais pas encore à l'heure de la tâche
+        // ou les rappels qui sont à venir (dans les 7 prochains jours)
+        const timeUntilReminder = reminderTime.getTime() - now.getTime();
+        return (reminderTime <= now && now < scheduled) || (timeUntilReminder > 0 && timeUntilReminder < 7 * 24 * 60 * 60 * 1000);
+      })
+      .map((task) => {
+        const scheduled = new Date(task.scheduledAt);
+        const reminderTime = new Date(
+          scheduled.getTime() - (task.reminderMinutesBefore || 0) * 60 * 1000,
+        );
+
+        return {
+          id: `${task.id}-reminder`,
+          taskId: task.id,
+          type: task.type,
+          title: task.title,
+          description: task.description,
+          priority: task.priority,
+          scheduledAt: task.scheduledAt,
+          reminderTime: reminderTime.toISOString(),
+          reminderMinutesBefore: task.reminderMinutesBefore,
+          contact: task.contact,
+          assignedUser: task.assignedUser,
+        };
+      })
+      .sort((a, b) => new Date(a.scheduledAt).getTime() - new Date(b.scheduledAt).getTime());
+
+    return NextResponse.json(reminders);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des rappels:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+

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

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { hashPassword } from '@/lib/auth';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { token, password } = body;
+
+    if (!token || !password) {
+      return NextResponse.json({ error: 'Token et mot de passe requis' }, { status: 400 });
+    }
+
+    if (password.length < 6) {
+      return NextResponse.json(
+        { error: 'Le mot de passe doit contenir au moins 6 caractères' },
+        { status: 400 },
+      );
+    }
+
+    // Valider le token
+    const verification = await prisma.verification.findFirst({
+      where: {
+        value: token,
+        expiresAt: {
+          gt: new Date(),
+        },
+      },
+    });
+
+    if (!verification) {
+      return NextResponse.json({ error: 'Lien invalide ou expiré' }, { status: 400 });
+    }
+
+    // Trouver l'utilisateur
+    const user = await prisma.user.findUnique({
+      where: { email: verification.identifier },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (!user || user.accounts.length === 0) {
+      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 },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: 'Mot de passe réinitialisé avec succès',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la complétion:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { email } = body;
+
+    if (!email) {
+      return NextResponse.json({ error: 'Email requis' }, { status: 400 });
+    }
+
+    // Vérifier si l'utilisateur existe
+    const user = await prisma.user.findUnique({
+      where: { email },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    // Ne pas révéler si l'email existe ou non (sécurité)
+    // Mais on envoie quand même un message de succès
+    if (!user || user.accounts.length === 0) {
+      // Retourner un succès même si l'utilisateur n'existe pas (sécurité)
+      return NextResponse.json({
+        success: true,
+        message: 'Si cet email existe, un code vous a été envoyé',
+      });
+    }
+
+    // Générer un code à 6 chiffres
+    const code = Math.floor(100000 + Math.random() * 900000).toString();
+
+    // Créer ou mettre à jour le token de vérification
+    const expiresAt = new Date();
+    expiresAt.setMinutes(expiresAt.getMinutes() + 15); // Valide 15 minutes
+
+    // Supprimer les anciens tokens pour cet email
+    await prisma.verification.deleteMany({
+      where: {
+        identifier: email,
+      },
+    });
+
+    // Créer le nouveau token avec le code
+    await prisma.verification.create({
+      data: {
+        id: crypto.randomUUID(),
+        identifier: email,
+        value: code,
+        expiresAt,
+      },
+    });
+
+    // Envoyer l'email avec le code
+    const baseUrl = process.env.BETTER_AUTH_URL || 'http://localhost:3000';
+
+    try {
+      await fetch(`${baseUrl}/api/send`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          to: email,
+          subject: 'Code de réinitialisation de mot de passe',
+          template: 'reset-password',
+          code,
+        }),
+      });
+    } catch (emailError) {
+      console.error("Erreur lors de l'envoi de l'email:", emailError);
+      // On continue même si l'email échoue
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: 'Si cet email existe, un code vous a été envoyé',
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la demande de réinitialisation:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const token = searchParams.get('token');
+
+    if (!token) {
+      return NextResponse.json({ error: 'Token manquant' }, { status: 400 });
+    }
+
+    // Trouver le token de vérification
+    const verification = await prisma.verification.findFirst({
+      where: {
+        value: token,
+        expiresAt: {
+          gt: new Date(), // Pas expiré
+        },
+      },
+    });
+
+    if (!verification) {
+      return NextResponse.json({ error: 'Lien invalide ou expiré' }, { status: 400 });
+    }
+
+    // Vérifier si l'utilisateur existe et a un compte
+    const user = await prisma.user.findUnique({
+      where: { email: verification.identifier },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (!user || user.accounts.length === 0) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    return NextResponse.json({
+      email: user.email,
+      valid: true,
+    });
+  } catch (error) {
+    console.error('Erreur lors de la validation:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,74 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { email, code } = body;
+
+    if (!email || !code) {
+      return NextResponse.json({ error: 'Email et code requis' }, { status: 400 });
+    }
+
+    if (code.length !== 6 || !/^\d+$/.test(code)) {
+      return NextResponse.json({ error: 'Code invalide' }, { status: 400 });
+    }
+
+    // Trouver le token de vérification
+    const verification = await prisma.verification.findFirst({
+      where: {
+        identifier: email,
+        value: code,
+        expiresAt: {
+          gt: new Date(), // Pas expiré
+        },
+      },
+    });
+
+    if (!verification) {
+      return NextResponse.json({ error: 'Code invalide ou expiré' }, { status: 400 });
+    }
+
+    // Vérifier si l'utilisateur existe et a un compte
+    const user = await prisma.user.findUnique({
+      where: { email },
+      include: {
+        accounts: {
+          where: { providerId: 'credential' },
+        },
+      },
+    });
+
+    if (!user || user.accounts.length === 0) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // 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
+
+    // Supprimer l'ancien token de code
+    await prisma.verification.delete({
+      where: { id: verification.id },
+    });
+
+    // Créer un nouveau token pour la réinitialisation
+    await prisma.verification.create({
+      data: {
+        id: crypto.randomUUID(),
+        identifier: email,
+        value: resetToken,
+        expiresAt,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      token: resetToken,
+    });
+  } catch (error) {
+    console.error('Erreur lors de la vérification:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,183 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { headers } from 'next/headers';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { logAudit } from '@/lib/audit-log';
+
+// PUT /api/roles/[id] - Modifier un profil
+export async function PUT(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de gérer les rôles
+    const hasPermission = await checkPermission('users.manage_roles');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 403 });
+    }
+
+    const { id } = await params;
+    const body = await req.json();
+    const { name, description, permissions } = body;
+
+    // Vérifier que le profil existe
+    const existingRole = await prisma.customRole.findUnique({
+      where: { id },
+      include: {
+        _count: {
+          select: { users: true },
+        },
+      },
+    });
+
+    if (!existingRole) {
+      return NextResponse.json({ error: 'Profil non trouvé' }, { status: 404 });
+    }
+
+    // Validation
+    if (name && typeof name !== 'string') {
+      return NextResponse.json(
+        { error: 'Le nom doit être une chaîne de caractères' },
+        { status: 400 },
+      );
+    }
+
+    if (permissions && !Array.isArray(permissions)) {
+      return NextResponse.json(
+        { error: 'Les permissions doivent être un tableau' },
+        { status: 400 },
+      );
+    }
+
+    // Vérifier que le nouveau nom n'existe pas déjà (si changé)
+    if (name && name.trim() !== existingRole.name) {
+      const duplicateName = await prisma.customRole.findUnique({
+        where: { name: name.trim() },
+      });
+
+      if (duplicateName) {
+        return NextResponse.json({ error: 'Un profil avec ce nom existe déjà' }, { status: 400 });
+      }
+    }
+
+    // Mettre à jour le profil
+    const updatedRole = await prisma.customRole.update({
+      where: { id },
+      data: {
+        ...(name && { name: name.trim() }),
+        ...(description !== undefined && { description: description?.trim() || null }),
+        ...(permissions && { permissions }),
+      },
+    });
+
+    await logAudit({
+      actorId: session.user.id,
+      action: 'ROLE_UPDATED',
+      entityType: 'ROLE',
+      entityId: updatedRole.id,
+      metadata: {
+        before: {
+          name: existingRole.name,
+          description: existingRole.description,
+          permissions: existingRole.permissions,
+        },
+        after: {
+          name: updatedRole.name,
+          description: updatedRole.description,
+          permissions: updatedRole.permissions,
+        },
+      },
+    });
+
+    return NextResponse.json({
+      message: 'Profil modifié avec succès',
+      role: {
+        id: updatedRole.id,
+        name: updatedRole.name,
+        description: updatedRole.description,
+        permissions: updatedRole.permissions,
+        isSystem: updatedRole.isSystem,
+        usersCount: existingRole._count.users,
+        createdAt: updatedRole.createdAt.toISOString(),
+        updatedAt: updatedRole.updatedAt.toISOString(),
+      },
+    });
+  } catch (error) {
+    console.error('Erreur lors de la modification du profil:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/roles/[id] - Supprimer un profil
+export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de gérer les rôles
+    const hasPermission = await checkPermission('users.manage_roles');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 403 });
+    }
+
+    const { id } = await params;
+
+    // Vérifier que le profil existe
+    const existingRole = await prisma.customRole.findUnique({
+      where: { id },
+      include: {
+        _count: {
+          select: { users: true },
+        },
+      },
+    });
+
+    if (!existingRole) {
+      return NextResponse.json({ error: 'Profil non trouvé' }, { status: 404 });
+    }
+
+    // Empêcher la suppression si des utilisateurs utilisent ce profil
+    if (existingRole._count.users > 0) {
+      return NextResponse.json(
+        {
+          error: `Ce profil ne peut pas être supprimé car ${existingRole._count.users} l'utilisent`,
+        },
+        { status: 400 },
+      );
+    }
+
+    // Supprimer le profil
+    await prisma.customRole.delete({
+      where: { id },
+    });
+
+    await logAudit({
+      actorId: session.user.id,
+      action: 'ROLE_DELETED',
+      entityType: 'ROLE',
+      entityId: existingRole.id,
+      metadata: {
+        name: existingRole.name,
+        description: existingRole.description,
+      },
+    });
+
+    return NextResponse.json({
+      message: 'Profil supprimé avec succès',
+    });
+  } catch (error) {
+    console.error('Erreur lors de la suppression du profil:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,140 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { headers } from 'next/headers';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { logAudit } from '@/lib/audit-log';
+
+// GET /api/roles - Récupérer tous les profils (système + personnalisés)
+export async function GET(req: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de gérer les rôles
+    const hasPermission = await checkPermission('users.manage_roles');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 403 });
+    }
+
+    // Récupérer tous les profils depuis la BDD (système + personnalisés)
+    const roles = await prisma.customRole.findMany({
+      include: {
+        _count: {
+          select: { users: true },
+        },
+      },
+      orderBy: [
+        { isSystem: 'desc' }, // Profils système en premier
+        { createdAt: 'desc' }, // Puis les plus récents
+      ],
+    });
+
+    // Formatter les profils
+    const formattedRoles = roles.map((role) => ({
+      id: role.id,
+      name: role.name,
+      description: role.description,
+      permissions: role.permissions as string[],
+      isSystem: role.isSystem,
+      usersCount: role._count.users,
+      createdAt: role.createdAt.toISOString(),
+      updatedAt: role.updatedAt.toISOString(),
+    }));
+
+    return NextResponse.json(formattedRoles);
+  } catch (error) {
+    console.error('Erreur lors de la récupération des profils:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 })
+  }
+}
+
+// POST /api/roles - Créer un nouveau profil personnalisé
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de gérer les rôles
+    const hasPermission = await checkPermission('users.manage_roles');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 403 });
+    }
+
+    const body = await req.json();
+    const { name, description, permissions } = body;
+
+    // Validation
+    if (!name || typeof name !== 'string' || name.trim().length === 0) {
+      return NextResponse.json({ error: 'Le nom du profil est requis' }, { status: 400 });
+    }
+
+    if (!Array.isArray(permissions)) {
+      return NextResponse.json(
+        { error: 'Les permissions doivent être un tableau' },
+        { status: 400 },
+      );
+    }
+
+    // Vérifier que le nom n'existe pas déjà
+    const existing = await prisma.customRole.findUnique({
+      where: { name: name.trim() },
+    });
+
+    if (existing) {
+      return NextResponse.json({ error: 'Un profil avec ce nom existe déjà' }, { status: 400 });
+    }
+
+    // Créer le profil
+    const newRole = await prisma.customRole.create({
+      data: {
+        name: name.trim(),
+        description: description?.trim() || null,
+        permissions: permissions,
+        isSystem: false,
+      },
+    });
+
+    await logAudit({
+      actorId: session.user.id,
+      action: 'ROLE_CREATED',
+      entityType: 'ROLE',
+      entityId: newRole.id,
+      metadata: {
+        name: newRole.name,
+        description: newRole.description,
+        permissions,
+      },
+    });
+
+    return NextResponse.json(
+      {
+        message: 'Profil créé avec succès',
+        role: {
+          id: newRole.id,
+          name: newRole.name,
+          description: newRole.description,
+          permissions: newRole.permissions,
+          isSystem: newRole.isSystem,
+          usersCount: 0,
+          createdAt: newRole.createdAt.toISOString(),
+          updatedAt: newRole.updatedAt.toISOString(),
+        },
+      },
+      { status: 201 },
+    );
+  } catch (error) {
+    console.error('Erreur lors de la création du profil:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}