Diese Seite wurde von der Cloud Translation API übersetzt.

Ereignisse erstellen

Stellen Sie sich eine App vor, mit der Nutzende die besten Wanderrouten finden. Durch Hinzufügen der als Kalendertermin erstellt haben, können die Nutzenden automatisch organisiert werden. Google Kalender bietet ihnen die Möglichkeit, erinnert sie daran, damit sie sich ohne Stress vorbereiten können. Dank der nahtlose Integration von Google-Produkten haben, werden sie von Google Now benachrichtigt, verlassen und Google Maps weist ihn pünktlich zum Treffpunkt hin.

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

Termin hinzufügen

Rufen Sie zum Erstellen eines Termins die Methode events.insert()-Methode, die unter mindestens diese Parameter:

calendarId ist die Kalender-ID und kann entweder die E-Mail-Adresse sein des Kalenders, in dem der Termin erstellt werden soll, oder ein bestimmtes Stichwort 'primary': Hiermit wird der Hauptkalender des angemeldeten Nutzers verwendet. Wenn die E-Mail-Adresse des gewünschten Kalenders nicht kennen, können Sie sie entweder in den Kalendereinstellungen in der UI (im Abschnitt "Kalenderadresse") oder Sie können danach suchen. im Ergebnis der calendarList.list()-Anruf.
event ist das Ereignis, das mit allen erforderlichen Details, z. B. „start“, erstellt werden soll. bis zum Ende. Die einzigen beiden Pflichtfelder sind start und end. Weitere Informationen finden Sie in der Referenz zu event für alle Ereignisse .
Legen Sie zeitgesteuerte Ereignisse mithilfe der start.dateTime fest. und end.dateTime. Für ganztägige Termine: start.date und end.date.

So erstellen Sie Ereignisse:

Legen Sie den OAuth-Bereich auf https://www.googleapis.com/auth/calendar fest, damit haben Sie Bearbeitungszugriff auf den Kalender des Nutzers.
Stellen Sie sicher, dass der authentifizierte Nutzer Schreibzugriff auf den Kalender mit der calendarId, die Sie angegeben haben (z. B. durch den Aufruf von calendarList.get() für den calendarId und überprüfe accessRole.

Ereignismetadaten hinzufügen

Sie können optional Terminmetadaten hinzufügen, wenn Sie einen Kalendertermin erstellen. Wenn Sie keine Metadaten während der Erstellung hinzufügen möchten, können Sie viele Felder mit der events.update(); Einige Felder, wie z. B. die Ereignis-ID, kann nur während einer events.insert()-Vorgang.

Standort

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

„Zeit zum Aufbrechen“ oder eine Karte mit einer Route anzeigen.

Ereignis-ID

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

die unseren Formatanforderungen entspricht. So können Sie Entitäten beibehalten, in Ihrer lokalen Datenbank synchronisiert und mit Terminen in Google Kalender synchronisiert. Außerdem verhindert die Erstellung doppelter Ereignisse, wenn der Vorgang nach einer gewissen Zeit fehlschlägt. und im Kalender-Back-End ausgeführt wird. Falls nein Ereignis-ID angegeben wurde, generiert der Server eine für Sie. Siehe Ereignis-ID finden Sie weitere Informationen.

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 an true bezüglich deiner Beilagenanfrage, die Teilnehmer werden erhalten auch eine E-Mail-Benachrichtigung für Ihren Termin. Ereignisse mit Leitfaden für mehrere Teilnehmer erhalten Sie weitere Informationen.

Die folgenden Beispiele zeigen, wie Sie ein Ereignis erstellen und die zugehörigen 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

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

Sie können Google Drive-Dateien anhängen, wie Besprechungsnotizen in Docs, Budgets in Tabellen, Präsentationen in Google Präsentationen oder anderen Google Drive-Dateien zu Ihren Kalenderterminen hinzufügen. Sie können den wenn Sie einen Termin mit events.insert() oder höher im Rahmen eines Aktualisierung zum Beispiel mit events.patch()

Das Anhängen einer Google Drive-Datei an einen Termin umfasst zwei Schritte:

Rufen Sie die URL der Datei alternateLink, title und mimeType aus der ab. Drive API-Dateiressource, in der Regel mit der Methode files.get().
Ereignis mit den in der Anfrage festgelegten attachments-Feldern erstellen oder aktualisieren Textkörper und der Parameter supportsAttachments auf true festgelegt ist.

Im folgenden Codebeispiel wird gezeigt, wie Sie ein vorhandenes Ereignis aktualisieren, um es hinzuzufügen. einen Anhang:

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

Video- und Telefonkonferenzen zu Terminen hinzufügen

Sie können Ereignisse mit Hangouts und Google Meet-Konferenzen, um Ihre Nutzer können sich per Telefon oder Videoanruf aus der Ferne treffen.

Das Feld conferenceData kann verwendet werden, um vorhandene Konferenzdetails zu lesen, zu kopieren und zu löschen; kann es auch sein, verwendet, um die Erstellung neuer Konferenzen anzufordern. Um das Erstellen und Änderung der Konferenzdetails, lege die conferenceDataVersion-Anfrage fest auf 1 setzen.

Derzeit werden drei Typen von conferenceData unterstützt, wie durch die conferenceData.conferenceSolution.key.type:

Hangouts für Privatnutzer (eventHangout)
Klassisches Hangouts für Google Workspace Nutzer (eingestellt; eventNamedHangout)
Google Meet (hangoutsMeet)

Sie können feststellen, welche Konferenzart für den jeweiligen Kalender einer anhand der conferenceProperties.allowedConferenceSolutionTypes in calendars und calendarList-Sammlungen. Sie können auch ob der Nutzer es vorzieht, Hangouts für alle seine neuen Ereignisse erstellt haben, indem Sie die Einstellung autoAddHangouts im settings-Sammlung.

Neben dem type gibt conferenceSolution auch die name und den iconUri-Felder, mit denen Sie die Konferenzlösung wie dargestellt darstellen können unten:

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 Eine neu generierte requestId, die eine zufällige string sein kann. Konferenzen sind werden asynchron erstellt. Sie können jedoch jederzeit den Status Ihrer Anfrage damit die Nutzer wissen, was passiert.

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 das vollständig ausgefüllte Feld conferenceData; Dies wird durch den Statuscode pending im Status ein. Der Statuscode ändert sich zu success, nachdem die Konferenzinformationen ausgefüllt. Das Feld entryPoints enthält Informationen zu dem Video und Telefon-URIs stehen Ihren Nutzern zur Verfügung, damit sie sich einwählen können.

Wenn Sie mehrere Kalendertermine mit demselben Konferenzdetails können Sie den gesamten conferenceData aus einem Termin kopieren in eine andere.

Das Kopieren ist in bestimmten Situationen nützlich. Angenommen, Sie entwickeln eine Recruiting-Anwendung, die separate Ereignisse für die sich bewerbende Person und die Sie möchten die Identität der Person, die das Interview durchführt, schützen, aber auch möchten, dass alle Teilnehmer an derselben Telefonkonferenz teilnehmen.