Sincronizando los cambios de la conferencia del calendario

Los usuarios pueden actualizar o borrar libremente los eventos del Calendario de Google. Si un usuario actualiza un evento después de crear una conferencia para él, es posible que tu complemento deba responder al cambio actualizando los datos de la conferencia. Si tu sistema de conferencias de terceros depende de realizar un seguimiento de los datos del evento, no actualizar la conferencia cuando se produce un cambio de evento puede hacerla inutilizable y dar como resultado una mala experiencia del usuario.

El proceso de mantener actualizados los datos de la conferencia con los cambios en el evento del Calendario de Google se denomina sincronización. Para sincronizar los cambios de eventos, puedes crear un activador instalable de Apps Script que se active cada vez que cambien los eventos en un calendario determinado. Por desgracia, el activador no informa qué eventos se modificaron y no puedes limitarlo a solo los eventos con conferencias que creaste. 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 de sincronización general 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 del 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. Todas las actualizaciones necesarias en las conferencias se realizan mediante solicitudes a la API de terceros.
5. Se almacena un nuevo token de sincronización para que la próxima ejecución del activador solo necesite examinar los cambios más recientes del calendario.

Cómo inicializar la sincronización

Una vez que el complemento haya creado correctamente una conferencia en un sistema de terceros, debería crear un activador instalable que responda a los cambios de eventos en este calendario, si 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, ejecuta la función del activador directamente.

Cómo crear un activador de Calendario

Para sincronizarse, el complemento debe detectar cuándo se cambia un evento del Calendario que tiene una conferencia adjunta. Esto se logra creando un activador instalable EventUpdated. Tu complemento solo necesita un activador para cada calendario y puede crearlos de forma 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 error, el complemento debe comprobar si el activador existe para este usuario y, de lo contrario, no debe crearlo.

Nota: Para crear activadores, se requiere que tu complemento esté autorizado con los niveles de acceso https://www.googleapis.com/auth/calendar.readonly y https://www.googleapis.com/auth/script.scriptapp.

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 de activador que usa tu complemento. Esta función de activador debería 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 tu complemento.

   Cuando la función activadora se ejecuta sin un token de sincronización válido, se retira en una sincronización completa. Las sincronizaciones completas solo intentan recuperar todos los eventos dentro de un período determinado para generar un nuevo token de sincronización válido.

   Precaución: En ocasiones, el servidor invalida los tokens de sincronización, lo que genera un error Sync token is no longer valid. Cuando esto suceda, tu código debería realizar una sincronización completa y reemplazar los tokens de sincronización almacenados.
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 cambió. Según el cambio, puede ser necesario modificar la conferencia asociada. Por ejemplo, si se borró un evento, es probable que el complemento también borre la conferencia.
4. Los cambios necesarios en la conferencia se realizan 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 Calendar.Events.list().

Actualiza el evento del Calendario de Google

En algunos casos, es posible que desees actualizar el evento de Calendario de Google cuando realices una sincronización. Si decides hacerlo, actualiza el evento con la solicitud correcta del servicio avanzado de Calendario de Google. Asegúrate de usar la actualización condicional con un encabezado If-Match. Esto evita que tus cambios reemplacen, de forma inadvertida, los cambios simultáneos que el usuario realizó 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.

  }
}