create-crm-tmp 2.0.0 → 2.1.0

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,8 +4,8 @@ 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 {
@@ -102,6 +102,13 @@ export async function POST(request: Request) {
       return Response.json({ error: 'Non authentifié' }, { status: 401 });
     }
 
+    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) {
       const result = await getAnyAdminSmtpConfig();
@@ -116,8 +123,11 @@ export async function POST(request: Request) {
     if (!smtpConfig) {
       const errorMsg =
         smtpError ||
-        'Aucune configuration SMTP trouvée. Veuillez configurer SMTP dans les paramètres.';
-      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 },
+      );
     }
 
     let emailComponent: React.ReactElement;
@@ -139,6 +149,7 @@ export async function POST(request: Request) {
       });
     }
 
+    const { render } = await import('@react-email/render');
     const emailHtml = await render(emailComponent);
     const emailText = htmlToText(emailHtml);
 
@@ -183,8 +194,9 @@ export async function POST(request: Request) {
       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 },
       );

package/template/src/app/api/settings/google-ads/route.ts

@@ -100,6 +100,20 @@ export async function POST(request: NextRequest) {
       },
     });
 
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'google_ads',
+        configId: config.id,
+        configName: config.name,
+        action: 'created',
+        actorId: session.user.id,
+        totalImported: 0,
+        totalDuplicates: 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({
       success: true,
       config: {

package/template/src/app/api/settings/google-calendar/calendars/route.ts

@@ -0,0 +1,97 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { encrypt } from '@/lib/encryption';
+import {
+  getValidAccessToken,
+  getUserGoogleAccount,
+  listGoogleCalendars,
+} from '@/lib/google-calendar';
+
+/**
+ * GET /api/settings/google-calendar/calendars
+ * Liste les calendriers Google de l'utilisateur + préférences CRM (défaut, affichage agenda).
+ */
+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 });
+    }
+
+    let googleAccount;
+    try {
+      googleAccount = await getUserGoogleAccount(session.user.id);
+    } catch (e: any) {
+      return NextResponse.json(
+        {
+          error: e.message || 'Compte Google non connecté',
+          calendars: [],
+          defaultGoogleCalendarId: null,
+          agendaVisibleGoogleCalendarIds: [],
+          agendaGoogleEventColor: null,
+        },
+        { status: 200 },
+      );
+    }
+
+    const accessToken = await getValidAccessToken(
+      googleAccount.accessToken,
+      googleAccount.refreshToken,
+      googleAccount.tokenExpiresAt,
+    );
+
+    if (accessToken !== googleAccount.accessToken) {
+      const tokenExpiresAt = new Date();
+      tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+      await prisma.userGoogleAccount.update({
+        where: { userId: session.user.id },
+        data: {
+          accessToken: encrypt(accessToken),
+          tokenExpiresAt,
+        },
+      });
+    }
+
+    let calendars;
+    try {
+      calendars = await listGoogleCalendars(accessToken);
+    } catch (listErr: any) {
+      const msg = listErr?.message || String(listErr);
+      const needsReconnect =
+        /403|insufficient|calendarList|Invalid Credentials/i.test(msg) ||
+        msg.includes('Erreur lors de la liste des calendriers');
+      return NextResponse.json(
+        {
+          error: needsReconnect
+            ? 'Reconnectez votre compte Google (Paramètres → Intégrations) pour autoriser la liste des calendriers.'
+            : msg,
+          calendars: [],
+          defaultGoogleCalendarId: googleAccount.defaultGoogleCalendarId ?? null,
+          agendaVisibleGoogleCalendarIds: normalizeAgendaIds(googleAccount.agendaVisibleGoogleCalendarIds),
+          agendaGoogleEventColor: googleAccount.agendaGoogleEventColor ?? null,
+          needsGoogleReconnect: Boolean(needsReconnect),
+        },
+        { status: 200 },
+      );
+    }
+
+    return NextResponse.json({
+      calendars,
+      defaultGoogleCalendarId: googleAccount.defaultGoogleCalendarId ?? null,
+      agendaVisibleGoogleCalendarIds: normalizeAgendaIds(googleAccount.agendaVisibleGoogleCalendarIds),
+      agendaGoogleEventColor: googleAccount.agendaGoogleEventColor ?? null,
+    });
+  } catch (error: any) {
+    console.error('GET google-calendar calendars:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+function normalizeAgendaIds(raw: unknown): string[] {
+  if (!raw || !Array.isArray(raw)) return [];
+  return raw.filter((x): x is string => typeof x === 'string' && x.trim() !== '');
+}

package/template/src/app/api/settings/google-calendar/route.ts

@@ -0,0 +1,124 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma, Prisma } from '@/lib/prisma';
+import { encrypt } from '@/lib/encryption';
+import {
+  getValidAccessToken,
+  getUserGoogleAccount,
+  assertWritableGoogleCalendar,
+  assertKnownGoogleCalendar,
+} from '@/lib/google-calendar';
+
+/**
+ * PATCH /api/settings/google-calendar
+ * Préférences : calendrier par défaut à la création, calendriers visibles dans l'agenda CRM.
+ */
+export async function PATCH(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 { defaultGoogleCalendarId, agendaVisibleGoogleCalendarIds, agendaGoogleEventColor } = body as {
+      defaultGoogleCalendarId?: string | null;
+      agendaVisibleGoogleCalendarIds?: string[];
+      agendaGoogleEventColor?: string | null;
+    };
+
+    const googleAccount = await getUserGoogleAccount(session.user.id);
+
+    const accessToken = await getValidAccessToken(
+      googleAccount.accessToken,
+      googleAccount.refreshToken,
+      googleAccount.tokenExpiresAt,
+    );
+
+    if (accessToken !== googleAccount.accessToken) {
+      const tokenExpiresAt = new Date();
+      tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+      await prisma.userGoogleAccount.update({
+        where: { userId: session.user.id },
+        data: {
+          accessToken: encrypt(accessToken),
+          tokenExpiresAt,
+        },
+      });
+    }
+
+    const data: {
+      defaultGoogleCalendarId?: string | null;
+      agendaVisibleGoogleCalendarIds?: Prisma.InputJsonValue;
+      agendaGoogleEventColor?: string | null;
+    } = {};
+
+    if ('defaultGoogleCalendarId' in body) {
+      if (defaultGoogleCalendarId === null || defaultGoogleCalendarId === '') {
+        data.defaultGoogleCalendarId = null;
+      } else if (typeof defaultGoogleCalendarId === 'string') {
+        const cal = defaultGoogleCalendarId.trim();
+        await assertWritableGoogleCalendar(accessToken, cal);
+        data.defaultGoogleCalendarId = cal === 'primary' ? null : cal;
+      } else {
+        return NextResponse.json({ error: 'defaultGoogleCalendarId invalide' }, { status: 400 });
+      }
+    }
+
+    if (agendaVisibleGoogleCalendarIds !== undefined) {
+      if (!Array.isArray(agendaVisibleGoogleCalendarIds)) {
+        return NextResponse.json(
+          { error: 'agendaVisibleGoogleCalendarIds doit être un tableau' },
+          { status: 400 },
+        );
+      }
+      const ids = [...new Set(agendaVisibleGoogleCalendarIds.filter((x) => typeof x === 'string' && x.trim() !== '').map((x: string) => x.trim()))];
+      await Promise.all(ids.map((id) => assertKnownGoogleCalendar(accessToken, id)));
+      data.agendaVisibleGoogleCalendarIds = ids;
+    }
+
+    if ('agendaGoogleEventColor' in body) {
+      if (agendaGoogleEventColor === null || agendaGoogleEventColor === '') {
+        data.agendaGoogleEventColor = null;
+      } else if (typeof agendaGoogleEventColor === 'string') {
+        const c = agendaGoogleEventColor.trim();
+        if (!/^#[0-9A-Fa-f]{6}$/.test(c)) {
+          return NextResponse.json(
+            { error: 'agendaGoogleEventColor doit être au format #RRGGBB' },
+            { status: 400 },
+          );
+        }
+        data.agendaGoogleEventColor = c;
+      } else {
+        return NextResponse.json({ error: 'agendaGoogleEventColor invalide' }, { status: 400 });
+      }
+    }
+
+    if (Object.keys(data).length === 0) {
+      return NextResponse.json({ error: 'Aucun champ à mettre à jour' }, { status: 400 });
+    }
+
+    const updated = await prisma.userGoogleAccount.update({
+      where: { userId: session.user.id },
+      data,
+    });
+
+    return NextResponse.json({
+      success: true,
+      defaultGoogleCalendarId: updated.defaultGoogleCalendarId ?? null,
+      agendaVisibleGoogleCalendarIds: normalizeAgendaIds(updated.agendaVisibleGoogleCalendarIds),
+      agendaGoogleEventColor: updated.agendaGoogleEventColor ?? null,
+    });
+  } catch (error: any) {
+    console.error('PATCH google-calendar settings:', error);
+    return NextResponse.json({ error: error.message || 'Erreur serveur' }, { status: 500 });
+  }
+}
+
+function normalizeAgendaIds(raw: unknown): string[] {
+  if (!raw || !Array.isArray(raw)) return [];
+  return raw.filter((x): x is string => typeof x === 'string' && x.trim() !== '');
+}

