create-crm-tmp 1.0.0

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

@@ -0,0 +1,140 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/templates/[id] - Récupérer un template spécifique
+export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    const template = await prisma.template.findFirst({
+      where: {
+        id,
+        userId: session.user.id,
+      },
+    });
+
+    if (!template) {
+      return NextResponse.json({ error: 'Template non trouvé' }, { status: 404 });
+    }
+
+    return NextResponse.json(template);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération du template:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// PUT /api/templates/[id] - Mettre à jour un template
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+    const 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({
+      where: {
+        id,
+        userId: session.user.id,
+      },
+    });
+
+    if (!existing) {
+      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' },
+        { status: 400 },
+      );
+    }
+
+    if (!['EMAIL', 'SMS', 'NOTE'].includes(type)) {
+      return NextResponse.json(
+        { error: 'Type invalide. Doit être EMAIL, SMS ou NOTE' },
+        { status: 400 },
+      );
+    }
+
+    // Pour EMAIL, le sujet est requis
+    if (type === 'EMAIL' && !subject) {
+      return NextResponse.json(
+        { error: 'Le sujet est requis pour les templates EMAIL' },
+        { status: 400 },
+      );
+    }
+
+    const template = await prisma.template.update({
+      where: { id },
+      data: {
+        name,
+        type,
+        subject: type === 'EMAIL' ? subject : null,
+        content,
+      },
+    });
+
+    return NextResponse.json(template);
+  } catch (error: any) {
+    console.error('Erreur lors de la mise à jour du template:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// DELETE /api/templates/[id] - Supprimer un template
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    // Vérifier que le template existe et appartient à l'utilisateur
+    const existing = await prisma.template.findFirst({
+      where: {
+        id,
+        userId: session.user.id,
+      },
+    });
+
+    if (!existing) {
+      return NextResponse.json({ error: 'Template non trouvé' }, { status: 404 });
+    }
+
+    await prisma.template.delete({
+      where: { id },
+    });
+
+    return NextResponse.json({ success: true, message: 'Template supprimé avec succès' });
+  } catch (error: any) {
+    console.error('Erreur lors de la suppression du template:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/templates - Récupérer tous les templates 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 { searchParams } = new URL(request.url);
+    const type = searchParams.get('type'); // EMAIL, SMS, NOTE
+
+    const where: any = {
+      userId: session.user.id,
+    };
+
+    if (type) {
+      where.type = type;
+    }
+
+    const templates = await prisma.template.findMany({
+      where,
+      orderBy: { updatedAt: 'desc' },
+    });
+
+    return NextResponse.json(templates);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des templates:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// POST /api/templates - Créer un nouveau template
+export async function POST(request: NextRequest) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const { name, type, subject, content } = body;
+
+    // Validation
+    if (!name || !type || !content) {
+      return NextResponse.json(
+        { error: 'Le nom, le type et le contenu sont requis' },
+        { status: 400 },
+      );
+    }
+
+    if (!['EMAIL', 'SMS', 'NOTE'].includes(type)) {
+      return NextResponse.json(
+        { error: 'Type invalide. Doit être EMAIL, SMS ou NOTE' },
+        { status: 400 },
+      );
+    }
+
+    // Pour EMAIL, le sujet est requis
+    if (type === 'EMAIL' && !subject) {
+      return NextResponse.json(
+        { error: 'Le sujet est requis pour les templates EMAIL' },
+        { status: 400 },
+      );
+    }
+
+    const template = await prisma.template.create({
+      data: {
+        name,
+        type,
+        subject: type === 'EMAIL' ? subject : null,
+        content,
+        userId: session.user.id,
+      },
+    });
+
+    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 });
+  }
+}

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

