This code analyzes a user's Google Contacts to categorize them based on their membership in various contact groups, determining both contact frequency and group affiliations.

Run example

npm run import -- "google contact settings"

google contact settings

var google = require('googleapis');
var people = google.people('v1');
var importer = require('../Core');
var getContacts = importer.import("list google contacts");
var getOauthClient = importer.import("import google calendar api");

var options = {
    scopes: [
        'https://www.googleapis.com/auth/contacts'
    ]
};

function googlePromise(func) {
    return new Promise((resolve, reject) => func((err, response) => {
        if (err) reject(err);
        try {
        } catch (e) {
            reject(e);
        }
        setTimeout(() => resolve(response), 100);
    })).catch(e => console.log(e));
};

function mapMembership(memberships) {
    return {
        'frequency': ((memberships.filter(m => m.contactGroupMembership.contactGroupLabel === 'Weekly'
                                        ||  m.contactGroupMembership.contactGroupLabel === 'Yearly'
                                        ||  m.contactGroupMembership.contactGroupLabel === 'Monthly')[0] || {})
            .contactGroupMembership || {}).contactGroupLabel,
        'circles': memberships.filter(m => m.contactGroupMembership.contactGroupLabel === 'YouTube'
                                        || m.contactGroupMembership.contactGroupLabel === 'Coworkers'
                                        || m.contactGroupMembership.contactGroupLabel === 'Family'
                                        || m.contactGroupMembership.contactGroupLabel === 'friends'
                                        || m.contactGroupMembership.contactGroupLabel === 'Recruiters'
                                        || m.contactGroupMembership.contactGroupLabel === 'E-Level'
                                        || m.contactGroupMembership.contactGroupLabel === 'A-Level'
                                        || m.contactGroupMembership.contactGroupLabel === 'C-Level'
                                        || m.contactGroupMembership.contactGroupLabel === 'Inner Circle'
                                        || m.contactGroupMembership.contactGroupLabel === 'Outer Circle')
            .map(c => c.contactGroupMembership.contactGroupLabel),
        'preferred': memberships.filter(m => m.contactGroupMembership.contactGroupLabel === 'LinkedIn'
                                        || m.contactGroupMembership.contactGroupLabel === 'Facebook'
                                        || m.contactGroupMembership.contactGroupLabel === 'Email'
                                        || m.contactGroupMembership.contactGroupLabel === 'Mobile'
                                        || m.contactGroupMembership.contactGroupLabel === 'Skype'
                                        || m.contactGroupMembership.contactGroupLabel === 'Slack')
            .map(c => c.contactGroupMembership.contactGroupLabel)
    }
}

function getSettings(name) {
    var groups;
    console.log('Searching for settings: ' + name);
    return getOauthClient(options)
        .then(() => googlePromise(
            people.contactGroups.list.bind(people.contactGroups.list, {
                auth: options.auth,
                pageToken: options.pageToken
            })).catch(e => console.log(e)))
        .then(g => groups = g.contactGroups)
        .then(() => {
            const options = {};
            if(name.indexOf('@') > -1) {
                options.emailAddress = name.split(/\s/).join('.*');
            } else {
                options.displayName = name.split(/\s/).join('.*');
            }
            return getContacts(options);
        })
        .then(contacts => contacts.map(c => {
            return Object.assign(c, {
                memberships: c.memberships.map(m => Object.assign(m, {
                    contactGroupMembership: Object.assign(m.contactGroupMembership, {
                        contactGroupLabel: (groups.filter(g => (g.resourceName || '').indexOf(m.contactGroupMembership.contactGroupId) > -1)[0] || {}).name
                    })
                }))
            });
        }))
        .then(contacts => mapMembership(contacts[0].memberships))
        .catch(e => console.log(e))
}
module.exports = getSettings;

const { google } = require('googleapis');
const { PeopleService } = google.people('v1');
const Core = require('../Core');

const getContacts = Core.import('list google contacts');
const getOauthClient = Core.import('import google calendar api');

class GoogleAPI {
  constructor(options) {
    this.people = new PeopleService();
    this.options = options;
  }

  async getSettings(name) {
    try {
      const groups = await this.getContactGroups();
      const contact = await this.getContact(name, groups);
      const memberships = contact.memberships.map(m => {
        const groupLabel = groups.find(g => g.resourceName && g.resourceName.includes(m.contactGroupMembership.contactGroupId)).name;
        return {...m, contactGroupMembership: {...m.contactGroupMembership, contactGroupLabel } };
      });
      const { frequency, circles, preferred } = this.mapMembership(memberships);
      return { frequency, circles, preferred };
    } catch (error) {
      console.error(error);
      throw error;
    }
  }

  async getContactGroups() {
    const auth = await getOauthClient(this.options);
    const { data } = await this.getGooglePromise(
      () => this.people.contactGroups.list({
        auth: auth,
        pageToken: this.options.pageToken
      })
    ).catch(error => console.error(error));
    return data.contactGroups;
  }

  async getContact(name, groups) {
    const options = {};
    if (name.indexOf('@') > -1) {
      options.emailAddress = name.split(/\s/).join('.*');
    } else {
      options.displayName = name.split(/\s/).join('.*');
    }
    const contacts = await getContacts(options);
    return contacts.map(c => Object.assign(c, {
      memberships: c.memberships.map(m => Object.assign(m, {
        contactGroupMembership: Object.assign(m.contactGroupMembership, {
          contactGroupLabel: groups.find(g => g.resourceName && g.resourceName.includes(m.contactGroupMembership.contactGroupId)).name
        })
      }))
    }));
  }

  async getGooglePromise(func) {
    return new Promise((resolve, reject) => {
      func((err, response) => {
        if (err) reject(err);
        try {
          resolve(response.data);
        } catch (error) {
          reject(error);
        }
      });
    }).catch(error => console.error(error));
  }

  mapMembership(memberships) {
    const frequency = memberships.find(m => ['Weekly', 'Yearly', 'Monthly'].includes(m.contactGroupMembership.contactGroupLabel)).contactGroupMembership.contactGroupLabel;
    const circles = memberships.filter(m => ['YouTube', 'Coworkers', 'Family', 'friends', 'Recruiters', 'E-Level', 'A-Level', 'C-Level', 'Inner Circle', 'Outer Circle'].includes(m.contactGroupMembership.contactGroupLabel)).map(c => c.contactGroupMembership.contactGroupLabel);
    const preferred = memberships.filter(m => ['LinkedIn', 'Facebook', 'Email', 'Mobile', 'Skype', 'Slack'].includes(m.contactGroupMembership.contactGroupLabel)).map(c => c.contactGroupMembership.contactGroupLabel);
    return { frequency, circles, preferred };
  }
}

module.exports = (options) => new GoogleAPI(options);

This code snippet retrieves a user's Google Contacts and analyzes their membership in various contact groups to categorize them.

Here's a breakdown:

1. Imports:

   • Imports modules for interacting with the Google People API and custom modules for listing contacts and handling OAuth authentication.

2. Configuration:

   • Defines options for Google API authentication, specifying the required scope.

3. googlePromise Function:

   • Wraps a function call to the Google API within a promise, handling potential errors and adding a short delay before resolving.

4. mapMembership Function:

   • Takes an array of contact group memberships and extracts information about the user's frequency of contact (weekly, monthly, yearly) and categorizes them into predefined circles (e.g., YouTube, Coworkers, Family).

Purpose:

This code likely serves as part of a system that analyzes user relationships based on their Google Contacts. It retrieves contact group memberships and categorizes contacts based on their frequency and group affiliations.