create-crm-tmp 1.1.3 → 2.1.0

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

@@ -95,28 +95,34 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           where: { id: customRoleId },
           select: { name: true },
         });
-        resolvedRole = resolveRoleFromCustomRoleName(customRole?.name ?? null);
+        resolvedRole = resolveRoleFromCustomRoleName(customRole?.name);
       } else {
-        resolvedRole = resolveRoleFromCustomRoleName(null);
+        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: {
-        customRole: {
-          select: {
-            id: true,
-            name: true,
+    const updatedUser = await prisma.$transaction(async (tx) => {
+      const userRow = await tx.user.update({
+        where: { id },
+        data: {
+          ...(name && { name }),
+          ...(customRoleId !== undefined && { customRoleId: customRoleId || null }),
+          ...(resolvedRole && { role: resolvedRole as any }),
+          ...(typeof active === 'boolean' && { active }),
+        },
+        include: {
+          customRole: {
+            select: {
+              id: true,
+              name: true,
+            },
           },
         },
-      },
+      });
+      if (typeof active === 'boolean' && active === false && existingUser.active) {
+        await tx.session.deleteMany({ where: { userId: id } });
+      }
+      return userRow;
     });
 
     // Récupérer les noms des profils pour les métadonnées

package/template/src/app/api/users/commercials/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/users/commercials - Récupérer la liste des commerciaux (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 });
+    }
+
+    // Récupérer tous les utilisateurs avec le rôle COMMERCIAL, ADMIN ou MANAGER
+    const users = await prisma.user.findMany({
+      where: {
+        active: true,
+        role: {
+          in: ['COMMERCIAL', 'ADMIN', 'MANAGER'],
+        },
+      },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+        role: true,
+      },
+      orderBy: { name: 'asc' },
+    });
+
+    return NextResponse.json(users);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des commerciaux:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/users/for-agenda/route.ts

