Ereignisse erstellen

Stellen Sie sich eine App vor, mit der Nutzer die besten Wanderrouten finden können. Wenn Sie den Wanderplan als Kalendertermin hinzufügen, erhalten die Nutzer automatisch viel Unterstützung bei der Organisation. Mit Google Kalender können sie den Plan teilen und sich daran erinnern lassen, damit sie sich ganz entspannt vorbereiten können. Dank der nahtlosen Integration von Google-Produkten werden sie von Google Now rechtzeitig daran erinnert, dass sie losfahren müssen, und von Google Maps rechtzeitig zum Treffpunkt geleitet.

In diesem Artikel wird erläutert, wie Sie Kalendertermine erstellen und den Kalendern Ihrer Nutzer hinzufügen.

Termin hinzufügen

Rufen Sie zum Erstellen eines Ereignisses die Methode events.insert() auf und geben Sie mindestens die folgenden Parameter an:

  • calendarId ist die Kalender-ID und kann entweder die E-Mail-Adresse des Kalenders sein, in dem das Ereignis erstellt werden soll, oder das spezielle Keyword 'primary', mit dem der primäre Kalender des angemeldeten Nutzers verwendet wird. Wenn Sie die E-Mail-Adresse des Kalenders, den Sie verwenden möchten, nicht kennen, können Sie sie entweder in den Kalendereinstellungen der Google Kalender-Web-UI (im Abschnitt „Kalenderadresse“) oder im Ergebnis des Aufrufs calendarList.list() nachsehen.
  • event ist das Ereignis, das mit allen erforderlichen Details wie Start- und Endzeit erstellt werden soll. Die einzigen beiden erforderlichen Felder sind die Zeiten start und end. Eine vollständige Liste der Ereignisfelder finden Sie in der event-Referenz.

Damit Sie Ereignisse erfolgreich erstellen können, müssen Sie Folgendes tun:

  • Legen Sie den OAuth-Bereich auf https://www.googleapis.com/auth/calendar fest, damit Sie Bearbeitungszugriff auf den Kalender des Nutzers haben.
  • Prüfen Sie, ob der authentifizierte Nutzer Schreibzugriff auf den Kalender mit der von Ihnen angegebenen calendarId hat (z. B. durch Aufrufen von calendarList.get() für die calendarId und Prüfen von accessRole).

Ereignis-Metadaten hinzufügen

Sie können optional Ereignismetadaten hinzufügen, wenn Sie einen Kalendertermin erstellen. Wenn Sie beim Erstellen keine Metadaten hinzufügen, können Sie viele Felder mit events.update() aktualisieren. Einige Felder, z. B. die Ereignis-ID, können jedoch nur bei einem events.insert()-Vorgang festgelegt werden.

Standort
Wenn Sie eine Adresse in das Feld „Ort“ eingeben, werden Funktionen wie „Abfahrtszeit“ oder eine Karte mit der Wegbeschreibung aktiviert.
Ereignis-ID
Beim Erstellen eines Ereignisses können Sie eine eigene Ereignis-ID generieren, die unseren Formatierungsanforderungen entspricht. So können Sie dafür sorgen, dass Entitäten in Ihrer lokalen Datenbank mit Terminen in Google Kalender synchronisiert werden. Außerdem wird verhindert, dass Termine doppelt erstellt werden, wenn der Vorgang nach der erfolgreichen Ausführung im Kalender-Backend fehlschlägt. Wenn keine Ereignis-ID angegeben ist, wird sie vom Server generiert. Weitere Informationen finden Sie in der Referenz zur Ereignis-ID.
Teilnehmer
Der von Ihnen erstellte Termin wird in allen primären Google-Kalendern der Teilnehmer angezeigt, die Sie mit derselben Termin-ID hinzugefügt haben. Wenn Sie sendUpdates in Ihrer Einfüge-Anfrage auf "all" oder "externalOnly" setzen, erhalten die entsprechenden Teilnehmer eine E-Mail-Benachrichtigung für Ihren Termin. Weitere Informationen

Die folgenden Beispiele zeigen, wie Sie ein Ereignis erstellen und seine Metadaten festlegen:

Ok