package/template/src/app/api/settings/google-sheet/[id]/route.ts

@@ -159,6 +159,20 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       data: updateData,
     });
 
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'google_sheet',
+        configId: config.id,
+        configName: config.name,
+        action: 'updated',
+        actorId: session.user.id,
+        totalImported: 0,
+        totalDuplicates: 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({
       success: true,
       config: {
@@ -216,6 +230,20 @@ export async function DELETE(
       where: { id },
     });
 
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'google_sheet',
+        configId: existingConfig.id,
+        configName: existingConfig.name,
+        action: 'deleted',
+        actorId: session.user.id,
+        totalImported: 0,
+        totalDuplicates: 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({
       success: true,
       message: 'Configuration Google Sheets supprimée avec succès.',

package/template/src/app/api/settings/google-sheet/auto-map/route.ts

@@ -56,9 +56,7 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    // Récupérer le compte Google de l'admin pour Google Sheets (utilise Drive)
-    // Note: Cette fonction n'existe plus dans google-calendar, utiliser celle de google-drive
-    const { getAdminGoogleAccount } = await import('@/lib/google-drive');
+    const { getAdminGoogleAccount } = await import('@/lib/google-calendar');
     let googleAccount;
     try {
       googleAccount = await getAdminGoogleAccount();
@@ -67,7 +65,8 @@ export async function POST(request: NextRequest) {
         {
           error:
             error.message ||
-            'Aucun compte Google configuré. Veuillez demander à un administrateur de connecter son compte Google dans les paramètres.',
+            'Aucun compte Google configuré. Veuillez demander à un administrateur de connecter son compte Google pour configurer l\'intégration Google Sheets.',
+          configLink: '/settings?section=integrations',
         },
         { status: 400 },
       );
@@ -125,6 +124,28 @@ export async function POST(request: NextRequest) {
       emailColumn: ['email', 'e-mail', 'mail', 'courriel', 'mél', 'mel'],
       cityColumn: ['ville', 'city', 'localité', 'locality'],
       postalCodeColumn: ['code postal', 'postal code', 'cp', 'zip', 'zipcode', 'code_postal'],
+      companyNameColumn: [
+        'société',
+        'societe',
+        'company',
+        'company name',
+        'company_name',
+        'company-name',
+        'companyname',
+        'organisation',
+        'organization',
+        'organisme',
+        'org',
+        'org name',
+        'org_name',
+        'org-name',
+        'business',
+        'business name',
+        'business_name',
+        'entreprise',
+        'nom entreprise',
+        'nom société',
+      ],
       originColumn: [
         'origine',
         'origin',
@@ -133,6 +154,18 @@ export async function POST(request: NextRequest) {
         'campaign',
         'origine de la campagne',
       ],
+      websiteColumn: [
+        'site',
+        'site web',
+        'website',
+        'url',
+        'web',
+        'site internet',
+      ],
+      linkedinColumn: ['linkedin', 'linkedin url', 'linkedin profile', 'linkedin profil'],
+      facebookColumn: ['facebook', 'facebook url', 'fb', 'facebook profile', 'facebook profil'],
+      twitterColumn: ['twitter', 'twitter url', 'x', 'x.com', 'twitter profile', 'twitter profil'],
+      instagramColumn: ['instagram', 'instagram url', 'insta', 'instagram profile', 'instagram profil'],
     };
 
     const mapping: Record<string, string> = {};

package/template/src/app/api/settings/google-sheet/preview/route.ts

@@ -35,13 +35,19 @@ export async function POST(request: NextRequest) {
 
     const spreadsheetId = extractSpreadsheetId(sheetUrl);
 
-    const { getAdminGoogleAccount } = await import('@/lib/google-drive');
+    const { getAdminGoogleAccount } = await import('@/lib/google-calendar');
     let googleAccount;
     try {
       googleAccount = await getAdminGoogleAccount();
     } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : 'Aucun compte Google configuré.';
-      return NextResponse.json({ error: message }, { status: 400 });
+      const message =
+        error instanceof Error
+          ? error.message
+          : 'Aucun compte Google configuré. Veuillez demander à un administrateur de connecter son compte Google pour configurer l\'intégration Google Sheets.';
+      return NextResponse.json(
+        { error: message, configLink: '/settings?section=integrations' },
+        { status: 400 },
+      );
     }
 
     const accessToken = await getValidAccessToken(

package/template/src/app/api/settings/google-sheet/route.ts

@@ -223,6 +223,20 @@ export async function POST(request: NextRequest) {
       },
     });
 
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'google_sheet',
+        configId: config.id,
+        configName: config.name,
+        action: 'created',
+        actorId: session.user.id,
+        totalImported: 0,
+        totalDuplicates: 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({
       success: true,
       config: {

package/template/src/app/api/settings/integrations/logs/route.ts

@@ -0,0 +1,93 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma, Prisma } from '@/lib/prisma';
+import { checkPermissions } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+
+const INTEGRATION_PERMISSIONS = [
+  'integrations.google_sheets.manage',
+  'integrations.meta.manage',
+  'integrations.google_ads.manage',
+] as const;
+
+function hasAnyIntegrationPermission(perms: Record<string, boolean>): boolean {
+  return INTEGRATION_PERMISSIONS.some((p) => perms[p]);
+}
+
+const SYNC_ACTIONS = ['synced', 'synced_manual', 'synced_auto'] as const;
+
+// GET /api/settings/integrations/logs - Liste paginée des logs d'intégration
+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 perms = await checkPermissions(...INTEGRATION_PERMISSIONS);
+    if (!hasAnyIntegrationPermission(perms)) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const { searchParams } = new URL(request.url);
+    const integrationType = searchParams.get('integrationType') || undefined;
+    const configId = searchParams.get('configId') || undefined;
+    const page = Math.max(1, Number.parseInt(searchParams.get('page') || '1', 10));
+    const pageSize = Math.min(50, Math.max(10, Number.parseInt(searchParams.get('pageSize') || '20', 10)));
+    const since = searchParams.get('since') || undefined;
+
+    const where: Prisma.IntegrationImportLogWhereInput = {};
+    if (integrationType) where.integrationType = integrationType;
+    if (configId) where.configId = configId;
+    if (since) {
+      const sinceDate = new Date(since);
+      if (!Number.isNaN(sinceDate.getTime())) where.createdAt = { gte: sinceDate };
+    }
+    // Synchronisations : afficher si au moins un contact concerné OU une erreur (cohérent avec ce qui est persisté)
+    where.OR = [
+      { action: { notIn: [...SYNC_ACTIONS] } },
+      { action: { in: [...SYNC_ACTIONS] }, totalImported: { gt: 0 } },
+      { action: { in: [...SYNC_ACTIONS] }, totalDuplicates: { gt: 0 } },
+      { action: { in: [...SYNC_ACTIONS] }, totalUpdated: { gt: 0 } },
+      { action: { in: [...SYNC_ACTIONS] }, totalErrors: { gt: 0 } },
+    ];
+
+    const [logs, total] = await Promise.all([
+      prisma.integrationImportLog.findMany({
+        where,
+        include: {
+          actor: {
+            select: { id: true, name: true, email: true },
+          },
+        },
+        orderBy: { createdAt: 'desc' },
+        skip: (page - 1) * pageSize,
+        take: pageSize,
+      }),
+      prisma.integrationImportLog.count({ where }),
+    ]);
+
+    return NextResponse.json({
+      logs: logs.map((log) => ({
+        id: log.id,
+        integrationType: log.integrationType,
+        configId: log.configId,
+        configName: log.configName,
+        action: log.action,
+        actorId: log.actorId,
+        actor: log.actor,
+        totalImported: log.totalImported,
+        totalDuplicates: log.totalDuplicates,
+        totalUpdated: log.totalUpdated,
+        totalErrors: log.totalErrors,
+        errorDetails: log.errorDetails,
+        createdAt: log.createdAt,
+      })),
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize),
+    });
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des logs d\'intégration:', error);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/settings/integrations/notifications/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { checkPermissions } from '@/lib/check-permission';
+import { auth } from '@/lib/auth';
+
+const INTEGRATION_PERMISSIONS = [
+  'integrations.google_sheets.manage',
+  'integrations.meta.manage',
+  'integrations.google_ads.manage',
+] as const;
+
+function hasAnyIntegrationPermission(perms: Record<string, boolean>): boolean {
+  return INTEGRATION_PERMISSIONS.some((p) => perms[p]);
+}
+
+const NOTIFICATION_ACTIONS = ['synced', 'synced_manual', 'synced_auto', 'created'] as const;
+
+// GET /api/settings/integrations/notifications?since=ISO_DATE
+// Retourne les logs récents pour le polling (notifications admin)
+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 perms = await checkPermissions(...INTEGRATION_PERMISSIONS);
+    if (!hasAnyIntegrationPermission(perms)) {
+      return NextResponse.json({ notifications: [] });
+    }
+
+    const { searchParams } = new URL(request.url);
+    const sinceParam = searchParams.get('since');
+    if (!sinceParam) {
+      return NextResponse.json({ notifications: [] });
+    }
+    const since = new Date(sinceParam);
+    if (Number.isNaN(since.getTime())) {
+      return NextResponse.json({ notifications: [] });
+    }
+
+    const logs = await prisma.integrationImportLog.findMany({
+      where: {
+        createdAt: { gt: since },
+        action: { in: [...NOTIFICATION_ACTIONS] },
+      },
+      orderBy: { createdAt: 'asc' },
+      take: 50,
+    });
+
+    const notifications = logs.map((log) => ({
+      id: log.id,
+      integrationType: log.integrationType,
+      configName: log.configName,
+      action: log.action,
+      totalImported: log.totalImported,
+      totalDuplicates: log.totalDuplicates,
+      totalUpdated: log.totalUpdated,
+      totalErrors: log.totalErrors,
+      createdAt: log.createdAt,
+    }));
+
+    return NextResponse.json({ notifications });
+  } catch (error: any) {
+    console.error('Erreur lors de la récupération des notifications d\'intégration:', error);
+    return NextResponse.json({ notifications: [] });
+  }
+}

package/template/src/app/api/settings/meta-leads/[id]/route.ts

@@ -67,7 +67,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
         id: config.id,
         name: config.name,
         pageId: config.pageId,
-        verifyToken: config.verifyToken,
         active: config.active,
         defaultStatusId: config.defaultStatusId,
         defaultAssignedUserId: config.defaultAssignedUserId,

package/template/src/app/api/settings/meta-leads/route.ts

@@ -33,7 +33,6 @@ export async function GET(request: NextRequest) {
         id: config.id,
         name: config.name,
         pageId: config.pageId,
-        verifyToken: config.verifyToken,
         active: config.active,
         defaultStatusId: config.defaultStatusId,
         defaultAssignedUserId: config.defaultAssignedUserId,
@@ -109,13 +108,26 @@ export async function POST(request: NextRequest) {
       },
     });
 
+    await prisma.integrationImportLog.create({
+      data: {
+        integrationType: 'meta_lead',
+        configId: config.id,
+        configName: config.name,
+        action: 'created',
+        actorId: session.user.id,
+        totalImported: 0,
+        totalDuplicates: 0,
+        totalUpdated: 0,
+        totalErrors: 0,
+      },
+    });
+
     return NextResponse.json({
       success: true,
       config: {
         id: config.id,
         name: config.name,
         pageId: config.pageId,
-        verifyToken: config.verifyToken,
         active: config.active,
         defaultStatusId: config.defaultStatusId,
         defaultAssignedUserId: config.defaultAssignedUserId,