Sincronizando cambios de la reunión del calendario

Los usuarios pueden actualizar o borrar sus eventos del Calendario de Google libremente. Si un usuario actualiza un evento después de crear una conferencia para este, es posible que tu complemento deba actualizar los datos de la conferencia para responder al cambio. Si tu sistema de conferencias de terceros depende de hacer un seguimiento de los datos del evento, no actualizar la conferencia ante un cambio de evento puede hacer que esta se vuelva inutilizable y dar como resultado una experiencia del usuario deficiente.

El proceso de mantener los datos de la conferencia actualizados con cambios en el evento del Calendario de Google se denomina sincronización. Para sincronizar los cambios de un evento, crea un activador instalable de Apps Script que se activa cada vez que los eventos cambian en un calendario determinado. Lamentablemente, el activador no informa qué eventos cambiaron, y no puedes limitarlo a eventos con conferencias que hayas creado. En su lugar, debes solicitar una lista de todos los cambios realizados en un calendario desde la última sincronización, filtrar la lista de eventos y realizar las actualizaciones según corresponda.

El procedimiento general de sincronización es el siguiente:

  1. La primera vez que un usuario crea una conferencia, se inicializa el proceso de sincronización.
  2. Cada vez que el usuario crea, actualiza o borra uno de sus eventos de Calendario, el activador ejecuta una función de activador en tu proyecto de complemento.
  3. La función activador examina el conjunto de cambios de eventos desde la última sincronización y determina si alguno requiere la actualización de una conferencia de terceros asociada.
  4. Las actualizaciones necesarias se realizan en las conferencias mediante solicitudes a la API de terceros.
  5. Se almacena un token de sincronización nuevo para que la próxima ejecución del activador solo deba examinar los cambios más recientes del calendario.

Inicializa la sincronización

Una vez que el complemento creó correctamente una conferencia en un sistema de terceros, debe crear un activador instalable que responda a los cambios de eventos de este calendario, si el activador aún no existe.

Después de crear el activador, la inicialización debería terminar con la creación del token de sincronización inicial. Para ello, se ejecuta la función activador directamente.

Crea un activador de Calendario

Para sincronizarlo, el complemento debe detectar cuándo se modifica un evento de Calendario que tiene una conferencia adjunta. Esto se logra mediante la creación de un activador instalable EventUpdated. Tu complemento solo necesita un activador para cada calendario y puede crearlos de manera programática.

Un buen momento para crear un activador es cuando el usuario crea su primera conferencia, ya que en ese momento comienza a usar el complemento. Después de crear una conferencia y verificar que no haya errores, tu complemento debe comprobar si existe el activador para este usuario y si no lo creó.

Implementa una función de activador de sincronización

Las funciones de activador se ejecutan cuando Apps Script detecta una condición que provoca que se active un activador. Los activadores de calendario EventUpdated se activan cuando un usuario crea, modifica o borra cualquier evento en un calendario especificado.

Debes implementar la función activadora que usa tu complemento. Esta función de activación debe hacer lo siguiente:

  1. Realiza una llamada Calendar.Events.list() del servicio avanzado de Calendario con un syncToken para recuperar una lista de eventos que cambiaron desde la última sincronización. Cuando usas un token de sincronización, reduces la cantidad de eventos que debe examinar el complemento.

    Cuando la función del activador se ejecuta sin un token de sincronización válido, realiza una retirada para lograr una sincronización completa. Las sincronizaciones completas simplemente intentan recuperar todos los eventos dentro de un período prescrito para generar un token de sincronización nuevo y válido.

  2. Cada evento modificado se examina para determinar si tiene una conferencia de terceros asociada.
  3. Si un evento tiene una conferencia, se examina para ver qué se modificó. Según el cambio, es posible que sea necesario modificar la conferencia asociada. Por ejemplo, si se borró un evento, es probable que el complemento también también deba borrar la conferencia.
  4. Cualquier cambio necesario en la conferencia se realiza mediante llamadas a la API al sistema de terceros.
  5. Después de realizar todos los cambios necesarios, almacena el nextSyncToken que muestra el método Calendar.Events.list(). Este token de sincronización se encuentra en la última página de resultados que muestra la llamada a Calendar.Events.list().

Actualizando el evento de Calendario de Google

En algunos casos, es posible que desees actualizar el evento del Calendario de Google cuando realizas una sincronización. Si decides hacerlo, actualiza el evento con la solicitud de servicio avanzado del Calendario de Google. Asegúrate de usar la actualización condicional con un encabezado If-Match. Esto evita que los cambios anulen por accidente los cambios simultáneos que realizó el usuario en un cliente diferente.

Ejemplo

En el siguiente ejemplo, se muestra cómo puedes configurar la sincronización de los eventos de calendario y sus conferencias asociadas.

/**
 *  Initializes syncing of conference data by creating a sync trigger and
 *  sync token if either does not exist yet.
 *
 *  @param {String} calendarId The ID of the Google Calendar.
 */
function initializeSyncing(calendarId) {
  // Create a syncing trigger if it doesn't exist yet.
  createSyncTrigger(calendarId);

  // Perform an event sync to create the initial sync token.
  syncEvents({'calendarId': calendarId});
}

