create-crm-tmp 2.0.0 → 2.1.0

package/template/src/lib/google-calendar-agenda.ts

@@ -0,0 +1,201 @@
+/**
+ * Utilitaires agenda Google Calendar sans dépendance serveur (importable depuis Client Components).
+ */
+
+export interface GoogleAgendaEventItem {
+  googleEventId: string;
+  calendarId: string;
+  title: string;
+  start: string; // ISO (évènements horodatés) ; pour all-day, voir allDayStartDate / allDayEndExclusive
+  end: string; // ISO
+  htmlLink?: string | null;
+  allDay: boolean;
+  /** YYYY-MM-DD (API Google). Présent si allDay. */
+  allDayStartDate?: string;
+  /** YYYY-MM-DD exclusif (API Google : lendemain du dernier jour inclus). Présent si allDay. */
+  allDayEndExclusive?: string;
+}
+
+/**
+ * Calendriers proposés comme cible à la création (tâche, RDV, Meet) : intersection des calendriers
+ * en écriture et des calendriers cochés « Afficher dans l'agenda du CRM » dans les paramètres.
+ * Si aucune préférence n'est enregistrée (liste vide côté API), tous les calendriers en écriture sont proposés.
+ */
+export function googleCalendarsForEventTargetPicker<T extends { id: string }>(
+  writableCalendars: T[],
+  agendaVisibleGoogleCalendarIds: string[] | undefined,
+): T[] {
+  const visible = agendaVisibleGoogleCalendarIds ?? [];
+  if (visible.length === 0) return writableCalendars;
+  return writableCalendars.filter((c) => visible.includes(c.id));
+}
+
+/** Clé calendrier locale YYYY-MM-DD (affichage / filtres agenda). */
+export function localCalendarDateKey(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+/** Bornes locales pour une plage all-day API (start YYYY-MM-DD, end exclusif YYYY-MM-DD). */
+export function googleAllDayLocalBoundsFromApiDates(
+  allDayStartDate: string,
+  allDayEndExclusive: string,
+): { start: Date; end: Date } {
+  const [sy, sm, sd] = allDayStartDate.split('-').map(Number);
+  const start = new Date(sy, sm - 1, sd, 0, 0, 0, 0);
+  const [ey, em, ed] = allDayEndExclusive.split('-').map(Number);
+  const endExclusiveLocal = new Date(ey, em - 1, ed, 0, 0, 0, 0);
+  const end = new Date(endExclusiveLocal.getTime() - 1);
+  return { start, end };
+}
+
+/**
+ * Plage locale pour chevauchement / layout : journée entière = [start 00:00, fin 23:59:59.999]
+ * du dernier jour inclus (end exclusif Google).
+ */
+export function googleAgendaEventLocalTimeRange(ev: GoogleAgendaEventItem): { start: Date; end: Date } {
+  if (ev.allDay && ev.allDayStartDate && ev.allDayEndExclusive) {
+    return googleAllDayLocalBoundsFromApiDates(ev.allDayStartDate, ev.allDayEndExclusive);
+  }
+  return { start: new Date(ev.start), end: new Date(ev.end) };
+}
+
+/** true si l'évènement all-day Google doit apparaître sur ce jour civil local. */
+export function googleAllDayCoversLocalDate(ev: GoogleAgendaEventItem, date: Date): boolean {
+  if (!ev.allDay || !ev.allDayStartDate || !ev.allDayEndExclusive) return false;
+  const k = localCalendarDateKey(date);
+  return ev.allDayStartDate <= k && k < ev.allDayEndExclusive;
+}
+
+const AGENDA_GOOGLE_COLOR_HEX_RE = /^#[0-9A-Fa-f]{6}$/;
+
+/** Bleu par défaut (lisible sur fond clair). */
+export const DEFAULT_GOOGLE_AGENDA_EVENT_COLOR = '#3b82f6';
+
+/** Valide / normalise une couleur stockée (#RRGGBB). */
+export function normalizeAgendaGoogleEventColor(input: string | null | undefined): string {
+  if (typeof input === 'string' && AGENDA_GOOGLE_COLOR_HEX_RE.test(input.trim())) {
+    return input.trim();
+  }
+  return DEFAULT_GOOGLE_AGENDA_EVENT_COLOR;
+}
+
+function hexToRgb(hex: string): { r: number; g: number; b: number } {
+  const h = normalizeAgendaGoogleEventColor(hex).slice(1);
+  return {
+    r: Number.parseInt(h.slice(0, 2), 16),
+    g: Number.parseInt(h.slice(2, 4), 16),
+    b: Number.parseInt(h.slice(4, 6), 16),
+  };
+}
+
+function srgbChannelToLinear(v: number): number {
+  const x = v / 255;
+  return x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+}
+
+/** Luminance relative sRGB (WCAG), pour borner le contraste avec du texte blanc. */
+function relativeLuminance(r: number, g: number, b: number): number {
+  const lr = srgbChannelToLinear(r);
+  const lg = srgbChannelToLinear(g);
+  const lb = srgbChannelToLinear(b);
+  return 0.2126 * lr + 0.7152 * lg + 0.0722 * lb;
+}
+
+/** Mélange la couleur marque vers le noir (teinte conservée, luminosité baissée). */
+function mixRgbTowardBlack(
+  r: number,
+  g: number,
+  b: number,
+  /** 0 = couleur d'origine, 1 = slate très sombre */
+  blackWeight: number,
+): { r: number; g: number; b: number } {
+  const k = Math.min(1, Math.max(0, blackWeight));
+  const br = 15;
+  const bg = 23;
+  const bb = 42;
+  return {
+    r: Math.round(r + (br - r) * k),
+    g: Math.round(g + (bg - g) * k),
+    b: Math.round(b + (bb - b) * k),
+  };
+}
+
+/**
+ * Assombrit le minimum nécessaire pour que le blanc reste lisible (~contraste 3.2+),
+ * sans forcer un mélange noir trop fort (couleurs encore reconnaissables).
+ */
+function rgbDarkenedForWhiteText(
+  r: number,
+  g: number,
+  b: number,
+  /** luminance max du fond (plus bas = texte blanc plus exigeant) */
+  maxBackgroundLuminance: number,
+  /** plafond de mélange vers le noir (évite les boues si la couleur est très claire) */
+  maxBlackMix: number,
+): { r: number; g: number; b: number } {
+  if (relativeLuminance(r, g, b) <= maxBackgroundLuminance) {
+    return { r, g, b };
+  }
+  let lo = 0;
+  let hi = maxBlackMix;
+  for (let i = 0; i < 16; i++) {
+    const mid = (lo + hi) / 2;
+    const c = mixRgbTowardBlack(r, g, b, mid);
+    if (relativeLuminance(c.r, c.g, c.b) > maxBackgroundLuminance) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  let out = mixRgbTowardBlack(r, g, b, hi);
+  if (relativeLuminance(out.r, out.g, out.b) > maxBackgroundLuminance) {
+    out = mixRgbTowardBlack(r, g, b, maxBlackMix);
+  }
+  return out;
+}
+
+function toRgbString(rgb: { r: number; g: number; b: number }): string {
+  return `rgb(${rgb.r},${rgb.g},${rgb.b})`;
+}
+
+const GOOGLE_AGENDA_ON_DARK_FG = '#ffffff';
+const GOOGLE_AGENDA_ON_DARK_FG_MUTED = 'rgba(255,255,255,0.92)';
+
+/** Pastilles / barres : contraste un peu plus sûr, teinte = couleur choisie (pastilles paramètres). */
+export function googleAgendaEventChromeStyle(hex: string): {
+  backgroundColor: string;
+  borderColor: string;
+  color: string;
+  iconColor: string;
+} {
+  const { r, g, b } = hexToRgb(hex);
+  const bgRgb = rgbDarkenedForWhiteText(r, g, b, 0.26, 0.62);
+  const borderRgb = mixRgbTowardBlack(bgRgb.r, bgRgb.g, bgRgb.b, 0.2);
+  return {
+    backgroundColor: toRgbString(bgRgb),
+    borderColor: toRgbString(borderRgb),
+    color: GOOGLE_AGENDA_ON_DARK_FG,
+    iconColor: GOOGLE_AGENDA_ON_DARK_FG,
+  };
+}
+
+/** Grandes cartes : un peu plus claires que les pastilles (même teinte, moins de sombrance). */
+export function googleAgendaEventCardChromeStyle(hex: string): {
+  backgroundColor: string;
+  borderColor: string;
+  color: string;
+  iconColor: string;
+} {
+  const { r, g, b } = hexToRgb(hex);
+  const bgRgb = rgbDarkenedForWhiteText(r, g, b, 0.3, 0.62);
+  const borderRgb = mixRgbTowardBlack(bgRgb.r, bgRgb.g, bgRgb.b, 0.18);
+  return {
+    backgroundColor: toRgbString(bgRgb),
+    borderColor: toRgbString(borderRgb),
+    color: GOOGLE_AGENDA_ON_DARK_FG,
+    iconColor: GOOGLE_AGENDA_ON_DARK_FG_MUTED,
+  };
+}

package/template/src/lib/google-calendar.ts

@@ -1,10 +1,73 @@
 /**
- * Utilitaires pour gérer l'authentification et les appels à Google Calendar API
+ * Utilitaires pour gérer l'authentification et les appels à Google Calendar/Meet API
  */
 
 import { prisma } from './prisma';
 import { decrypt } from './encryption';
 import { googleFetch } from './google-fetch';
+import type { GoogleAgendaEventItem } from './google-calendar-agenda';
+import { googleAllDayLocalBoundsFromApiDates } from './google-calendar-agenda';
+
+export type { GoogleAgendaEventItem } from './google-calendar-agenda';
+export {
+  localCalendarDateKey,
+  googleAllDayLocalBoundsFromApiDates,
+  googleAgendaEventLocalTimeRange,
+  googleAllDayCoversLocalDate,
+} from './google-calendar-agenda';
+
+export type GoogleCalendarContactFooterInput = {
+  firstName?: string | null;
+  lastName?: string | null;
+  email: string;
+};
+
+/** Ligne de pied de page « Contact » pour la description Google Calendar (texte brut). */
+export function formatGoogleCalendarContactFooter(
+  contact: GoogleCalendarContactFooterInput,
+): string {
+  const name =
+    [contact.firstName, contact.lastName].filter(Boolean).join(' ').trim() ||
+    contact.email.split('@')[0];
+  return `Contact : ${name} – ${contact.email}`;
+}
+
+/** Ajoute le pied de page contact sans dupliquer s’il est déjà en fin de texte. */
+export function appendGoogleCalendarContactFooter(
+  plainText: string,
+  contact: GoogleCalendarContactFooterInput,
+): string {
+  const footer = formatGoogleCalendarContactFooter(contact);
+  const trimmed = plainText.trimEnd();
+  if (!trimmed) return footer;
+  if (trimmed === footer || trimmed.endsWith(`\n${footer}`) || trimmed.endsWith(footer)) {
+    return trimmed;
+  }
+  return `${trimmed}\n\n${footer}`;
+}
+
+/**
+ * Récupère le compte Google de l'administrateur (utilisé pour Calendar, Meet, Sheets).
+ */
+export async function getAdminGoogleAccount() {
+  const adminUser = await prisma.user.findFirst({
+    where: { role: 'ADMIN' },
+    include: { googleAccount: true },
+    orderBy: { createdAt: 'asc' },
+  });
+
+  if (!adminUser || !adminUser.googleAccount) {
+    throw new Error(
+      'Aucun compte Google configuré. Veuillez demander à un administrateur de connecter son compte Google dans Paramètres.',
+    );
+  }
+
+  return {
+    ...adminUser.googleAccount,
+    accessToken: decrypt(adminUser.googleAccount.accessToken),
+    refreshToken: decrypt(adminUser.googleAccount.refreshToken),
+  };
+}
 
 interface GoogleTokenResponse {
   access_token: string;
@@ -13,6 +76,13 @@ interface GoogleTokenResponse {
   token_type: string;
 }
 
+export interface GoogleCalendarListItem {
+  id: string;
+  summary: string;
+  primary?: boolean;
+  accessRole?: string;
+}
+
 interface GoogleCalendarEvent {
   id?: string;
   summary: string;
@@ -224,15 +294,192 @@ export async function getValidAccessToken(
   return accessToken;
 }
 
+/** ID calendrier stocké en base (null = ancien comportement = primary). */
+export function resolveTaskGoogleCalendarId(stored: string | null | undefined): string {
+  return stored && stored.trim() !== '' ? stored : 'primary';
+}
+
+function calendarEventsBaseUrl(calendarId: string): string {
+  return `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`;
+}
+
+/**
+ * Liste les calendriers accessibles (calendarList), avec pagination.
+ */
+export async function listGoogleCalendars(accessToken: string): Promise<GoogleCalendarListItem[]> {
+  const out: GoogleCalendarListItem[] = [];
+  let pageToken: string | undefined;
+
+  do {
+    const params = new URLSearchParams({ minAccessRole: 'freeBusyReader' });
+    if (pageToken) params.set('pageToken', pageToken);
+
+    const response = await googleFetch(
+      `https://www.googleapis.com/calendar/v3/users/me/calendarList?${params.toString()}`,
+      {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+        },
+      },
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Erreur lors de la liste des calendriers: ${error}`);
+    }
+
+    const data = (await response.json()) as {
+      items?: Array<{ id: string; summary?: string; primary?: boolean; accessRole?: string }>;
+      nextPageToken?: string;
+    };
+
+    for (const item of data.items ?? []) {
+      if (item.id) {
+        out.push({
+          id: item.id,
+          summary: item.summary || item.id,
+          primary: item.primary,
+          accessRole: item.accessRole,
+        });
+      }
+    }
+    pageToken = data.nextPageToken;
+  } while (pageToken);
+
+  return out;
+}
+
+const WRITABLE_CALENDAR_ROLES = new Set(['owner', 'writer']);
+
+/**
+ * Vérifie que l'utilisateur peut créer des événements sur ce calendrier.
+ */
+export async function assertWritableGoogleCalendar(
+  accessToken: string,
+  calendarId: string,
+): Promise<void> {
+  const resolved = calendarId.trim() === '' ? 'primary' : calendarId;
+  const response = await googleFetch(
+    `https://www.googleapis.com/calendar/v3/users/me/calendarList/${encodeURIComponent(resolved)}`,
+    {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${accessToken}` },
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Calendrier Google invalide ou inaccessible: ${error}`);
+  }
+
+  const entry = (await response.json()) as { accessRole?: string };
+  if (!entry.accessRole || !WRITABLE_CALENDAR_ROLES.has(entry.accessRole)) {
+    throw new Error('Vous n’avez pas la permission d’ajouter des événements sur ce calendrier.');
+  }
+}
+
+/**
+ * Vérifie qu'un ID appartient à la liste (pour préférences agenda / défaut).
+ */
+export async function assertKnownGoogleCalendar(
+  accessToken: string,
+  calendarId: string,
+): Promise<void> {
+  const resolved = calendarId.trim() === '' ? 'primary' : calendarId;
+  const response = await googleFetch(
+    `https://www.googleapis.com/calendar/v3/users/me/calendarList/${encodeURIComponent(resolved)}`,
+    {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${accessToken}` },
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Calendrier Google invalide ou inaccessible: ${error}`);
+  }
+}
+
+/**
+ * Événements sur une plage (pour l'agenda CRM). singleEvents + orderBy=startTime.
+ */
+export async function listGoogleCalendarEvents(
+  accessToken: string,
+  calendarId: string,
+  timeMin: Date,
+  timeMax: Date,
+): Promise<GoogleAgendaEventItem[]> {
+  const params = new URLSearchParams({
+    timeMin: timeMin.toISOString(),
+    timeMax: timeMax.toISOString(),
+    singleEvents: 'true',
+    orderBy: 'startTime',
+    maxResults: '2500',
+  });
+
+  const response = await googleFetch(`${calendarEventsBaseUrl(calendarId)}?${params.toString()}`, {
+    method: 'GET',
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors du chargement des événements: ${error}`);
+  }
+
+  const data = (await response.json()) as {
+    items?: Array<{
+      id: string;
+      summary?: string;
+      start?: { dateTime?: string; date?: string; timeZone?: string };
+      end?: { dateTime?: string; date?: string; timeZone?: string };
+      htmlLink?: string;
+    }>;
+  };
+
+  const items: GoogleAgendaEventItem[] = [];
+  for (const ev of data.items ?? []) {
+    if (!ev.id) continue;
+    const allDay = Boolean(ev.start?.date && !ev.start?.dateTime);
+    const startRaw = ev.start?.dateTime || ev.start?.date;
+    const endRaw = ev.end?.dateTime || ev.end?.date;
+    if (!startRaw || !endRaw) continue;
+
+    let startIso = startRaw;
+    let endIso = endRaw;
+    /** Pour all-day, Google donne end.date exclusif : bornes locales pour ISO + champs bruts pour filtres. */
+    if (allDay) {
+      const { start, end } = googleAllDayLocalBoundsFromApiDates(startRaw, endRaw);
+      startIso = start.toISOString();
+      endIso = end.toISOString();
+    }
+
+    items.push({
+      googleEventId: ev.id,
+      calendarId,
+      title: ev.summary?.trim() ? ev.summary : '(Sans titre)',
+      start: startIso,
+      end: endIso,
+      htmlLink: ev.htmlLink ?? null,
+      allDay,
+      ...(allDay ? { allDayStartDate: startRaw, allDayEndExclusive: endRaw } : {}),
+    });
+  }
+
+  return items;
+}
+
 /**
  * Crée un évènement Google Calendar avec Google Meet
  */
 export async function createGoogleCalendarEvent(
   accessToken: string,
+  calendarId: string,
   event: GoogleCalendarEvent,
 ): Promise<GoogleCalendarEventResponse> {
   const response = await googleFetch(
-    'https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1',
+    `${calendarEventsBaseUrl(calendarId)}?conferenceDataVersion=1`,
     {
       method: 'POST',
       headers: {
@@ -256,11 +503,12 @@ export async function createGoogleCalendarEvent(
  */
 export async function updateGoogleCalendarEvent(
   accessToken: string,
+  calendarId: string,
   eventId: string,
   event: Partial<GoogleCalendarEvent>,
 ): Promise<GoogleCalendarEventResponse> {
   const response = await googleFetch(
-    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}?conferenceDataVersion=1`,
+    `${calendarEventsBaseUrl(calendarId)}/${encodeURIComponent(eventId)}?conferenceDataVersion=1`,
     {
       method: 'PATCH',
       headers: {
@@ -284,10 +532,11 @@ export async function updateGoogleCalendarEvent(
  */
 export async function deleteGoogleCalendarEvent(
   accessToken: string,
+  calendarId: string,
   eventId: string,
 ): Promise<void> {
   const response = await googleFetch(
-    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
+    `${calendarEventsBaseUrl(calendarId)}/${encodeURIComponent(eventId)}`,
     {
       method: 'DELETE',
       headers: {
@@ -320,10 +569,11 @@ export function extractMeetLink(eventResponse: GoogleCalendarEventResponse): str
  */
 export async function getGoogleCalendarEvent(
   accessToken: string,
+  calendarId: string,
   eventId: string,
 ): Promise<GoogleCalendarEventResponse> {
   const response = await googleFetch(
-    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
+    `${calendarEventsBaseUrl(calendarId)}/${encodeURIComponent(eventId)}`,
     {
       method: 'GET',
       headers: {

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

@@ -0,0 +1,96 @@
+import { prisma } from '@/lib/prisma';
+import { publishGoogleSheetSyncJob } from '@/lib/qstash';
+
+type EnqueueParams = {
+  requestedByUserId?: string | null;
+  configId?: string | null;
+  triggerType?: 'MANUAL' | 'SCHEDULED';
+};
+
+const MANUAL_RATE_LIMIT_WINDOW_MS = 60_000;
+const MANUAL_RATE_LIMIT_MAX_PER_WINDOW = 6;
+const STALE_JOB_TIMEOUT_MS = 10 * 60_000; // 10 minutes
+
+export class SyncJobRateLimitError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SyncJobRateLimitError';
+  }
+}
+
+export async function enqueueGoogleSheetSyncJob(params: EnqueueParams) {
+  const { requestedByUserId = null, configId = null, triggerType = 'MANUAL' } = params;
+
+  if (triggerType === 'MANUAL' && requestedByUserId) {
+    const windowStart = new Date(Date.now() - MANUAL_RATE_LIMIT_WINDOW_MS);
+    const manualCount = await prisma.googleSheetSyncJob.count({
+      where: {
+        triggerType: 'MANUAL',
+        requestedByUserId,
+        createdAt: {
+          gte: windowStart,
+        },
+      },
+    });
+    if (manualCount >= MANUAL_RATE_LIMIT_MAX_PER_WINDOW) {
+      throw new SyncJobRateLimitError(
+        'Trop de synchronisations demandées en peu de temps. Réessayez dans une minute.',
+      );
+    }
+  }
+
+  const pendingStatuses = ['QUEUED', 'RUNNING'] as const;
+  const staleThreshold = new Date(Date.now() - STALE_JOB_TIMEOUT_MS);
+
+  // Mark stale jobs as FAILED so they don't block new ones
+  await prisma.googleSheetSyncJob.updateMany({
+    where: {
+      status: { in: [...pendingStatuses] },
+      configId: configId ?? null,
+      triggerType,
+      createdAt: { lt: staleThreshold },
+    },
+    data: {
+      status: 'FAILED',
+      finishedAt: new Date(),
+      error: 'Job expiré (timeout)',
+    },
+  });
+
+  const alreadyPending = await prisma.googleSheetSyncJob.findFirst({
+    where: {
+      status: { in: [...pendingStatuses] },
+      configId: configId ?? null,
+      triggerType,
+    },
+    orderBy: { createdAt: 'desc' },
+  });
+  if (alreadyPending) {
+    return alreadyPending;
+  }
+
+  const job = await prisma.googleSheetSyncJob.create({
+    data: {
+      requestedByUserId,
+      configId,
+      triggerType,
+      payload: configId ? { configId } : {},
+    },
+  });
+
+  try {
+    await publishGoogleSheetSyncJob({ jobId: job.id });
+  } catch (publishError: any) {
+    await prisma.googleSheetSyncJob.update({
+      where: { id: job.id },
+      data: {
+        status: 'FAILED',
+        finishedAt: new Date(),
+        error: publishError?.message || "Impossible d'envoyer le job à QStash",
+      },
+    });
+    throw publishError;
+  }
+
+  return job;
+}