Créer des événements

Imaginez une application qui aide les utilisateurs à trouver les meilleurs itinéraires de randonnée. En ajoutant le plan de randonnée comme événement d'agenda, les utilisateurs sont automatiquement mieux organisés. Google Agenda les aide à partager le plan et leur envoie des rappels pour qu'ils puissent se préparer sans stress. De plus, grâce à l'intégration parfaite des produits Google, Google Now leur indique quand partir et Google Maps les guide jusqu'au lieu de rendez-vous à l'heure.

Cet article explique comment créer des événements d'agenda et les ajouter aux agendas de vos utilisateurs.

Ajouter un événement

Pour créer un événement, appelez la events.insert() méthode en fournissant au moins les paramètres suivants :

• calendarId est l'identifiant de l'agenda. Il peut s'agir de l'adresse e-mail de l'agenda dans lequel créer l'événement ou du mot clé spécial 'primary' qui utilise l'agenda principal de l'utilisateur connecté. Si vous ne connaissez pas l'adresse e-mail de l'agenda que vous souhaitez utiliser, vous pouvez la consulter dans les paramètres de l'agenda de l'interface utilisateur Web de Google Agenda (dans la section "Adresse de l'agenda") ou la rechercher dans le résultat de l' calendarList.list() appel.
• event est l'événement à créer avec tous les détails nécessaires, tels que le début et la fin. Les deux seuls champs obligatoires sont les heures de start et de end. Consultez la event documentation de référence pour obtenir l'ensemble des champs d'événement.
  Spécifiez les événements programmés à l'aide des champs start.dateTime et end.dateTime. Pour les événements qui durent toute la journée, utilisez plutôt start.date et end.date.

Pour créer des événements, vous devez :

• définir votre champ d'application OAuth sur https://www.googleapis.com/auth/calendar afin de disposer d'un accès en modification à l'agenda de l'utilisateur ;
• vous assurer que l'utilisateur authentifié dispose d'un accès en écriture à l'agenda avec le calendarId que vous avez fourni (par exemple, en appelant calendarList.get() pour le calendarId et en vérifiant le accessRole).

Ajouter des métadonnées d'événement

Vous pouvez éventuellement ajouter des métadonnées d'événement lorsque vous créez un événement d'agenda. Si vous choisissez de ne pas ajouter de métadonnées lors de la création, vous pouvez mettre à jour de nombreux champs à l'aide de events.update(). Toutefois, certains champs, tels que l'ID d'événement, ne peuvent être définis que lors d'une opération events.insert().

Emplacement

L'ajout d'une adresse dans le champ de l'emplacement active des fonctionnalités telles que "Heure de départ" ou l'affichage d'une carte avec l'itinéraire.

ID de l'événement

Lorsque vous créez un événement, vous pouvez choisir de générer votre propre ID d'événement conforme à nos exigences de format. Cela vous permet de synchroniser les entités de votre base de données locale avec les événements de Google Agenda. Cela empêche également la création d'événements en double si l'opération échoue à un moment donné après son exécution réussie dans le backend Agenda. Si aucun ID d'événement n'est fourni, le serveur en génère un pour vous. Pour en savoir plus, consultez la documentation de référence sur l'ID d'événement.

Participants

L'événement que vous créez s'affiche dans tous les agendas Google principaux des participants que vous avez inclus avec le même ID d'événement. Si vous définissez sendUpdates sur "all" ou "externalOnly" dans votre requête d'insertion, les participants correspondants reçoivent une notification par e-mail pour votre événement. Pour en savoir plus, consultez la section Événements avec plusieurs participants.

Les exemples suivants montrent comment créer un événement et définir ses métadonnées :

Go

// Refer to the Go quickstart on how to setup the environment:
// https://developers.google.com/workspace/calendar/quickstart/go
// Change the scope to calendar.CalendarScope and delete any stored credentials.

