Ereignisse erstellen

Stellen Sie sich eine App vor, mit der Nutzende die besten Wanderrouten finden. Wenn Sie den Wanderplan als Kalendertermin hinzufügen, können die Nutzer automatisch den Überblick behalten. Google Kalender hilft ihnen dabei, den Plan zu teilen, und erinnert sie daran, damit sie sich ohne Stress vorbereiten können. Dank der nahtlosen Integration von Google-Produkten werden sie von Google Now darüber informiert, wann sie aufbrechen müssen, und Google Maps weist sie pünktlich zum Treffpunkt hin.

In diesem Artikel erfahren Sie, wie Sie Kalendertermine erstellen und zu den Kalendern Ihrer Nutzer hinzufügen.

Termin hinzufügen

Rufen Sie zum Erstellen eines Ereignisses die Methode events.insert() auf und stellen Sie dabei mindestens die folgenden Parameter bereit:

  • calendarId ist die Kalender-ID und kann entweder die E-Mail-Adresse des Kalenders sein, in dem der Termin erstellt werden soll, oder ein spezielles Schlüsselwort 'primary', mit dem der Hauptkalender des angemeldeten Nutzers verwendet wird. Wenn Sie die E-Mail-Adresse des Kalenders nicht kennen, können Sie ihn entweder in den Kalendereinstellungen der Weboberfläche von Google Kalender (im Abschnitt „Kalenderadresse“) prüfen oder im Ergebnis des Aufrufs calendarList.list() danach suchen.
  • event ist das Ereignis, das mit allen erforderlichen Details wie Start und Ende erstellt werden soll. Die einzigen beiden Pflichtfelder sind start und end. Eine vollständige Liste der Ereignisfelder finden Sie in der Referenz zu event.

So erstellen Sie Ereignisse:

  • Legen Sie den OAuth-Bereich auf https://www.googleapis.com/auth/calendar fest, damit Sie Bearbeitungszugriff auf den Kalender des Nutzers haben.
  • Sorgen Sie dafür, dass der authentifizierte Nutzer Schreibzugriff auf den Kalender mit der von Ihnen angegebenen calendarId hat. Dazu müssen Sie z. B. calendarList.get() für calendarId aufrufen und accessRole prüfen.

Ereignismetadaten hinzufügen

Sie können optional Terminmetadaten hinzufügen, wenn Sie einen Kalendertermin erstellen. Wenn Sie beim Erstellen keine Metadaten hinzufügen, können Sie viele Felder mit dem events.update() aktualisieren. Einige Felder, z. B. die Ereignis-ID, können jedoch nur während eines events.insert()-Vorgangs festgelegt werden.

Standort

Durch das Hinzufügen einer Adresse in das Standortfeld werden Funktionen wie

„Abfahrtszeit“ oder eine Karte mit Wegbeschreibung angezeigt.

Ereignis-ID

Wenn Sie ein Ereignis erstellen, können Sie eine eigene Ereignis-ID generieren.

die unseren Formatanforderungen entspricht. So können Sie Entitäten in Ihrer lokalen Datenbank mit Terminen in Google Kalender synchronisieren. Außerdem wird verhindert, dass Termine doppelt erstellt werden, wenn der Vorgang nach der erfolgreichen Ausführung im Kalender-Back-End irgendwann fehlschlägt. Wenn keine Ereignis-ID angegeben wird, generiert der Server eine für Sie. Weitere Informationen finden Sie in der Referenz zu Ereignis-IDs.

Teilnehmer

Der von Ihnen erstellte Termin wird in allen primären Google-Kalendern von

alle Gäste, die Sie mit derselben Termin-ID angegeben haben. Wenn Sie sendNotifications in Ihrer Einfügeanfrage auf true setzen, erhalten die Teilnehmer auch eine E-Mail-Benachrichtigung für Ihren Termin. Weitere Informationen finden Sie im Leitfaden Termine mit mehreren Teilnehmern.

Die folgenden Beispiele zeigen, wie Sie ein Ereignis erstellen und die zugehörigen Metadaten festlegen:

Ok

// 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:"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/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/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/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/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}"

Terminen Google Drive-Anhänge hinzufügen

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

Das Anhängen einer Google Drive-Datei an einen Termin umfasst zwei Schritte:

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

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

Video- und Telefonkonferenzen zu Terminen hinzufügen

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

Mit dem Feld conferenceData lassen sich vorhandene Konferenzdetails lesen, kopieren und löschen. Außerdem können Sie damit die Erstellung neuer Konferenzen anfordern. Wenn Sie das Erstellen und Ändern von Konferenzdetails zulassen möchten, legen Sie den Anfrageparameter conferenceDataVersion auf 1 fest.

Derzeit werden drei Typen von conferenceData unterstützt, wie durch conferenceData.conferenceSolution.key.type angegeben:

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

In den conferenceProperties.allowedConferenceSolutionTypes-Sammlungen der calendars- und calendarList-Sammlungen können Sie sehen, welcher Konferenztyp für den jeweiligen Kalender eines Nutzers unterstützt wird. Sie können auch prüfen, ob der Nutzer für alle neu erstellten Termine Hangouts möchte, indem Sie die Einstellung autoAddHangouts in der Sammlung settings aktivieren.

Neben dem type enthält der conferenceSolution auch die Felder name und iconUri, die Sie zur Darstellung der Konferenzlösung verwenden können, wie unten gezeigt:

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 einen Termin erstellen, indem Sie eine createRequest mit einer neu generierten requestId angeben, die eine zufällige string sein kann. Konferenzen werden asynchron erstellt. Sie können jedoch jederzeit den Status Ihrer Anfrage prüfen, um Ihre Nutzer darüber zu informieren.

So fordern Sie beispielsweise die Erstellung einer Konferenz für einen vorhandenen Termin an:

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

Die sofortige Antwort auf diesen Aufruf enthält möglicherweise noch nicht das vollständig ausgefüllte conferenceData-Objekt. Dies wird durch den Statuscode pending im Feld status angezeigt. Der Statuscode ändert sich zu success, nachdem die Konferenzinformationen eingegeben wurden. Das Feld entryPoints enthält Informationen zu den Video- und Telefon-URIs, über die sich Ihre Nutzer einwählen können.

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

Das Kopieren ist in bestimmten Situationen nützlich. Angenommen, Sie entwickeln eine Recruiting-Anwendung, die separate Ereignisse 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 Telefonkonferenz teilnehmen.