Ereignisse erstellen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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 viel Hilfe bei der automatischen Organisation. Google Kalender hilft ihnen, den Plan zu teilen, und erinnert sie sich daran, damit sie sich ohne großen Aufwand vorbereiten können. Und dank der nahtlosen Einbindung von Google-Produkten erhalten die Nutzer von Google Now eine Benachrichtigung, wann sie das Haus verlassen müssen. Google Maps leitet sie rechtzeitig an die entsprechende Stelle weiter.

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 diese Parameter an:

  • calendarId ist die Kalender-ID und kann entweder die E-Mail-Adresse des Kalenders sein, für den der Termin erstellt werden soll, oder ein spezielles 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 ihn entweder in den Kalendereinstellungen der Google Kalender-Weboberfläche (im Abschnitt „Kalenderadresse“) prüfen oder im Ergebnis des Aufrufs calendarList.list() suchen.
  • event ist das zu erstellende Ereignis mit allen erforderlichen Details wie Start und Ende. Die einzigen beiden Pflichtfelder sind start- und end-mal. Die vollständige Liste der Ereignisfelder finden Sie in der Referenz zu event.

So erstellen Sie Termine:

  • Legen Sie den OAuth-Bereich auf https://www.googleapis.com/auth/calendar fest.
  • Achte darauf, dass der authentifizierte Nutzer Schreibzugriff auf den Kalender mit der von dir bereitgestellten calendarId hat (z. B. durch Aufrufen von calendarList.get() für calendarId und Prüfen der accessRole).

Ereignismetadaten hinzufügen

Optional können Sie beim Erstellen eines Kalendertermins Ereignismetadaten hinzufügen. Wenn Sie beim Erstellen keine Metadaten hinzufügen, können Sie viele Felder mit 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 Standortfeld eingeben, können Sie z. B. „Zeit zum Aufbrechen“ aktivieren oder eine Karte mit einer Wegbeschreibung anzeigen.
Termin-ID
Beim Erstellen eines Ereignisses können Sie eine eigene Ereignis-ID erstellen, die unseren Formatanforderungen entspricht. Dadurch können Sie Entitäten in Ihrer lokalen Datenbank mit Terminen in Google Kalender synchronisieren. Außerdem wird so die doppelte Terminerstellung verhindert, wenn der Vorgang irgendwann nach der erfolgreichen Ausführung im Kalender-Back-End fehlschlägt. Wenn keine Ereignis-ID angegeben ist, generiert der Server eine für Sie. 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 angegeben haben. Wenn Sie für Ihre Einfügeanfrage sendNotifications auf true festlegen, erhalten die Teilnehmer außerdem eine E-Mail-Benachrichtigung für Ihr Ereignis. Weitere Informationen finden Sie im Leitfaden zu Veranstaltungen mit mehreren Teilnehmern.

Die folgenden Beispiele zeigen, wie ein Ereignis erstellt und seine Metadaten festgelegt werden:

Einfach loslegen (Go)

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

Terminen Anhänge hinzufügen

Sie haben die Möglichkeit, 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 Kalendertermine anzuhängen. Sie können den Anhang hinzufügen, wenn Sie ein Ereignis mit events.insert() oder später im Rahmen eines Updates erstellen, z. B. mit events.patch()

So hängen Sie eine Google Drive-Datei an einen Termin an:

  1. Rufen Sie die URL alternateLink, title und mimeType der Datei aus der Drive API-Datei 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 zum Hinzufügen eines Anhangs aktualisieren:

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 Fernzugriff per Telefonanruf oder Videoanruf teilnehmen können.

Mit dem Feld conferenceData können Sie Konferenzdetails lesen, kopieren und löschen. Außerdem lässt sich damit das Generieren 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 die 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 calendars und calendarList sehen Sie, welcher Konferenztyp für jeden Kalender eines Nutzers unterstützt wird. Wenn Sie prüfen möchten, ob der Nutzer Hangouts für alle neu erstellten Ereignisse bevorzugen, können Sie die Einstellung autoAddHangouts in der Sammlung settings aktivieren.

Neben dem 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 einen createRequest mit einem neu generierten requestId angeben, der eine zufällige string sein kann. Konferenzen werden asynchron erstellt, Sie können jedoch jederzeit den Status Ihrer Anfrage prüfen, damit Ihre Nutzer wissen, was geschieht.

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,
  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ändige Feld conferenceData. Dies wird durch den Statuscode pending im Feld status angezeigt. Der Statuscode ändert sich in success, nachdem die Konferenzinformationen eingegeben wurden. Das Feld entryPoints enthält Informationen dazu, welche Video- und Telefon-URIs sich die 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 Rekrutierungsanwendung, die separate Termine für den Kandidaten und den Interviewer einrichtet. Sie möchten die Identität des Interviewers schützen, aber gleichzeitig sicherstellen, dass alle Teilnehmer an demselben Konferenzanruf teilnehmen.