event := &calendar.Event{
  Summary: "Google I/O 2015",
  Location: "800 Howard St., San Francisco, CA 94103",
  Description: "A chance to hear more about Google's developer products.",
  Start: &calendar.EventDateTime{
    DateTime: "2015-05-28T09:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  End: &calendar.EventDateTime{
    DateTime: "2015-05-28T17:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  Recurrence: []string{"RRULE:FREQ=DAILY;COUNT=2"},
  Attendees: []*calendar.EventAttendee{
    &calendar.EventAttendee{Email:"[e-mail]"},
    &calendar.EventAttendee{Email:"[e-mail]"},
  },
}

calendarId := "primary"
event, err = srv.Events.Insert(calendarId, event).Do()
if err != nil {
  log.Fatalf("Unable to create event. %v\n", err)
}
fmt.Printf("Event created: %s\n", event.HtmlLink)

Java

// Refer to the Java quickstart on how to setup the environment:
// https://developers.google.com/workspace/calendar/quickstart/java
// Change the scope to CalendarScopes.CALENDAR and delete any stored
// credentials.

Event event = new Event()
    .setSummary("Google I/O 2015")
    .setLocation("800 Howard St., San Francisco, CA 94103")
    .setDescription("A chance to hear more about Google's developer products.");

DateTime startDateTime = new DateTime("2015-05-28T09:00:00-07:00");
EventDateTime start = new EventDateTime()
    .setDateTime(startDateTime)
    .setTimeZone("America/Los_Angeles");
event.setStart(start);

DateTime endDateTime = new DateTime("2015-05-28T17:00:00-07:00");
EventDateTime end = new EventDateTime()
    .setDateTime(endDateTime)
    .setTimeZone("America/Los_Angeles");
event.setEnd(end);

String[] recurrence = new String[] {"RRULE:FREQ=DAILY;COUNT=2"};
event.setRecurrence(Arrays.asList(recurrence));

EventAttendee[] attendees = new EventAttendee[] {
    new EventAttendee().setEmail("[e-mail]"),
    new EventAttendee().setEmail("[e-mail]"),
};
event.setAttendees(Arrays.asList(attendees));

EventReminder[] reminderOverrides = new EventReminder[] {
    new EventReminder().setMethod("email").setMinutes(24 * 60),
    new EventReminder().setMethod("popup").setMinutes(10),
};
Event.Reminders reminders = new Event.Reminders()
    .setUseDefault(false)
    .setOverrides(Arrays.asList(reminderOverrides));
event.setReminders(reminders);

String calendarId = "primary";
event = service.events().insert(calendarId, event).execute();
System.out.printf("Event created: %s\n", event.getHtmlLink());

JavaScript

// Refer to the JavaScript quickstart on how to setup the environment:
// https://developers.google.com/workspace/calendar/quickstart/js
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'}
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10}
    ]
  }
};

const request = gapi.client.calendar.events.insert({
  'calendarId': 'primary',
  'resource': event
});

request.execute(function(event) {
  appendPre('Event created: ' + event.htmlLink);
});

Node.js

// Refer to the Node.js quickstart on how to setup the environment:
// https://developers.google.com/workspace/calendar/quickstart/node
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
};

calendar.events.insert({
  auth: auth,
  calendarId: 'primary',
  resource: event,
}, function(err, event) {
  if (err) {
    console.log('There was an error contacting the Calendar service: ' + err);
    return;
  }
  console.log('Event created: %s', event.htmlLink);
});

PHP

$event = new Google_Service_Calendar_Event(array(
  'summary' => 'Google I/O 2015',
  'location' => '800 Howard St., San Francisco, CA 94103',
  'description' => 'A chance to hear more about Google\'s developer products.',
  'start' => array(
    'dateTime' => '2015-05-28T09:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'end' => array(
    'dateTime' => '2015-05-28T17:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'recurrence' => array(
    'RRULE:FREQ=DAILY;COUNT=2'
  ),
  'attendees' => array(
    array('email' => '[e-mail]'),
    array('email' => '[e-mail]'),
  ),
  'reminders' => array(
    'useDefault' => FALSE,
    'overrides' => array(
      array('method' => 'email', 'minutes' => 24 * 60),
      array('method' => 'popup', 'minutes' => 10),
    ),
  ),
));