// 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:"lpage@example.com"},
    &calendar.EventAttendee{Email:"sbrin@example.com"},
  },
}

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("lpage@example.com"),
    new EventAttendee().setEmail("sbrin@example.com"),
};
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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'}
  ],
  '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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'},
  ],
  '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' => 'lpage@example.com'),
    array('email' => 'sbrin@example.com'),
  ),
  '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': 'lpage@example.com'},
    {'email': 'sbrin@example.com'},
  ],
  '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: 'lpage@example.com'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: 'sbrin@example.com'
    )
  ],
  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}"

Drive-Anhänge zu Terminen hinzufügen

Sie können Google Drive-Dateien wie Besprechungsnotizen in Google Docs, Budgets in Google Sheets, Präsentationen in Google Präsentationen oder andere relevante Google Drive-Dateien an Ihre Kalendertermine anhängen. Sie können die Anlage hinzufügen, wenn Sie einen Termin mit events.insert() erstellen oder später im Rahmen einer Aktualisierung, z. B. mit events.patch().

Das Anhängen einer Google Drive-Datei an einen Termin besteht aus zwei Teilen:

  1. Rufen Sie die Datei-URL alternateLink, title und mimeType aus der Drive API-Dateiresource ab, in der Regel mit der Methode files.get().
  2. Erstellen oder aktualisieren Sie ein Ereignis, wobei die Felder attachments im Anfragetext und der Parameter supportsAttachments auf true festgelegt sind.

Das folgende Codebeispiel zeigt, wie Sie ein vorhandenes Ereignis aktualisieren, um einen Anhang hinzuzufügen:

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()

Terminen Video- und Telefonkonferenzen hinzufügen

Sie können Termine mit Hangouts- und Google Meet-Konferenzen verknüpfen, damit Ihre Nutzer per Telefon- oder Videoanruf remote an Besprechungen teilnehmen können.

Das Feld conferenceData kann verwendet werden, um vorhandene Konferenzdetails zu lesen, zu kopieren und zu löschen. Außerdem kann es verwendet werden, um die Generierung neuer Konferenzen anzufordern. Wenn Sie das Erstellen und Ändern von Konferenzdetails zulassen möchten, legen Sie den conferenceDataVersion-Anfrageparameter auf 1 fest.

Derzeit werden drei Arten von conferenceData unterstützt, die durch die conferenceData.conferenceSolution.key.type gekennzeichnet sind:

  1. Hangouts für Privatnutzer (eventHangout)
  2. Das klassische Hangouts für Google Workspace-Nutzer (eingestellt; eventNamedHangout)
  3. Google Meet (hangoutsMeet)

Sie können herausfinden, welcher Konferenztyp für einen bestimmten Kalender eines Nutzers unterstützt wird, indem Sie sich die conferenceProperties.allowedConferenceSolutionTypes in den Sammlungen calendars und calendarList ansehen. Sie können auch herausfinden, ob der Nutzer Hangouts für alle neu erstellten Termine bevorzugt, indem Sie die Einstellung autoAddHangouts in der Sammlung settings prüfen.

Neben type bietet conferenceSolution auch die Felder name und iconUri, mit denen Sie die Konferenzlösung wie unten dargestellt darstellen können:

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);

Sie können eine neue Konferenz für ein Ereignis erstellen, indem Sie ein createRequest mit einer neu generierten requestId angeben, die eine zufällige string sein kann. Videokonferenzen werden asynchron erstellt. Sie können aber jederzeit den Status Ihrer Anfrage prüfen, um Ihre Nutzer auf dem Laufenden zu halten.

So fordern Sie beispielsweise die Generierung einer Videokonferenz für ein vorhandenes Ereignis an:

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);
});

Die unmittelbare Antwort auf diesen Aufruf enthält möglicherweise noch nicht die vollständig ausgefüllte conferenceData. Dies wird durch den Statuscode pending im Feld status angegeben. Der Statuscode ändert sich in success, nachdem die Konferenzinformationen eingefügt wurden. Das Feld entryPoints enthält Informationen dazu, welche Video- und Telefon-URIs für Ihre Nutzer verfügbar sind, um sich einzuwählen.

Wenn Sie mehrere Kalendertermine mit denselben Konferenzinformationen planen möchten, können Sie die gesamte conferenceData aus einem Termin in einen anderen kopieren.

Das Kopieren ist in bestimmten Situationen nützlich. Angenommen, Sie entwickeln eine Recruiting-Anwendung, die separate Termine für den Kandidaten und den Interviewer einrichtet. Sie möchten die Identität des Interviewers schützen, aber auch dafür sorgen, dass alle Teilnehmer an derselben Videokonferenz teilnehmen.