<\/p>\n
In verschiedenen anderen Artikeln haben wir die Techniken vorgestellt, mit denen per VBA wir Termine in den Google Calendar eintragen können und auf Ereignisse wie das Anlegen, Ändern oder Löschen von Terminen in Outlook reagieren können. Wir wollen dies nun alles in einem COM-Add-In zusammenbringen. Das COM-Add-In stellt Ribbon- und Kontextmenü-Einträge bereit, mit denen man Termine per Mausklick nach Google übertragen kann und hält Automatismen bereit, die dafür sorgen, dass Änderungen an Terminen wie das Anlegen, Bearbeiten oder Löschen automatisch in den Google Calendar übertragen werden. Damit ist nur noch eine kurze Installation nötig, um diese Funktionen in Outlook bereitzustellen.<\/b><\/p>\nVoraussetzungen und Vorbereitungen<\/h2>\n
Die erste Voraussetzung ist, dass Du eine App bei Google erstellt hast. Wie das gelingt, zeigen wir im Artikel Google Calendar programmieren – Vorbereitungen <\/b>(www.vbentwickler.de\/408<\/b>). Außerdem benötigst Du die .NET-DLL, mit der wir das Access-Token für den Zugriff auf den Google Calender holen: Google-Authentifzierung mit OAuth2, Update <\/b>(www.vbentwickler.de\/414<\/b>). Grundlegende Techniken zum automatischen Reagieren auf das Hinzufügen, Ändern und Löschen von Outlook-Terminen beschreiben wir in Outlook: Ereignisse für Termine implementieren <\/b>(www.vbentwickler.de\/417<\/b>). Außerdem liefert der Artikel Termine von Outlook zum Google Calendar exportieren <\/b>(www.vbentwickler.de\/418<\/b>) Informationen darüber, wie wir Termine von Outlook zum Google Calendar schicken. Schließlich lernst Du Einiges über das Programmieren der Rest-API von Google in den Artikeln Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) und Google Calendar per Rest-API programmieren, Teil 2 <\/b>(www.vbentwickler.de\/416<\/b>)<\/p>\nLösung ausprobieren<\/h2>\n
Bevor wir beschreiben, wie die Lösung funktioniert, zeigen wir erst einmal, wie Du sie auf Deinem Rechner installieren und ausprobieren kannst. Dazu führen wir folgende Schritte aus:<\/p>\n
Doch eins nach dem anderen.<\/p>\n
Die .NET-DLL aus dem Artikel Google-Token per DLL holen <\/b>(www.vbentwickler.de\/409<\/b>) findest Du in den Verzeichnissen x64 <\/b>und x86<\/b>. Je nachdem, welche Office-Version Du installiert hast, verwendest Du die aus dem Verzeichnis x64 <\/b>(64-Bit) oder x86<\/b> (32-Bit). Du benötigst das komplette Verzeichnis auf Deinem Rechner. Wo Du dieses speicherst, spielt keine Rolle.<\/p>\n
Um die jeweilige Version zu installieren, gehst Du wie folgt vor:<\/p>\n
![\"Registrieren](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_001.png\")
<\/p>\n
Bild 1: Registrieren der .NET-DLL<\/span><\/b><\/p>\n<\/ul>\n Ob die .NET-DLL korrekt installiert ist, können wir in einem beliebigen VBA-Projekt testen. Hier öffnen wir den Verweise<\/b>-Dialog (Extras|Verweise<\/b>) und suchen nach dem Eintrag amvGoogleOAuth2<\/b>. Ist der Eintrag wie in Bild 2 vorhanden, können wir fortfahren.<\/p>\n Bild 2: Prüfen, ob die .NET-DLL erfolgreich installiert wurde<\/span><\/b><\/p>\n Als Nächstes installieren wir das COM-Add-In, dessen Erstellung wir später in diesem Artikel erläutern. Das COM-Add-In kommt ebenfalls in zwei Versionen für die 32-Bit- und die 64-Bit-Fassung von Outlook.<\/p>\n Die entsprechenden Dateien heißen amvAppointmentsToGoogle_win32.dll <\/b>und amvAppointmentsToGoogle_win64.dll<\/b>. Die Installation ist etwas einfacher:<\/p>\n Bild 3: Installieren des COM-Add-Ins in Outlook<\/span><\/b><\/p>\n<\/ul>\n Wenn nicht nur dieser Eintrag vorhanden ist, sondern Du unter Datei ganz unten auch noch den Eintrag amvAppointmentToGoogle<\/b>, hat alles funktioniert.<\/p>\n Um fortzufahren, benötigen wir die Client-ID und das Client-Secret einer Google-App. Wie Du diese erhältst, haben wir in Google Calendar programmieren – Vorbereitungen <\/b>(www.vbentwickler.de\/408<\/b>) ausführlich gezeigt.<\/p>\n Damit können wir, falls nicht bereits geöffnet, Outlook starten und die soeben ermittelten Werte in die entsprechenden Optionen eintragen. Dazu wählen wir im Ribbon-Tab Datei<\/b> den Eintrag amvAppointmentToGoogle<\/b> aus. Dies zeigt den Bereich aus Bild 4 an.<\/p>\n Bild 4: Die Optionen des COM-Add-Ins amv-Appoint-ment-ToGoogle<\/span><\/b><\/p>\n Hier sehen wir oben die beiden Eigenschaften Client-ID <\/b>und Client-Secret<\/b>, die noch leer sein dürften. Hier trägst Du die beim Erstellen der Google-App erhaltenen Informationen ein.<\/p>\n Danach klicken wir auf die Schaltfläche Token aktualisieren<\/b>, um erstmalig das Access-Token zu ermitteln, das wir für den Zugriff auf den Google Calendar im Kontext eines Benutzers benötigen.<\/p>\n Für diesen Schritt benötigen wir die .NET-DLL. Die darin enthaltenen Funktionen konnten wir nicht mit vertretbarem Aufwand in einer DLL auf Basis von VB6\/twinBASIC erstellen geschweige denn mit VBA realisieren, daher haben wir hier .NET gewählt.<\/p>\n Danach öffnet sich ein Webbrowser und zeigt den Dialog an, mit dem wir angeben wollen, welches Konto wir als Kontext für den Zugriff auf den Google Calendar nutzen wollen (siehe Bild 5).<\/p>\n Bild 5: Konto für das Access-Token authentifizieren<\/span><\/b><\/p>\n Durch die Anmeldung mit diesem Konto erfolgt die Authentifizierung und die .NET-DLL liefert uns das Access-Token, ein Refresh-Token und die Zeit, wie lange das Token gültig ist und für den Zugriff auf den Google Calendar über die Rest-API erfolgen kann. Das Access-Token wird daraufhin gleich im entsprechenden Feld der Optionen angezeigt.<\/p>\n Wir können uns auch gleich die E-Mail-Adresse merken, die wir für die Authentifizierung verwendet haben. Diese tragen wir nun in das Feld Calendar-ID <\/b>der Optionen des COM-Add-Ins ein. Alle Daten, die Du in den Optionen siehst, werden in der Registry gespeichert – mehr dazu später.<\/p>\n Danach können wir das COM-Add-In in Outlook ausprobieren. Wir haben folgende Funktionen implementiert:<\/p>\n Wenn wir beispielsweise einen Termin aktivieren, zeigt das Ribbon-Tab Termin <\/b>im Bereich Google Calendar <\/b>zwei Befehle an. Mit In Google Calendar übertragen <\/b>schicken wir den Termin zum Google Calendar.<\/p>\n Mit Aus Google Calendar löschen <\/b>entfernen wir den Termin wieder beziehungsweise setzen seinen Status auf Cancelled<\/b> (siehe Bild 6).<\/p>\n Bild 6: Funktionen zum manuellen Übertragen und Löschen von Terminen<\/span><\/b><\/p>\n Die gleichen Befehle tauchen nochmals auf, wenn wir das Kontextmenü eines Termins öffnen und dort das Untermenü Google Calendar … <\/b>öffnen.<\/p>\n Damit Termindaten automatisch zum Google Calendar übertragen werden, sobald ein Termin angelegt, geändert oder gelöscht wird, müssen wir einige Optionen aktivieren. Diese finden wir im unteren Bereich der Optionen von amvAppointmentToGoogle<\/b>.<\/p>\n Hier können wir festlegen, ob neu angelegte Termine, geänderte Termine oder gelöschte Termine mit dem Google Calendar synchronisiert werden sollen (siehe Bild 7). Mit der Option Mit Google synchronisierte Termine in diese Kategorie: <\/b>können wir festlegen, dass Termine in Outlook, die nach Google übertragen wurden, automatisch eine bestimmte Kategorie erhalten. Den Namen dieser Kategorie geben wir im Textfeld rechts daneben an. Wichtig: Die Kategorie muss vorhanden sein, sonst wird diese nicht zugeordnet.<\/p>\n Bild 7: Aktivieren der automatischen Synchronisierung<\/span><\/b><\/p>\n Das COM-Add-In haben wir mit twinBASIC programmiert, der neuen Entwicklungsumgebung, die sich als Nachfolger von VB6 anschickt und über die wir bereits in einigen Artikeln geschrieben haben – mehr liefert die Suchfunktion mit dem Begriff twinBASIC auf https:\/\/www.vbentwickler.de<\/b>.<\/p>\n Wir legen ein neues twinBASIC-Projekt an und stellen unter Settings den Projektnamen, die Beschreibung und den Anwendungstitel alle auf den Text amvAppointmentsToGoogle <\/b>ein.<\/p>\n Außerdem fügen wir unter Library References <\/b>noch einige zusätzliche Einträge hinzu (siehe Bild 8). Vor allem ist hier der Verweis auf die .NET-DLL amvGoogleOAuth2 <\/b>wichtig.<\/p>\n Bild 8: Verweise des twinBASIC-Projekts<\/span><\/b><\/p>\n Damit das COM-Add-In beim Start von Outlook ebenfalls gestartet wird, nehmen wir am Modul DLLRegistration <\/b>der COM-Add-In-Vorlage von twinBASIC einige Änderungen vor.<\/p>\n Für die Konstante AddinClassName <\/b>tragen wir amvAppointmentsToGoogle <\/b>ein. Den Zielpfad in der Registry passen wir auf Outlook an:<\/p>\n Die restlichen Anpassungen kannst Du im Modul DLLRegistration<\/b> anschauen.<\/p>\n Die Programmierung des Ribbons und der Kontextmenüs von Outlook haben wir bereits in den folgenden Artikel ausführlich erläutert:<\/p>\n Daher gehen wir hier etwas knapper auf die verwendeten Techniken ein und beschreiben diese einmal etwas anders – nämlich nach dem Zeitpunkt des Aufrufs.<\/p>\n Sobald das COM-Add-In einmal erstellt und registriert ist, stehen in der Registry einige Einträge, die Outlook beim Start ausliest.<\/p>\n Dadurch wird das COM-Add-In direkt beim Start von Outlook ebenfalls geladen.<\/p>\n Die dazu wichtigsten Funktionen sind in der Hauptklasse des COM-Add-Ins namens amvAppointmentsToGoogle <\/b>enthalten.<\/p>\n Beim Starten geschehen zwei Dinge:<\/p>\n Wir benötigen verschiedene Variablen, die beim Starten des COM-Add-Ins gefüllt werden. Eine davon muss anwendungsweit verfügbar sein und nimmt den Verweis auf die Outlook-Anwendung auf, die das COM-Add-In geladen hat.<\/p>\n Daher deklarieren wir diese als Public im Modul mdlOutlook<\/b>:<\/p>\n Drei weitere Variablen benötigen wir nur in der Klasse amvAppointmentsToGoogle<\/b>:<\/p>\n Die Initialisierung der Variablen erfolgt in der beim Start von Outlook ausgelösten Ereignisprozedur OnConnection<\/b> (siehe Listing 1).<\/p>\n Listing 1: Die Funktion GetCustomUI stellt eine Ribbondefinition zusammen und gibt diese zurück.<\/span><\/b><\/p>\n Diese erhält mit ihren Parametern zum Beispiel einen Verweis auf die aufrufende Anwendung. Diesen speichern wir in der Objektvariablen objOutlook<\/b>.<\/p>\n Den Kalender<\/b>-Ordner für die Variable objCalendar <\/b>ermitteln wir über die Funktion GetDefaultFolder <\/b>des MAPI-Namespaces und in objCalendarItems <\/b>speichern wir die Items<\/b>-Auflistung des gleichen Ordners.<\/p>\n Damit unsere Ribbondefinition beim Laden eingelesen wird, ruft das COM-Add-In beim Starten automatisch die Funktion GetCustomUI <\/b>auf, welche die Ribbondefinition zusammenstellen.<\/p>\n Diese besteht unterhalb der Elemente customUI <\/b>und ribbon <\/b>aus mehreren Teilen, die genau so angeordnet werden müssen, wie es hier der Fall ist:<\/p>\n Eine komplette Beschreibung der Ribbondefinition würde den Rahmen sprengen. Einige Feinheiten wollen wir jedoch dokumentieren.<\/p>\n Die Schaltflächen, die wir in den drei Ribbonerweiterungen definieren, enthalten jeweils das Attribut onAction<\/b>.<\/p>\n Ein Klick diese Schaltflächen löst die dafür hinterlegte VBA-Prozedur onAction <\/b>aus, die wie folgt aussieht:<\/p>\n Die Select Case<\/b>-Bedingung prüft den Wert der Eigenschaft Id <\/b>des Parameters Control<\/b>, die den Namen des Steuerelements liefert. Darüber rufen wir verschiedene Prozeduren auf. Die beiden Schaltflächen btnInGoogleCalendarUebertragen<\/b> und btnInGoogleCalendarUebertragen_Shortcut <\/b>sorgen für den Aufruf der Prozedur InsertEventInGoogleCalendar<\/b>, die beiden Schaltflächen btnAusGoogleCalendarLoeschen <\/b>und btnAusGoogleCalendarLoeschen_Shortcut <\/b>die Prozedur DeleteEventFromGoogleCalendar<\/b>.<\/p>\n Diese Schaltflächen finden wir bei aktiviertem Termin im Ribbon (siehe Bild 9) und im Kontextmenü eines Termins.<\/p>\n Bild 9: Benutzerdefinierte Ribbonbefehle für einen Termin<\/span><\/b><\/p>\n Die Schaltfläche btnRefreshToken<\/b> wiederum befindet sich im Backstage-Bereich. Sie dient der Ermittlung des Access-Tokens für den Rest-API-Zugriff auf den Google Calendar über die Funktion GetTokens<\/b> (siehe Listing 2).<\/p>\n Listing 2: Die Funktion GetTokens startet den Prozess zur Ermittlung des Access-Tokens.<\/span><\/b><\/p>\n Wie weiter oben schon beschrieben, ist das Holen des Access-Tokens ein wichtiger Schritt zum Arbeiten mit der Rest-API des Google Calendars.<\/p>\n Daher schauen wir uns dies genauer an. Der Vorgang wird initial einmal über die Schaltfläche Token aktualisieren <\/b>ausgelöst, aber auch bei erneuten Zugriffen auf die Rest-API.<\/p>\n Für das Verständnis ist es wichtig, dass wir die Optionen, die im Backstage-Bereich des Ribbons unter amvAppointmentsToGoogle <\/b>angezeigt werden, in der Registry speichern (siehe Bild 10).<\/p>\n Bild 10: Einstellungen des COM-Add-Ins in der Registry<\/span><\/b><\/p>\n Zum Einlesen und zum Speichern nutzen wir zwei Routinen, die wir im Artikel Anwendungsdaten in der Registry <\/b>(www.vbentwickler.de\/411<\/b>) vorgestellt haben. Die Prozedur SaveAppSetting <\/b>speichert einen Wert in einem vorgegebenen Pfad der Registry, die Funktion GetAppSetting <\/b>liest diese wieder aus. Beide Routinen befinden sich im Modul mdlRegistry<\/b>.<\/p>\n Die Funktion GetTokens <\/b>prüft nun als Erstes, ob bereits Client-ID und Client-Secret in den Optionen hinterlegt wurden. Falls nicht, erscheint jeweils eine entsprechende Meldung und die Funktion wird beendet. Liegen beide Informationen vor, löscht die Prozedur eine Datei, die eventuell Probleme beim Versuch macht, das Access-Token erneut freizugeben.<\/p>\n Dann ruft sie die Prozedur GetTokensDLL <\/b>auf und übergibt Client-ID und Client-Secret. Außerdem verwendet sie drei Rückgabeparameter für das Refresh-Token, das Access-Token und die Anzahl der Sekunden, für die das Access-Token ab jetzt gültig ist.<\/p>\n War der Aufruf erfolgreich, speichert die Funktion die von GetTokensDLL <\/b>zurückgelieferten Informationen in der Registry und gibt den Wert True <\/b>zurück. Die Funktion GetTokensDLL <\/b>haben wir bereits im Artikel Google Calendar per Rest-API programmieren <\/b>(www.vbentwickler.de\/410<\/b>) beschrieben.<\/p>\n Wenn die Funktion GetTokens <\/b>über die Backstage-Schaltfläche Token aktualisieren <\/b>gestartet wurde, wird anschließend noch die folgende Anweisung aufgerufen:<\/p>\n Dies sorgt dafür, dass die Elemente des Ribbons, die mit Callback-Funktionen ausgestattet sind, aktualisiert werden. Dazu gehören alle Elemente des Backstage-Bereichs, die Daten aus der Registry anzeigen.<\/p>\n In der Ribbondefinition für den Backstage-Bereich finden wir beispielsweise solche editBox<\/b>-Steuerelemente:<\/p>\n Dies betrachten wir stellvertretend für alle editBox<\/b>-Elemente. Wichtig sind hier die beiden Attribute getText <\/b>und onChange<\/b>. getText <\/b>wird beim Anzeigen des Backstage-Bereichs oder beim Aufrufen der Invalidate<\/b>-Methode des Objekts objRibbon <\/b>ausgelöst und ermöglicht es uns, das editBox<\/b>-Elements zur Laufzeit zu füllen.<\/p>\n Die Funktion GetText <\/b>verarbeitet in einer Select Case<\/b>-Bedingung den Namen des aufrufenden Steuerelements und ermittelt den entsprechenden Wert aus der Registry, sodass dieser von der Funktion zurückgegeben und im editBox<\/b>-Element angezeigt werden kann (siehe Listing 3).<\/p>\n Listing 3: Die Funktion GetText liest die Texte für die editBox-Elemente ein.<\/span><\/b><\/p>\n Die Funktion onChange<\/b> sieht wie in Listing 4 aus. Sie erhält neben dem Verweis auf das aufrufende Steuerelement den aktuellen Inhalt des editBox<\/b>-Elements als Parameter.<\/p>\n Listing 4: Die Funktion onChange aktualisiert die Werte in der Registry.<\/span><\/b><\/p>\n Sie verwendet ebenfalls eine Select Case<\/b>-Bedingung, in der die Werte des editBox<\/b>-Elements an der entsprechenden Stelle im der Registry eingetragen werden.<\/p>\n Für die checkBox<\/b>-Elemente schauen wir uns stellvertretend die Definition des folgenden Elements an:<\/p>\n Hier finden wir zwei andere Callback-Attribute, nämlich getPressed <\/b>und onAction<\/b>.<\/p>\n Die Callback-Funktion getPressed <\/b>ermittelt den gewünschten Zustand für das checkBox<\/b>-Element, also entweder aktiviert oder nicht aktiviert (siehe Listing 5). Wie bei den editBox<\/b>-Elementen verarbeiten wir die verschiedenen aufrufenden Steuerelemente in einer Select Case<\/b>-Bedingung.<\/p>\n Listing 5: Die Funktion GetPressed ermittelt den Status eines checkBox-Elements.<\/span><\/b><\/p>\n Darin ermitteln wir jeweils den Wert der entsprechenden Einstellung aus der Registry und geben diesen als Funktionswert zurück, sodass das checkBox<\/b>-Element entweder einen Haken anzeigt oder leer ist.<\/p>\n Die umgekehrte Funktion erreichen wir mit der für das Attribut onAction <\/b>hinterlegten Prozedur onActionCheckBox<\/b>. Warum überhaupt eine eigene Prozedur für die checkBox<\/b>-Elemente, wenn wir doch schon eine onAction<\/b>-Prozedur für die button<\/b>-Elemente haben? Weil die für das checkBox<\/b>-Element eine andere Signatur aufweist, denn sie hat noch einen weiteren Parameter, der beim Anklicken den aktuellen Zustand des ![\"Prüfen,](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_003.png\")
<\/p>\nCOM-Add-In für Outlook installieren<\/h2>\n
\n
![\"Installieren](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_002.png\")
<\/p>\nGoogle-App für den Zugriff auf den Kalender <\/h2>\n
Outlook starten und Optionen eintragen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_004.png\")
<\/p>\nAuthentifizieren<\/h2>\n
![\"Konto](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_005.png\")
<\/p>\nCOM-Add-In anwenden<\/h2>\n
\n
![\"Funktionen](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_006.png\")
<\/p>\nAutomatische Synchronisierung aktivieren<\/h2>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_007.png\")
<\/p>\nProgrammieren des COM-Add-Ins<\/h2>\n
Anlegen des Projekts und Optionen einstellen<\/h2>\n
![\"Verweise](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_008.png\")
<\/p>\nRegistrierung auf Outlook anpassen<\/h2>\n
Const RootRegistryFolder As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Outlook\\Addins\\\" & AddinQualifiedClassName & \"\\\"<\/pre>\n\n
Start des COM-Add-Ins<\/h2>\n
\n
Wichtige Variablen initialisieren<\/h2>\n
Public <\/span>objOutlook As <\/span>Outlook.Application<\/pre>\nPrivate <\/span>objRibbon As <\/span>IRibbonUI\r\nPrivate <\/span>WithEvents objCalendar As <\/span>Outlook.Folder\r\nPrivate <\/span>WithEvents objCalendarItems As <\/span>Outlook.Items<\/pre>\n\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, ByVal ConnectMode As <\/span>ext_ConnectMode, ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnConnection\r\n Set<\/span> objOutlook = Application\r\n Set<\/span> objCalendar = objOutlook.GetNamespace(\"MAPI\").GetDefaultFolder(olFolderCalendar)\r\n Set<\/span> objCalendarItems = objCalendar.Items\r\nEnd Sub<\/span><\/pre>\nLaden des Ribbons<\/h2>\n
\n
Aufruf der Ribbon-Befehle<\/h2>\n
Public Sub <\/span>OnAction(control As <\/span>IRibbonControl)\r\n Select Case control.Id\r\n Case <\/span>\"btnRefreshToken\"\r\n GetTokens\r\n objRibbon.Invalidate()\r\n Case <\/span>\"btnInGoogleCalendarUebertragen\", _\r\n \"btnInGoogleCalendarUebertragen_Shortcut\"\r\n Call<\/span> InsertEventInGoogleCalendar\r\n Case <\/span>\"btnAusGoogleCalendarLoeschen\", _\r\n \"btnAusGoogleCalendarLoeschen_Shortcut\"\r\n Call<\/span> DeleteEventFromGoogleCalendar\r\n Case Else<\/span>\r\n MsgBox<\/span> \"OnAction nicht behandelt: \" & control.Id\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Benutzerdefinierte](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_009.png\")
<\/p>\nPublic 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. Gebe diesen Wert in den Optionen ein.\", _\r\n vbOKOnly + 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. Gebe diesen Wert in den Optionen ein.\", _\r\n vbOKOnly + 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>\nAccess-Token holen<\/h2>\n
Speichern der Optionen in der Registry<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2024_01\/pic_419_010.png\")
<\/p>\nClient-ID und Client-Secret prüfen<\/h2>\n
objRibbon.Invalidate()<\/pre>\n
Backstage mit Daten füllen<\/h2>\n
<editBox id=\"\"txtClientID\"\" getText=\"\"getText\"\" sizeString=\"\"yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\"\" onChange=\"\"onChange\"\"\/>\"<\/pre>\n
Function <\/span>GetText(control As <\/span>IRibbonControl) As String<\/span>\r\n Select Case control.Id\r\n Case <\/span>\"txtClientID\"\r\n Return GetAppSetting(\"ClientID\")\r\n Case <\/span>\"txtClientSecret\"\r\n Return GetAppSetting(\"ClientSecret\")\r\n Case <\/span>\"txtCalendarID\"\r\n Return GetAppSetting(\"CalendarID\")\r\n Case <\/span>\"txtTokenExpiresAt\"\r\n Return GetAppSetting(\"TokenExpiresAt\")\r\n Case <\/span>\"txtAccessToken\"\r\n Return GetAppSetting(\"AccessToken\")\r\n Case <\/span>\"txtSynchronisierteInDieseKategorie\"\r\n Return GetAppSetting(\"CategoryForSynchronizedEvents\")\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nSub <\/span>OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n Select Case control.Id\r\n Case <\/span>\"txtClientID\"\r\n SaveAppSetting \"ClientID\", text\r\n Case <\/span>\"txtClientSecret\"\r\n SaveAppSetting \"ClientSecret\", text\r\n Case <\/span>\"txtCalendarID\"\r\n SaveAppSetting \"CalendarID\", text\r\n Case <\/span>\"txtTokenExpiresAt\"\r\n SaveAppSetting \"TokenExpiresAt\", text\r\n Case <\/span>\"txtAccessToken\"\r\n SaveAppSetting \"AccessToken\", text\r\n Case <\/span>\"txtSynchronisierteInDieseKategorie\"\r\n SaveAppSetting \"CategoryForSynchronizedEvents\", text\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\ncheckBox-Elemente lesen und schreiben<\/h2>\n
<checkBox id=\"\"chkBeimAnlegenAutomatischUebertragen\"\" getPressed=\"\"getPressed\"\" onAction=\"\"onActionCheckBox\"\"\/>\"<\/pre>\n
Function <\/span>GetPressed(control As <\/span>IRibbonControl) As Boolean<\/span>\r\n Select Case control.Id\r\n Case <\/span>\"chkBeimAnlegenAutomatischUebertragen\"\r\n Return GetAppSetting(\"CreateGoogleEventOnAdd\", False<\/span>)\r\n Case <\/span>\"chkBeimAendernAutomatischUebertragen\"\r\n Return GetAppSetting(\"CreateGoogleEventOnUpdate\", False<\/span>)\r\n Case <\/span>\"chkBeimLloeschenAuchInGoogleCalendarLoeschen\"\r\n Return GetAppSetting(\"DeleteGoogleEventOnDelete\", False<\/span>)\r\n Case <\/span>\"chkSynchronisierteInKategorie\"\r\n Return GetAppSetting(\"SetCategoryForSynchronizedEvents\", False<\/span>)\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n