Diese Seite wurde von der Cloud Translation API übersetzt.

Ereignisse erstellen

Stellen Sie sich eine App vor, mit der Nutzer die besten Wanderrouten finden können. Indem der Wanderplan als Kalendertermin hinzugefügt wird, können Nutzer automatisch besser organisiert bleiben. Mit Google Kalender kann sie den Plan teilen und sich daran erinnern lassen, damit sie sich stressfrei vorbereiten kann. Dank der nahtlosen Integration von Google-Produkten wird er von Google Now über die Abfahrtszeit informiert und Google Maps leitet ihn pünktlich zum Treffpunkt.

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

Termin hinzufügen

Wenn Sie ein Ereignis erstellen möchten, rufen Sie die Methode events.insert() mit mindestens den folgenden Parametern auf:

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 Keyword 'primary', für das der primäre Kalender des angemeldeten Nutzers verwendet wird. Wenn Sie die E-Mail-Adresse des gewünschten Kalenders nicht kennen, können Sie sie entweder in den Einstellungen des Kalenders in der Weboberfläche von Google Kalender (im Bereich „Kalenderadresse“) oder im Ergebnis des calendarList.list()-Aufrufs suchen.
event ist das Ereignis, das mit allen erforderlichen Details wie Beginn und Ende erstellt werden soll. Die einzigen beiden Pflichtfelder sind die Zeiten start und end. Eine vollständige Liste der Ereignisfelder finden Sie in der event-Referenz.
Geben Sie zeitgesteuerte Ereignisse mit den Feldern start.dateTime und end.dateTime an. Verwenden Sie für ganztägige Ereignisse stattdessen start.date und end.date.

Damit Sie Ereignisse erstellen können, müssen folgende Voraussetzungen erfüllt sein:

Legen Sie den OAuth-Umfang 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. Rufen Sie dazu beispielsweise calendarList.get() für die calendarId auf und prüfen Sie die accessRole.

Ereignismetadaten hinzufügen

Sie können beim Erstellen eines Kalendertermins optional Ereignismetadaten hinzufügen. 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 „Standort“ eingeben, sind Funktionen wie

„Abfahrtszeit“ oder eine Karte mit der Wegbeschreibung angezeigt.

Ereignis-ID

Beim Erstellen eines Ereignisses 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 dupliziert werden, wenn der Vorgang nach der erfolgreichen Ausführung im Kalender-Backend 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

die Teilnehmer, die Sie mit derselben Ereignis-ID hinzugefügt haben. Wenn Sie in Ihrer Anfrage zum Einfügen sendNotifications auf true festlegen, erhalten die Teilnehmer auch eine E-Mail-Benachrichtigung für Ihre Veranstaltung. Weitere Informationen finden Sie im Leitfaden zu Veranstaltungen mit mehreren Teilnehmern.

In den folgenden Beispielen wird gezeigt, wie ein Ereignis erstellt und seine Metadaten festgelegt werden:

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 Drive-Anhänge hinzufügen

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

Es gibt zwei Schritte, um eine Google Drive-Datei an ein Ereignis anzuhängen:

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

Im folgenden Codebeispiel wird gezeigt, wie ein vorhandenes Ereignis aktualisiert wird, 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 an einer Videokonferenz teilnehmen können.

Mit dem Feld conferenceData können Sie vorhandene Konferenzdetails lesen, kopieren und löschen. Außerdem können Sie damit die Generierung neuer Konferenzen anfordern. Wenn Sie Konferenzdetails erstellen und ändern möchten, legen Sie den conferenceDataVersion-Anfrageparameter auf 1 fest.

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

Hangouts für Verbraucher (eventHangout)
Klassisches Hangouts für -Nutzer (veraltet; eventNamedHangout)
Google Meet (hangoutsMeet)

Welcher Konferenztyp für einen bestimmten Kalender eines Nutzers unterstützt wird, sehen Sie anhand des conferenceProperties.allowedConferenceSolutionTypes in den Sammlungen calendars und calendarList. Sie können auch prüfen, ob der Nutzer möchte, dass für alle neu erstellten Ereignisse Hangouts erstellt werden. Sehen Sie dazu in der Sammlung settings nach, ob die Einstellung autoAddHangouts aktiviert ist.

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 eine createRequest mit einer neu generierten requestId angeben. Dies kann eine zufällige string sein. Konferenzen werden asynchron erstellt. Sie können den Status Ihrer Anfrage jederzeit prüfen, um Ihre Nutzer auf dem Laufenden zu halten.

So fordern Sie beispielsweise die Erstellung 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,
  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 die vollständig ausgefüllte conferenceData. Dies wird durch den Statuscode pending im Feld status angezeigt. Der Statuscode ändert sich in success, nachdem die Konferenzinformationen ausgefüllt wurden. Das Feld entryPoints enthält Informationen dazu, welche Video- und Telefon-URIs für Ihre Nutzer verfügbar sind.

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 Rekrutierungsanwendung, in der separate Ereignisse für den Bewerber und den Interviewer eingerichtet werden. Sie möchten die Identität des Interviewers schützen, aber auch dafür sorgen, dass alle Teilnehmer an derselben Videokonferenz teilnehmen.