@@ -0,0 +1,168 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+import { logAudit } from '@/lib/audit-log';
+
+// GET /api/users/[id] - Récupérer un utilisateur spécifique
+export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de voir les utilisateurs
+    const hasPermission = await checkPermission('users.view');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+    const { id } = await params;
+
+    const user = await prisma.user.findUnique({
+      where: { id },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // Retourner l'utilisateur avec le rôle
+    return NextResponse.json({
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      role: user.role || 'USER',
+      emailVerified: user.emailVerified,
+      active: user.active,
+      image: user.image,
+      createdAt: user.createdAt,
+      updatedAt: user.updatedAt,
+    });
+  } catch (error: any) {
+    console.error('Erreur:', 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 });
+  }
+}
+
+// PUT /api/users/[id] - Mettre à jour un utilisateur
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de modifier des utilisateurs
+    const hasPermission = await checkPermission('users.edit');
+    if (!hasPermission) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+    const { id } = await params;
+    const body = await request.json();
+    const { name, customRoleId, active } = body;
+
+    // Vérifier que l'utilisateur existe
+    const existingUser = await prisma.user.findUnique({
+      where: { id },
+    });
+
+    if (!existingUser) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // Mettre à jour l'utilisateur
+    const updatedUser = await prisma.user.update({
+      where: { id },
+      data: {
+        ...(name && { name }),
+        ...(customRoleId !== undefined && { customRoleId: customRoleId || null }),
+        ...(typeof active === 'boolean' && { active }),
+      },
+      include: {
+        customRole: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    });
+
+    // Récupérer les noms des profils pour les métadonnées
+    const getRoleName = async (roleId: string | null) => {
+      if (!roleId) return null;
+      const role = await prisma.customRole.findUnique({
+        where: { id: roleId },
+        select: { name: true },
+      });
+      return role?.name || null;
+    };
+
+    // Log d'audit : modification utilisateur
+    const changes: Record<string, { old: any; new: any }> = {};
+    if (name && name !== existingUser.name) {
+      changes.name = { old: existingUser.name, new: name };
+    }
+    if (customRoleId !== undefined && customRoleId !== existingUser.customRoleId) {
+      const oldRoleName = await getRoleName(existingUser.customRoleId);
+      const newRoleName = await getRoleName(customRoleId || null);
+      changes.profil = {
+        old: oldRoleName || 'Aucun',
+        new: newRoleName || 'Aucun',
+      };
+    }
+    if (typeof active === 'boolean' && active !== existingUser.active) {
+      changes.active = {
+        old: existingUser.active ? 'Actif' : 'Inactif',
+        new: active ? 'Actif' : 'Inactif',
+      };
+    }
+
+    if (Object.keys(changes).length > 0) {
+      await logAudit({
+        actorId: session.user.id,
+        targetUserId: updatedUser.id,
+        action: 'USER_UPDATED',
+        entityType: 'USER',
+        entityId: updatedUser.id,
+        metadata: {
+          changes,
+        },
+      });
+    }
+
+    // Retourner l'utilisateur avec le profil
+    return NextResponse.json({
+      id: updatedUser.id,
+      name: updatedUser.name,
+      email: updatedUser.email,
+      role: updatedUser.role || 'USER',
+      customRoleId: updatedUser.customRoleId,
+      customRole: updatedUser.customRole,
+      emailVerified: updatedUser.emailVerified,
+      active: updatedUser.active,
+      updatedAt: updatedUser.updatedAt,
+    });
+  } catch (error: any) {
+    console.error('Erreur:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+// NOTE: L'API DELETE n'est plus utilisée : les comptes sont désormais désactivés via le booléen `active`.

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

@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } 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)
+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 });
+    }
+
+    // Vérifier que l'utilisateur a la permission de gérer les rôles (admin)
+    const hasPermission = await checkPermission('users.manage_roles');
+    if (!hasPermission) {
+      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,
+          },
+        },
+      },
+      orderBy: { name: 'asc' },
+    });
+
+    return NextResponse.json(users);
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des utilisateurs:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+
+// GET /api/users/me - Récupérer les informations de l'utilisateur actuel (y compris le rôle)
+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 l'utilisateur avec son profil depuis la base de données
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      include: {
+        customRole: {
+          select: {
+            id: true,
+            name: true,
+            permissions: true,
+          },
+        },
+      },
+    });
+
+    if (!user) {
+      return NextResponse.json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+    }
+
+    // Retourner l'utilisateur avec son profil et ses permissions
+    return NextResponse.json({
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      role: 'USER', // Tous les utilisateurs ont le rôle USER
+      customRole: user.customRole,
+      emailVerified: user.emailVerified,
+      image: user.image,
+    });
+  } catch (error) {
+    console.error('Erreur:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}