Synchronisation des modifications apportées aux conférences de l'agenda

Les utilisateurs peuvent librement mettre à jour ou supprimer leurs événements Google Agenda. Si un utilisateur met à jour un événement après la création d'une conférence pour celui-ci, votre module complémentaire devra peut-être répondre au changement en mettant à jour les données de la conférence. Si votre le système de conférence tiers dépend du suivi des données d’événement, l'échec de la mise à jour de la conférence sur un changement d'événement peut afficher la conférence et nuit à l'expérience utilisateur.

Processus consistant à mettre à jour les données de la conférence en fonction des modifications apportées à la Cet événement Google Agenda s'appelle la synchronisation. Vous pouvez synchroniser les modifications apportées aux événements création d'un script Apps Script déclencheur installable qui se déclenche chaque fois que des événements changent dans un agenda donné. Malheureusement, le déclencheur ne signaler les événements modifiés et vous ne pouvez pas limiter cette fonctionnalité aux seuls événements conférences que vous avez créées. Au lieu de cela, vous devez demander une liste de toutes les modifications apportées à un agenda depuis la dernière synchronisation, filtrez par la liste des événements, et apportez les modifications nécessaires.

La procédure générale de synchronisation est la suivante:

1. La première fois qu'un utilisateur crée une conférence, le processus de synchronisation est initialisé.
2. Chaque fois que l'utilisateur crée, met à jour ou supprime l'un de ses événements d'agenda. le déclencheur exécute une fonction de déclencheur dans votre projet complémentaire.
3. La fonction du déclencheur examine l'ensemble des modifications d'événements depuis la dernière et détermine si un tiers associé doit être mis à jour conférence.
4. Les mises à jour requises sont ensuite apportées aux conférences via des Requêtes API.
5. Un nouveau jeton de synchronisation est stocké de sorte que l'exécution du déclencheur suivant n'ait plus qu'à examiner les dernières modifications apportées au calendrier.

Initialiser la synchronisation

Une fois que le module complémentaire a créé une conférence sur un système tiers, un déclencheur installable doit être créé. qui répond à modifications des événements dans cet agenda, si le déclencheur n'existe pas déjà.

Une fois le déclencheur créé, l'initialisation doit se terminer en créant le déclencheur et le jeton de synchronisation. Pour ce faire, vous devez exécuter directement la fonction de déclencheur.

Créer un déclencheur Agenda

Pour effectuer la synchronisation, votre module complémentaire doit détecter les événements d'agenda associés à conférence est modifié. Pour ce faire, créez un EventUpdated. déclencheur installable. Votre module complémentaire un seul déclencheur pour chaque agenda et vous pouvez les créer par programmation.

Un bon moment pour créer un déclencheur est lorsque l'utilisateur crée sa première conférence, car à ce moment-là, l’utilisateur commence à utiliser le module complémentaire. Après création d'une conférence et en vérifiant qu'il n'y a pas d'erreur, le module complémentaire doit vérifier pour cet utilisateur. Si ce n'est pas le cas, créez-le.

Implémenter une fonction de déclencheur de synchronisation

Les fonctions de déclenchement sont exécutées lorsqu'Apps Script détecte une condition qui provoque un déclencheur. EventUpdated déclencheurs d'agenda se déclencher lorsqu'un utilisateur crée, modifie ou supprime un événement dans un événement Google Agenda.

Vous devez implémenter la fonction de déclencheur utilisée par votre module complémentaire. Cette fonction de déclencheur doit procéder comme suit:

1. Passez un appel au service avancé d'Agenda Calendar.Events.list() à l'aide d'un syncToken pour récupérer la liste des événements qui ont été modifiés depuis le dernier synchroniser. L'utilisation d'un jeton de synchronisation vous permet de réduire le nombre d'événements que votre module complémentaire devez examiner.

   Lorsque la fonction de déclencheur s'exécute sans jeton de synchronisation valide, elle sauvegarde pour effectuer une synchronisation complète. Les synchronisations complètes tentent simplement de récupérer tous les événements. dans un délai imparti afin de générer une nouvelle synchronisation valide. à partir d'un jeton d'accès.

2. Chaque événement modifié est examiné pour déterminer s'il est associé à conférence tierce.
3. Si un événement inclut une conférence, il est examiné pour identifier ce qui a été modifié. En fonction des changements, les modifications apportées à la conférence associée peuvent si nécessaire. Par exemple, si un événement a été supprimé, le module complémentaire probablement supprimer la conférence également.
4. Pour apporter les modifications nécessaires à la conférence, vous devez appeler l'API système tiers.
5. Après avoir effectué toutes les modifications nécessaires, stockez le nextSyncToken renvoyé par la méthode Calendar.Events.list(). Ce jeton de synchronisation se trouve sur la dernière page de résultats renvoyée par l'appel Calendar.Events.list().

Mise à jour de l'événement Google Agenda...

Dans certains cas, vous souhaiterez peut-être mettre à jour l'événement Google Agenda lors de l'exécution une synchronisation. Si vous choisissez de le faire, mettez à jour l'événement avec les Service avancé Google Agenda requête. Veillez à utiliser mise à jour conditionnelle avec un en-tête If-Match. Cela permet d'éviter que les modifications apportées par inadvertance écraser les modifications simultanées apportées par l'utilisateur dans un autre client.

Exemple

L'exemple suivant montre comment configurer la synchronisation des événements d'agenda et les conférences associées.

/**
 *  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.

  }
}