Créer des événements

Imaginez une application qui aide les utilisateurs à trouver les meilleurs itinéraires de randonnée. En ajoutant le paramètre un plan de randonnée en tant qu'événement d'agenda, les utilisateurs obtiennent beaucoup d'aide pour rester organisées automatiquement. Google Agenda les aide à partager le plan et le rappelle à ce sujet afin qu'il puisse se préparer sans stress. De plus, grâce à intégration parfaite des produits Google, Google Now les pingue pour leur indiquer le moment partir et Google Maps le dirigera vers le lieu du rendez-vous à l'heure.

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

Ajouter un événement

Pour créer un événement, appelez la méthode La méthode events.insert() fournit au moins ces paramètres:

• calendarId est l'identifiant de l'agenda. Il peut s'agir de l'adresse e-mail correspondante du calendrier sur lequel créer l'événement ou un mot clé spécial 'primary', qui utilisera l'agenda principal de l'utilisateur connecté. Si vous ne connaissez pas l'adresse e-mail de l'agenda que vous souhaitez utiliser, pouvez le vérifier dans les paramètres de Google Agenda sur le Web dans l'interface utilisateur (dans la section "Adresse URL de l'agenda") dans le résultat Appel calendarList.list().
• event est l'événement à créer avec tous les détails nécessaires, tels que "start" (début) et à la fin. Les deux seuls champs obligatoires sont les champs start et end. Consultez le Documentation de référence sur event pour l'ensemble complet des événements .
  Spécifier des événements chronométrés à l'aide de start.dateTime et end.dateTime. Pour les événements d'une journée entière, utilisez start.date et end.date à la place.

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

• Définissez le champ d'application OAuth sur https://www.googleapis.com/auth/calendar pour que vous êtes autorisé à modifier l'agenda de l'utilisateur.
• Assurez-vous 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 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 la propriété events.update(); mais certains champs, l'ID de l'événement, par exemple, ne peuvent être définis Opération events.insert().

Lieu

L'ajout d'une adresse dans le champ "Emplacement" permet d'utiliser des fonctionnalités telles que

"il est l'heure de partir" ou afficher une carte contenant 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

qui respecte nos exigences de format. Cela vous permet de conserver des entités de votre base de données locale à l'aide des événements de Google Agenda. Il y a aussi empêche la création d'événements en double si l'opération échoue après il s'exécute correctement dans le backend d'Agenda. Si non si un ID d'événement est fourni, le serveur en génère un pour vous. Voir l'ID de l'événement référence.

Participants

L'événement que vous créez apparaît dans tous les agendas Google principaux de

les participants que vous avez inclus avec le même ID d'événement. Si vous définissez sendNotifications à true sur votre demande d'insertion, les participants également recevoir une notification par e-mail pour votre événement. Voir les événements avec guide de plusieurs participants plus d'informations.

Les exemples suivants illustrent la création d'un événement et la définition de ses métadonnées:

Go

// Refer to the Go quickstart on how to setup the environment:
// https://developers.google.com/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/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/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/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/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 à des événements

Vous pouvez joindre Google Drive des fichiers comme les notes de réunion dans Docs, les budgets dans des feuilles de calcul, des présentations dans Slides les fichiers Google Drive pertinents pour vos événements d'agenda. Vous pouvez ajouter lorsque vous créez un événement avec events.insert() ou version ultérieure dans le cadre d'une mise à jour (events.patch(), par exemple)

L'ajout d'un fichier Google Drive à un événement se fait en deux étapes:

1. Récupérez l'URL alternateLink du fichier, title et mimeType à partir de la ressource des fichiers de l'API Drive, généralement avec la méthode files.get().
2. Créer ou mettre à jour un événement avec les champs attachments définis dans 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 l'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 l'activation du paramètre supportsAttachments pour l'événement modifications lors de l'ajout de pièces jointes dans votre application existante qui stocke en local. Si vous n'effectuez pas d'abord de synchronisation, vous pouvez supprimer par inadvertance pièces jointes existantes provenant d'événements de l'utilisateur.

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

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

Le champ conferenceData peut être utilisée pour lire, copier et effacer les détails d'une conférence existante ; il peut aussi être utilisée pour demander la création de nouvelles conférences. Pour autoriser la création modification des détails de la conférence, définir la requête conferenceDataVersion sur 1.

Trois types de conferenceData sont actuellement pris en charge, comme indiqué par le conferenceData.conferenceSolution.key.type:

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

Vous pouvez identifier le type de conférence pris en charge dans n'importe quel agenda d'une utilisateur en consultant conferenceProperties.allowedConferenceSolutionTypes dans les calendars et calendarList. Vous pouvez également déterminer si l'utilisateur préfère que des Hangouts soient créés pour tous ses nouveaux les événements créés en cochant le paramètre autoAddHangouts dans collection settings.

En plus de type, conferenceSolution fournit également les name et les Champs iconUri que vous pouvez utiliser pour représenter la solution de conférence, comme indiqué 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 à createRequest les éléments suivants : un requestId nouvellement généré, qui peut être un string aléatoire. Les conférences sont sont créées de manière asynchrone, mais vous pouvez toujours vérifier l'état de votre demande 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,
  sendNotifications: true,
  conferenceDataVersion: 1
}).execute(function(event) {
  console.log("Conference created for event: %s", event.htmlLink);
});

Il est possible que la réponse immédiate à cet appel ne contienne pas encore conferenceData; cela est indiqué par le code d'état pending dans état . Le code d'état passe à success lorsque les informations sur la conférence sont renseignés. Le champ entryPoints contient des informations sur les types de vidéos et des URI de téléphone sont disponibles pour que vos utilisateurs puissent y accéder par téléphone.

Si vous souhaitez planifier plusieurs événements Agenda ayant informations sur la conférence, vous pouvez copier l'intégralité de conferenceData d'un événement vers une 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 vous voulez protéger l'identité de l'intervieweur, 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 la conférence (en définissant le paramètre paramètre de requête conferenceDataVersion sur 1 pour les modifications d'événements) lorsque ajouter une 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 conférences d'utilisateurs événements.