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, können sie sich automatisch besser organisieren. Über Google Kalender können sie den Plan teilen und werden daran erinnert, damit sie sich stressfrei vorbereiten können. Dank der nahtlosen Integration von Google-Produkten werden sie außerdem rechtzeitig von Google Maps 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 Termins die events.insert Methode auf, und geben Sie mindestens die folgenden Parameter an:

• calendarId ist die Kalender-ID. Sie kann entweder die E-Mail-Adresse des Kalenders sein, in dem der Termin erstellt werden soll, oder das spezielle Keyword 'primary', das den primären Kalender des angemeldeten Nutzers verwendet. Wenn Sie die E-Mail-Adresse des gewünschten Kalenders nicht kennen, können Sie sie in den Einstellungen des Kalenders in der Google Kalender-Weboberfläche (im Abschnitt „Kalenderadresse“) oder im Ergebnis des calendarList.list Aufrufs nachsehen.
• event ist der Termin, der mit allen erforderlichen Details wie Start- und Endzeit erstellt werden soll. Die einzigen beiden Pflichtfelder sind die start- und end-Zeit. Eine vollständige Liste der Ereignisfelder finden Sie in der Referenz zur Ressource Events.
  Geben Sie Termine mit Uhrzeit mit den Feldern start.dateTime und end.dateTime an. Verwenden Sie für ganztägige Termine stattdessen start.date und end.date.

So erstellen Sie Termine:

• 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 calendarId angegebenen hat (z. B. durch Aufrufen von calendarList.get für die calendarId und Prüfen von accessRole).

Terminmetadaten hinzufügen

Optional können Sie beim Erstellen eines Kalendertermins Terminmetadaten hinzufügen. Wenn Sie beim Erstellen keine Metadaten hinzufügen, können Sie viele Felder mit der Methode events.update aktualisieren. Einige Felder wie die Ereignis-ID können jedoch nur während eines events.insert-Vorgangs festgelegt werden.

Standort

Wenn Sie eine Adresse in das Feld „Standort“ eingeben, werden Funktionen wie „Zeit zum Aufbrechen“ aktiviert oder eine Karte mit einer Wegbeschreibung angezeigt.

Ereignis-ID

Beim Erstellen eines Termins können Sie eine eigene Ereignis-ID generieren, die den Formatierungsanforderungen 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 Google Kalender-Backend an einem bestimmten Punkt fehlschlägt. Wenn Sie keine Ereignis-ID angeben, wird eine 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 Kalender-Kalendern der Teilnehmer angezeigt, die Sie mit derselben Ereignis-ID hinzugefügt haben. Wenn Sie sendUpdates auf "all" oder "externalOnly" in Ihrer Einfügeanfrage setzen, erhalten die entsprechenden Teilnehmer eine E-Mail-Benachrichtigung für Ihren Termin. Weitere Informationen finden Sie unter Termine mit mehreren Teilnehmern.

In den folgenden Beispielen wird gezeigt, wie Sie einen Termin 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:"[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}"

Terminen Drive-Anhänge hinzufügen

Sie können Ihren Kalenderterminen Google Drive Dateien wie Besprechungsnotizen in Google Docs, Budgets in Google Sheets, Präsentationen in Google Präsentationen oder andere relevante Drive-Dateien anhängen. Sie können den Anhang 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 Drive-Datei an einen Termin besteht aus zwei Teilen:

1. Rufen Sie die URL alternateLink, title und mimeType der Datei aus der Ressource „Files“ der Google Drive API ab, in der Regel mit der files.get Methode.
2. Erstellen oder aktualisieren Sie einen Termin, wobei die Felder attachments im Anfragetext und der Parameter supportsAttachments auf true gesetzt sind.

Das folgende Codebeispiel zeigt, wie Sie einen vorhandenen Termin 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()

Wichtig: Sie müssen eine [vollständige Synchronisierung](/workspace/calendar/api/guides/sync) aller Termine durchführen, bevor Sie den Parameter `supportsAttachments` für Termin änderungen aktivieren, wenn Sie Ihrer vorhandenen App, in der Termine lokal gespeichert werden, Unterstützung für Anhänge hinzufügen. Wenn Sie zuerst keine Synchronisierung durchführen, entfernen Sie möglicherweise versehentlich vorhandene Anhänge aus den Terminen der Nutzer.

Terminen Video- und Telefonkonferenzen hinzufügen

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

Das conferenceData Feld ermöglicht das Lesen, Kopieren und Löschen vorhandener Konferenzdetails oder das Anfordern der Generierung neuer Konferenzen. Wenn Sie das Erstellen und Ändern von Konferenzdetails zulassen möchten, setzen Sie den Anfrageparameter conferenceDataVersion auf 1.

Die folgenden Konferenztypen werden unterstützt, wie durch conferenceData.conferenceSolution.key.type angegeben:

1. Google Meet (hangoutsMeet)

In den Sammlungen calendars und calendarList können Sie unter conferenceProperties.allowedConferenceSolutionTypes nachsehen, welcher Konferenztyp für einen bestimmten Kalender eines Nutzers unterstützt wird.

Neben type enthält 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 einen Termin erstellen, indem Sie eine createRequest mit einer neu generierten requestId als zufälligen String angeben. Konferenzen werden asynchron erstellt. Sie können jedoch jederzeit den Status Ihrer Anfrage prüfen, um Ihre Nutzer auf dem Laufenden zu halten.

So fordern Sie beispielsweise die Konferenzerstellung für einen vorhandenen Termin 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 sofortige Antwort auf diesen Aufruf enthält möglicherweise noch nicht die vollständig ausgefüllten conferenceData. Das Status -Feld enthält pending. 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 Recruiting-Anwendung, mit der separate Termine für den Kandidaten 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 Telefonkonferenz teilnehmen.

Wichtig: Sie müssen eine [vollständige Synchronisierung](/workspace/calendar/api/guides/sync) aller Termine durchführen, bevor Sie die Unterstützung für Konferenzdaten aktivieren (indem Sie den Anfrageparameter `conferenceDataVersion` für Terminänderungen auf `1` setzen), wenn Sie Ihrer vorhandenen App, in der Termine lokal gespeichert werden, Unterstützung für Konferenzen hinzufügen. Wenn Sie zuerst keine Synchronisierung durchführen, entfernen Sie möglicherweise versehentlich vorhandene Konferenzen aus den Terminen der Nutzer.