{"id":55000418,"date":"2024-02-01T00:00:00","date_gmt":"2024-02-24T18:01:18","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=418"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Termine_von_Outlook_zum_Google_Calendar_exportieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Termine_von_Outlook_zum_Google_Calendar_exportieren\/","title":{"rendered":"Termine von Outlook zum Google Calendar exportieren"},"content":{"rendered":"

\"\"<\/p>\n

Wenn wir Outlook und Google Calendar nutzen, wollen wir vielleicht auch Termine von Outlook aus zum Google Calendar exportieren. In diesem Artikel zeigen wir, wie das für einfache Termine mit den grundlegenden Eigenschaften gelingen kann. Später schauen wir uns an, wie wir die hier geschaffenen Prozeduren von verschiedenen Stellen in Outlook aufrufen können – beispielsweise über das Ribbon oder das Kontextmenüs eines Termins.<\/b><\/p>\n

Ziel dieses Artikels<\/h2>\n

Wenn Du diesen Artikel bis zum Ende gelesen hast, verfügst Du über Kenntnisse, um einen Termin aus Outlook per VBA in den Google Calendar zu übertragen (siehe Bild 1). Zusätzlich erfährst Du, wie Änderungen an diesem Termin in Outlook automatisch in den Termin im Google Calender übertragen werden.<\/p>\n

\"Ein<\/p>\n

Bild 1: Ein von Outlook in den Google Calender übertragener Termin<\/span><\/b><\/p>\n

Übertragen von Terminen mit Basisdaten<\/h2>\n

Termine von Outlook und von Google Calendar können sehr viele unterschiedliche Eigenschaften erfordern – gerade, wenn es um Serientermine geht. Deshalb wollen wir es in diesem Artikel erst einmal einfach halten und nur Termine mit Betreff, Inhalt und den wichtigsten Informationen wie Startdatum und -zeit sowie Enddatum und -zeit übermitteln. Auch um ganztägige Termine wollen wir uns kümmern.<\/p>\n

Als Basis für die Prozeduren dieses Artikels können wir die im Artikel Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) vorgestellten Techniken nurtzen, die wir im Artikel Google Calendar per Rest-API programmieren, Teil 2 <\/b>(www.vbentwickler.de\/415<\/b>) noch erweitert haben. Die Grundlagen für die Authentifizierung für den Austausch von Daten mit dem Google Calendar haben wir in den Artikeln OAuth2-Token für Google per .NET-App holen <\/b>(www.vbentwickler.de\/413<\/b>), Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) und Google-Token per DLL holen <\/b>(www.vbentwickler.de\/409<\/b>).<\/p>\n

Grundlegende Techniken für den Zugriff auf Outlook-Termine findest Du im Artikel Outlook: Kalender und Termine programmieren <\/b>(www.vbentwickler.de\/415<\/b>).<\/p>\n

Ablauf beim Übertragen von Terminen<\/h2>\n

Grundsätzlich ist das Übertragen eines Termins von Outlook zum Google Calendar kein Hexenwerk, wenn wir die Techniken aus den oben vorgestellten Artikeln kennen. Wir brauchen nur den zu übertragenden Termin zu identifizieren, die relevanten Informationen wie Betreff, Inhalt, Startzeit und Endzeit in einer JSON-Datei zusammenzufassen und diese an Google zu senden.<\/p>\n

Allerdings kann es sein, dass sich ein solcher Termin einmal ändert. Wie können wir sicherstellen, dass diese Änderung auch in den Google Calendar übertragen wird? Dazu müssen wir als Erstes ein eindeutiges Merkmal des Termins im Google Calendar ermitteln und dieses mit dem übertragenen Termin speichern. Wenn sich dieser dann ändert, können wir die ID nutzen, um den Google-Termin entsprechend anzupassen. An diese ID kommen wir problemlos heran. Speichern können wir diese in der Eigenschaft BillingInformation <\/b>– das ist eine Eigenschaft, die von Outlook selbst nicht genutzt wird und die auch über die Benutzeroberfläche nicht verfügbar ist.<\/p>\n

