This code retrieves and processes a list of events from a user's Google Calendar, handling authorization, date corrections, and pagination.

Run example

npm run import -- "list events"

list events

var importer = require('../Core');
var {
    authorizeCalendar,
    correctTimeLimits,
    correctCalendarId
} = importer.import("authorize google calendar",
"correct dates time",
"lookup calendar name");

function processResult(response, options) {
    var resultEvents = []; // reset the array
    var events = response.data.items;
    if (events.length === 0) {
        const q = Object.assign({}, options);
        delete q.auth;
        console.log('No events found for ' + JSON.stringify(q));
    } else {
        for (var i = 0; i < events.length; i++) {
            var event = events[i];
            var start = event.start.dateTime || event.start.date;
            resultEvents[resultEvents.length] = {
                start: new Date(start), event: event
            };
        }
    }
    return resultEvents;
};


/**
 * Lists the next 10 events on the user's primary calendar.
 *
 * @param {google.auth.OAuth2} auth An authorized OAuth2 client.
 */
function listEvents(options = {calendarId: 'primary'}) {
    let calendar, events = [];
    return authorizeCalendar(options)
        .then(c => calendar = c)
        .then(() => correctTimeLimits(options))
        .then(() => correctCalendarId(options))
        .then(() => {
            var data = Object.assign({}, options, {
                maxResults: 1000,
                singleEvents: true,
                orderBy: 'startTime'
            });
            return new Promise((resolve, reject) => {
                calendar.events.list(data, (err, response) => {
                    if (err) reject(err);
                    try {
                        return resolve(response);
                    } catch (e) {
                        return reject(e);
                    }
                });
            })
        })
        .then(response => {
            events = events.concat(processResult(response, options));
            //console.log(response)
            if(response.data.nextPageToken) {
                console.log('paging ' + response.data.nextPageToken)
                return listEvents(Object.assign({}, options, {pageToken: response.data.nextPageToken}))
                    .then(e => events.concat(e));
            }
            return events;
        })
};
module.exports = listEvents;

// Import necessary modules
const { google } = require('googleapis');
const {
  authorizeCalendar,
  correctTimeLimits,
  correctCalendarId
} = require('../Core');

/**
 * Function to process the result of the calendar API call.
 * 
 * @param {Object} response The response object from the calendar API.
 * @param {Object} options The options object passed to the function.
 * 
 * @returns {Array} An array of events with their start dates.
 */
function processResult(response, options) {
  const resultEvents = response.data.items
   .map(event => ({
      start: new Date(event.start.dateTime || event.start.date),
      event
    }))
   .filter(event => event.event.id); // Filter out events without IDs

  if (resultEvents.length === 0) {
    console.log(`No events found for ${JSON.stringify(options)}`);
  }

  return resultEvents;
}

/**
 * Lists the next 10 events on the user's primary calendar.
 * 
 * @param {Object} options The options object with calendarId and pageToken.
 * 
 * @returns {Promise} A promise that resolves to an array of events.
 */
async function listEvents(options = { calendarId: 'primary' }) {
  // Initialize variables
  let calendar;
  let events = [];

  // Authorize the calendar API
  calendar = await authorizeCalendar(options);

  // Correct the time limits and calendar ID
  await correctTimeLimits(options);
  await correctCalendarId(options);

  // Get the next page of events if necessary
  while (true) {
    // Set up the API request parameters
    const data = Object.assign({}, options, {
      maxResults: 1000,
      singleEvents: true,
      orderBy:'startTime'
    });

    try {
      // Make the API request
      const response = await calendar.events.list(data);

      // Process the events
      events = events.concat(processResult(response, options));

      // If there's a next page, get it
      if (response.data.nextPageToken) {
        options.pageToken = response.data.nextPageToken;
      } else {
        break;
      }
    } catch (error) {
      console.error('Error getting events:', error);
      break;
    }
  }

  return events;
}

module.exports = listEvents;

This code snippet fetches and processes events from a Google Calendar.

Here's a breakdown:

1. Imports:

   • It imports functions for authorizing access to the Google Calendar API, correcting date and time information, and looking up calendar IDs.

2. processResult Function:

   • This function takes the raw response from the Google Calendar API and processes it.
   • It checks if any events were found. If not, it logs a message.
   • If events are found, it iterates through them, extracts the start time, and creates an object containing the start date and the event details.

3. listEvents Function:

   • This function is responsible for fetching events from the user's calendar.
   • It first authorizes access to the calendar using the provided options.
   • Then, it corrects any time limits or calendar IDs based on the provided options.
   • It constructs a request to the Google Calendar API to retrieve the next 1000 events (or all events if fewer than 1000 exist) from the specified calendar.
   • It handles the asynchronous response, processes the events using processResult, and returns the processed events.

Key Points:

• Asynchronous Operations: The code uses promises to handle the asynchronous nature of interacting with the Google Calendar API.
• Error Handling: The code includes basic error handling using try...catch blocks.
• Pagination: The code includes logic to handle pagination if there are more than 1000 events.

Let me know if you have any other code snippets you'd like me to explain!