$calendarId = 'primary';
$event = $service->events->insert($calendarId, $event);
printf('Event created: %s\n', $event->htmlLink);

Python

# Refer to the Python quickstart on how to setup the environment:
# https://developers.google.com/workspace/calendar/quickstart/python
# Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
# stored credentials.

event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': False,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
}

event = service.events().insert(calendarId='primary', body=event).execute()
print 'Event created: %s' % (event.get('htmlLink'))

Ruby

event = Google::Apis::CalendarV3::Event.new(
  summary: 'Google I/O 2015',
  location: '800 Howard St., San Francisco, CA 94103',
  description: 'A chance to hear more about Google\'s developer products.',
  start: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T09:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  end: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T17:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  recurrence: [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  attendees: [
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    )
  ],
  reminders: Google::Apis::CalendarV3::Event::Reminders.new(
    use_default: false,
    overrides: [
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'email',
        minutes: 24 * 60
      ),
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'popup',
        minutes: 10
      )
    ]
  )
)

result = client.insert_event('primary', event)
puts "Event created: #{result.html_link}"

Ajouter des pièces jointes Drive aux événements

Vous pouvez joindre des fichiers Google Drive tels que des notes de réunion dans Docs, des budgets dans Sheets, des présentations dans Slides ou tout autre fichier Google Drive pertinent à vos événements d'agenda. Vous pouvez ajouter la pièce jointe lorsque vous créez un événement avec events.insert() ou ultérieurement dans le cadre d'une mise à jour, par exemple avec events.patch()

Pour joindre un fichier Google Drive à un événement, vous devez effectuer les deux étapes suivantes :

1. Obtenez l'URL du fichier alternateLink, title et mimeType à partir de la ressource Fichiers de l'API Drive , généralement avec la méthode files.get().
2. Créez ou mettez à jour un événement avec les champs attachments définis dans le corps de la requête et le paramètre supportsAttachments défini sur true.

L'exemple de code suivant montre comment mettre à jour un événement existant pour ajouter une pièce jointe :

Java

public static void addAttachment(Calendar calendarService, Drive driveService, String calendarId,
    String eventId, String fileId) throws IOException {
  File file = driveService.files().get(fileId).execute();
  Event event = calendarService.events().get(calendarId, eventId).execute();

  List<EventAttachment> attachments = event.getAttachments();
  if (attachments == null) {
    attachments = new ArrayList<EventAttachment>();
  }
  attachments.add(new EventAttachment()
      .setFileUrl(file.getAlternateLink())
      .setMimeType(file.getMimeType())
      .setTitle(file.getTitle()));

  Event changes = new Event()
      .setAttachments(attachments);
  calendarService.events().patch(calendarId, eventId, changes)
      .setSupportsAttachments(true)
      .execute();
}

PHP

function addAttachment($calendarService, $driveService, $calendarId, $eventId, $fileId) {
  $file = $driveService->files->get($fileId);
  $event = $calendarService->events->get($calendarId, $eventId);
  $attachments = $event->attachments;

  $attachments[] = array(
    'fileUrl' => $file->alternateLink,
    'mimeType' => $file->mimeType,
    'title' => $file->title
  );
  $changes = new Google_Service_Calendar_Event(array(
    'attachments' => $attachments
  ));

  $calendarService->events->patch($calendarId, $eventId, $changes, array(
    'supportsAttachments' => TRUE
  ));
}

Python

def add_attachment(calendarService, driveService, calendarId, eventId, fileId):
    file = driveService.files().get(fileId=fileId).execute()
    event = calendarService.events().get(calendarId=calendarId,
                                         eventId=eventId).execute()

    attachments = event.get('attachments', [])
    attachments.append({
        'fileUrl': file['alternateLink'],
        'mimeType': file['mimeType'],
        'title': file['title']
    })

    changes = {
        'attachments': attachments
    }
    calendarService.events().patch(calendarId=calendarId, eventId=eventId,
                                   body=changes,
                                   supportsAttachments=True).execute()

