create-crm-tmp 2.0.0 → 2.1.0

package/template/src/lib/google-sheet-sync-runner.ts

@@ -0,0 +1,514 @@
+import { prisma } from '@/lib/prisma';
+import { getValidAccessToken, GoogleTokenError } from '@/lib/google-calendar';
+import { handleContactDuplicate } from '@/lib/contact-duplicate';
+import { normalizePhoneNumber, parseImportDate } from '@/lib/utils';
+import { googleFetch } from '@/lib/google-fetch';
+import { encrypt, decrypt } from '@/lib/encryption';
+import { shouldPersistSyncedIntegrationLog } from '@/lib/integration-import-log';
+
+export type GoogleSheetSyncResultItem = {
+  configId: string;
+  configName: string;
+  imported: number;
+  updated: number;
+  skipped: number;
+  duplicates?: number;
+  errors?: number;
+  error?: string;
+};
+
+export type GoogleSheetSyncRunResult = {
+  totalImported: number;
+  totalUpdated: number;
+  totalSkipped: number;
+  results: GoogleSheetSyncResultItem[];
+  message?: string;
+};
+
+/** Timeout transaction interactive Prisma (défaut 5s insuffisant : appels Google + import lignes). ms */
+const GOOGLE_SHEET_SYNC_TX_TIMEOUT_MS = Math.max(
+  60_000,
+  Number.parseInt(process.env.GOOGLE_SHEET_SYNC_TRANSACTION_TIMEOUT_MS ?? '', 10) || 15 * 60 * 1000,
+);
+
+export async function runGoogleSheetSync(params: {
+  sessionUserId?: string | null;
+  requestedConfigId?: string;
+}): Promise<GoogleSheetSyncRunResult> {
+  const { sessionUserId: rawSessionUserId, requestedConfigId } = params;
+  const sessionUserId = rawSessionUserId ?? null;
+  const where: { active: true; id?: string } = { active: true };
+  if (requestedConfigId) where.id = requestedConfigId;
+
+  const configs = await prisma.googleSheetSyncConfig.findMany({
+    where,
+    include: {
+      ownerUser: true,
+    },
+  });
+
+  if (!configs || configs.length === 0) {
+    return {
+      totalImported: 0,
+      totalUpdated: 0,
+      totalSkipped: 0,
+      results: [],
+      message: "Aucune configuration Google Sheets active n'a été trouvée.",
+    };
+  }
+
+  const results: GoogleSheetSyncResultItem[] = [];
+  let totalImported = 0;
+  let totalUpdated = 0;
+  let totalSkipped = 0;
+
+  type DbClient = Pick<typeof prisma, 'integrationImportLog'>;
+  async function createSyncLog(
+    config: { id: string; name: string },
+    entry: {
+      imported?: number;
+      updated?: number;
+      skipped?: number;
+      duplicates?: number;
+      error?: string;
+    },
+    db: DbClient = prisma,
+  ) {
+    const imported = entry.imported ?? 0;
+    const duplicates = entry.duplicates ?? 0;
+    const updated = entry.updated ?? 0;
+    const hasError = Boolean(entry.error);
+
+    if (
+      !shouldPersistSyncedIntegrationLog({
+        totalImported: imported,
+        totalDuplicates: duplicates,
+        totalUpdated: updated,
+        hasError,
+      })
+    ) {
+      return;
+    }
+
+    await db.integrationImportLog.create({
+      data: {
+        integrationType: 'google_sheet',
+        configId: config.id,
+        configName: config.name,
+        action: sessionUserId ? 'synced_manual' : 'synced_auto',
+        actorId: sessionUserId ?? undefined,
+        totalImported: imported,
+        totalDuplicates: duplicates,
+        totalUpdated: updated,
+        totalErrors: hasError ? 1 : 0,
+        errorDetails: entry.error ? { message: entry.error } : undefined,
+      },
+    });
+  }
+
+  const GLOBAL_LOCK_KEY = 'google_sheet_sync_global';
+  await prisma.$transaction(
+    async (tx) => {
+      const [globalLock] =
+        await tx.$queryRaw<Array<{ locked: boolean }>>`SELECT pg_try_advisory_xact_lock(hashtext(${GLOBAL_LOCK_KEY}), 4261) AS locked`;
+      if (!globalLock?.locked) {
+        for (const c of configs) {
+          const lockError =
+            'Une synchronisation est déjà en cours. Veuillez patienter qu’elle se termine puis relancer.';
+          results.push({
+            configId: c.id,
+            configName: c.name,
+            imported: 0,
+            updated: 0,
+            skipped: 0,
+            error: lockError,
+          });
+          await createSyncLog(c, { error: lockError }, tx);
+        }
+        return;
+      }
+
+      for (const config of configs) {
+        try {
+          const range = encodeURIComponent(config.sheetName);
+          const candidateUserIds = Array.from(
+            new Set(
+              [config.ownerUserId, config.defaultAssignedUserId, sessionUserId].filter(
+                (value): value is string => Boolean(value),
+              ),
+            ),
+          );
+
+          let selectedSheetsResponse: Response | null = null;
+          let lastAuthError =
+            'Aucun compte Google compatible trouvé pour cette configuration. Reconnectez Google puis partagez le Sheet avec ce compte.';
+
+          for (const candidateUserId of candidateUserIds) {
+            const googleAccount = await tx.userGoogleAccount.findUnique({
+              where: { userId: candidateUserId },
+            });
+            if (!googleAccount) {
+              lastAuthError = 'Aucun compte Google connecté parmi les utilisateurs autorisés.';
+              continue;
+            }
+
+            try {
+              const decryptedAccess = decrypt(googleAccount.accessToken);
+              const decryptedRefresh = decrypt(googleAccount.refreshToken);
+              const accessToken = await getValidAccessToken(
+                decryptedAccess,
+                decryptedRefresh,
+                googleAccount.tokenExpiresAt,
+              );
+
+              if (accessToken !== decryptedAccess) {
+                const tokenExpiresAt = new Date();
+                tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+                await tx.userGoogleAccount.update({
+                  where: { userId: candidateUserId },
+                  data: { accessToken: encrypt(accessToken), tokenExpiresAt },
+                });
+              }
+
+              const candidateResponse = await googleFetch(
+                `https://sheets.googleapis.com/v4/spreadsheets/${config.spreadsheetId}/values/${range}`,
+                {
+                  headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                  },
+                },
+              );
+
+              if (candidateResponse.ok) {
+                selectedSheetsResponse = candidateResponse;
+                break;
+              }
+
+              const errorText = await candidateResponse.text();
+              lastAuthError =
+                candidateResponse.status === 401 || candidateResponse.status === 403
+                  ? 'Le compte Google connecté n’a pas accès à ce Sheet. Partagez le document avec ce compte ou reconnectez Google.'
+                  : 'Impossible de lire les données depuis Google Sheets.';
+              console.error(
+                `Erreur lors de la lecture du Google Sheet ${config.name} (user ${candidateUserId}):`,
+                errorText,
+              );
+            } catch (error: any) {
+              if (error instanceof GoogleTokenError && error.isRevoked) {
+                lastAuthError = error.message;
+              } else {
+                lastAuthError = error?.message || 'Erreur lors de la validation du compte Google.';
+              }
+            }
+          }
+
+          if (!selectedSheetsResponse) {
+            results.push({
+              configId: config.id,
+              configName: config.name,
+              imported: 0,
+              updated: 0,
+              skipped: 0,
+              error: lastAuthError,
+            });
+            await createSyncLog(config, { error: lastAuthError }, tx);
+            continue;
+          }
+
+          const data = await selectedSheetsResponse.json();
+          const values: string[][] = data.values || [];
+          if (!values.length) {
+            results.push({
+              configId: config.id,
+              configName: config.name,
+              imported: 0,
+              updated: 0,
+              skipped: 0,
+            });
+            await createSyncLog(config, { imported: 0, updated: 0, skipped: 0 }, tx);
+            continue;
+          }
+
+          const headerRowIndex = config.headerRow - 1;
+          const startRowIndex = Math.max(headerRowIndex + 1, (config.lastSyncedRow || headerRowIndex) + 1);
+          const headerRow = values[headerRowIndex] || [];
+          const columnMappings: Record<string, number> = {};
+          const noteFields: Array<{ name: string; index: number }> = [];
+
+          if (!config.columnMappings) {
+            const error = "La configuration n'utilise pas le nouveau format de mapping. Veuillez reconfigurer cette intégration.";
+            results.push({ configId: config.id, configName: config.name, imported: 0, updated: 0, skipped: 0, error });
+            await createSyncLog(config, { error }, tx);
+            continue;
+          }
+
+          const mappings = typeof config.columnMappings === 'string' ? JSON.parse(config.columnMappings) : config.columnMappings;
+          if (!Array.isArray(mappings)) {
+            const error = 'Format de mapping invalide.';
+            results.push({ configId: config.id, configName: config.name, imported: 0, updated: 0, skipped: 0, error });
+            await createSyncLog(config, { error }, tx);
+            continue;
+          }
+
+          const headerIndexMap = new Map<string, number>();
+          headerRow.forEach((h: string, i: number) => {
+            if (h) headerIndexMap.set(h.trim().toLowerCase(), i);
+          });
+
+          mappings.forEach((mapping: any) => {
+            if (mapping.action === 'map' && mapping.crmField && mapping.columnName) {
+              const columnIndex = headerIndexMap.get(mapping.columnName.trim().toLowerCase()) ?? -1;
+              if (columnIndex !== -1) columnMappings[mapping.crmField] = columnIndex;
+            } else if (mapping.action === 'note' && mapping.columnName) {
+              const columnIndex = headerIndexMap.get(mapping.columnName.trim().toLowerCase()) ?? -1;
+              if (columnIndex !== -1) noteFields.push({ name: mapping.columnName, index: columnIndex });
+            }
+          });
+
+          if (columnMappings.phone === undefined) {
+            const error = "La colonne téléphone n'est pas correctement mappée.";
+            results.push({ configId: config.id, configName: config.name, imported: 0, updated: 0, skipped: 0, error });
+            await createSyncLog(config, { error }, tx);
+            continue;
+          }
+
+          const phoneIdx = columnMappings.phone;
+          let effectiveDefaultStatusId = config.defaultStatusId || null;
+          if (!effectiveDefaultStatusId) {
+            const fallbackStatus = await tx.status.findFirst({ where: { name: 'Nouveau' } });
+            if (fallbackStatus) effectiveDefaultStatusId = fallbackStatus.id;
+          }
+
+          let assignedCommercialId: string | null = null;
+          let assignedTeleproId: string | null = null;
+          if (config.defaultAssignedUserId) {
+            const defaultUser = await tx.user.findUnique({
+              where: { id: config.defaultAssignedUserId },
+              select: { role: true },
+            });
+            if (defaultUser?.role === 'COMMERCIAL' || defaultUser?.role === 'ADMIN' || defaultUser?.role === 'MANAGER') {
+              assignedCommercialId = config.defaultAssignedUserId;
+            } else if (defaultUser?.role === 'TELEPRO') {
+              assignedTeleproId = config.defaultAssignedUserId;
+            }
+          }
+
+          const escapeHtml = (text: string): string =>
+            text.replace(/[&<>"']/g, (m) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#039;' }[m]!));
+
+          const formatNoteContent = (noteItems: Array<{ label: string; value: string }>) => {
+            const escapedConfigName = escapeHtml(config.name);
+            if (noteItems.length === 0) {
+              return `<p style="font-size: 14px; line-height: 1.5; color: #374151; margin-bottom: 0;">Ce contact a été importé automatiquement depuis Google Sheets (${escapedConfigName}).</p>`;
+            }
+            let html = `<p style="font-size: 14px; line-height: 1.5; color: #374151; margin-bottom: 16px;">Ce contact a été importé automatiquement depuis Google Sheets (${escapedConfigName}).</p>`;
+            html += '<div style="display: flex; flex-direction: column; gap: 12px; margin-top: 16px;">';
+            noteItems.forEach((item) => {
+              const humanLabel = item.label
+                .split(/(?=[A-Z])/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join(' ');
+              const escapedLabel = escapeHtml(humanLabel);
+              const escapedValue = escapeHtml(String(item.value)).replace(/\n/g, '<br>');
+              html += `<div style="padding: 12px 14px; background: linear-gradient(to right, #f8fafc 0%, #f1f5f9 100%); border-radius: 10px; border-left: 4px solid #6366f1; box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.05);"><div style="font-size: 11px; font-weight: 700; color: #64748b; text-transform: uppercase; letter-spacing: 0.8px; margin-bottom: 6px;">${escapedLabel}</div><div style="font-size: 14px; line-height: 1.5; color: #0f172a; font-weight: 500;">${escapedValue}</div></div>`;
+            });
+            html += '</div>';
+            return html;
+          };
+
+          const createGoogleSheetsImportMetadata = (
+            noteItems: Array<{ label: string; value: string }>,
+            htmlContent: string,
+          ) => ({
+            htmlContent,
+            isGoogleSheetsImport: true,
+            sourceName: config.name,
+            importedFields: noteItems,
+          });
+
+          let imported = 0;
+          let updated = 0;
+          let skipped = 0;
+          let duplicateCount = 0;
+          let maxProcessedRow = config.lastSyncedRow || headerRowIndex;
+          const seenRowKeys = new Set<string>();
+
+          for (let rowIndex = startRowIndex; rowIndex < values.length; rowIndex++) {
+            const row = values[rowIndex];
+            if (!row) continue;
+            const phone = row[phoneIdx]?.trim();
+            if (!phone) {
+              skipped++;
+              continue;
+            }
+
+            const firstName = columnMappings.firstName !== undefined ? row[columnMappings.firstName]?.trim() || undefined : undefined;
+            const lastName = columnMappings.lastName !== undefined ? row[columnMappings.lastName]?.trim() || undefined : undefined;
+            const email = columnMappings.email !== undefined ? row[columnMappings.email]?.trim() || undefined : undefined;
+            const city = columnMappings.city !== undefined ? row[columnMappings.city]?.trim() || undefined : undefined;
+            const postalCodeRaw = columnMappings.postalCode !== undefined ? row[columnMappings.postalCode]?.trim() || undefined : undefined;
+            const postalCode = postalCodeRaw ? (postalCodeRaw.match(/\d{4,5}/)?.[0] || postalCodeRaw) : undefined;
+            const companyName = columnMappings.companyName !== undefined ? row[columnMappings.companyName]?.trim() || undefined : undefined;
+            const origin = columnMappings.origin !== undefined ? row[columnMappings.origin]?.trim() || 'Google Sheets' : 'Google Sheets';
+            const website = columnMappings.website !== undefined ? row[columnMappings.website]?.trim() || null : null;
+            const civilityRaw = columnMappings.civility !== undefined ? row[columnMappings.civility]?.trim() || null : null;
+            const civility = civilityRaw && ['M', 'MME', 'MLLE'].includes(civilityRaw.toUpperCase()) ? (civilityRaw.toUpperCase() as 'M' | 'MME' | 'MLLE') : null;
+            const address = columnMappings.address !== undefined ? row[columnMappings.address]?.trim() || null : null;
+            const secondaryPhoneRaw = columnMappings.secondaryPhone !== undefined ? row[columnMappings.secondaryPhone]?.trim() || null : null;
+            const secondaryPhone = secondaryPhoneRaw ? normalizePhoneNumber(secondaryPhoneRaw) || null : null;
+            const jobTitle = columnMappings.jobTitle !== undefined ? row[columnMappings.jobTitle]?.trim() || null : null;
+            const createdAtRaw = columnMappings.createdAt !== undefined ? row[columnMappings.createdAt]?.trim() : undefined;
+            const createdAtImport = createdAtRaw ? parseImportDate(createdAtRaw) : null;
+
+            const normalizedEmail = email ? email.trim().toLowerCase() : '';
+            const normalizedPhone = normalizePhoneNumber(phone);
+            const normalizedFirstName = firstName ? firstName.trim().toLowerCase() : '';
+            const normalizedLastName = lastName ? lastName.trim().toLowerCase() : '';
+            const rowKey = normalizedEmail
+              ? `email:${normalizedEmail}`
+              : normalizedPhone
+                ? `phone:${normalizedPhone}`
+                : `name:${normalizedFirstName}|${normalizedLastName}`;
+            if (seenRowKeys.has(rowKey)) {
+              skipped++;
+              continue;
+            }
+            seenRowKeys.add(rowKey);
+
+            const noteContents: Array<{ label: string; value: string }> = [];
+            noteFields.forEach(({ name, index }) => {
+              if (row[index]) noteContents.push({ label: name, value: row[index].trim() });
+            });
+
+            const assignedUserId = config.defaultAssignedUserId ?? config.ownerUserId ?? sessionUserId ?? '';
+            const duplicateContactId = await handleContactDuplicate(firstName, lastName, email, origin, assignedUserId);
+
+            let contact;
+            if (duplicateContactId) {
+              contact = await tx.contact.findUnique({ where: { id: duplicateContactId } });
+              updated++;
+              duplicateCount++;
+            } else {
+              contact =
+                (email &&
+                  (await tx.contact.findFirst({
+                    where: {
+                      OR: [{ email: email.toLowerCase() }, { phone: normalizedPhone }],
+                    },
+                  }))) ||
+                (await tx.contact.findFirst({
+                  where: { phone: normalizedPhone },
+                }));
+
+              if (!contact) {
+                const formattedContent = formatNoteContent(noteContents);
+                contact = await tx.contact.create({
+                  data: {
+                    civility: civility ?? undefined,
+                    firstName: firstName || null,
+                    lastName: lastName || null,
+                    email: email ? email.toLowerCase() : null,
+                    phone: normalizedPhone,
+                    secondaryPhone: secondaryPhone ?? undefined,
+                    address: address ?? undefined,
+                    city: city || null,
+                    postalCode: postalCode || null,
+                    companyName: companyName || null,
+                    origin,
+                    ...(website && { website }),
+                    jobTitle: jobTitle ?? undefined,
+                    ...(createdAtImport && { createdAt: createdAtImport }),
+                    statusId: effectiveDefaultStatusId,
+                    assignedCommercialId,
+                    assignedTeleproId,
+                    createdById: config.defaultAssignedUserId || config.ownerUserId,
+                    interactions: {
+                      create: [
+                        {
+                          type: 'NOTE',
+                          title: `Contact importé depuis Google Sheets: ${config.name}`,
+                          content: formattedContent,
+                          userId: config.defaultAssignedUserId || config.ownerUserId,
+                          date: new Date(),
+                          metadata: {
+                            ...createGoogleSheetsImportMetadata(noteContents, formattedContent),
+                          },
+                        },
+                      ],
+                    },
+                  },
+                });
+                imported++;
+              } else {
+                await tx.contact.update({
+                  where: { id: contact.id },
+                  data: {
+                    ...(columnMappings.civility !== undefined && { civility: civility ?? undefined }),
+                    firstName: contact.firstName || firstName || null,
+                    lastName: contact.lastName || lastName || null,
+                    email: contact.email || (email ? email.toLowerCase() : null),
+                    ...(columnMappings.secondaryPhone !== undefined && {
+                      secondaryPhone: secondaryPhone ?? undefined,
+                    }),
+                    ...(columnMappings.address !== undefined && { address: address ?? undefined }),
+                    city: contact.city || city || null,
+                    postalCode: contact.postalCode || postalCode || null,
+                    companyName: contact.companyName || (contact.companyId ? null : companyName || null),
+                    origin: contact.origin || origin,
+                    ...(columnMappings.website !== undefined && { website: website || null }),
+                    ...(columnMappings.jobTitle !== undefined && { jobTitle: jobTitle ?? undefined }),
+                    statusId: contact.statusId || effectiveDefaultStatusId,
+                    assignedCommercialId: contact.assignedCommercialId || assignedCommercialId,
+                    assignedTeleproId: contact.assignedTeleproId || assignedTeleproId,
+                  },
+                });
+                updated++;
+              }
+            }
+
+            if (rowIndex > maxProcessedRow) maxProcessedRow = rowIndex;
+          }
+
+          if (maxProcessedRow > (config.lastSyncedRow || headerRowIndex)) {
+            await tx.googleSheetSyncConfig.update({
+              where: { id: config.id },
+              data: { lastSyncedRow: maxProcessedRow },
+            });
+          }
+
+          totalImported += imported;
+          totalUpdated += updated;
+          totalSkipped += skipped;
+          results.push({
+            configId: config.id,
+            configName: config.name,
+            imported,
+            updated,
+            skipped,
+            duplicates: duplicateCount,
+          });
+          await createSyncLog(config, { imported, updated, skipped, duplicates: duplicateCount }, tx);
+        } catch (error: any) {
+          console.error(`Erreur lors de la synchronisation de ${config.name}:`, error);
+          results.push({
+            configId: config.id,
+            configName: config.name,
+            imported: 0,
+            updated: 0,
+            skipped: 0,
+            error: error.message || 'Erreur lors de la synchronisation',
+          });
+          await createSyncLog(config, { error: error.message || 'Erreur lors de la synchronisation' }, tx).catch(
+            (err) => console.error('Erreur création log sync:', err),
+          );
+        }
+      }
+    },
+    {
+      maxWait: 15_000,
+      timeout: GOOGLE_SHEET_SYNC_TX_TIMEOUT_MS,
+    },
+  );
+
+  return { totalImported, totalUpdated, totalSkipped, results };
+}

package/template/src/lib/integration-import-log.ts

@@ -0,0 +1,21 @@
+/**
+ * Aligné sur GET /api/settings/integrations/logs : les entrées de synchronisation
+ * (`synced`, `synced_manual`, `synced_auto`) avec
+ * 0 importés, 0 doublons et 0 mises à jour ne sont pas listées côté UI.
+ * Ne pas les persister évite de polluer la table.
+ *
+ * Les sync en erreur (message d’erreur) restent enregistrées pour le suivi.
+ */
+export function shouldPersistSyncedIntegrationLog(params: {
+  totalImported?: number;
+  totalDuplicates?: number;
+  totalUpdated?: number;
+  /** Présence d’un message d’erreur (sync échouée, verrou, accès refusé, etc.) */
+  hasError?: boolean;
+}): boolean {
+  if (params.hasError) return true;
+  const i = params.totalImported ?? 0;
+  const d = params.totalDuplicates ?? 0;
+  const u = params.totalUpdated ?? 0;
+  return i > 0 || d > 0 || u > 0;
+}

package/template/src/lib/permissions.ts

@@ -32,6 +32,18 @@ export const PERMISSIONS: Permission[] = [
     description: 'Permet de voir le tableau de bord principal',
     category: PERMISSION_CATEGORIES.DASHBOARD,
   },
+  {
+    code: 'dashboard.widgets.manage',
+    name: 'Gérer les widgets du dashboard',
+    description: "Permet d'ajouter, supprimer et réorganiser les widgets du tableau de bord",
+    category: PERMISSION_CATEGORIES.DASHBOARD,
+  },
+  {
+    code: 'dashboard.widgets.reset',
+    name: 'Réinitialiser le dashboard',
+    description: 'Permet de réinitialiser le tableau de bord à sa configuration par défaut',
+    category: PERMISSION_CATEGORIES.DASHBOARD,
+  },
 
   // Analytics
   {
@@ -92,8 +104,16 @@ export const PERMISSIONS: Permission[] = [
   },
   {
     code: 'contacts.assign',
-    name: 'Assigner des contacts',
-    description: "Permet d'assigner des contacts à d'autres utilisateurs",
+    name: 'Assigner des contacts (tous rôles)',
+    description:
+      "Permet d'assigner des contacts à tout utilisateur habilité (commercial, télépro, manager, admin)",
+    category: PERMISSION_CATEGORIES.CONTACTS,
+  },
+  {
+    code: 'contacts.assign_to_sales',
+    name: 'Assigner à un commercial ou télépro',
+    description:
+      "Permet d'assigner des contacts uniquement à un commercial ou un télépro (pas aux managers/admins)",
     category: PERMISSION_CATEGORIES.CONTACTS,
   },
   {
@@ -271,8 +291,16 @@ export const PERMISSIONS: Permission[] = [
   },
   {
     code: 'tasks.assign',
-    name: 'Assigner des tâches',
-    description: "Permet d'assigner des tâches à d'autres utilisateurs",
+    name: 'Assigner des tâches (tous rôles)',
+    description:
+      "Permet d'assigner des tâches à tout utilisateur habilité (commercial, télépro, manager, admin)",
+    category: PERMISSION_CATEGORIES.TASKS,
+  },
+  {
+    code: 'tasks.assign_to_sales',
+    name: 'Assigner des tâches à un commercial ou télépro',
+    description:
+      "Permet d'assigner des tâches uniquement à un commercial ou un télépro (pas aux managers/admins)",
     category: PERMISSION_CATEGORIES.TASKS,
   },
 
@@ -512,6 +540,8 @@ export const DEFAULT_ROLES = {
     description: "Gestion d'équipe et accès étendu aux leads",
     permissions: [
       'dashboard.view',
+      'dashboard.widgets.manage',
+      'dashboard.widgets.reset',
       'analytics.view',
       'general.view_all_companies',
       'contacts.view_all',
@@ -548,10 +578,6 @@ export const DEFAULT_ROLES = {
       'workflows.edit',
       'workflows.activate',
       'settings.workflows.manage',
-      'workflows.view',
-      'workflows.create',
-      'workflows.edit',
-      'workflows.activate',
       'templates.view',
       'templates.create',
       'templates.edit',
@@ -577,10 +603,12 @@ export const DEFAULT_ROLES = {
     description: 'Accès de base pour la gestion des leads personnels',
     permissions: [
       'dashboard.view',
+      'dashboard.widgets.manage',
       'contacts.view_own',
       'contacts.view_unassigned',
       'contacts.create',
       'contacts.edit_own',
+      'contacts.assign_to_sales',
       'contacts.export',
       'contacts.view_files',
       'contacts.upload_files',
@@ -599,7 +627,7 @@ export const DEFAULT_ROLES = {
       'tasks.view_own',
       'tasks.create',
       'tasks.edit_own',
-      'tasks.assign',
+      'tasks.assign_to_sales',
       'audit.view_own',
       'templates.view',
       'templates.create',
@@ -615,10 +643,12 @@ export const DEFAULT_ROLES = {
     description: 'Accès limité pour la qualification de leads',
     permissions: [
       'dashboard.view',
+      'dashboard.widgets.manage',
       'contacts.view_own',
       'contacts.view_unassigned',
       'contacts.create',
       'contacts.edit_own',
+      'contacts.assign_to_sales',
       'contacts.view_files',
       'contacts.upload_files',
       'contacts.view_closing_pipeline',
@@ -636,7 +666,7 @@ export const DEFAULT_ROLES = {
       'tasks.view_own',
       'tasks.create',
       'tasks.edit_own',
-      'tasks.assign',
+      'tasks.assign_to_sales',
       'templates.view',
       'templates.create',
       'templates.edit',

package/template/src/lib/prisma.ts

@@ -1,6 +1,9 @@
 import 'dotenv/config';
 import { PrismaPg } from '@prisma/adapter-pg';
 import { PrismaClient } from '../../generated/prisma/client';
+
+export type { Role } from '../../generated/prisma/client';
+export { Prisma } from '../../generated/prisma/client';
 import { Pool } from 'pg';
 
 const connectionString = `${process.env.DATABASE_URL}`;
@@ -13,7 +16,7 @@ const pool = new Pool({
   connectionTimeoutMillis: 10000, // Timeout de connexion de 10s
 });
 
-const adapter = new PrismaPg(pool);
+const adapter = new PrismaPg(pool as any);
 
 const globalForPrisma = globalThis as unknown as {
   prisma?: PrismaClient;