Google contacts handle invalid credentials (#2560)

* add leadminer as a tag to vcard

* fix: handle missing credentials & frontend i18n tweaks

* fix notification include number of exported contacts

* remove  useless template literal

Author: malek10xdev

backend/package-lock.json

@@ -43,6 +43,7 @@
     "email-reply-parser": "^2.0.1",
     "express": "^4.21.2",
     "express-sse": "^1.0.0",
+    "gaxios": "^7.1.3",
     "generic-pool": "^3.9.0",
     "googleapis": "^169.0.0",
     "html-entities": "^2.6.0",

backend/package.json

@@ -31,10 +31,24 @@ async function validateRequest(
     throw new Error(`Invalid export type: ${exportType}`);
   }
 
-  const oauthCredentials = (await miningSources.getCredentialsBySourceEmail(
-    user.id,
-    user.email as string
-  )) as OAuthMiningSourceCredentials;
+  let googleContactsOptions: ExportOptions['googleContactsOptions'] = {
+    accessToken: undefined,
+    refreshToken: undefined,
+    updateEmptyFieldsOnly
+  };
+
+  if (exportType === ExportType.GOOGLE_CONTACTS) {
+    const oauthCredentials = (await miningSources.getCredentialsBySourceEmail(
+      user.id,
+      user.email as string
+    )) as OAuthMiningSourceCredentials;
+
+    googleContactsOptions = {
+      accessToken: oauthCredentials?.accessToken,
+      refreshToken: oauthCredentials?.refreshToken,
+      updateEmptyFieldsOnly
+    };
+  }
 
   const {
     emails,
@@ -50,11 +64,7 @@ async function validateRequest(
       exportOptions: {
         locale: localeFromHeader,
         delimiter: undefined,
-        googleContactsOptions: {
-          accessToken: oauthCredentials?.accessToken,
-          refreshToken: oauthCredentials?.refreshToken,
-          updateEmptyFieldsOnly
-        }
+        googleContactsOptions
       }
     };
   }
@@ -69,11 +79,7 @@ async function validateRequest(
     exportOptions: {
       locale: localeFromHeader,
       delimiter: delimiterOption,
-      googleContactsOptions: {
-        accessToken: oauthCredentials?.accessToken,
-        refreshToken: oauthCredentials?.refreshToken,
-        updateEmptyFieldsOnly
-      }
+      googleContactsOptions
     }
   };
 }

backend/src/controllers/contacts.controller.ts

@@ -1,4 +1,5 @@
 import { google, people_v1 } from 'googleapis';
