{"id":55000416,"date":"2024-02-01T00:00:00","date_gmt":"2024-02-24T18:01:10","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=416"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Google_Calendar_per_RestAPI_programmieren_Teil_2","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Google_Calendar_per_RestAPI_programmieren_Teil_2\/","title":{"rendered":"Google Calendar per Rest-API programmieren, Teil 2"},"content":{"rendered":"

\"\"<\/p>\n

Im ersten Teil unserer Artikelserie haben wir grundlegende Funktionen vorgestellt, die es ermöglichen, Termine zwischen Outlook und Google Calendar zu synchronisieren. Jetzt gehen wir einen Schritt weiter und optimieren diese Funktionen an, um die Aktualisierung von Terminen effektiver zu gestalten. Zum Beispiel ist es von Vorteil, die EventID eines im Google Calendar erstellten Termins im entsprechenden Outlook-Termin zu speichern, um Änderungen zwischen beiden Kalendern synchron zu halten. Außerdem fügen wir neue Funktionen zur Aktualisierung von Kalendereinträgen und zum Abrufen von Terminen anhand ihrer EventID hinzu. Darüber hinaus diskutieren wir Herausforderungen, auf die wir gestoßen sind, und präsentieren Lösungen sowie Erweiterungen, die wir implementiert haben.<\/b><\/p>\n

Anpassungen der bestehenden Funktionen<\/h2>\n

Die Funktionen aus dem ersten Teil dieser Artikelreihe, Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>), haben wir noch ein wenig angepasst, damit wir besser für Exporte und anschließend notwendige Aktualisieren vorbereitet sind.<\/p>\n

Wenn wir also einen Termin aus Outlook zum Google Calendar exportieren wollen, ist es sinnvoll, dass wir die EventID<\/b> für den im Google Calendar angelegten Termin im Outlook-Termin zu speichern. Auf diese Weise können wir Änderungen an diesem Termin in Outlook auf den Termin im Google Calendar übertragen.<\/p>\n

Und auch wenn der Termin in Outlook gelöscht wird, wollen wir dies gegebenenfalls im Google Calendar abbilden – also passen wir die Funktion, mit der wir einen Termin im Google Calendar anlegen, so an, dass diese die EventID<\/b> des neu angelegten Termins zurückgibt.<\/p>\n

Diese schreiben wir in der Funktion InsertEvent <\/b>in den Parameter strEventID<\/b> (siehe Listing 1). Außerdem haben wir noch weitere Parameter hinzugefügt, mit denen man die Zeitzone für das Start- und das Enddatum übergeben kann. Diese beiden Parameter heißen strStartTimeZone <\/b>und strEndTimeZone <\/b>und erhalten den Standardwert Europe\/Berlin<\/b>. Und mit dem Parameter bolAllDayEvent<\/b> können wir angeben, ob es sich bei dem anzulegenden Termin um einen Ganztagestermin handelt.<\/p>\n

