{"id":55000414,"date":"2024-02-01T00:00:00","date_gmt":"2024-02-25T19:10:19","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=414"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"GoogleAuthentifizierung_mit_OAuth2_Update","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/GoogleAuthentifizierung_mit_OAuth2_Update\/","title":{"rendered":"Google-Authentifizierung mit OAuth2, Update"},"content":{"rendered":"

\"\"<\/p>\n

In den beiden Artikeln “OAuth2-Token für Google per .NET-App holen” (www.vbentwickler.de\/413) und “Google-Token per DLL holen” (www.vbentwickler.de\/409) haben wir Techniken beschrieben, mit denen wir ein Google OAuth2-Token ermitteln können, das wir für den Zugriff auf die Google Rest API per VBA benötigen. Dazu haben wir das NuGet-Paket Google.Apis.Calendar.v3 <\/b>verwendet. Leider funktionierte das Ermitteln des Access-Tokens mit dem Refresh-Token nicht wie gewünscht. Also stellen wir in diesem Artikel eine Erweiterung der Projekte aus den vorgenannten Artikeln vor, mit denen wir den Zugriff immer erneuern können – wenn auch jeweils auf Kosten einer erneuten Anmeldung über den Webbrowser.<\/b><\/p>\n

Wie erhielten, wenn wir per VBA die mit den oben genannten Lösungen ermittelten Access-Token für den Zugriff auf die Google Calendar-API genutzt haben, in vielen Fällen die Meldung, dass Token nicht mehr gültig sei (siehe Bild 1).<\/p>\n

\"Fehlermeldung<\/p>\n

Bild 1: Fehlermeldung bei fehlgeschlagener Authentifizierung<\/span><\/b><\/p>\n

Andererseits erlaubten uns die in den beiden Projekten verwendeten Versuche der Authorisierung über die Methode AuthorizeAsync <\/b>der Klasse GoogleWebAuthorizationBroker <\/b>nicht, das Token zu erneuern oder dieses erneut freizuschalten.<\/p>\n

Nach einer Weile intensiven Suchens haben wir im Internet herausgefunden, dass diese Klasse eine Datei im folgenden Verzeichnis anlegt:<\/p>\n

C:\\Users\\[Benutzername]\\AppData\\Roaming\\Google.Apis.Auth<\/pre>\n
Diese Datei heißt Google.Apis.Auth.OAuth2.Responses.TokenResponse-user <\/b>und sieht wie in Bild 2 aus.<\/p>\n
\"Die<\/p>\n
Bild 2: Die Datei mit den aktuellen Authentifizierungsdaten<\/span><\/b><\/p>\n
Erst, wenn wir diese löschen, erhalten wir die Möglichkeit, uns mit dem Webdialog aus Bild 3 erneut zu authentifizieren.<\/p>\n
\"Erneute<\/p>\n
Bild 3: Erneute Authentifizierung nach dem Löschen der Datei<\/span><\/b><\/p>\n
Danach können wir wieder für eine Stunde mit diesen Zugangsdaten arbeiten, danach müssen wir uns erneut authentifizieren.<\/p>\n
Herausfinden, ob das Konto noch verbunden ist<\/h2>\n
Wenn wir das Konto so ausgewählt und den Zugriff gestattet haben, können wir mit den VBA-Routinen, die wir zum Beispiel im Artikel Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) vorgestellt haben, auf den Kalender des Benutzers zugreifen, in dessen Kontext wir den Zugriff freigeschaltet haben.<\/p>\n
Manchmal gelingt dies nicht, und wir können dann die Verbindung für dieses Konto zuerst löschen und dann wieder herstellen. Dazu müssen wir erst einmal wissen, wo man einsieht, ob für dieses Konto überhaupt noch eine Verbindung besteht.<\/p>\n
Dazu geben wir im Browser die folgende URL ein:<\/p>\n
https:\/\/myaccount.google.com\/<\/pre>\n
Auf der nun erscheinenden Seite wählen wir links den Bereich Sicherheit <\/b>aus und scrollen dann nach unten zu Ihre Verbindungen zu Drittanbieter-Apps und -diensten <\/b>(siehe Bild 4).<\/p>\n
\"Der<\/p>\n
Bild 4: Der Bereich Sicherheit im Google-Benutzerkonto<\/span><\/b><\/p>\n
Hier erscheint bereits der Eintrag namens amvGoogleCalender<\/b>, den wir untersuchen wollen. Sollte dieser nicht direkt sichtbar sein, klicken wir unten auf Alle Verbindungen ansehen<\/b>.<\/p>\n
Danach klicken wir auf den Eintrag amvGoogleCalendar<\/b>. Es erscheint die Anzeige aus Bild 5. Hier sehen wir zwei Möglichkeiten:<\/p>\n
\"Details<\/p>\n
Bild 5: Details zur App amvGoogleCalendar<\/span><\/b><\/p>\n
    \n
  • Anzeige von Details über die Zugriffsberechtigungen<\/li>\n
  • Löschen der Verbindungen mit der App amvGoogleCalendar<\/b><\/li>\n<\/ul>\n
    Wenn wir die erste Möglichkeit nutzen und auf die Schaltfläche Details ansehen <\/b>klicken, finden wir die Seite aus Bild 6 vor. Hier sehen wir wichtige Informationen, zum Beispiel wann der Zugriff gewährt wurde – also wann das Access-Token freigeschaltet wurde. Wir können noch einen Bereich aufklappen, der uns anzeigt, welche Berechtigungen wir der App genau freigeben. Wir können aber auch hier auf Zugriff entfernen klicken, was dazu führt, dass eine Meldung mit den Konsequenzen angezeigt wird. In diesem Fall werden alle Berechtigungen der App für unseren Kalender entzogen. Wir können dies nur wiederherstellen, indem wir das Access-Token erneut generieren.<\/p>\n
    \"Details<\/p>\n
    Bild 6: Details über die Zugriffsberechtigungen<\/span><\/b><\/p>\n
    Entfernen wir die Zugriffsrechte für die App und versuchen anschließend, mit den VBA-Prozeduren auf den Google-Kalender zuzugreifen, erhalten wir wieder die Antwort, dass wir mit ungültigen Credentials zugegriffen haben.<\/p>\n
    Erneut anmelden<\/h2>\n
    Rufen wir nun beispielsweise die Funktion GetTokens <\/b>aus der VBA-Lösung auf, läuft diese ohne Probleme durch und zeigt uns eine Meldung mit den ermittelten Daten, in diesem Fall dem Access-Token und dem Refresh-Token (siehe Bild 7).<\/p>\n
    \"Meldung<\/p>\n
    Bild 7: Meldung mit den ermittelten Zugriffsdaten<\/span><\/b><\/p>\n
    Allerdings erscheint kein Webbrowser mit der Abfrage des zu verwendenden Kontos und der Bestätigung des Zugriffs durch die App amvGoogleCalendar <\/b>auf dieses Konto. Das heißt nichts Gutes, denn dieser Schritt sollte nach dem Entfernen und dem Erneuern der Berechtigungen erfolgen.<\/p>\n
    Hier ist nun das oben beschriebene Problem aufgetreten: Dadurch, dass die Datei Google.Apis.Auth.OAuth2.Responses.TokenResponse-user <\/b>noch im Ordner C:\\Users\\User\\AppData\\Roaming\\Google.Apis.Auth <\/b>gespeichert ist, nimmt die DLL an, das dies noch gültige Zugangsdaten sind.<\/p>\n
    Wir müssen also an irgendeiner Stelle das Löschen oder Umbenennen dieser Datei integrieren.<\/p>\n
    Wir integrieren dies in die Prozedur GetTokens<\/b> der Beispieldatenbank GoogleCalendar2<\/b>. Als Erstes müssen wir dazu herausfinden, wie wir zuverlässig auf das Verzeichnis zugreifen, in dem sich die Datei Google.Apis.Auth.OAuth2.Responses.TokenResponse-user <\/b>befindet.<\/p>\n
    Dies ist das Anwendungsverzeichnis im Verzeichnis des aktuellen Benutzers. Um dieses zu erhalten, nutzen wir die Funktion Environ <\/b>mit dem Parameter AppData<\/b>. An dieses hängen wir das Verzeichnis Google.Apis.Auth <\/b>an und dahinter den Dateinamen der zu löschenden Datei. Den Löschvorgang mit der Kill<\/b>-Anweisung fassen wir noch in On Error Resume Next <\/b>und On Error Goto 0 <\/b>ein.<\/p>\n
    Damit verhindern wir, dass ein Fehler ausgelöst wird, wenn die Datei noch gar nicht oder nicht mehr vorhanden ist. Die neue Version der Routine GetTokens<\/b> sieht wie in Listing 1 aus.<\/p>\n
    Public Function <\/span>GetTokens() As Boolean<\/span>\r\n     Dim <\/span>strClientID As String<\/span>\r\n     Dim <\/span>strClientSecret As String<\/span>\r\n     Dim <\/span>strRefreshToken As String<\/span>\r\n     Dim <\/span>strAccessToken As String<\/span>\r\n     Dim <\/span>lngExpiresInSeconds As Long<\/span>\r\n     strClientID = GetAppSetting(\"ClientID\")\r\n     If <\/span>Len<\/span>(strClientID) = 0 Then<\/span>\r\n         MsgBox<\/span> \"Keine ClientID in der Registry gefunden. Verwende die Prozedur SetClientData.\", vbOKOnly + _\r\n             vbExclamation, \"ClientID fehlt\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     strClientSecret = GetAppSetting(\"ClientSecret\")\r\n     If <\/span>Len<\/span>(strClientSecret) = 0 Then<\/span>\r\n         MsgBox<\/span> \"Kein ClientSecret in der Registry gefunden. Verwende die Prozedur SetClientData.\", vbOKOnly + _\r\n             vbExclamation, \"ClientSecret fehlt\"\r\n         Exit Function<\/span>\r\n     End If<\/span>\r\n     On Error Resume Next<\/span>\r\n     Kill Environ(\"AppData\") & \"\\Google.Apis.Auth\\Google.Apis.Auth.OAuth2.Responses.TokenResponse-user\"\r\n     On Error GoTo<\/span> 0\r\n     If <\/span>GetTokensDLL(strClientID, strClientSecret, strRefreshToken, strAccessToken, lngExpiresInSeconds) Then<\/span>\r\n         SaveAppSetting \"RefreshToken\", strRefreshToken\r\n         SaveAppSetting \"AccessToken\", strAccessToken\r\n         SaveAppSetting \"TokenExpiresAt\", DateAdd(\"s\", lngExpiresInSeconds, Now)\r\n         GetTokens = True<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
    Listing 1: Die Prozedur GetTokens holt die Token für die ClientID und das ClientSecret.<\/span><\/b><\/p>\n
    Diese haben wir außerden noch in eine Funktion umgewandelt, die den Wert True <\/b>zurückgibt, wenn die Funktion GetTokensDLL <\/b>erfolgreich ausgeführt wurde.<\/p>\n
    Access-Token erneuern oder beide Token neu erstellen<\/h2>\n
    Nachdem wir nun die Prozedur GetTokens <\/b>so aktualisiert haben, dass diese automatisch die Datei mit den aktuellen Zugangsdaten löscht, damit diese neu erstellt und freigegeben werden kann, wollen wir auch noch die Prozedur RefreshAccessToken <\/b>so erweitern, dass diese prüft, ob das Access-Token erneuert werden konnte (siehe Listing 2).<\/p>\n
    Public Function <\/span>RefreshAccessToken() As Boolean<\/span>\r\n     Dim <\/span>strClientID As String<\/span>\r\n     Dim <\/span>strClientSecret As String<\/span>\r\n     Dim <\/span>lngExpiresIn As Long<\/span>\r\n     Dim <\/span>strRefreshToken As String<\/span>\r\n     Dim <\/span>strAccessToken As String<\/span>\r\n     Dim <\/span>lngStatus As Long<\/span>\r\n     Dim <\/span>strErrorTitle As String<\/span>\r\n     Dim <\/span>strErrorDescription As String<\/span>\r\n     \r\n     strClientID = GetAppSetting(\"ClientID\")\r\n     strClientSecret = GetAppSetting(\"ClientSecret\")\r\n     strRefreshToken = GetAppSetting(\"RefreshToken\")\r\n         \r\n     If RefreshAccessTokenRestAPI(strClientID, strClientSecret, strRefreshToken, strAccessToken, lngExpiresIn, _\r\n             lngStatus, strErrorTitle, strErrorDescription) = True<\/span> Then\r\n         SaveAppSetting \"AccessToken\", strAccessToken\r\n         SaveAppSetting \"TokenExpiresAt\", DateAdd(\"s\", lngExpiresIn, Now)\r\n         RefreshAccessToken = True<\/span>\r\n     Else<\/span>\r\n         Select Case strErrorTitle\r\n             Case <\/span>\"invalid_grant\"\r\n                 If MsgBox<\/span>(\"Authentifizierungstoken nicht mehr gültig. Erneuern?\", vbYesNo + vbExclamation, _\r\n                         \"Token ungültig\") = vbYes Then\r\n                     If <\/span>GetTokens = True<\/span> Then<\/span>\r\n                         RefreshAccessToken = True<\/span>\r\n                     End If<\/span>\r\n                 End If<\/span>\r\n             Case Else<\/span>\r\n                 MsgBox<\/span> \"Status: \" & lngStatus & vbCrLf<\/span> & vbCrLf<\/span> & \"Fehler: \" & strErrorTitle & vbCrLf<\/span> & vbCrLf<\/span> _\r\n                     & \"Beschreibung: \" & strErrorDescription, vbCr<\/span>itical + vbOKOnly, \"Fehler bei Refresh Token\"\r\n         End Select<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
    Listing 2: Erneuern des Access-Tokens oder beider Token<\/span><\/b><\/p>\n
    Ist dies nicht der Fall, sollen beide Token, also Refresh-Token und Access-Token, erneuert werden.<\/p>\n
    Das erledigen wir durch den Aufruf der soeben beschriebenen Prozedur GetTokens<\/b>, allerdings nur in einem bestimmten Fall.<\/p>\n
    Dazu haben wir der Funktion RefreshAccessToken<\/b> eine Select Case<\/b>-Bedingung im Else<\/b>-Teil der If…Then<\/b>-Bedingung hinzugefügt, die prüft, ob RefreshAccessTokenRestAPI <\/b>erfolgreich war.<\/p>\n
    War diese nicht erfolgreich, folgt im Else<\/b>-Zweig die Select Case-Anweisung, die den Inhalt des Parameters strErrorTitle <\/b>mit dem Titel des Fehlers prüft. Lautet dieser auf invalid_grant<\/b>, zeigt die Funktion eine Meldung an, in welcher der Benutzer entscheiden kann, ob er beide Token komplett neu erstellen und freigeben lassen möchte. Ist das der Fall, rufen wir die oben beschriebene Funktion GetTokens <\/b>auf. Sofern diese den Wert True <\/b>zurückliefert, stellen wir auch den Rückgabewert der Funktion RefreshAccessToken <\/b>ebenfalls auf den Wert True <\/b>ein.<\/p>\n
    Dazu haben wir aus der Prozedur CheckToken<\/b> ebenfalls eine Funktion gemacht, die nun wie in Listing 3 aussieht.<\/p>\n
    Public Function <\/span>CheckToken() As Boolean<\/span>\r\n     Dim <\/span>datTokenExpiresAt As Date<\/span>\r\n     If <\/span>Len<\/span>(GetAppSetting(\"TokenExpiresAt\")) = 0 Then<\/span>\r\n         datTokenExpiresAt = 0\r\n     Else<\/span>\r\n         datTokenExpiresAt = GetAppSetting(\"TokenExpiresAt\")\r\n     End If<\/span>\r\n     If <\/span>datTokenExpiresAt < Now Then<\/span>\r\n         If <\/span>RefreshAccessToken Then<\/span>\r\n             CheckToken = True<\/span>\r\n         End If<\/span>\r\n     Else<\/span>\r\n         CheckToken = True<\/span>\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
    Listing 3: Prüfen des Tokens<\/span><\/b><\/p>\n
    Erweiterung der App zum Erneuern der Token<\/h2>\n
    Auch die App, die wir im Artikel OAuth2-Token für Google per .NET-App holen <\/b>(www.vbentwickler.de\/413<\/b>) vorgestellt haben, haben wir etwas überarbeitet.<\/p>\n
    Als Erstes haben wir eine weitere Schaltfläche hinzugefügt, die den Test der Verbindung per Rest-API mit den aktuell angezeigten Daten erlaubt. Diese zeigt nun entweder an, dass der Test erfolgreich war, oder liefert eine Fehlermeldung wie in Bild 8.<\/p>\n
    \"Erweiterung<\/p>\n
    Bild 8: Erweiterung der amvGetGoogleToken-App um eine Funktion zum Testen der Authentifizierung<\/span><\/b><\/p>\n
    Hinter dieser Schaltfläche verbirgt sich prinzipiell die gleiche Funktion, die wir auch in der Access-Datenbank GoogleCalendar2.accdb <\/b>verwenden. Ein wichtiger Unterschied: Unter VB.NET müssen wir Parameter, die Werte zurückliefern sollen, explizit als ByRef <\/b>deklarieren.<\/p>\n
    Daneben haben wir die Prozedur erweitert, die durch die Schaltfläche zum Aktualisieren der Token dient (btnRefresh<\/b>) – siehe Listing 4.<\/p>\n
    Private Sub <\/span>btnRefresh_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     Dim <\/span>objCalendarService As <\/span>Google.Apis.Calendar.v3.CalendarService\r\n     Dim <\/span>objClientSecrets As <\/span>New<\/span> ClientSecrets\r\n     Dim <\/span>objCredential As <\/span>Google.Apis.Auth.OAuth2.UserCredential\r\n     Dim <\/span>objInitializer As <\/span>BaseClientService.Initializer\r\n     Dim <\/span>intCode As Integer<\/span>\r\n     Dim <\/span>strResponse As String<\/span> = \"\"\r\n     Dim <\/span>strTokenFile As String<\/span> = \"\"\r\n     With<\/span> objClientSecrets\r\n         .ClientId = txtClientID.Text\r\n         .ClientSecret = txtClientSecret.Text\r\n     End With<\/span>\r\n     Try\r\n         objCredential = GoogleWebAuthorizationBroker.AuthorizeAsync(objClientSecrets, _\r\n             {CalendarService.Scope.Calendar}, \"user\", CancellationToken.None).Result\r\n         objInitializer = New<\/span> BaseClientService.Initializer\r\n         objInitializer.HttpClientInitializer = objCredential\r\n         objCalendarService = New<\/span> CalendarService(objInitializer)\r\n         txtRefreshToken.Text = objCredential.Token.RefreshToken\r\n         txtAccessToken.Text = objCredential.Token.AccessToken\r\n         txtExpiresAt.Text = DateAdd(DateInterval.Second, CLng(objCredential.Token.ExpiresInSeconds), Now)\r\n     Catch ex As <\/span>Exception\r\n         MsgBox<\/span>(\"Ausnahme: \" & ex.Message)\r\n     End Try\r\n     If <\/span>TestRequest(strResponse, intCode) = True<\/span> Then<\/span>\r\n         MsgBox<\/span>(\"Token erneuert.\", vbOKOnly + vbExclamation, \"amvGetGoogleToken\")\r\n     Else<\/span>\r\n         MsgBox<\/span>(\"Token nicht erneuert.\" & vbCrLf<\/span> & vbCrLf<\/span> & strResponse, vbOKOnly + vbCr<\/span>itical, \"amvGetGoogleToken\")\r\n         strTokenFile = Environ(\"AppData\") & \"\\Google.Apis.Auth\\Google.Apis.Auth.OAuth2.Responses.TokenResponse-user\"\r\n         If <\/span>Not<\/span> Len<\/span>(Dir(strTokenfile)) = 0 Then<\/span>\r\n             If MsgBox<\/span>(\"Dies kann daran liegen, dass die folgende Datei erst gelöscht werden muss:\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n                     & strTokenFile & vbCrLf<\/span> & vbCrLf<\/span> & \"Löschen und erneut versuchen?\", vbYesNo + vbExclamation, _\r\n                     \"amvGetGoogleTokens\") = vbYes Then\r\n                 Try\r\n                     Kill(strTokenFile)\r\n                     btnRefresh_Click(sender, e)\r\n                 Catch\r\n                 End Try\r\n             End If<\/span>\r\n         End If<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Listing 4: Aktualisieren der Token<\/span><\/b><\/p>\n
    Dieser Prozedur haben wir hinter dem eigentlichen Vorgang zum Aktualisieren des Tokens einen Aufruf der Prozedur TestRequest <\/b>hinzugefügt, die einen einfachen Aufruf an die Google Rest-API sendet. Wenn diese den Wert True <\/b>zurückliefert, war der Aufruf erfolgreich und das Token kann nun verwendet werden.<\/p>\n
    Wenn nicht, erscheint eine Meldung mit dem Hinweis, dass das Token nicht erneut erstellt und autorisiert werden konnte. Zusätzlich wird die von der Rest-API zurückgelieferte Fehlermeldung übergeben. In einer zweiten Meldung fragt die App den Benutzer, ob dieser die Datei Google.Apis.Auth.OAuth2.Responses.TokenResponse-user <\/b>löschen möchte.<\/p>\n
    Stimmt der Benutzer dem zu, versucht die Prozedur, die Datei mit der Kill<\/b>-Anweisung zu löschen und ruft sich anschließend erneut selbst auf.<\/p>\n
    Zusammenfassung und Ausblick<\/h2>\n
    Wir haben in diesem Artikel untersucht, ob und wann die Authentifizierung nicht mehr funktioniert und warum diese nicht einfach erneuert werden kann, wenn sie nicht mehr funktioniert.<\/p>\n
    Der Grund ist, dass die NuGet-Bibliothek Google.Apis.Calendar.v3<\/b> zum Erstellen des Tokens eine Datei mit den resultierenden Informationen speichert, die bei späteren Versuchen der Authentifizierung geprüft wird. Wenn diese Datei noch vorhanden ist, geht die Bibliothek offensichtlich davon aus, dass auch die Authentifizierung mit dem aktuell gespeicherten Access-Token noch funktioniert.<\/p>\n
    Deshalb haben wir sowohl die VBA-Prozedur in der Access-Datenbank amvGoogleCalendar2.accdb <\/b>als auch das .NET-Tool zum Erstellen der Token so erweitert, dass diese die Datei vor dem erneuten Autorisieren eines Tokens löscht und dann erst die Neuerstellung der Token anstößt.<\/p>\n
    Mit diesen optimierten Prozeduren können wir nun weitere Möglichkeiten der Rest-API für den Google Calendar untersuchen als auch konkrete Lösungen programmieren – beispielsweise, um Termine von Outlook per Mausklick an den Google-Kalender zu übertragen oder auch Einträge aus dem Google-Kalender nach Outlook zu importieren. Dies schauen wir uns in weiteren Artikeln an.<\/p>\n
    Downloads zu diesem Beitrag<\/h2>\n
    Enthaltene Beispieldateien:<\/p>\n
    amvGoogleOAuth2.zip<\/p>\n
    Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    In den beiden Artikeln “OAuth2-Token für Google per .NET-App holen” (www.vbentwickler.de\/413) und “Google-Token per DLL holen” (www.vbentwickler.de\/409) haben wir Techniken beschrieben, mit denen wir ein Google OAuth2-Token ermitteln können, das wir für den Zugriff auf die Google Rest API per VBA benötigen. Dazu haben wir das NuGet-Paket Google.Apis.Calendar.v3 verwendet. Leider funktionierte das Ermitteln des Access-Tokens mit dem Refresh-Token nicht wie gewünscht. Also stellen wir in diesem Artikel eine Erweiterung der Projekte aus den vorgenannten Artikeln vor, mit denen wir den Zugriff immer erneuern können – wenn auch jeweils auf Kosten einer erneuten Anmeldung über den Webbrowser.<\/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,44000012,44000023,44000036],"tags":[],"yst_prominent_words":[],"class_list":["post-55000414","post","type-post","status-publish","format-standard","hentry","category-66012024","category-662024","category-Interaktiv","category-PowerApps","category-Ribbon_programmieren"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000414","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=55000414"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000414\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000414"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000414"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000414"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000414"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}