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 die Nutzer automatisch 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 zu 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.
• 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 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

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

„Abfahrtszeit“ oder eine Karte mit 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 doppelte Termine erstellt 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

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 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:"[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/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/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/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/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 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().

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.

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

Wichtig :Wenn Sie Ihrer vorhandenen App, in der Ereignisse lokal gespeichert werden, die Unterstützung für Anhänge hinzufügen, müssen Sie zuerst eine Vollsynchronisierung aller Ereignisse durchführen, bevor Sie den Parameter supportsAttachments für Ereignisänderungen aktivieren. Wenn Sie nicht zuerst eine Synchronisierung durchführen, werden möglicherweise vorhandene Anhänge versehentlich aus den Ereignissen des Nutzers entfernt.

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:

1. Hangouts für Privatnutzer (eventHangout)
2. Klassisches Hangouts für Google Workspace Nutzer (eingestellt; eventNamedHangout)
3. 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 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 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 darüber, welche Video- und Telefon-URIs für die Nutzer zur Einwahl 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, 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.

Wichtig :Sie müssen eine vollständige Synchronisierung aller Termine durchführen, bevor Sie die Unterstützung für Konferenzdaten aktivieren. Dazu setzen Sie den Anfrageparameter conferenceDataVersion für Ereignisänderungen auf 1, wenn Sie die Unterstützung für Konferenzen in Ihrer vorhandenen App hinzufügen, die Ereignisse lokal speichert. Wenn Sie zuerst keine Synchronisierung ausführen, entfernen Sie möglicherweise versehentlich vorhandene Konferenzen aus den Terminen der Nutzer.