Außerdem benötigen wir noch Automatismen, die dafür sorgen, dass Aktionen wie das Ändern oder Löschen eines Termins in Outlook direkt in den Google Calendar übertragen werden.<\/p>\n

Modul im VBA-Projekt von Outlook anlegen<\/h2>\n

Um die benötigten VBA-Prozeduren unterzubringen, legen wir ein neues Modul im VBA-Projekt von Outlook an:<\/p>\n

    \n
  • Wechseln zum VBA-Editor mit der Tastenkombination Alt + F11<\/b><\/li>\n
  • Erstellen eines neuen Moduls mit Einfügen|Modul<\/b><\/li>\n
  • Aktivieren des Eigenschaftenfensters mit der Taste F4<\/b><\/li>\n
  • Markieren des Moduls<\/li>\n
  • Ändern des Namens in mdlGoogleCalendar<\/b><\/li>\n<\/ul>\n

    Dem neuen Modul fügen wir nun erst einmal die beiden Funktionen GetDefaultCalendar<\/b> und GetSelectedAppointmentItem <\/b>hinzu, die wir im Artikel Outlook: Kalender und Termine programmieren <\/b>(www.vbentwickler.de\/415<\/b>) beschreiben. Diese nutzen wir, um den aktuell selektierten Termin in Outlook zu referenzieren. Genau diesen wollen wir nun in den Google Calendar übertragen.<\/p>\n

    Weitere Vorbereitungen<\/h2>\n

    Wir haben alle Module, die wir für die Export-Funktion von Terminen zum Google Calendar benötigen, im Download bereitgestellt. Außerdem findest Du dort ein funktionsfähiges VBA-Projekt für Outlook. Wenn Du dieses ausprobieren möchtest, kannst Du dieses zeitweise statt Deines eigenen VBA-Projekts unter Outlook nutzen. Dazu öffnest Du im Windows Explorer das Verzeichnis C:\\Users\\[Benutzername]\\AppData\\Roaming\\Microsoft\\Outlook<\/b>. Hier findest Du eine Datei namens VbaProject.OTM <\/b>vor. Dieses benennst Du um und fügst die gleichnamige Datei aus dem Download zu diesem Artikel hinzu.<\/p>\n

    Du kannst auch die Module aus dem Download einzeln in das VBA-Projekt importieren. Dazu ziehst Du diese einfach aus dem Windows Explorer in den Projekt-Explorer des VBA-Editors von Outlook. Du musst dann allerdings noch einige Verweise zum VBA-Projekt hinzufügen – in diesem Fall die unteren drei aus Bild 2:<\/p>\n

    \"Notwendige<\/p>\n

    Bild 2: Notwendige Verweise für den Einsatz unserer Beispiellösung<\/span><\/b><\/p>\n

      \n
    • Microsoft Scripting Runtime<\/b><\/li>\n
    • Microsoft XML, v6.0<\/b><\/li>\n
    • amvGoogleOAuth2<\/b><\/li>\n<\/ul>\n

      Für den letzten Verweis musst Du außerdem noch die DLL amvGoogleOAuth2.dll <\/b>installieren. Alle notwendigen Informationen dazu findest Du im Artikel Google-Token per DLL holen <\/b>(www.vbentwickler.de\/409<\/b>).<\/p>\n

      Termin in den Google Calendar übertragen<\/h2>\n

      Damit kommen wir zu der Funktion, mit der wir einen Termin zum Google Calendar übertragen wollen. Sie heißt AppointmentItemToGoogleCalendar<\/b> und sieht wie in Listing 1 aus.<\/p>\n

      Public Function <\/span>AppointmentItemToGoogleCalendar(objAppointmentItem As <\/span>Outlook.AppointmentItem) As String<\/span>\r\n     Dim <\/span>strToken As String<\/span>\r\n     Dim <\/span>strCalendarID As String<\/span>\r\n     Dim <\/span>strSummary As String<\/span>\r\n     Dim <\/span>strDescription As String<\/span>\r\n     Dim <\/span>datStart As Date<\/span>\r\n     Dim <\/span>datEnd As Date<\/span>\r\n     Dim <\/span>intColor As <\/span>eColor\r\n     Dim <\/span>bolAllDayEvent As Boolean<\/span>\r\n     Dim <\/span>strEventID As String<\/span>\r\n     strToken = GetAppSetting(\"AccessToken\")\r\n     strCalendarID = GetAppSetting(\"CalendarID\")\r\n     With<\/span> objAppointmentItem\r\n         strSummary = .Subject\r\n         strDescription = .Body\r\n         datStart = .Start\r\n         datEnd = .End\r\n         bolAllDayEvent = .AllDayEvent\r\n         intColor = colBanane\r\n     End With<\/span>\r\n     CheckToken\r\n     If InsertEvent(strToken, strCalendarID, strSummary, strDescription, datStart, datEnd, bolAllDayEvent, , , _\r\n             intColor, , strEventID) = True<\/span> Then\r\n         MsgBox<\/span> \"Anlegen erfolgreich.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"EventID: \" & strEventID\r\n         AppointmentItemToGoogleCalendar = strEventID\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Anlegen nicht erfolgreich.\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 1: Funktion zum Übertragen eines Termins von Outlook zum Google Calendar<\/span><\/b><\/p>\n
      Die Funktion erwartet nur einen Parameter – den Verweis auf den Termin, der in den Google Calendar geschrieben werden soll. Für den Rückgabewert der Funktion definieren wir den Datentyp String<\/b>. Die Funktion soll im Erfolgsfall die EventID <\/b>des neu hinzugefügten Kalendereintrags liefern.<\/p>\n
      Die Funktion liest das Token und die ID des Zielkalenders aus der Registry ein. Mehr zu diesem Thema liest Du im Artikel Anwendungsdaten in der Registry <\/b>(www.vbentwickler.de\/411<\/b>). Im Artikel Anwendungsdaten in der Registry <\/b>(www.vbentwickler.de\/411<\/b>) beschreiben wir, wie diese Werte zuvor in die Registry geschrieben werden.<\/p>\n
      Den Wert für den Kalender, den wir zuvor teilweise fest im Code verankert hatten, haben wir mit der folgenden Anweisung in der Registry gespeichert (bitte eigenen Kalendernamen einsetzen, der in der Regel der E-Mail-Adresse zum Anmelden entspricht):<\/p>\n
      SaveAppSetting \"CalendarID\", \"andre.minhorst@googlemail.com\"<\/pre>\n
      Danach lesen wir einfach die relevanten Informationen in die dafür vorgesehenen Variablen ein, zum Beispiel Betreff, Inhalt, Startdatum und Enddatum.<\/p>\n
      Nach dem Aufruf der Funktion CheckToken<\/b>, welche die Gültigkeit des Tokens prüft und dieses gegebenenfalls erneuert, rufen wir die Funktion InsertEvent<\/b> auf.<\/p>\n
      Diese haben wir im Artikel Google Calendar per Rest-API programmieren, Teil 2 <\/b>(www.vbentwickler.de\/416<\/b>) beschrieben. <\/p>\n
      Beim Aufruf von InsertEvent <\/b>prüfen wir den Rückgabewert in einer If…Then<\/b>-Bedingung.<\/p>\n
      Wenn die Funktion den Wert True zurückliefert, geben wir eine Meldung aus, die auch die mit dem Parameter strEventID <\/b>zurückgelieferte ID des Termins ausgibt.<\/p>\n
      Aufrufen der Prozedur zum Hinzufügen eines Kalendereintrags im Google Calendar<\/h2>\n
      Die Prozedur aus Listing 2 trifft die Vorbereitungen und ruft die Funktion AppointmentItemToGoogleCalendar <\/b>auf. Sie holt mit der Funktion GetSelectedAppointmentItem <\/b>(siehe Artikel Outlook: Kalender und Termine programmieren <\/b>(www.vbentwickler.de\/415<\/b>)) den aktuell markierten Termin aus Outlook. Wenn dieser nicht leer ist, weil beispielsweise gerade kein Termin markiert ist, ruft die Prozedur die Funktion AppointmentItemToGoogleCalendar <\/b>auf und übergibt das AppointmentItem<\/b>-Element. Der Rückgabewert ist im Erfolgsfall die EventID<\/b> des neu erstellten Termins. Diesen trägt die Prozedur anschließend in die Eigenschaft BillingInformation <\/b>des aus Outlook exportierten Termins ein und speichert diesen.<\/p>\n
      Public Sub <\/span>Test_AppointmentItemToGoogleCalendar()\r\n     Dim <\/span>objAppointmentItem As <\/span>Outlook.AppointmentItem\r\n     Dim <\/span>strEventID As String<\/span>\r\n     Set<\/span> objAppointmentItem = GetSelectedAppointmentItem\r\n     If <\/span>Not<\/span> objAppointmentItem Is Nothing Then<\/span>\r\n         strEventID = AppointmentItemToGoogleCalendar(objAppointmentItem)\r\n         With<\/span> objAppointmentItem\r\n             .BillingInformation = strEventID\r\n             .Save\r\n         End With<\/span>\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Kein zu exportierender Termin angegeben.\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Listing 2: Prozedur zum Aufrufen der Funktion AppointmentItemToGoogleCalendar<\/span><\/b><\/p>\n
      Testen, ob die EventID im Outlook-Termin gespeichert wurde<\/h2>\n
      Mit einer kleinen Prozedur wollen wir nun testen, ob die EventID <\/b>in der Eigenschaft BillingInformation <\/b>eingetragen wurde. Das erledigen wir wieder mit Unterstützung der Funktion GetSelectedAppointmentItem<\/b>:<\/p>\n
      Public Sub <\/span>Test_EntryID()\r\n     Dim <\/span>objAppointmentItem As <\/span>Outlook.AppointmentItem\r\n     Set<\/span> objAppointmentItem = GetSelectedAppointmentItem\r\n     Debug.Print<\/span> objAppointmentItem.BillingInformation\r\nEnd Sub<\/span><\/pre>\n
      Dies liefert ein Ergebnis wie 36kis3n1kt1sc5ch82a54k4u5k<\/b>.<\/p>\n
      Was können wir mit dieser Information nun anfangen? Augenscheinlich sollten wir die EventID <\/b>nutzen können, um damit einen bereits zum Google Calendar übertragenen Termin aktualisieren zu können. Es gibt aber noch einen anderen Nutzen im Hinblick auf das Übertragen von Terminen zum Google Calendar. Wie können an dem Wert in der Eigenschaft BillingInformation <\/b>erkennen, ob ein Outlook-Termin bereits nach Google übertragen wurde. Und das sollten wir erst einmal in der Funktion AppointmentItemToGoogleCalendar <\/b>berücksichtigen, damit ein bereits übertragener Termin nicht nochmals übertragen wird.<\/p>\n
      Prüfen, ob ein Termin bereits übertragen wurde<\/h2>\n
      Dazu müssen wir vor dem Aufruf der Funktion InsertEvent <\/b>den Wert von BillingInformation <\/b>prüfen. Dies ist ein erster Hinweis darauf, dass dieser Termin zumindest schon einmal zum Google Calendar übertragen wurde. Es kann aber auch sein, dass dieser Termin in Google wieder gelöscht wurde. Wir müssten also zusätzlich noch prüfen, ob dieser Termin noch in Google vorhanden ist.<\/p>\n
      Dazu nutzen wir die Funktion aus Listing 3. Diese prüft zuerst, ob strEventID <\/b>überhaupt gefüllt ist (strEventID <\/b>kommt aus der Eigenschaft BillingInformation <\/b>des Outlook-Termins). Ist dies nicht der Fall, wird die Funktion direkt mit dem Rückgabewert False <\/b>beendet. Anderenfalls ruft die Funktion eine weitere Funktion namens GetEventByID<\/b> auf, die wir im Artikel Google Calendar per Rest-API programmieren, Teil 2 <\/b>(www.vbentwickler.de\/416<\/b>) vorstellen. Sie liefert den Wert True <\/b>zurück, wenn es bereits einen Termin mit der angegebenen EventID <\/b>gibt.<\/p>\n
      Public Function <\/span>CheckIfEventExists(strToken As String<\/span>, strCalendarID As String<\/span>, strEventID As String<\/span>) As Boolean<\/span>\r\n     If <\/span>Len<\/span>(strEventID) = 0 Then<\/span>\r\n         Exit Function<\/span>\r\n     Else<\/span>\r\n         If <\/span>GetEventByID(strEventID) = True<\/span> Then<\/span>\r\n             CheckIfEventExists = True<\/span>\r\n         End If<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 3: Funktion zur Prüfung, ob ein Outlook-Termin bereits als Google-Termin angelegt wurde<\/span><\/b><\/p>\n
      Vorhandenen Termin anpassen<\/h2>\n
      Wenn der Termin bereits vorhanden ist, wollen wir diesen in Google mit den Werten des Outlook-Termins anpassen. Dazu nutzen wir eine weitere Funktion namens UpdateEvent<\/b>, die wir ebenfalls im oben genannten Artikel vorstellen. Diese Funktion erwartet fast die gleichen Parameter wie die weiter oben bereits verwendete InsertEvent<\/b>. Der einzige Unterschied ist, dass wir dieser bereits einen Wert für den Parameter strEventID <\/b>übergeben, denn sie soll ja einen vorhandenen Google-Termin mit den Daten aus Outlook aktualisieren.<\/p>\n
      Funktion AppointmentItemToGoogleCalendar um Aktualisierung erweitern<\/h2>\n
      Die obige Funktion AppointmentItemToGoogleCalendar <\/b>enthält bisher nur den Aufruf der Funktion InsertEvent<\/b>. Dies wollen wir nun so erweitern, dass wir auch die Funktion UpdateEvent <\/b>nutzen können. An der Stelle, wo wir bisher einfach die Funktion InsertEvent <\/b>aufgerufen haben, fügen wir nun eine If…Then<\/b>-Bedingung ein. Diese nutzt die Funktion CheckIfEventExists<\/b>, um zu ermitteln, ob der Termin bereits vorhanden ist. Ist das der Fall, ruft die Prozedur im If<\/b>-Teil die Funktion InsertEvent <\/b>auf und legt so den Termin neu an. Im Erfolgsfall erscheint eine Meldung mit der EventID <\/b>des neuen Termins.<\/p>\n
      Anderenfalls ruft die Routine im Else<\/b>-Teil die Funktion UpdateEvent <\/b>auf. Liefert diese den Wert True <\/b>zurück, erscheint ebenfalls eine entsprechende Meldung (siehe Listing 4).<\/p>\n
      Public Function <\/span>AppointmentItemToGoogleCalendar(objAppointmentItem As <\/span>Outlook.AppointmentItem) As String<\/span>\r\n     ''...wie in der vorherigen Version\r\n     If <\/span>CheckToken Then<\/span>\r\n         If <\/span>Not<\/span> CheckIfEventExists(strToken, strCalendarID, strEventID) Then<\/span>\r\n             If InsertEvent(strToken, strCalendarID, strSummary, strDescription, datStart, datEnd, _\r\n                     bolAllDayEvent, , , intColor, , strEventID) = True<\/span> Then\r\n                 MsgBox<\/span> \"Anlegen erfolgreich.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"EventID: \" & strEventID\r\n                 AppointmentItemToGoogleCalendar = strEventID\r\n             Else<\/span>\r\n                 MsgBox<\/span> \"Anlegen nicht erfolgreich.\"\r\n             End If<\/span>\r\n         Else<\/span>\r\n             If UpdateEvent(strToken, strCalendarID, strSummary, strDescription, datStart, datEnd, _\r\n                    bolAllDayEvent, , , intColor, , strEventID) = True<\/span> Then\r\n                 MsgBox<\/span> \"Aktualisieren erfolgreich.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"EventID: \" & strEventID\r\n                 AppointmentItemToGoogleCalendar = strEventID\r\n             Else<\/span>\r\n                 MsgBox<\/span> \"Aktualisieren nicht erfolgreich.\"\r\n             End If<\/span>\r\n         End If<\/span>\r\n     Else<\/span>\r\n         MsgBox<\/span> \"Authentifizierung nicht erfolgreich.\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
      Listing 4: Funktion zum Anlegen oder Aktualisieren eines Outlook-Termins im Google Calendar<\/span><\/b><\/p>\n
      Google-Termine löschen, wenn Outlook-Termin gelöscht wird<\/h2>\n
      Im Artikel Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) haben wir mit DeleteEvent <\/b>bereits eine Funktion beschreiben, mit der wir einen Termin im Google Calendar löschen können.<\/p>\n
      Diese müssten wir aufrufen, wenn der Benutzer einen Termin in Outlook löschen. Das ist allerdings ein wenig aufwendiger, denn dazu müssen wir das entsprechende Ereignis des Termins implementieren.<\/p>\n
      Im Grunde sind aber auch die bisher vorgestellten Routinen nur dann sinnvoll, wenn wir diese aufrufen, wenn die entsprechenden Aktionen in Outlook ausgelöst wurde – also wenn wir einen neuen Termin angelegt oder einen bestehenden Termin geändert haben. Und nun kommt noch das Löschen eines Termins hinzu, sodass wir über das Implementieren von Ereignissen nachdenken sollten.<\/p>\n
      Outlook-Termine immer in den Google Calendar synchronisieren<\/h2>\n
      Wir müssen also die entsprechenden Elemente von Outlook mit WithEvents <\/b>deklarieren und die benötigten Ereignisse implementieren.<\/p>\n
      Das erledigen wir allerdings nicht mehr in diesem Artikel, sondern in einem weiteren Artikel namens Outlook: Ereignisse für Termine implementieren <\/b>(www.vbentwickler.de\/417<\/b>).<\/p>\n
      Hier schauen wir uns an, wie wir neue Termine direkt beim Erstellen referenzieren und auf die Ereignisse dieses Termins reagieren – vor allem auf das Speichern und Löschen des Termins. Mit dem Speichern erschlagen wir zwei Fliegen mit einer Klappe: Damit können wir nämlich sowohl das Anlegen neuer Termine als auch das Aktualisieren von Terminen erfassen.<\/p>\n
      Zusammenfassung und Ausblick<\/h2>\n
      Dieser Artikel zeigt, wie wir Termine von Outlook in den Google Calendar übertragen. Dabei lesen wir direkt die EventID<\/b> des neu angelegten Termins aus und speichern diesen mit dem Outlook-Termin.<\/p>\n
      Dadurch können wir bei Änderungen des Termins in Outlook gleich eine Aktualisierung des entsprechenden Termins im Google Calendar durchführen. Offen ist noch das Löschen von Terminen, die grundlegenden Techniken schauen wir uns in dem oben erwähnten Beitrag Outlook: Ereignisse für Termine implementieren <\/b>an.<\/p>\n
      Downloads zu diesem Beitrag<\/h2>\n
      Enthaltene Beispieldateien:<\/p>\n
      ThisOutlookSession.cls<\/p>\n
      Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      Wenn wir Outlook und Google Calendar nutzen, wollen wir vielleicht auch Termine von Outlook aus zum Google Calendar exportieren. In diesem Artikel zeigen wir, wie das für einfache Termine mit den grundlegenden Eigenschaften gelingen kann. Später schauen wir uns an, wie wir die hier geschaffenen Prozeduren von verschiedenen Stellen in Outlook aufrufen können – beispielsweise über das Ribbon oder das Kontextmenüs eines Termins.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012024,662024,44000027,44000026],"tags":[],"yst_prominent_words":[],"class_list":["post-55000418","post","type-post","status-publish","format-standard","hentry","category-66012024","category-662024","category-Excel_programmieren","category-Outlook_programmieren"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000418","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000418"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000418\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000418"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000418"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000418"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000418"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}