Important : Vous devez effectuer une synchronisation complète de tous les événements avant d’activer le paramètre supportsAttachments pour les modifications d’événements lorsque vous ajoutez la prise en charge des pièces jointes à votre application existante qui stocke les événements localement. Si vous n'effectuez pas de synchronisation au préalable, vous risquez de supprimer par inadvertance des pièces jointes existantes des événements des utilisateurs.

Ajouter des visioconférences et des conférences téléphoniques aux événements

Vous pouvez associer des événements à des conférences Hangouts et Google Meet pour permettre à vos utilisateurs de se réunir à distance par appel téléphonique ou appel vidéo.

Le champ conferenceData peut être utilisé pour lire, copier et effacer les détails de conférence existants. Il peut également être utilisé pour demander la génération de nouvelles conférences. Pour autoriser la création et la modification des détails de conférence, définissez le paramètre de requête conferenceDataVersion sur 1.

Trois types de conferenceData sont actuellement compatibles, comme indiqué par les conferenceData.conferenceSolution.key.type :

1. Hangouts pour les consommateurs (eventHangout)
2. Version classique de Hangouts pour les utilisateurs Google Workspace (obsolète ; eventNamedHangout)
3. Google Meet (hangoutsMeet)

Vous pouvez savoir quel type de conférence est compatible avec un agenda donné d'un utilisateur en examinant les conferenceProperties.allowedConferenceSolutionTypes dans les collections calendars et calendarList. Vous pouvez également déterminer si l'utilisateur préfère que Hangouts soit créé pour tous ses événements nouvellement créés en vérifiant le paramètre autoAddHangouts dans la settings collection.

Outre le type, le conferenceSolution fournit également les champs name et iconUri que vous pouvez utiliser pour représenter la solution de conférence, comme illustré ci-dessous :

JavaScript

const solution = event.conferenceData.conferenceSolution;

const content = document.getElementById("content");
const text = document.createTextNode("Join " + solution.name);
const icon = document.createElement("img");
icon.src = solution.iconUri;

content.appendChild(icon);
content.appendChild(text);

Vous pouvez créer une conférence pour un événement en fournissant une createRequest avec un requestId nouvellement généré, qui peut être une string aléatoire. Les conférences sont créées de manière asynchrone, mais vous pouvez toujours vérifier l'état de votre requête pour informer vos utilisateurs de ce qui se passe.

Par exemple, pour demander la génération d'une conférence pour un événement existant :

JavaScript

const eventPatch = {
  conferenceData: {
    createRequest: {requestId: "7qxalsvy0e"}
  }
};

gapi.client.calendar.events.patch({
  calendarId: "primary",
  eventId: "7cbh8rpc10lrc0ckih9tafss99",
  resource: eventPatch,
  sendUpdates: "all",
  conferenceDataVersion: 1
}).execute(function(event) {
  console.log("Conference created for event: %s", event.htmlLink);
});

La réponse immédiate à cet appel peut ne pas encore contenir le conferenceData entièrement renseigné. Cela est indiqué par un code d'état pending dans le champ d'état . Le code d'état passe à success une fois les informations de la conférence renseignées. Le champ entryPoints contient des informations sur les URI vidéo et téléphoniques que vos utilisateurs peuvent utiliser pour participer par téléphone.

Si vous souhaitez planifier plusieurs événements d'agenda avec les mêmes détails de conférence, vous pouvez copier l'intégralité de conferenceData d'un événement à un autre.

La copie est utile dans certaines situations. Par exemple, supposons que vous développiez une application de recrutement qui configure des événements distincts pour le candidat et l'interviewer. Vous souhaitez protéger l'identité de l'interviewer, mais vous voulez également vous assurer que tous les participants rejoignent la même conférence téléphonique.

Important : Vous devez effectuer une synchronisation complète de tous les événements avant d'activer la prise en charge des données de conférence (en définissant le paramètre de requête conferenceDataVersion sur 1 pour les modifications d'événements) lorsque vous ajoutez la prise en charge des conférences à votre application existante qui stocke les événements localement. Si vous n'effectuez pas de synchronisation au préalable, vous risquez de supprimer par inadvertance des conférences existantes des événements des utilisateurs.