/**
 *  Creates a sync trigger if it does not exist yet.
 *
 *  @param {String} calendarId The ID of the Google Calendar.
 */
function createSyncTrigger(calendarId) {
  // Check to see if the trigger already exists; if does, return.
  var allTriggers = ScriptApp.getProjectTriggers();
  for (var i = 0; i < allTriggers.length; i++) {
    var trigger = allTriggers[i];
    if (trigger.getTriggerSourceId() == calendarId) {
      return;
    }
  }

  // Trigger does not exist, so create it. The trigger calls the
  // 'syncEvents()' trigger function when it fires.
  var trigger = ScriptApp.newTrigger('syncEvents')
      .forUserCalendar(calendarId)
      .onEventUpdated()
      .create();
}

/**
 *  Sync events for the given calendar; this is the syncing trigger
 *  function. If a sync token already exists, this retrieves all events
 *  that have been modified since the last sync, then checks each to see
 *  if an associated conference needs to be updated and makes any required
 *  changes. If the sync token does not exist or is invalid, this
 *  retrieves future events modified in the last 24 hours instead. In
 *  either case, a new sync token is created and stored.
 *
 *  @param {Object} e If called by a event updated trigger, this object
 *      contains the Google Calendar ID, authorization mode, and
 *      calling trigger ID. Only the calendar ID is actually used here,
 *      however.
 */
function syncEvents(e) {
  var calendarId = e.calendarId;
  var properties = PropertiesService.getUserProperties();
  var syncToken = properties.getProperty('syncToken');

  var options;
  if (syncToken) {
    // There's an existing sync token, so configure the following event
    // retrieval request to only get events that have been modified
    // since the last sync.
    options = {
      syncToken: syncToken
    };
  } else {
    // No sync token, so configure to do a 'full' sync instead. In this
    // example only recently updated events are retrieved in a full sync.
    // A larger time window can be examined during a full sync, but this
    // slows down the script execution. Consider the trade-offs while
    // designing your add-on.
    var now = new Date();
    var yesterday = new Date();
    yesterday.setDate(now.getDate() - 1);
    options = {
      timeMin: now.toISOString(),          // Events that start after now...
      updatedMin: yesterday.toISOString(), // ...and were modified recently
      maxResults: 50,   // Max. number of results per page of responses
      orderBy: 'updated'
    }
  }

  // Examine the list of updated events since last sync (or all events
  // modified after yesterday if the sync token is missing or invalid), and
  // update any associated conferences as required.
  var events;
  var pageToken;
  do {
    try {
      options.pageToken = pageToken;
      events = Calendar.Events.list(calendarId, options);
    } catch (err) {
      // Check to see if the sync token was invalidated by the server;
      // if so, perform a full sync instead.
      if (err.message ===
            "Sync token is no longer valid, a full sync is required.") {
        properties.deleteProperty('syncToken');
        syncEvents(e);
        return;
      } else {
        throw new Error(err.message);
      }
    }

    // Read through the list of returned events looking for conferences
    // to update.
    if (events.items && events.items.length > 0) {
      for (var i = 0; i < events.items.length; i++) {
         var calEvent = events.items[i];
         // Check to see if there is a record of this event has a
         // conference that needs updating.
         if (eventHasConference(calEvent)) {
           updateConference(calEvent, calEvent.conferenceData.conferenceId);
         }
      }
    }

    pageToken = events.nextPageToken;
  } while (pageToken);

  // Record the new sync token.
  if (events.nextSyncToken) {
    properties.setProperty('syncToken', events.nextSyncToken);
  }
}

/**
 *  Returns true if the specified event has an associated conference
 *  of the type managed by this add-on; retuns false otherwise.
 *
 *  @param {Object} calEvent The Google Calendar event object, as defined by
 *      the Calendar API.
 *  @return {boolean}
 */
function eventHasConference(calEvent) {
  var name = calEvent.conferenceData.conferenceSolution.name || null;

  // This version checks if the conference data solution name matches the
  // one of the solution names used by the add-on. Alternatively you could
  // check the solution's entry point URIs or other solution-specific
  // information.
  if (name) {
    if (name === "My Web Conference" ||
        name === "My Recorded Web Conference") {
      return true;
    }
  }
  return false;
}

/**
 *  Update a conference based on new Google Calendar event information.
 *  The exact implementation of this function is highly dependant on the
 *  details of the third-party conferencing system, so only a rough outline
 *  is shown here.
 *
 *  @param {Object} calEvent The Google Calendar event object, as defined by
 *      the Calendar API.
 *  @param {String} conferenceId The ID used to identify the conference on
 *      the third-party conferencing system.
 */
function updateConference(calEvent, conferenceId) {
  // Check edge case: the event was cancelled
  if (calEvent.status === 'cancelled' || eventHasConference(calEvent)) {
    // Use the third-party API to delete the conference too.


  } else {
    // Extract any necessary information from the event object, then
    // make the appropriate third-party API requests to update the
    // conference with that information.

  }
}