+import { GaxiosError } from 'gaxios';
 import { Contact } from '../../../db/types';
 import {
   ExportStrategy,
@@ -15,82 +16,106 @@ export default class GoogleContactsExport implements ExportStrategy<Contact> {
 
   readonly type = ExportType.GOOGLE_CONTACTS;
 
-  private static getPeopleService(accessToken: string, refreshToken?: string) {
-    if (!accessToken) {
-      throw new Error('Invalid credentials.');
-    }
+  private static async getPeopleService(
+    options: ExportOptions['googleContactsOptions']
+  ) {
+    const accessToken = options?.accessToken;
+    const refreshToken = options?.refreshToken;
 
-    const oauth2Client = new google.auth.OAuth2(
-      ENV.GOOGLE_CLIENT_ID,
-      ENV.GOOGLE_SECRET
-    );
+    try {
+      if (!accessToken && !refreshToken) {
+        throw new Error('Invalid credentials.');
+      }
 
-    oauth2Client.setCredentials({
-      access_token: accessToken,
-      refresh_token: refreshToken
-    });
+      const oauth2Client = new google.auth.OAuth2(
+        ENV.GOOGLE_CLIENT_ID,
+        ENV.GOOGLE_SECRET
+      );
 
-    return google.people({ version: 'v1', auth: oauth2Client });
-  }
+      const token = googleOAuth2Client.createToken({
+        access_token: accessToken,
+        refresh_token: refreshToken
+      });
 
-  private static validateCredentials(
-    accessToken: string,
-    refreshToken?: string
-  ) {
-    const token = googleOAuth2Client.createToken({
-      access_token: accessToken,
-      refresh_token: refreshToken
-    });
+      if (token.expired(1000) && !refreshToken) {
+        throw new Error('Invalid credentials.');
+      }
 
-    if (token.expired(1000) && !refreshToken) {
-      throw new Error('Invalid credentials.');
-    }
+      oauth2Client.setCredentials({
+        access_token: accessToken,
+        refresh_token: refreshToken
+      });
 
-    return {
-      accessToken: token.token.access_token as string,
-      refreshToken
-    };
+      const peopleService = google.people({
+        version: 'v1',
+        auth: oauth2Client
+      });
+
+      // Update cache and validate credentials
+      await peopleService.people.searchContacts({
+        query: '',
+        readMask: 'names,emailAddresses,phoneNumbers,organizations,metadata'
+      });
+
+      return peopleService;
+    } catch (err) {
+      console.log(err, accessToken, refreshToken);
+      if (err instanceof GaxiosError) {
+        logger.error(
+          `Error creating google.people service: ${err.message}`,
+          err
+        );
+        if (err.response?.status === 401) {
+          throw new Error('Invalid credentials.');
+        }
+      } else {
+        logger.error(
+          `Error creating google.people service: ${(err as Error).message}`,
+          err
+        );
+      }
+      throw err;
+    }
   }
 
   async export(
     contacts: Contact[],
     options: ExportOptions
   ): Promise<ExportResult> {
-    if (!options.googleContactsOptions) {
+    if (!options.googleContactsOptions)
       throw new Error('Invalid contact options.');
-    }
 
+    const peopleService = await GoogleContactsExport.getPeopleService(
+      options.googleContactsOptions
+    );
     const {
-      googleContactsOptions: {
-        accessToken: at,
-        refreshToken: rt,
-        updateEmptyFieldsOnly
-      }
+      googleContactsOptions: { updateEmptyFieldsOnly }
     } = options;
-    const { accessToken, refreshToken } =
-      GoogleContactsExport.validateCredentials(at, rt);
-    const peopleService = GoogleContactsExport.getPeopleService(
-      accessToken,
-      refreshToken
-    );
     const updateEmptyOnly = updateEmptyFieldsOnly ?? false;
 
-    contacts.forEach(async (contact) => {
-      const existing = await GoogleContactsExport.fetchGoogleContacts(
-        peopleService,
-        contact
-      );
-      if (existing) {
-        await GoogleContactsExport.updateContact(
+    /* eslint-disable no-await-in-loop */
+    for (const contact of contacts) {
+      try {
+        const existing = await GoogleContactsExport.fetchGoogleContacts(
           peopleService,
-          existing,
-          contact,
-          updateEmptyOnly
+          contact
         );
-      } else {
-        await GoogleContactsExport.createContact(peopleService, contact);
+
+        if (existing) {
+          await GoogleContactsExport.updateContact(
+            peopleService,
+            existing,
+            contact,
+            updateEmptyOnly
+          );
+        } else {
+          await GoogleContactsExport.createContact(peopleService, contact);
+        }
+      } catch (err) {
+        logger.error('Failed to create/update contact', err);
       }
-    });
+    }
+    /* eslint-disable no-await-in-loop */
 
     return {
       content: '',

backend/src/services/export/exports/googleContacts.ts

@@ -23,6 +23,8 @@ export default class VCardExport implements ExportStrategy<Contact> {
   private static contactToVCard(contact: Contact): string {
     const vcard = new VCard();
 
+    vcard.addCategories(['leadminer']);
+
     if (contact.given_name?.length || contact.family_name?.length) {
       vcard.addName(contact.family_name ?? '', contact.given_name ?? '');
     } else if (contact.name) {

backend/src/services/export/exports/vcard.ts

@@ -8,7 +8,7 @@ export interface ExportOptions {
   delimiter?: string;
   locale?: string;
   googleContactsOptions?: {
-    accessToken: string;
+    accessToken?: string;
     refreshToken?: string;
     updateEmptyFieldsOnly?: boolean;
   };

backend/src/services/export/types.ts

@@ -81,6 +81,7 @@ import {
   CreditsDialogExportRef,
   openCreditsDialog,
 } from '@/utils/credits';
+import type { FetchError } from 'ofetch';
 
 enum ExportTypes {
   CSV = 'csv',
@@ -220,9 +221,6 @@ async function exportTable(
       onResponse({ response }) {
         activeExport.value = false;
 
-        if (response.status === 401) {
-          $consentSidebar.show('google', $profile.value?.email);
-        }
         if (response.status === 402 || response.status === 266) {
           openCreditModel(response.status === 402, response._data);
           return;
@@ -234,17 +232,35 @@ async function exportTable(
             saveFile(response._data, filename, config.mimeType);
           }
 
+          let message;
+          if (contactsToTreat.value === undefined) {
+            message = $t('contacts_exported_successfully.all');
+          } else if (contactsToTreat.value.length === 0) {
+            message = $t('contacts_exported_successfully.none');
+          } else if (contactsToTreat.value.length === 1) {
+            message = $t('contacts_exported_successfully.one');
+          } else
+            message = $t('contacts_exported_successfully.other', {
+              count: contactsToTreat.value.length,
+            });
+
           $toast.add({
             severity: 'success',
             summary: t(config.successSummaryKey),
-            detail: t('contacts_exported_successfully'),
+            detail: message,
             life: 8000,
           });
         }
       },
     });
   } catch (err) {
     activeExport.value = false;
+
+    if ((err as FetchError).response?.status === 401) {
+      $consentSidebar.show('google', $profile.value?.email);
+      return;
+    }
+
     throw err;
   }
 }
@@ -281,23 +297,33 @@ const exportItems = computed(() => [
 {
   "en": {
     "export_csv": "Export as CSV",
-    "export_vcard": "Export as vcard",
-    "export_google_contacts": "Export to google contacts",
-    "confirm_google_export": "Confirm export to google contacts",
+    "export_vcard": "Export as vcards",
+    "export_google_contacts": "Synchronize to Google Contacts",
+    "confirm_google_export": "Confirm export to Google Contacts",
     "google_export_confirmation": "Choose how your contacts should be synced with google contacts.",
     "update_empty_fields": "Update empty fields only",
     "overwrite_all_fields": "Overwrite all fields",
-    "contacts_exported_successfully": "Contacts exported successfully"
+    "contacts_exported_successfully": {
+      "all": "All contacts have been exported successfully",
+      "none": "No contacts exported",
+      "one": "contact exported successfully",
+      "other": "{count} contacts exported successfully"
+    }
   },
   "fr": {
     "export_csv": "Exporter en CSV",
-    "export_vcard": "Exporter en vcard",
+    "export_vcard": "Exporter en vcards",
     "export_google_contacts": "Vers google contacts",
-    "confirm_google_export": "Confirmer l’export vers Google Contacts",
+    "confirm_google_export": "Synchroniser vers Google Contacts",
     "google_export_confirmation": "Choisissez comment vos contacts doivent être synchronisés avec Google Contacts.",
     "update_empty_fields": "Uniquement les champs vides",
     "overwrite_all_fields": "Tous les champs",
-    "contacts_exported_successfully": "Contacts exportés avec succès"
+    "contacts_exported_successfully": {
+      "all": "Tous les contacts ont été exportés avec succès",
+      "none": "Aucun contact exporté",
+      "one": "contact exporté avec succès",
+      "other": "{count} contacts exportés avec succès"
+    }
   }
 }
 </i18n>