Ereignisse erstellen

Stellen Sie sich eine App vor, mit der Nutzende die besten Wanderrouten finden können. Das Hinzufügen des Wanderplans als Kalendertermin hilft den Nutzern dabei, automatisch organisiert zu bleiben. Google Kalender hilft ihnen, den Plan freizugeben, 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 sollten, und Google Maps leitet sie pünktlich zum Treffpunkt.

In diesem Artikel erfahren Sie, 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 dabei mindestens die folgenden Parameter an:

  • 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', das den primären Kalender des angemeldeten Nutzers verwendet. Wenn Sie die E-Mail-Adresse des Kalenders, den Sie verwenden möchten, nicht kennen, können Sie sie entweder in den Kalendereinstellungen der Weboberfläche von Google Kalender (im Abschnitt „Kalenderadresse“) oder im Ergebnis des Aufrufs calendarList.list() danach suchen.
  • event ist das zu erstellende Ereignis mit allen erforderlichen Details wie Start und Ende. Die einzigen beiden Pflichtfelder sind start und end. Die vollständige Liste der Ereignisfelder finden Sie in der event-Referenz.

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 mit der von Ihnen angegebenen calendarId Schreibzugriff auf den Kalender hat. Rufen Sie beispielsweise calendarList.get() für calendarId auf und prüfen Sie accessRole.

Ereignismetadaten hinzufügen

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

Standort

Wenn Sie eine Adresse in das Standortfeld eingeben, stehen Ihnen unter anderem folgende Funktionen zur Verfügung:

„Zeit zum Aufbrechen“ oder die Anzeige einer Karte mit der Route.

Termin-ID

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

die unseren Formatanforderungen entspricht. Auf diese Weise können Sie Entitäten in Ihrer lokalen Datenbank mit Terminen in Google Kalender synchronisieren. Außerdem wird die Erstellung doppelter Ereignisse verhindert, wenn der Vorgang nach erfolgreicher Ausführung im Kalender-Back-End 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 erscheint in allen primären Google-Kalendern Ihrer

für die Teilnehmer, die Sie mit derselben Termin-ID angegeben haben. Wenn Sie sendNotifications in Ihrer Anfrage zum Einfügen auf true setzen, erhalten die Teilnehmer außerdem eine E-Mail-Benachrichtigung für Ihren Termin. Weitere Informationen finden Sie im Leitfaden Veranstaltungen mit mehreren Teilnehmern.

Die folgenden Beispiele zeigen, wie Sie ein Ereignis erstellen und dessen 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

// Refer to the PHP quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/php
// Change the scope to Google_Service_Calendar::CALENDAR and delete any stored
// credentials.

$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}"

Drive-Anhänge zu Terminen hinzufügen

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

Zum Anhängen einer Google Drive-Datei an einen Termin bestehen zwei Schritte:

  1. Rufen Sie die alternateLink-URL, title und mimeType der Datei aus der Dateiressource für die Drive API ab, in der Regel mit der Methode files.get().
  2. Erstellen oder aktualisieren Sie ein Ereignis, wobei die attachments-Felder 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 an Besprechungen teilnehmen können.

Mit dem Feld conferenceData können Sie vorhandene Konferenzdetails lesen, kopieren und löschen sowie die Erstellung neuer Konferenzen anfordern. Wenn Sie das Erstellen und Ändern von Konferenzdetails zulassen möchten, setzen Sie den Anfrageparameter conferenceDataVersion auf 1.

Derzeit werden drei Arten 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)

Wenn Sie wissen möchten, welcher Konferenztyp für den jeweiligen Kalender eines Nutzers unterstützt wird, sehen Sie sich die conferenceProperties.allowedConferenceSolutionTypes in den Sammlungen calendars und calendarList an. Wenn Sie wissen möchten, ob der Nutzer Hangouts für alle neu erstellten Termine bevorzugt, können Sie die Einstellung autoAddHangouts in der Sammlung settings prüfen.

Neben dem type enthält der conferenceSolution auch die Felder name und iconUri, die Sie verwenden können, um die Konferenzlösung darzustellen:

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. Dazu stellen Sie eine createRequest mit einer neu generierten requestId bereit, 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, was gerade passiert.

So fordern Sie beispielsweise die Generierung 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 unmittelbare Antwort auf diesen Aufruf enthält unter Umständen noch nicht das vollständig ausgefüllte conferenceData. Dies wird durch den Statuscode pending im Feld status angezeigt. Der Statuscode ändert sich in success, sobald die Konferenzinformationen eingegeben wurden. Das Feld entryPoints enthält Informationen darüber, welche Video- und Telefon-URIs für die Einwahl Ihrer 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.

Kopieren ist in bestimmten Situationen hilfreich. Angenommen, Sie entwickeln eine Recruiting-Anwendung, mit der separate Termine für den Kandidaten und den Vorstellungsgespräch eingerichtet werden. Sie möchten die Identität des Interviewers schützen und gleichzeitig sicherstellen, dass alle Teilnehmer an derselben Telefonkonferenz teilnehmen.