Public Function <\/span>InsertEvent(strToken As String<\/span>, strCalendarID As String<\/span>, strSummary As String<\/span>, strDescription _\r\n         As String<\/span>, datStart As Date<\/span>, datEnd As Date<\/span>, Optional<\/span> bolAllDayEvent As Boolean<\/span>, Optional<\/span> strStartTimeZone _\r\n         As String<\/span> = \"Europe\/Berlin\", Optional<\/span> strEndTimeZone As String<\/span> = \"Europe\/Berlin\", Optional<\/span> intColor _\r\n         As <\/span>eColor = colLavendel, Optional<\/span> strResponse As String<\/span>, Optional<\/span> ByRef strEventID As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>strURL As String<\/span>, strMethod As String<\/span>, strAuthorization As String<\/span>, objJSON As Object<\/span>\r\n     Dim <\/span>strJSON As String<\/span>, dictMain As <\/span>Dictionary, dictStart As <\/span>Dictionary, dictEnd As <\/span>Dictionary\r\n     Set<\/span> dictMain = New<\/span> Dictionary\r\n     Set<\/span> dictStart = New<\/span> Dictionary\r\n     Set<\/span> dictEnd = New<\/span> Dictionary\r\n     dictMain.Add \"start\", dictStart\r\n     dictMain.Add \"end\", dictEnd\r\n     If <\/span>Not<\/span> bolAllDayEvent Then<\/span>\r\n         dictStart.Add \"dateTime\", Format(datStart, \"yyyy-mm-ddThh:nn:ss\")\r\n         dictEnd.Add \"dateTime\", Format(datEnd, \"yyyy-mm-ddThh:nn:ss\")\r\n     Else<\/span>\r\n         datStart = Int(datStart)\r\n         datEnd = datStart + 1\r\n         dictStart.Add \"dateTime\", Format(datStart, \"yyyy-mm-ddThh:nn:ss\")\r\n         dictEnd.Add \"dateTime\", Format(datEnd, \"yyyy-mm-ddThh:nn:ss\")\r\n     End If<\/span>\r\n     dictStart.Add \"timeZone\", strStartTimeZone\r\n     dictEnd.Add \"timeZone\", strEndTimeZone\r\n     dictMain.Add \"summary\", strSummary\r\n     dictMain.Add \"description\", strDescription\r\n     dictMain.Add \"colorId\", intColor\r\n     strJSON = ConvertToJson(dictMain)\r\n     strURL = cStrURLBase & \"\/calendars\/\" & strCalendarID & \"\/events\"\r\n     strMethod = \"POST\"\r\n     strAuthorization = \"Bearer \" & strToken\r\n     If <\/span>RefreshAccessToken(\"InsertEvent\") Then<\/span>\r\n         Select Case HTTPRequest(strURL, strAuthorization, strMethod, , strJSON, strResponse)\r\n             Case <\/span>200\r\n                 InsertEvent = True<\/span>\r\n                 Set<\/span> objJSON = ParseJson(strResponse)\r\n                 strEventID = objJSON.Item(\"id\")\r\n             Case Else<\/span>\r\n                 MsgBox<\/span> strResponse\r\n         End Select<\/span>\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Access-Token ungültig oder nicht aktualisierbar.\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 1: Neue Version der Funktion InsertEvent<\/span><\/b><\/p>\n
Für den Parameter intColor <\/b>haben wir als Standardwert den Wert colLavendel <\/b>vorgemerkt.<\/p>\n
Die Zeitzonen übergeben wir in der Funktion jeweils für das Element timeZone<\/b>.<\/p>\n
Für die Verarbeitung des Parameters bolAllDayEvent <\/b>mussten wir eine If…Then<\/b>-Bedingung zur Funktion hinzufügen. Wenn bolAllDayEvent <\/b>den Wert False <\/b>enthält, werden die Werte für Start- und Enddatum wie zuvor hinzugefügt. Im Else<\/b>-Teil der Bedingung behandeln wir den Fall eines ganztägigen Termins.<\/p>\n
Hier ermitteln wir als Startzeit das Datum der mit datStart <\/b>übergebenen Startzeit und stellen die Uhrzeit auf 00:00 <\/b>ein, indem wir die Nachkommastellen von datStart <\/b>mit der Int<\/b>-Funktion entfernen.<\/p>\n
Als Enddatum legen wir in datEnd <\/b>das Datum des folgenden Tages fest – wieder mit der Uhrzeit 00:00<\/b>. Die Rest-API von Google Calendar sieht keine spezielle Eigenschaft für einen ganztätigen Termin vor, sodass wir diese Notation verwenden.<\/p>\n
In der Benutzeroberfläche sehen wir anschließend allerdings einen Ganztagestermin (siehe Bild 1). Wenn die Funktion HTTPRequest <\/b>den Wert True <\/b>zurückliefert, lesen wir aus dem mit strResponse <\/b>gelieferten JSON-Dokument den Wert id <\/b>aus und tragen diesen für den Parameter strEventID <\/b>ein. Diesen kann man dann nach dem Aufruf verarbeiten, wenn dies nötig ist.<\/p>\n
\"Ein<\/p>\n
Bild 1: Ein ganztägiger Termin im Google Calendar<\/span><\/b><\/p>\n
Rest-API-Funktion zum Abrufen eines Termins per EventID<\/h2>\n
Bei den im ersten Teil dieses Artikels beschriebenen Funktionen können wir die kompletten Informationen zu einem Termin abrufen. In den Beispielen speichern wir diese Daten in einer Access-Tabelle, darunter auch die EventID<\/b>, ein eindeutiges Merkmal eines Google Calendar-Termins. Damit können wir wiederum gezielt erneut auf einen solchen Termin zugreifen – beispielsweise um den aktuellen Stand abzufragen, denn ein Termin kann ja auch durch den Benutzer in Google geändert werden.<\/p>\n
Dies erledigen wir mit der Funktion GetEventByID<\/b> (siehe Listing 2). Diese erwartet folgende Parameter:<\/p>\n
Public Function <\/span>GetEventByID(strToken As String<\/span>, strCalendarID As String<\/span>, strEventID As String<\/span>, Optional<\/span> strJSON _\r\n         As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strMethod As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>strAuthorization As String<\/span>\r\n     strURL = cStrURLBase & \"\/calendars\/\" & strCalendarID & \"\/events\/\" & strEventID\r\n     strMethod = \"GET\"\r\n     strAuthorization = \"Bearer \" & strToken\r\n     If <\/span>RefreshAccessToken(\"GetEventByID\") Then<\/span>\r\n         Select Case HTTPRequest(strURL, strAuthorization, strMethod, , , strResponse)\r\n             Case <\/span>200\r\n                 strJSON = strResponse\r\n                 GetEventByID = True<\/span>\r\n             Case Else<\/span>\r\n                 GetEventByID = False<\/span>\r\n         End Select<\/span>\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Access-Token ungültig oder nicht aktualisierbar.\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 2: Funktion zum Einlesen eines Termins von Google<\/span><\/b><\/p>\n
    \n
  • strToken<\/b>: Access-Token für den Zugriff auf den Google Calendar<\/li>\n
  • strCalendarID<\/b>: Bezeichnung des Kalenders, in der Regel die Google-E-Mail-Adresse<\/li>\n
  • strEventID<\/b>: ID des zu ermittelnden Termins<\/li>\n
  • strJSON<\/b>: Parameter, der das Ergebnis der Abfrage entgegennimmt<\/li>\n<\/ul>\n
    Die Funktion stellt die URL für den Zugriff auf die Rest-API zusammen, die beispielsweise so aussieht:<\/p>\n
    https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/andre.minhorst@googlemail.com\/events\/36kis3n1kt1sc5ch82a54k4u5k<\/pre>\n
    Als Methode verwenden wir GET<\/b>, und mit der Variablen strAuthorization <\/b>übergeben wir das Token an die Funktion, die den eigentlichen Request ausführt. Zuvor rufen wir noch die Prozedur CheckToken <\/b>aus, welche die Gültigkeit des Tokens prüft.  Ist dieses ungültig, erfolgt erst gar kein Zugriff auf die Rest-API und es erscheint eine Meldung. Danach erfolgt der Aufruf der Funktion HTTPRequest<\/b>. Das Ergebnis ist ein Status. Lautet dieser 200<\/b>, war der Zugriff erfolgreich und wir geben die Antwort über den Rückgabeparameter strJSON <\/b>zurück. Außerdem stellen wir den Rückgabewert der Funktion auf True <\/b>ein.<\/p>\n
    Diese Funktion rufen wir beispielsweise wie folgt auf:<\/p>\n
    Public Sub <\/span>Test_GetEventByID()\r\n     Dim <\/span>strToken As String<\/span>\r\n     Dim <\/span>strCalendarID As String<\/span>\r\n     Dim <\/span>strEventID As String<\/span>\r\n     Dim <\/span>strJSON As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     strToken = GetAppSetting(\"AccessToken\")\r\n     strCalendarID = GetAppSetting(\"CalendarID\")\r\n     strEventID = \"36kis3n1kt1sc5ch82a54k4u5k\"\r\n     If GetEventByID(strToken, strCalendarID, strEventID, _\r\n             strJSON) = True<\/span> Then\r\n         Set<\/span> objJSON = ParseJson(strJSON)\r\n         Debug.Print<\/span> GetJSONDOM(strJSON, True<\/span>)\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Die beiden Parameter strToken <\/b>und strCalendarID <\/b>lesen wir aus der Registry aus, die EventID <\/b>haben wir hier fest angegeben. War der Aufruf erfolgreich, lassen wir uns das Zugriffsmodell für das JSON-Dokument im Direktbereich ausgeben. Hier können wir uns dann die Elemente heraussuchen, die wir in der aufrufenden Prozedur weiterverarbeiten wollen (siehe Bild 2).<\/p>\n
    \"Ausdrücke<\/p>\n
    Bild 2: Ausdrücke zum Auslesen von Termineigenschaften<\/span><\/b><\/p>\n
    Rest-API-Funktion zum Aktualisieren eines Kalendereintrags<\/h2>\n
    Wenn wir einen vorhandenen Termin im Google Calendar aktualisieren wollen, haben wir zwei Möglichkeiten. Die erste ist die Patch-Methode. Damit können wir gezielt einzelne Eigenschaften anpassen. Mehr dazu liest Du hier:<\/p>\n
    https:\/\/developers.google.com\/calendar\/api\/v3\/reference\/events\/patch?hl=en<\/pre>\n
    Bei dieser Methode werden nur die Eigenschaften des Termins aktualisiert, die wir im Aufruf der Rest-API an Google übergeben. Die übrigen Eigenschaftswerte werden beibehalten. Die Alternative ist das Update. Damit aktualisieren wir den kompletten Termin:<\/p>\n
    https:\/\/developers.google.com\/calendar\/api\/v3\/reference\/events\/update?hl=en<\/pre>\n
    Damit werden alle Eigenschaften aktualisiert. Wir machen es uns einfach und aktualisieren einfach den kompletten Termin. Die dazu verwendete Funktion UpdateEvent <\/b>ist der Funktion InsertEvent <\/b>sehr ähnlich, daher haben wir in nur die Teile abgebildet, wo sich Unterschiede befinden.<\/p>\n
    Neben dem Funktionsnamen ist dies vor allem die Methode des Aufrufs, hier PUT <\/b>statt POST<\/b>. Die URL wird um die EventID aus der Variablen strEventID <\/b>ergänzt. Außerdem enthält die Zeile, die dem Rückgabewert den Wert True <\/b>zuweist, den Namen der Funktion (siehe Listing 3).<\/p>\n
    Public Function <\/span>UpdateEvent(strToken As String<\/span>, strCalendarID As String<\/span>, strSummary As String<\/span>, strDescription _\r\n         As String<\/span>, datStart As Date<\/span>, datEnd As Date<\/span>, bolAllDayEvent, Optional<\/span> strStartTimeZone _\r\n         As String<\/span> = \"Europe\/Berlin\", Optional<\/span> strEndTimeZone As String<\/span> = \"Europe\/Berlin\", Optional<\/span> _\r\n         intColor As <\/span>eColor = colLavendel, Optional<\/span> strResponse As String<\/span>, Optional<\/span> ByRef strEventID As String<\/span>) _\r\n         As Boolean<\/span>\r\n     ''... Identisch mit InsertEvent\r\n         strURL = cStrURLBase & \"\/calendars\/\" & strCalendarID & \"\/events\/\" & strEventID\r\n         strMethod = \"PUT\"\r\n         strAuthorization = \"Bearer \" & strToken\r\n         If <\/span>RefreshAccessToken(\"UpdateEvent\") Then<\/span>\r\n             Select Case HTTPRequest(strURL, strAuthorization, strMethod, , strJSON, strResponse)\r\n                 Case <\/span>200\r\n                     UpdateEvent = True<\/span>\r\n                     Set<\/span> objJSON = ParseJson(strResponse)\r\n                     strEventID = objJSON.Item(\"id\")\r\n                 Case <\/span>404\r\n                     MsgBox<\/span> \"Der Termin mit der EventID ''\" & strEventID & \"'' konnte nicht gefunden werden.\"\r\n                 Case Else<\/span>\r\n                     MsgBox<\/span> strResponse\r\n             End Select<\/span>\r\n         Else<\/span>\r\n             MsgBox<\/span> \"Access-Token ungültig oder nicht aktualisierbar.\"\r\n         End If<\/span>\r\nEnd Function<\/span><\/pre>\n
    Listing 3: Funktion zum Aktualisieren eines Termins<\/span><\/b><\/p>\n
    Schließlich haben wir die Select Case<\/b>-Bedingung, mit der wir den Rückgabewert der Funktion HTTPRequest <\/b>abfragen, um einen Zweig für den Wert 404 erweitert. Dieser wird angesteuert, wenn wir eine EventID angeben, die es nicht gibt, und gibt eine entsprechende Meldung aus.<\/p>\n
    “Löschen” von Terminen im Google Calender<\/h2>\n
    Um die Funktion UpdateEvent <\/b>auszuprobieren, haben wir einen Termin mit der Funktion InsertEvent <\/b>im Google Calendar angelegt. Die Funktion hat daraufhin die EventID <\/b>zurückgeliefert:<\/p>\n
    Public Sub <\/span>Test_InsertEvent()\r\n     Dim <\/span>strEventID As String<\/span>\r\n     If InsertEvent(GetAppSetting(\"AccessToken\"), _\r\n         \"andre.minhorst@googlemail.com\", \"Summary\", _\r\n         \"Description\", Now, Now + 1 \/ 24, , , , , , _\r\n         strEventID) = True<\/span> Then\r\n         Debug.Print<\/span> \"Termin ''\" & strEventID & \"'' angelegt.\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Danach haben wir diese EventID als letzten Parameter eines Aufrufs der Funktion UpdateEvent <\/b>genutzt und konnten damit den Termin in Google aktualisieren:<\/p>\n
    Public Sub <\/span>Test_UpdateEvent()\r\n     Dim <\/span>strEventID As String<\/span>\r\n     strEventID = \"leka4d24rapsjiu77fqikvturk\"\r\n     If UpdateEvent(GetAppSetting(\"AccessToken\"), _\r\n             \"andre.minhorst@googlemail.com\", _\r\n             \"Neue Summary\", Description\", Now, _\r\n             Now + 1 \/ 24, , , , , , _\r\n             strEventID) = True<\/span> Then\r\n         Debug.Print<\/span> \"Termin ''\" & strEventID & \"'' geändert.\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Dies hat den Betreff des Termins wie gewünscht geändert.<\/p>\n
    Dann haben wir den Termin durch Markieren im Google Calendar und anschließendes Betätigen der Entfernen<\/b>-Taste gelöscht.<\/p>\n
    Danach haben wir erneut die Prozedur Test_UpdateEvent <\/b>aufgerufen. Dies führte allerdings nicht zu der Meldung, dass es keinen Termin mit dieser EventID<\/b> gibt, sondern es erschien eine Meldung über die erfolgreiche Aktualisierung.<\/p>\n
    Außerdem erschien der bereits gelöschte Termin wieder im Google Calendar. Das konnten wir auch reproduzieren, wenn wir die Funktion DeleteEvent <\/b>verwendet haben, um den Termin zu löschen.<\/p>\n
    Also haben wir den Termin nochmals gelöscht und uns diesen mit der Funktion GetEventByID <\/b>erneut geholt, um seinen JSON-Code anzusehen. Dieser sieht wie folgt aus und die entscheidende Eigenschaft heißt status <\/b>– hier finden wir den Wert cancelled <\/b>vor:<\/p>\n
    {\r\n  \"kind\": \"calendar#event\",\r\n  \"etag\": \"\\\"3408935113444000\\\"\",\r\n  \"id\": \"e4d35j9hsdovo57be5kigrg2f0\",\r\n  \"status\": \"cancelled\",\r\n  ...\r\n  \"eventType\": \"default\"\r\n}<\/pre>\n
    Das heißt, dass das Löschen eines Termins lediglich zur Änderung des Status in den Wert cancelled <\/b>führt.<\/p>\n
    Mehr Informationen dazu finden wir auf der folgenden Seite, welche die Eigenschaften eines Event-Elements erläutert:<\/p>\n
    https:\/\/developers.google.com\/calendar\/api\/v3\/reference\/events?hl=en<\/pre>\n
    Hier lesen wir von folgenden Werten für den Status:<\/p>\n
      \n
    • confirmed<\/b>: Der Termin ist bestätigt.<\/li>\n
    • tentative<\/b>: Der Termin ist vorläufig bestätigt.<\/li>\n
    • cancelled<\/b>: Der Termin wurde abgesagt (gelöscht).<\/li>\n<\/ul>\n
      Termine werden als cancelled <\/b>markiert und nicht gelöscht, weil er unter Umständen mehrere Teilnehmer hat. Wenn ein Termin, der bereits an Teilnehmer kommuniziert wurde, gelöscht wird, sollten auch alle Teilnehmer über die Absage des Termins informiert werden können. Deshalb wird der Termin nicht direkt gelöscht. Wir können aber mit einem bestimmten Parameter dafür sorgen, dass direkt beim Löschen alle Teilnehmer von der Absage informiert werden.<\/p>\n
      Kalendereinträge einlesen<\/h2>\n
      Im ersten Teil der Artikelreihe mit dem Titel Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) haben wir gezeigt, wie wir Kalendereinträge aus dem Google Calendar einlesen können.<\/p>\n
      Als wir die Funktion im Rahmen dieses Artikels getestet haben, hat alles wie gewünscht funktioniert – anscheinend passte die Konstellation zu diesem Zeitpunkt und mit den getätigten Abfragen.<\/p>\n
      Mittlerweile haben wir die Erfahrung gemacht, dass es etwas komplizierter ist, über die Rest-API an die gewünschten Events zu kommen.<\/p>\n
      In einem neueren Test im Rahmen des vorliegenden Artikels konnten wir plötzlich keinerlei Events mehr auslesen.<\/p>\n
      Die gute Nachricht war: Es lag nicht an unserem Code.<\/p>\n
      Wir haben die gleiche Abfrage nämlich auf der Webseite von Google ausgeführt, wo wir einfach einmal alle Termine einlesen wollten:<\/p>\n
      https:\/\/developers.google.com\/calendar\/api\/v3\/reference\/events\/list<\/pre>\n
      Hier haben wir nur für calendarId<\/b> den Namen unseres Google-Kontos eingegeben und alle anderen Parameter leer gelassen (siehe Bild 3).<\/p>\n
      \"Testen<\/p>\n
      Bild 3: Testen einer Termin-Abfrage<\/span><\/b><\/p>\n
      Das Ergebnis nach einem Klick auf die Schaltfläche Execute <\/b>lieferte zwar keine Fehler, aber auch keine Termine, obwohl wir definitiv einige Termine angelegt hatten (siehe Bild 4).<\/p>\n
      \"Ergebnis<\/p>\n
      Bild 4: Ergebnis eines ersten Tests<\/span><\/b><\/p>\n
      Also untersuchen wir einmal genauer, woran dies liegt. Unten sehen wir ein leeres Element namens items<\/b>. Interessanterweise befindet sich darüber ein Element namens nextPageToken<\/b>. Wir haben damit ausprobiert, ob sich die gesuchten Events vielleicht mit einer weiteren Abfrage finden lassen, die wir mit dem Wert aus nextPageToken <\/b>für die Eigenschaft pageToken <\/b>ausgeführt haben. Es erscheint der gleiche Inhalt, aber diesmal mit einem anderen Wert für nextPageToken<\/b>. Vielleicht ist dies ein Bug.<\/p>\n
      Nur Einzeltermine ausgeben<\/h2>\n
      Als Nächstes haben wir ausprobiert, durch Einstellen der Option singleEvents <\/b>auf den Wert true <\/b>nur einzelne Termine auszulesen und keine Serientermine. Dies lieferte 250 Einträge<\/p>\n
      Die Einstellung false <\/b>für den Wert singleEvents <\/b>lieferte wie erwartet keine Einträge, da wir nur einzelne Termine angelegt hatten.<\/p>\n
      Die Abfrage der singleEvents <\/b>enthielt jedoch wieder den Parameter nextPageToken<\/b>, den wir bei der nächsten Abfrage für die Eigenschaft pageToken <\/b>angegeben haben. Dies lieferte die nächsten 250 Einträge. Auf diese Weise können wir alle Einträge durchlaufen – zumindest die als singleEvents <\/b>angelegten.<\/p>\n
      Weiterhin haben wir dann mit den Parametern für die Datums- und Zeitangabe experimentiert und alles in eine Prozedur gepackt. Dabei handelt es sich um eine Weiterentwicklung der Prozedur GetEventList <\/b>aus dem ersten Teil der Artikelreihe (siehe Listing 4).<\/p>\n
      Public Sub <\/span>GetEventList(strToken As String<\/span>, strCalendarID As String<\/span>, Optional<\/span> intSingleEvents As Integer<\/span> = 1, _\r\n         Optional<\/span> strPageToken As String<\/span>, Optional<\/span> datStart As Date<\/span>, Optional<\/span> datEnd As Date<\/span> , Optional<\/span> intTimeZone As Integer<\/span>)\r\n     Dim <\/span>strURL As String<\/span>\r\n     Dim <\/span>strMethod As String<\/span>\r\n     Dim <\/span>strResponse As String<\/span>\r\n     Dim <\/span>strAuthorization As String<\/span>\r\n     Dim <\/span>objJSON As Object<\/span>\r\n     Dim <\/span>strNextPageToken As String<\/span>\r\n     Dim <\/span>lngItems As Long<\/span>\r\n     strURL = cStrURLBase & \"\/calendars\/\" & strCalendarID & \"\/events\"\r\n     Select Case intSingleEvents\r\n         Case <\/span>False<\/span>\r\n             strURL = strURL & \"?singleEvents=false\"\r\n         Case <\/span>True<\/span>\r\n             strURL = strURL & \"?singleEvents=true\"\r\n     End Select<\/span>\r\n     If <\/span>Len<\/span>(strPageToken) > 0 Then<\/span>\r\n         AddAndOrQuestionmark strURL\r\n         strURL = strURL & \"pageToken=\" & strPageToken\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> datStart = 0 Then<\/span>\r\n         AddAndOrQuestionmark strURL\r\n         strURL = strURL & \"timeMin=\" & Format(DateAdd(\"h\", -intTimeZone, datMin), \"yyyy-mm-ddThh:nn:ssZ\")\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> datEnd = 0 Then<\/span>\r\n         AddAndOrQuestionmark strURL\r\n         strURL = strURL & \"timeMax=\" & Format(DateAdd(\"h\", -intTimeZone, datMax), \"yyyy-mm-ddThh:nn:ssZ\")\r\n     End If<\/span>\r\n     strMethod = \"GET\"\r\n     strAuthorization = \"Bearer \" & strToken\r\n     Select Case HTTPRequest(strURL, strAuthorization, strMethod, , , strResponse)\r\n         Case <\/span>200\r\n             Set<\/span> objJSON = ParseJson(strResponse)\r\n             SaveEventsToTable objJSON\r\n             lngItems = objJSON.Item(\"items\").Count\r\n             Debug.Print<\/span> lngItems, objJSON.Item(\"nextPageToken\")\r\n             If <\/span>lngItems > 0 Then<\/span>\r\n                 strNextPageToken = objJSON.Item(\"nextPageToken\")\r\n                 If <\/span>Not<\/span> Len<\/span>(strNextPageToken) = 0 Then<\/span>\r\n                     GetEventList strToken, strCalendarID, intSingleEvents, strNextPageToken\r\n                 End If<\/span>\r\n             End If<\/span>\r\n         Case Else<\/span>\r\n             MsgBox<\/span> strResponse\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Listing 4: Funktion zum Auslesen von Terminen von Google<\/span><\/b><\/p>\n
      Diese Prozedur erwartet nun einige Parameter mehr als die erste Version:<\/p>\n