create-crm-tmp 1.0.0

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

@@ -0,0 +1,300 @@
+/**
+ * Utilitaires pour gérer l'authentification et les appels à Google Calendar API
+ */
+
+interface GoogleTokenResponse {
+  access_token: string;
+  refresh_token?: string;
+  expires_in: number;
+  token_type: string;
+}
+
+interface GoogleCalendarEvent {
+  id?: string;
+  summary: string;
+  description?: string;
+  start: {
+    dateTime: string;
+    timeZone?: string;
+  };
+  end: {
+    dateTime: string;
+    timeZone?: string;
+  };
+  attendees?: Array<{ email: string }>;
+  conferenceData?: {
+    createRequest: {
+      requestId: string;
+      conferenceSolutionKey: {
+        type: 'hangoutsMeet';
+      };
+    };
+  };
+  conferenceDataVersion?: number;
+}
+
+interface GoogleCalendarEventResponse {
+  id: string;
+  summary: string;
+  description?: string;
+  start: {
+    dateTime: string;
+    timeZone?: string;
+  };
+  end: {
+    dateTime: string;
+    timeZone?: string;
+  };
+  attendees?: Array<{ email: string }>;
+  conferenceData?: {
+    createRequest?: {
+      requestId: string;
+      conferenceSolutionKey: {
+        type: 'hangoutsMeet';
+      };
+    };
+    entryPoints?: Array<{
+      entryPointType: string;
+      uri: string;
+    }>;
+  };
+}
+
+/**
+ * Échange un code d'autorisation contre des tokens
+ */
+export async function exchangeGoogleCodeForTokens(
+  code: string,
+  redirectUri: string,
+): Promise<GoogleTokenResponse> {
+  const clientId = process.env.GOOGLE_CLIENT_ID;
+  const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+
+  if (!clientId || !clientSecret) {
+    throw new Error('GOOGLE_CLIENT_ID et GOOGLE_CLIENT_SECRET doivent être configurés');
+  }
+
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: new URLSearchParams({
+      code,
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: redirectUri,
+      grant_type: 'authorization_code',
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors de l'échange du code: ${error}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Erreur personnalisée pour les tokens Google invalides
+ */
+export class GoogleTokenError extends Error {
+  constructor(
+    message: string,
+    public code?: string,
+    public isRevoked: boolean = false,
+  ) {
+    super(message);
+    this.name = 'GoogleTokenError';
+  }
+}
+
+/**
+ * Rafraîchit un access token expiré
+ */
+export async function refreshGoogleToken(refreshToken: string): Promise<GoogleTokenResponse> {
+  const clientId = process.env.GOOGLE_CLIENT_ID;
+  const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+
+  if (!clientId || !clientSecret) {
+    throw new Error('GOOGLE_CLIENT_ID et GOOGLE_CLIENT_SECRET doivent être configurés');
+  }
+
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: new URLSearchParams({
+      refresh_token: refreshToken,
+      client_id: clientId,
+      client_secret: clientSecret,
+      grant_type: 'refresh_token',
+    }),
+  });
+
+  if (!response.ok) {
+    let errorData: any;
+    try {
+      errorData = await response.json();
+    } catch {
+      const errorText = await response.text();
+      throw new Error(`Erreur lors du rafraîchissement du token: ${errorText}`);
+    }
+
+    // Détecter si le token a été révoqué ou a expiré
+    if (errorData.error === 'invalid_grant') {
+      throw new GoogleTokenError(
+        'Le token Google a expiré ou a été révoqué. Veuillez reconnecter votre compte Google dans les paramètres.',
+        'invalid_grant',
+        true,
+      );
+    }
+
+    throw new GoogleTokenError(
+      `Erreur lors du rafraîchissement du token: ${errorData.error_description || errorData.error || JSON.stringify(errorData)}`,
+      errorData.error,
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Obtient un access token valide (rafraîchit si nécessaire)
+ */
+export async function getValidAccessToken(
+  accessToken: string,
+  refreshToken: string,
+  tokenExpiresAt: Date,
+): Promise<string> {
+  // Si le token expire dans moins de 5 minutes, on le rafraîchit
+  const now = new Date();
+  const expiresAt = new Date(tokenExpiresAt);
+  const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
+
+  if (expiresAt <= fiveMinutesFromNow) {
+    const newTokens = await refreshGoogleToken(refreshToken);
+    return newTokens.access_token;
+  }
+
+  return accessToken;
+}
+
+/**
+ * Crée un évènement Google Calendar avec Google Meet
+ */
+export async function createGoogleCalendarEvent(
+  accessToken: string,
+  event: GoogleCalendarEvent,
+): Promise<GoogleCalendarEventResponse> {
+  const response = await fetch(
+    'https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1',
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(event),
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors de la création de l'évènement: ${error}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Met à jour un évènement Google Calendar
+ */
+export async function updateGoogleCalendarEvent(
+  accessToken: string,
+  eventId: string,
+  event: Partial<GoogleCalendarEvent>,
+): Promise<GoogleCalendarEventResponse> {
+  const response = await fetch(
+    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}?conferenceDataVersion=1`,
+    {
+      method: 'PATCH',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(event),
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors de la mise à jour de l'évènement: ${error}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Supprime un évènement Google Calendar
+ */
+export async function deleteGoogleCalendarEvent(
+  accessToken: string,
+  eventId: string,
+): Promise<void> {
+  const response = await fetch(
+    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
+    {
+      method: 'DELETE',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors de la suppression de l'évènement: ${error}`);
+  }
+}
+
+/**
+ * Extrait le lien Google Meet depuis la réponse de l'API
+ */
+export function extractMeetLink(eventResponse: GoogleCalendarEventResponse): string | null {
+  if (eventResponse.conferenceData?.entryPoints) {
+    const meetEntry = eventResponse.conferenceData.entryPoints.find(
+      (entry) => entry.entryPointType === 'video',
+    );
+    return meetEntry?.uri || null;
+  }
+  return null;
+}
+
+/**
+ * Récupère un évènement Google Calendar
+ */
+export async function getGoogleCalendarEvent(
+  accessToken: string,
+  eventId: string,
+): Promise<GoogleCalendarEventResponse> {
+  const response = await fetch(
+    `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
+    {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+    },
+  );
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Erreur lors de la récupération de l'évènement: ${error}`);
+  }
+
+  return response.json();
+}

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

@@ -0,0 +1,372 @@
+/**
+ * Utilitaires pour gérer les fichiers avec Google Drive API
+ */
+
+import { prisma } from '@/lib/prisma';
+import { getValidAccessToken } from './google-calendar';
+
+// Nom de l'application (peut être configuré via variable d'environnement)
+const APP_NAME = process.env.APP_NAME || 'CRM Template';
+
+/**
+ * Crée ou récupère un dossier dans Google Drive
+ */
+async function getOrCreateFolder(
+  accessToken: string,
+  folderName: string,
+  parentId?: string,
+): Promise<string> {
+  // Construire la requête de recherche
+  // Important: Ne pas encoder le nom dans les guillemets, mais échapper les guillemets simples dans le nom
+  // Google Drive API attend le nom tel quel, pas encodé
+  const escapedName = folderName.replace(/'/g, "\\'");
+  let query = `name='${escapedName}' and mimeType='application/vnd.google-apps.folder' and trashed=false`;
+  if (parentId) {
+    query += ` and '${parentId}' in parents`;
+  } else {
+    // Pour la racine, on cherche les dossiers qui n'ont pas de parents (ou qui ont 'root' comme parent)
+    query += ` and 'root' in parents`;
+  }
+
+  // Chercher si le dossier existe déjà
+  const searchUrl = `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name,parents)&pageSize=10`;
+  const searchResponse = await fetch(searchUrl, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!searchResponse.ok) {
+    const errorText = await searchResponse.text();
+    throw new Error(`Erreur lors de la recherche du dossier: ${errorText}`);
+  }
+
+  const searchData = await searchResponse.json();
+
+  // Si le dossier existe, vérifier qu'il est bien dans le bon parent
+  if (searchData.files && searchData.files.length > 0) {
+    // Si on cherche à la racine, vérifier que le dossier est bien à la racine
+    if (!parentId) {
+      // Vérifier que le dossier est bien à la racine (parents contient 'root' ou est vide)
+      const rootFolder = searchData.files.find((file: any) => {
+        if (!file.parents || file.parents.length === 0) return true;
+        // Vérifier si le dossier est directement à la racine
+        return file.parents.length === 1 && file.parents[0] === 'root';
+      });
+
+      if (rootFolder) {
+        return rootFolder.id;
+      }
+
+      // Si aucun n'est exactement à la racine, prendre le premier
+      return searchData.files[0].id;
+    }
+
+    // Si on cherche dans un parent spécifique, vérifier que le dossier est bien dans ce parent
+    const matchingFolder = searchData.files.find(
+      (file: any) => file.parents && file.parents.includes(parentId),
+    );
+
+    if (matchingFolder) {
+      return matchingFolder.id;
+    }
+
+    // Si aucun ne correspond exactement, prendre le premier (cas de migration)
+    return searchData.files[0].id;
+  }
+
+  // Sinon, créer le dossier
+  const folderData: any = {
+    name: folderName,
+    mimeType: 'application/vnd.google-apps.folder',
+  };
+
+  if (parentId) {
+    folderData.parents = [parentId];
+  } else {
+    // Pour la racine, on spécifie explicitement 'root' comme parent
+    folderData.parents = ['root'];
+  }
+
+  const createResponse = await fetch('https://www.googleapis.com/drive/v3/files', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(folderData),
+  });
+
+  if (!createResponse.ok) {
+    const error = await createResponse.json();
+    throw new Error(`Erreur lors de la création du dossier: ${JSON.stringify(error)}`);
+  }
+
+  const createdData = await createResponse.json();
+
+  // Configurer les permissions pour rendre le dossier accessible avec le lien
+  try {
+    await setFilePublicWithLink(accessToken, createdData.id);
+  } catch (permError) {
+    console.error('Erreur lors de la configuration des permissions du dossier:', permError);
+    // On continue même si la configuration des permissions échoue
+  }
+
+  return createdData.id;
+}
+
+/**
+ * Configure les permissions d'un fichier/dossier pour le rendre accessible avec le lien
+ * Type: 'anyone' avec rôle 'reader' = accessible à quiconque possède le lien
+ */
+async function setFilePublicWithLink(accessToken: string, fileId: string): Promise<void> {
+  const permissionResponse = await fetch(
+    `https://www.googleapis.com/drive/v3/files/${fileId}/permissions`,
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        type: 'anyone',
+        role: 'reader',
+      }),
+    },
+  );
+
+  if (!permissionResponse.ok) {
+    const error = await permissionResponse.json();
+    throw new Error(`Erreur lors de la configuration des permissions: ${JSON.stringify(error)}`);
+  }
+}
+
+/**
+ * Crée un dossier dans Google Drive pour un contact
+ * Structure: CRM Template > Contacts > Contact - [Nom]
+ * Retourne l'ID du dossier créé ou existant
+ */
+export async function getOrCreateContactFolder(
+  userId: string,
+  contactId: string,
+  contactName: string,
+): Promise<string> {
+  const googleAccount = await prisma.userGoogleAccount.findUnique({
+    where: { userId },
+  });
+
+  if (!googleAccount) {
+    throw new Error('Aucun compte Google connecté');
+  }
+
+  const accessToken = await getValidAccessToken(
+    googleAccount.accessToken,
+    googleAccount.refreshToken,
+    googleAccount.tokenExpiresAt,
+  );
+
+  // Mettre à jour le token si nécessaire
+  if (accessToken !== googleAccount.accessToken) {
+    const tokenExpiresAt = new Date();
+    tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+    await prisma.userGoogleAccount.update({
+      where: { userId },
+      data: {
+        accessToken,
+        tokenExpiresAt,
+      },
+    });
+  }
+
+  // 1. Créer ou récupérer le dossier racine "CRM Template"
+  const appFolderId = await getOrCreateFolder(accessToken, APP_NAME);
+
+  // 2. Créer ou récupérer le dossier "Contacts" dans "CRM Template"
+  const contactsFolderId = await getOrCreateFolder(accessToken, 'Contacts', appFolderId);
+
+  // 3. Créer ou récupérer le dossier du contact dans "Contacts"
+  const contactFolderName = `Contact - ${contactName || contactId}`;
+  const contactFolderId = await getOrCreateFolder(accessToken, contactFolderName, contactsFolderId);
+
+  return contactFolderId;
+}
+
+/**
+ * Upload un fichier vers Google Drive dans le dossier du contact
+ */
+export async function uploadFileToDrive(
+  userId: string,
+  contactId: string,
+  contactName: string,
+  file: File,
+): Promise<{ fileId: string; webViewLink: string }> {
+  const folderId = await getOrCreateContactFolder(userId, contactId, contactName);
+
+  const googleAccount = await prisma.userGoogleAccount.findUnique({
+    where: { userId },
+  });
+
+  if (!googleAccount) {
+    throw new Error('Aucun compte Google connecté');
+  }
+
+  const accessToken = await getValidAccessToken(
+    googleAccount.accessToken,
+    googleAccount.refreshToken,
+    googleAccount.tokenExpiresAt,
+  );
+
+  // Mettre à jour le token si nécessaire
+  if (accessToken !== googleAccount.accessToken) {
+    const tokenExpiresAt = new Date();
+    tokenExpiresAt.setSeconds(tokenExpiresAt.getSeconds() + 3600);
+    await prisma.userGoogleAccount.update({
+      where: { userId },
+      data: {
+        accessToken,
+        tokenExpiresAt,
+      },
+    });
+  }
+
+  // Vérifier si un fichier avec le même nom existe déjà dans le dossier
+  const searchQuery = `name='${encodeURIComponent(file.name)}' and '${folderId}' in parents and trashed=false`;
+  const searchResponse = await fetch(
+    `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(searchQuery)}&fields=files(id,name,webViewLink)`,
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    },
+  );
+
+  if (searchResponse.ok) {
+    const searchData = await searchResponse.json();
+    // Si un fichier avec le même nom existe déjà, le supprimer avant d'uploader le nouveau
+    if (searchData.files && searchData.files.length > 0) {
+      for (const existingFile of searchData.files) {
+        try {
+          await fetch(`https://www.googleapis.com/drive/v3/files/${existingFile.id}`, {
+            method: 'DELETE',
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+            },
+          });
+        } catch (error) {
+          // Ignorer l'erreur de suppression du fichier existant
+        }
+      }
+    }
+  }
+
+  // Créer les métadonnées du fichier
+  const metadata = {
+    name: file.name,
+    parents: [folderId],
+  };
+
+  // Créer le FormData pour l'upload multipart
+  const formData = new FormData();
+  formData.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
+  formData.append('file', file);
+
+  // Upload le fichier
+  const uploadResponse = await fetch(
+    'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,webViewLink',
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: formData,
+    },
+  );
+
+  if (!uploadResponse.ok) {
+    const error = await uploadResponse.json();
+    throw new Error(`Erreur lors de l'upload: ${JSON.stringify(error)}`);
+  }
+
+  const fileData = await uploadResponse.json();
+
+  // Configurer les permissions pour rendre le fichier accessible avec le lien
+  try {
+    await setFilePublicWithLink(accessToken, fileData.id);
+  } catch (permError) {
+    console.error('Erreur lors de la configuration des permissions du fichier:', permError);
+    // On continue même si la configuration des permissions échoue
+  }
+
+  return {
+    fileId: fileData.id,
+    webViewLink: fileData.webViewLink || `https://drive.google.com/file/d/${fileData.id}/view`,
+  };
+}
+
+/**
+ * Récupère les informations d'un fichier depuis Google Drive
+ */
+export async function getFileInfo(
+  userId: string,
+  fileId: string,
+): Promise<{ name: string; size: string; mimeType: string; webViewLink: string }> {
+  const googleAccount = await prisma.userGoogleAccount.findUnique({
+    where: { userId },
+  });
+
+  if (!googleAccount) {
+    throw new Error('Aucun compte Google connecté');
+  }
+
+  const accessToken = await getValidAccessToken(
+    googleAccount.accessToken,
+    googleAccount.refreshToken,
+    googleAccount.tokenExpiresAt,
+  );
+
+  const response = await fetch(
+    `https://www.googleapis.com/drive/v3/files/${fileId}?fields=id,name,size,mimeType,webViewLink`,
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error('Erreur lors de la récupération du fichier');
+  }
+
+  return await response.json();
+}
+
+/**
+ * Supprime un fichier de Google Drive
+ */
+export async function deleteFileFromDrive(userId: string, fileId: string): Promise<void> {
+  const googleAccount = await prisma.userGoogleAccount.findUnique({
+    where: { userId },
+  });
+
+  if (!googleAccount) {
+    throw new Error('Aucun compte Google connecté');
+  }
+
+  const accessToken = await getValidAccessToken(
+    googleAccount.accessToken,
+    googleAccount.refreshToken,
+    googleAccount.tokenExpiresAt,
+  );
+
+  const response = await fetch(`https://www.googleapis.com/drive/v3/files/${fileId}`, {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!response.ok && response.status !== 404) {
+    // 404 signifie que le fichier n'existe plus, ce qui est OK
+    throw new Error('Erreur lors de la suppression du fichier');
+  }
+}