@@ -3,7 +3,7 @@ import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 
-// GET /api/users/for-agenda - Liste les utilisateurs avec leur eventColor pour le filtre de l'agenda
+// GET /api/users/for-agenda - Liste les utilisateurs pour le filtre de l'agenda
 export async function GET(request: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -25,7 +25,6 @@ export async function GET(request: NextRequest) {
         id: true,
         name: true,
         email: true,
-        eventColor: true,
       },
       orderBy: {
         name: 'asc',

package/template/src/app/api/users/list/route.ts

@@ -1,9 +1,14 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
-import { prisma } from '@/lib/prisma';
+import { prisma, type Role } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 
-// GET /api/users/list - Récupérer la liste des utilisateurs avec leurs profils (pour les admins)
+// Tous les rôles assignables (permission contacts.assign)
+const ASSIGNABLE_ROLES: Role[] = ['ADMIN', 'MANAGER', 'COMMERCIAL', 'TELEPRO'];
+// Uniquement commercial et télépro (permission contacts.assign_to_sales)
+const SALES_ROLES: Role[] = ['COMMERCIAL', 'TELEPRO'];
+
+// GET /api/users/list - Liste des utilisateurs (admins: tous ; édition contacts: liste pour attribution)
 export async function GET(request: NextRequest) {
   try {
     const session = await auth.api.getSession({
@@ -14,28 +19,61 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
-    // Vérifier que l'utilisateur a la permission de gérer les rôles (admin)
-    const hasPermission = await checkPermission('users.manage_roles');
-    if (!hasPermission) {
+    const [canManageRoles, canAssignContactsFull, canAssignContactsToSales, canAssignTasksFull, canAssignTasksToSales, canEditOwn, canEditAll] = await Promise.all([
+      checkPermission('users.manage_roles'),
+      checkPermission('contacts.assign'),
+      checkPermission('contacts.assign_to_sales'),
+      checkPermission('tasks.assign'),
+      checkPermission('tasks.assign_to_sales'),
+      checkPermission('contacts.edit_own'),
+      checkPermission('contacts.edit_all'),
+    ]);
+    const canEditContacts = canEditOwn || canEditAll;
+
+    const canAssignFull = canAssignContactsFull || canAssignTasksFull;
+    const canAssignToSales = canAssignContactsToSales || canAssignTasksToSales;
+
+    const canAccessList =
+      canManageRoles ||
+      canAssignFull ||
+      canAssignToSales ||
+      canEditContacts;
+    if (!canAccessList) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    // Récupérer tous les utilisateurs avec leurs profils
-    const users = await prisma.user.findMany({
-      select: {
-        id: true,
-        name: true,
-        email: true,
-        customRole: {
-          select: {
-            id: true,
-            name: true,
-            permissions: true,
-          },
+    const select = {
+      id: true,
+      name: true,
+      email: true,
+      role: true,
+      customRole: {
+        select: {
+          id: true,
+          name: true,
+          permissions: true,
         },
       },
-      orderBy: { name: 'asc' },
-    });
+    };
+
+    // Déterminer les rôles à inclure : admins = tous ; assign (contacts ou tâches) full = ASSIGNABLE_ROLES ; sinon SALES_ROLES
+    const assignableRoles = canManageRoles
+      ? undefined
+      : canAssignFull
+        ? ASSIGNABLE_ROLES
+        : SALES_ROLES;
+
+    const users =
+      assignableRoles === undefined
+        ? await prisma.user.findMany({
+            select,
+            orderBy: { name: 'asc' },
+          })
+        : await prisma.user.findMany({
+            where: { role: { in: assignableRoles }, active: true },
+            select,
+            orderBy: { name: 'asc' },
+          });
 
     return NextResponse.json(users);
   } catch (error: any) {

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

@@ -1,10 +1,17 @@
 import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
 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';
 
+const createUserSchema = z.object({
+  name: z.string().trim().min(1, 'Le nom est requis'),
+  email: z.string().trim().email('Email invalide'),
+  customRoleId: z.string().trim().min(1, 'Le profil est requis'),
+});
+
 // GET /api/users - Liste tous les utilisateurs (admin seulement)
 export async function GET(request: NextRequest) {
   try {
@@ -30,27 +37,68 @@ export async function GET(request: NextRequest) {
             name: true,
           },
         },
+        accounts: {
+          where: { providerId: 'credential' },
+          select: { id: true },
+        },
       },
       orderBy: {
         createdAt: 'desc',
       },
     });
 
-    // Mapper les utilisateurs avec le profil
-    const usersWithRole = users.map((user: any) => ({
-      id: user.id,
-      name: user.name,
-      email: user.email,
-      role: user.role || 'USER',
-      customRoleId: user.customRoleId,
-      customRole: user.customRole,
-      emailVerified: user.emailVerified,
-      active: user.active,
-      createdAt: user.createdAt,
-      updatedAt: user.updatedAt,
-      image: user.image,
-      eventColor: user.eventColor,
-    }));
+    const emails: string[] = [];
+    for (const u of users) {
+      if (!u.emailVerified && u.accounts.length === 0) {
+        emails.push(u.email);
+      }
+    }
+
+    const verifications =
+      emails.length > 0
+        ? await prisma.verification.findMany({
+            where: { identifier: { in: emails } },
+            select: { identifier: true, expiresAt: true },
+            orderBy: { expiresAt: 'desc' },
+          })
+        : [];
+
+    const latestTokenByEmail = new Map<string, Date>();
+    for (const v of verifications) {
+      if (!latestTokenByEmail.has(v.identifier)) {
+        latestTokenByEmail.set(v.identifier, v.expiresAt);
+      }
+    }
+
+    const now = new Date();
+    const usersWithRole = users.map((user: any) => {
+      let invitationStatus: 'completed' | 'pending' | 'expired' | null = null;
+      if (user.emailVerified || user.accounts.length > 0) {
+        invitationStatus = 'completed';
+      } else {
+        const expiresAt = latestTokenByEmail.get(user.email);
+        if (!expiresAt) {
+          invitationStatus = 'expired';
+        } else {
+          invitationStatus = expiresAt > now ? 'pending' : 'expired';
+        }
+      }
+
+      return {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        role: user.role || 'USER',
+        customRoleId: user.customRoleId,
+        customRole: user.customRole,
+        emailVerified: user.emailVerified,
+        active: user.active,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt,
+        image: user.image,
+        invitationStatus,
+      };
+    });
 
     return NextResponse.json(usersWithRole);
   } catch (error: any) {
@@ -76,17 +124,20 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
     }
 
-    const body = await request.json();
-    const { name, email, customRoleId } = body;
+    const json = await request.json();
+    const parseResult = createUserSchema.safeParse(json);
 
-    // Validation
-    if (!name || !email) {
-      return NextResponse.json({ error: 'Nom et email requis' }, { status: 400 });
+    if (!parseResult.success) {
+      return NextResponse.json(
+        {
+          error: 'Données invalides',
+          details: parseResult.error.flatten(),
+        },
+        { status: 400 },
+      );
     }
 
-    if (!customRoleId) {
-      return NextResponse.json({ error: 'Le profil est requis' }, { status: 400 });
-    }
+    const { name, email, customRoleId } = parseResult.data;
 
     // Vérifier si l'email existe déjà
     const existingUser = await prisma.user.findUnique({
@@ -106,13 +157,11 @@ export async function POST(request: NextRequest) {
       // Si l'utilisateur existe mais sans compte, on peut régénérer un token
     }
 
-    // Résoudre le rôle enum à partir du profil attribué
     const customRole = await prisma.customRole.findUnique({
       where: { id: customRoleId },
       select: { name: true },
     });
-    const customRoleName = customRole?.name ?? null;
-    const resolvedRole = resolveRoleFromCustomRoleName(customRoleName);
+    const resolvedRole = resolveRoleFromCustomRoleName(customRole?.name);
 
     let user;
     if (existingUser && existingUser.accounts.length === 0) {
@@ -126,12 +175,6 @@ export async function POST(request: NextRequest) {
         },
       });
     } else {
-      const colors = [
-        '#EF4444', '#3B82F6', '#10B981', '#F59E0B', '#8B5CF6', '#EC4899',
-        '#06B6D4', '#84CC16', '#F97316', '#6366F1', '#14B8A6', '#A855F7',
-      ];
-      const randomColor = colors[Math.floor(Math.random() * colors.length)];
-
       user = await prisma.user.create({
         data: {
           id: crypto.randomUUID(),
@@ -141,11 +184,12 @@ export async function POST(request: NextRequest) {
           customRoleId,
           emailVerified: false,
           active: true,
-          eventColor: randomColor,
         },
       });
     }
 
+    const customRoleName = customRole?.name || null;
+
     // Log d'audit : création ou réactivation d'utilisateur
     await logAudit({
       actorId: session.user.id,
@@ -213,6 +257,9 @@ export async function POST(request: NextRequest) {
           statusText: emailResponse.statusText,
           error: errorData,
         });
+      } else {
+        const successData = await emailResponse.json().catch(() => ({}));
+        console.log("✅ Email d'invitation envoyé avec succès:", successData);
       }
     } catch (emailError: any) {
       console.error("❌ Erreur lors de l'envoi de l'email:", emailError);
@@ -248,6 +295,14 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: 'Cet email est déjà utilisé' }, { status: 400 });
     }
 
-    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 },
+    );
   }
 }