Im Beitrag „Outlook.com mit Access und VBA: Vorbereitungen“ haben wir gezeigt, wie wir die Voraussetzungen für den Zugriff auf unser Outlook-Konto mit der Rest-API von Microsoft erschaffen. Dabei haben wir eine Anwendung bei Microsoft registriert und die notwendigen Daten wie die Application-ID, die Tenant-ID und die SecretID ermittelt, die wir für den Zugriff auf die Rest-API benötigen. Außerdem haben wir dort die benötigten Berechtigungen eingestellt, hier erst einmal für das Senden von E-Mails. Was wir nun benötigen, sind zwei Dinge: Erstens ein Token, das wir für die Authentifizierung bei der Rest-API benötigen, zweitens den VBA-Code für die Ausführung der eigentlichen Rest-API-Aufrufe. Damit erstellen wir eine erste Prozedur, mit der wir E-Mails über unser Outlook.com-Konto versenden können. Darauf aufbauend werden wir in weiteren Beiträgen zeigen, wie wir weitere Funktionen implementieren können.<\/b><\/p>\n
Die Ergebnisse des Beitrags Outlook.com mit Access und VBA: Vorbereitungen <\/b>(www.access-im-unternehmen.de\/1531<\/b>) sehen wie folgt aus:<\/p>\n Damit steigen wir nun in die Programmierung des Zugriffs auf die Microsoft Graph API für den Zugriff auf unser Outlook-Konto ein.<\/p>\n Dazu führen wir folgende Schritte durch:<\/p>\n Wir benötigen die folgenden beiden Verweise:<\/p>\n Der Verweise<\/b>-Dialog sieht nach dem Hinzufügen dieser Verweise wie in Bild 1 aus.<\/p>\n Bild 1: Verweise, die wir für den Zugriff auf die Rest-API benötigen<\/span><\/b><\/p>\n Wenn Sie die Beispieldatenbank neu aufbauen wollen, fügen Sie nun aus unserer Datenbank die beiden Module mdlJSON <\/b>und mdlJSONDOM <\/b>hinzu.<\/p>\n Das erste enthält Methoden, um JSON-Dokumente in ein Objektmodell zu überführen und um JSON-Dokumente wieder aus diesem Objektmodell auszulesen.<\/p>\n Das zweite bietet die Möglichkeit, die Anweisungen auszugeben, die für den Zugriff aller Elemente dieses Objektmodells nötig sind. Die genaue Funktionsweise zeigen wir gleich im Praxiseinsatz.<\/p>\n Es gibt verschieden aufwendige Zugriffsarten für Rest-APIs.<\/p>\n Manche begnügen sich damit, dass man ein API-Kennwort auf der Webseite des Anbieters holt und dieses in seinen Aufruf einbettet.<\/p>\n Andere erfordern es, dass man mit den Daten wie der Anwendungs-ID und einem geheimen Schlüssel erst noch ein Authentifizierungstoken holt, mit dem man dann den eigentlichen Aufruf durchführen kann. Dies ist hier der Fall, da wir im Kontext der Anwendung auf die Methoden wie Mail.Send<\/b> zugreifen.<\/p>\n Einen Schritt weiter gehen wir, wenn wir eine Anwendung für den Zugriff auf eine Rest-API bauen, die im Kontext eines Benutzers verwendet werden soll. Dann müssten wir zum Holen des Authentifizierungstokens erst noch eine Webseite anzeigen, auf der sich der Benutzer authentifiziert, bevor wir das Token erhalten. Auch dies ist bei der Rest-API möglich, die wir hier ansteuern wollen.<\/p>\n Für unsere Zwecke reicht allerdings die Methode aus, mit der wir auch das Token über die Rest-API holen.<\/p>\n Das erledigen wir mit der Funktion aus Listing 1. Die Funktion hat zwei Parameter:<\/p>\n Listing 1: Funktion zum Holen des Access-Tokens<\/span><\/b><\/p>\n Das Ergebnis der Funktion selbst ist ein Boolean<\/b>-Wert. Ist dieser True<\/b>, war der Abruf des Tokens erfolgreich, anderenfalls liefert die Funktion den Wert False <\/b>zurück.<\/p>\n Die Funktion deklariert zunächst eine Objektvariable des Typs XMLHTTP60<\/b>. Diese ermöglicht den Zugriff auf die Rest-API. In objJSON <\/b>speichern wir das Objektmodell der Antwort im JSON-Format. strURL <\/b>nimmt die Adresse des Endpunktes der Rest-API auf und strData <\/b>die zu übergebenden Parameter. In strJSON <\/b>speichern wir schließlich das Ergebnis des Aufrufs.<\/p>\n Die Funktion trägt als Erstes die URL für den Endpunkt der Rest-API in die Variable strURL <\/b>ein. Diese besteht aus der Zeichenkette https:\/\/login.microsoftonline.com\/<\/b>, der Tenant-ID sowie der Zeichenkette \/oauth2\/v2.0\/token<\/b>.<\/p>\n Insgesamt sieht die URL beispielsweise wie folgt aus:<\/p>\n Danach folgt die Variable strData<\/b>, in der wir die übrigen für die Authentifizierung benötigten Informationen einarbeiten.<\/p>\n Der darin gespeicherte Ausdruck sieht anschließend wie folgt aus:<\/p>\n Damit erstellen wir nun eine Instanz von MSXML2.XMLHTTP <\/b>und referenzieren diese mit der Variablen objXMLHTTP<\/b>.<\/p>\n Wir rufen die Open<\/b>-Methode dieses Objekts auf und übergeben drei Parameter:<\/p>\n Mit der setRequestHeader<\/b>-Eigenschaft legen wir den Wert für das Attribut Content-Type <\/b>fest, hier auf application\/x-www-form-urlencoded<\/b>.<\/p>\n Schließlich senden wir die Anfrage mit der Send<\/b>-Methode und dem Parameter strData <\/b>ab.<\/p>\n Durch die Angabe, dass wir einen synchronen Aufruf starten wollen, wird der Code erst fortgesetzt, wenn der Aufruf beendet ist und das XMLHTTP<\/b>-Objekt das Ergebnis enthält.<\/p>\n Wir können dann anhand der Eigenschaft Status <\/b>ermitteln, ob der Aufruf erfolgreich war oder ob ein Fehler aufgetreten ist. Liefert Status <\/b>den Wert 200 <\/b>zurück, war der Aufruf erfolgreich.<\/p>\n In diesem Fall erhalten wir mit objXMLHTTP.responseText <\/b>die folgende Antwort (hier in gekürzter Form), die wir anschließend in die Variable strJSON <\/b>schreiben:<\/p>\n Wir erstellen daraus mit der Funktion ParseJson <\/b>ein Objektmodell, das wir mit der Variablen objJSON <\/b>referenzieren und stellen als Rückgabewert der Funktion den Wert True <\/b>ein.<\/p>\n Außerdem tragen wir für den Rückgabeparameter strToken <\/b>das Ergebnis des Ausdrucks objJSON(„access_token“)<\/b> ein.<\/p>\n Woher wissen wir, dass wir diesen Ausdruck aufrufen müssen, um das Token auszulesen? <\/p>\n Dazu können wir die folgende Zeile zwischenschalten:<\/p>\n Dies liefert das folgende Ergebnis im Direktbereich des VBA-Editors:<\/p>\n GetJSONDOM <\/b>hat die Aufgabe, den Inhalt des Objektmodells aus objJSON <\/b>dahingehend zu analysieren, dass es die Aufrufe ausgibt, die nötig sind, um die entsprechenden Inhalte abzurufen. Durch das Einstellen des zweiten Parameters bolValues <\/b>auf den Wert True <\/b>werden wie oben angezeigt auch die Werte ausgegeben.<\/p>\n Wenn wir nun gezielt den Wert des Tokens auslesen wollen, müssen wir also auf objJSON.Item(„access_token“) <\/b>zugreifen. Wichtig ist, dass wir zuvor mit Set objJSON = ParseJSON(strJSON) <\/b>das Objektmodell erzeugt haben.<\/p>\n Wenn Status einen anderen Wert als 200 <\/b>zurückgibt, beispielsweise 400 <\/b>oder 401<\/b>, ist offensichtlich ein Problem aufgetreten. In diesem Fall untersuchen wir die Antwort ebenfalls und schreiben den Wert aus objJSON.Item(„error_description“) <\/b>als Rückgabewert in die Variable strResponse<\/b>.<\/p>\n Zum Testen dieser Funktion können wir die folgende Prozedur nutzen:<\/p>\n Diese ruft die Funktion GetAccessToken <\/b>mit den Parametern strToken <\/b>und strResponse <\/b>auf, die jeweils leer sind, und gibt die Ergebnisse aus.<\/p>\n Damit können wir uns der eigentlichen Aufgabe widmen: Einer Prozedur, mit der wir per VBA eine E-Mail versenden und dabei die Microsoft Graph API nutzen.<\/p>\n Diese Prozedur finden wir in Listing 2.<\/p>\n Listing 2: Prozedur zum Senden einer E-Mail<\/span><\/b><\/p>\n Die Prozedur deklariert wieder ein XMLHTTP60<\/b>-Objekt sowie einige String<\/b>-Variablen.<\/p>\n Sie ruft die Funktion GetAccessToken <\/b>auf, um das Authentifizierungstoken zu holen. Gelingt dies, trägt sie die E-Mail-Adresse, die als Absenderadresse verwendet werden soll, in die Variable strUser <\/b>ein.<\/p>\n Wir verwenden hier die Adresse, unter der auch das Microsoftkonto betrieben wird beziehungsweise die Microsoft für uns angelegt hat.<\/p>\n Diese Adresse fügen wir in die URL ein, die wir der Variablen strURL <\/b>hinzufügen und die beispielsweise wie folgt aussieht:<\/p>\n Dann stellen wir in der Variablen strBody <\/b>die Eigenschaften und Inhalte der E-Mail zusammen. Der Inhalt sieht in diesem Fall danach wie folgt aus:<\/p>\n Hier sehen wir bereits die wichtigsten Elemente einer E-Mail:<\/p>\n Danach erstellt die Prozedur das XMLHTTP<\/b>-Objekt und referenziert es mit der Variablen objXMLHTTP<\/b>. Es öffnet das Objekt mit der Open<\/b>-Methode und übergibt die bereits bekannten Parameter.<\/p>\n Sie fügt jedoch einen zusätzlichen RequestHeader <\/b>namens Authorization<\/b> hinzu, der die Zeichenkette Bearer <\/b>und das zuvor ermittelte Token enthält.<\/p>\n Schließlich wird die Anfrage mit der Send<\/b>-Methode und dem Inhalt aus strBody <\/b>als Parameter abgesendet.<\/p>\n Das Ergebnis werten wir wieder in einer Select Case<\/b>-Bedingung aus. Diesmal erhalten wir für die erfolgreiche Ausführung jedoch den Statuswert 202 <\/b>zurück, was wir entsprechend berücksichtigen. Im Fehlerfall geben wir den Fehler als Meldung aus.<\/p>\n Hier ist der Versand jedoch erfolgreich und wir finden die E-Mail im Postfach des Empfängers wieder (siehe Bild 2).<\/p>\n Bild 2: Die erfolgreich gesendete E-Mail im neuen Outlook<\/span><\/b><\/p>\n Nachdem wir die erste E-Mail erfolgreich versendet haben, können wir die nächsten Schritte angehen:<\/p>\n Während wir bereits alle notwendigen Elemente rund um das Verwenden der E-Mail vorbereitet haben, gibt es noch einige weitere Informationen, die wir mit einer E-Mail versenden können.<\/p>\n Dazu gehören die folgenden:<\/p>\n Wo finden wir diese Informationen? Die erste Informationsquelle sollten die entsprechenden Seiten von Microsoft sein. In diesem Fall schauen wir beispielsweise in der Dokumentation zur Microsoft Graph API nach, wie hier für das mail<\/b>-Element:<\/p>\n Hier finden wir die verschiedenen Eigenschaften für das mail<\/b>-Element und seine Unterelemente. Dadurch erfahren wir auch, wie das JSON-Dokument für weitere Informationen erweitert werden muss.<\/p>\n Im folgenden Beispiel haben wir bereits einige Erweiterungen vorgenommen. Im ersten Teil finden wir zunächst statt des Text-Formats einen Body im HTML-Format.<\/p>\n Dazu stellen wir contentType <\/b>auf HTML <\/b>ein und geben für den Inhalt den Text inklusive HTML-Markierungen ein:<\/p>\n Die Angabe des Addressaten kennen wir bereits:<\/p>\n Einen Empfänger im Cc:<\/b> geben wir im folgenden Element an:<\/p>\n Einen Bcc:<\/b>-Empfänger, der den übrigen Empfängern nicht angezeigt werden soll, fügen wir wie folgt hinzu:<\/p>\n Die Priorität geben wir mit dem Element importance an, welches die Werte low<\/b>, normal <\/b>und high <\/b>annehmen kann:<\/p>\n Während die bisherigen Eigenschaften noch recht einfach zu realisieren waren und nur einige Zeichenketten-Operationen erforderten, ist das Hinzufügen eines Attachments bereits um einiges aufwendiger. Im Objektmodell von Outlook konnten wir dazu einfach die Attachments<\/b>-Auflistung verwenden und den Pfad der hinzuzufügenden Datei angeben.<\/p>\n Hier müssen wir zwar eigentlich „nur“ einige weitere Elemente zum JSON-Dokument hinzufügen. Wir können allerdings nicht einfach den Pfad zur hinzuzufügenden Datei angeben, sondern wir müssen diese erst in eine Zeichenkette umwandeln und sie dann zum entsprechenden Element im JSON-Dokument hinzufügen.<\/p>\n Die Funktion, um eine Datei in die entsprechende Zeichenkette umzuwandeln, sehen Sie in Listing 3.<\/p>\n Listing 3: Funktion zum Erstellen einer Zeichenkette auf Basis einer Datei<\/span><\/b><\/p>\n Die Funktion EncodeFileToBase64<\/b> dient dazu, eine Datei in eine Base64-codierte Zeichenkette zu konvertieren. Diese Codierung ist beispielsweise notwendig, um Dateien in JSON-Dokumenten für Microsoft Graph API-Aufrufe zu übertragen.<\/p>\n Zunächst wird eine ADODB.Stream<\/b>-Instanz erstellt, um die Datei im Binärformat zu lesen. Die Methode LoadFromFile <\/b>lädt den Inhalt der mit dem Parameter strPath <\/b>angegebenen Datei, dessen Binärdaten anschließend in ein Byte-Array (bytData<\/b>) überführt werden. Nach dem Lesen wird der Stream geschlossen, um die Ressourcen freizugeben.<\/p>\n Die Base64-Codierung erfolgt mithilfe eines MSXML2.DOMDocument60<\/b>-Objekts. Dabei wird ein XML-Knoten vom Typ base64<\/b> erstellt, dessen Datentyp explizit auf bin.base64<\/b> gesetzt wird. Durch die Zuweisung der Binärdaten zu nodeTypedValue <\/b>wird die Base64-Zeichenkette erzeugt, die über die Text<\/b>-Eigenschaft des Knotens abgerufen werden kann. Um mögliche Zeilenumbrüche in der Ausgabe zu vermeiden, entfernt die Funktion diese mithilfe der Replace<\/b>-Funktion.<\/p>\n Die Funktion gibt die resultierende Base64-Zeichenkette als Rückgabewert zurück.<\/p>\n Damit das Attachment korrekt verarbeitet wird, fügen wir dieses als weiteres Unterelement des message<\/b>-Elements an. Dazu nutzen wir ein Element namens Attachments<\/b>, dem wir ein oder mehrere Elemente zuweisen können. Jedes dieser Elemente hat die folgenden drei Unterelemente:<\/p>\n Im folgenden Beispiel haben wir die Zeichenkette stark gekürzt:<\/p>\n Das immer umfangreicher werdende JSON-Dokument könnten wir weiterhin mit einfachen Zeichenketten-Funktionen zusammenstellen.<\/p>\n Dies ist aber recht fehleranfällig, weil man allzu schnell ein Komma zu viel oder zu wenig schreibt oder eine öffnende oder schließende eckige oder geschweifte Klammer fehlt.<\/p>\n Weiter oben haben wir schon gesehen, dass wir das JSON-Dokument mit dem Ergebnis über ein Objektmodell viel einfacher analysieren und auf die enthaltenen Elemente zugreifen können als es mit Zeichenkettenfunktionen möglich wäre.<\/p>\n Diesen Weg wollen wir nun in umgekehrter Reihenfolge gehen. Das heißt, wir bauen ein Objektmodell aus verschiedenen Dictionary<\/b>– und Collection<\/b>-Elementen auf und erstellen anschließend mit der Funktion ConvertToJson <\/b>das gewünschte JSON-Dokument daraus. Dieses ist dann garantiert frei von den üblichen Flüchtigkeitsfehlern.<\/p>\n Eine Beispielfunktion zum Zusammenstellen eines solchen JSON-Dokuments finden wir in Listing 4.<\/p>\n\n
\n
Verweise hinzufügen<\/h2>\n
\n
![\"Verweise,](\"..\/fileadmin\/_temp_\/2025_01\/pic_1532_033.png\")
<\/p>\nModule hinzufügen<\/h2>\n
Token für die Authentifizierung holen<\/h2>\n
Function <\/span>GetAccessToken(strToken As String<\/span>, strResponse As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>objJSON As Object<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strData As String<\/span>\r\n Dim <\/span>strJSON As String<\/span>\r\n \r\n strURL = \"https:\/\/login.microsoftonline.com\/\" & cStrTenantID & \"\/oauth2\/v2.0\/token\"\r\n \r\n strData = \"grant_type=client_credentials\" & _\r\n \"&client_id=1\" & cStrApplicationID & _\r\n \"&client_secret=\" & cStrSecretValue & _\r\n \"&scope=https:\/\/graph.microsoft.com\/.default\"\r\n \r\n Set<\/span> objXMLHTTP = CreateObject(\"MSXML2.XMLHTTP\")\r\n objXMLHTTP.Open \"POST\", strURL, False<\/span>\r\n objXMLHTTP.setRequestHeader \"Content-Type\", \"application\/x-www-form-urlencoded\"\r\n objXMLHTTP.Send strData\r\n \r\n Select Case objXMLHTTP.status\r\n Case <\/span>200\r\n strJSON = objXMLHTTP.responseText\r\n Set<\/span> objJSON = ParseJson(strJSON)\r\n GetAccessToken = True<\/span>\r\n strToken = objJSON(\"access_token\")\r\n Case Else<\/span>\r\n strJSON = objXMLHTTP.responseText\r\n Set<\/span> objJSON = ParseJson(strJSON)\r\n strResponse = objJSON.Item(\"error_description\")\r\n Debug.Print<\/span> GetJSONDOM(strJSON, True<\/span>)\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n\n
https:\/\/login.microsoftonline.com\/dcc87x1c-44xb-43x8-9x0d-xa1cxxxxxxxx\/oauth2\/v2.0\/token<\/pre>\n
grant_type=client_credentials&client_id=15bddxdx5-xbf3-x248-bxaa-fd41x6xb18xd&client_secret=6Ax8Q~ZxDxItTxAlycqxPcY6kxZnpfxzitTxca2e&scope=https:\/\/graph.microsoft.com\/.default<\/pre>\n
\n
{\"token_type\":\"Bearer\",\"expires_in\":3599,\"ext_expires_in\":3599,\"access_token\":\"eyJ0e...5_7xA\"}<\/pre>\nDebug.Print<\/span> GetJSONDOM(strJSON, True<\/span>)<\/pre>\nobjJSON.Item(\"token_type\"):Bearer\r\nobjJSON.Item(\"expires_in\"):3599\r\nobjJSON.Item(\"ext_expires_in\"):3599\r\nobjJSON.Item(\"access_token\"):eyJ0eXAiOi...jmubh-6KQ<\/pre>\n
Public Sub <\/span>Test_GetAccessToken()\r\n Dim <\/span>strToken As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n If <\/span>GetAccessToken(strToken, strResponse) = True<\/span> Then<\/span>\r\n Debug.Print<\/span> \"Token erfolgreich geholt:\"\r\n Debug.Print<\/span> strToken\r\n Else<\/span>\r\n Debug.Print<\/span> \"Token nicht geholt:\"\r\n Debug.Print<\/span> strResponse\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nE-Mail via Microsoft Graph API versenden<\/h2>\n
Public Sub <\/span>SendEmail()\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\r\n Dim <\/span>strUser As String<\/span>\r\n Dim <\/span>strURL As String<\/span>\r\n Dim <\/span>strToken As String<\/span>\r\n Dim <\/span>strBody As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n \r\n If <\/span>GetAccessToken(strToken, strResponse) = True<\/span> Then<\/span>\r\n \r\n ''strURL = \"https:\/\/graph.microsoft.com\/v1.0\/me\/sendMail\"\r\n strUser = \"andre@andreminhorstverlag.onmicrosoft.com\"\r\n strURL = \"https:\/\/graph.microsoft.com\/v1.0\/users\/\" & strUser & \"\/sendMail\"\r\n \r\n strBody = strBody & \"{\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"message\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"subject\"\": \"\"Test E-Mail\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"body\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"contentType\"\": \"\"Text\"\",\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"content\"\": \"\"Dies ist eine Test-E-Mail über Microsoft Graph.\"\"\" & vbCrLf<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"toRecipients\"\": [\" & vbCrLf<\/span>\r\n strBody = strBody & \" {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"emailAddress\"\": {\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"address\"\": \"\"andre@minhorst.com\"\"\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" }\" & vbCrLf<\/span>\r\n strBody = strBody & \" ]\" & vbCrLf<\/span>\r\n strBody = strBody & \" },\" & vbCrLf<\/span>\r\n strBody = strBody & \" \"\"saveToSentItems\"\": \"\"true\"\"\" & vbCrLf<\/span>\r\n strBody = strBody & \"}\" & vbCrLf<\/span>\r\n \r\n Set<\/span> objXMLHTTP = CreateObject(\"MSXML2.XMLHTTP\")\r\n objXMLHTTP.Open \"POST\", strURL, False<\/span>\r\n objXMLHTTP.setRequestHeader \"Authorization\", \"Bearer \" & strToken\r\n objXMLHTTP.setRequestHeader \"Content-Type\", \"application\/json\"\r\n objXMLHTTP.Send strBody\r\n \r\n Select Case objXMLHTTP.status\r\n Case <\/span>202\r\n MsgBox<\/span> \"E-Mail erfolgreich gesendet.\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden der E-Mail: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.responseText\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nhttps:\/\/graph.microsoft.com\/v1.0\/users\/andre@andreminhorstverlag.onmicrosoft.com\/sendMail<\/pre>\n
{\r\n \"message\": {\r\n \"subject\": \"Test E-Mail\",\r\n \"body\": {\r\n \"contentType\": \"Text\",\r\n \"content\": \"Dies ist eine Test-E-Mail über Microsoft Graph.\"\r\n },\r\n \"toRecipients\": [\r\n {\r\n \"emailAddress\": {\r\n \"address\": \"andre@minhorst.com\"\r\n }\r\n }\r\n ]\r\n },\r\n \"saveToSentItems\": \"true\"\r\n}<\/pre>\n\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_01\/pic_1532_001.png\")
<\/p>\nNächste Schritte<\/h2>\n
\n
Weitere Eigenschaften und Möglichkeiten<\/h2>\n
\n
https:\/\/learn.microsoft.com\/en-us\/graph\/api\/resources\/mail-api-overview?view=graph-rest-1.0<\/pre>\n
{\r\n \"message\": {\r\n \"subject\": \"Betreff der E-Mail (Entwurf)\",\r\n \"body\": {\r\n \"contentType\": \"HTML\",\r\n \"content\": \"<h1>\\u00DCberschrift<\/h1> <p>Dies ist der Inhalte der E-Mail<\/p>\"\r\n },<\/pre>\n \"toRecipients\": [ \r\n { \"emailAddress\": \r\n { \"address\": \"andre@minhorst.com\" } \r\n } \r\n ],<\/pre>\n \"ccRecipients\": [ \r\n { \"emailAddress\": \r\n { \"address\": \"info@amvshop.de\" } \r\n }\r\n ],<\/pre>\n \"bccRecipients\": [ \r\n { \"emailAddress\": \r\n { \"address\": \"andre01@minhorst.com\" } \r\n } \r\n ],<\/pre>\n \"importance\": \"high\"\r\n },\r\n \"saveToSentItems\": \"true\"\r\n}<\/pre>\n
Attachments hinzufügen<\/h2>\n
Funktion zum Konvertieren einer Datei in eine Base64-Zeichenkette<\/h2>\n
Function <\/span>EncodeFileToBase64(strPath As String<\/span>) As String<\/span>\r\n Dim <\/span>objXML As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objNode As <\/span>IXMLDOMElement\r\n Dim <\/span>objInputStream As Object<\/span>\r\n Dim <\/span>bytData() As Byte<\/span>\r\n Dim <\/span>strBase64 As String<\/span>\r\n Set<\/span> objInputStream = CreateObject(\"ADODB.Stream\")\r\n objInputStream.Type = 1 '' Binärdaten\r\n objInputStream.Open\r\n objInputStream.LoadFromFile filePath\r\n bytData = objInputStream.Read\r\n objInputStream.Close\r\n Set<\/span> objXML = New<\/span> MSXML2.DOMDocument60\r\n Set<\/span> objNode = objXML.createElement(\"base64\")\r\n objNode.DataType = \"bin.base64\"\r\n objNode.nodeTypedValue = bytData\r\n strBase64 = Replace<\/span>(objNode.Text, vbLf<\/span>, \"\")\r\n \r\n EncodeFileToBase64 = strBase64\r\nEnd Function<\/span><\/pre>\nEinbetten der Zeichenkette im JSON-Dokument<\/h2>\n
\n
{\r\n \"message\": {\r\n \"subject\": \"Betreff der E-Mail\",\r\n \"body\": {\r\n \"contentType\": \"HTML\",\r\n \"content\": \"<h1>\\u00DCberschrift<\/h1><p>Dies ist der Inhalte der E-Mail<\/p>\"\r\n },\r\n \"toRecipients\": [ { \"emailAddress\": { \"address\": \"andre@minhorst.com\" } } ],\r\n \"importance\": \"high\",\r\n \"attachments\": [\r\n {\r\n \"@odata.type\": \"#microsoft.graph.fileattachment\",\r\n \"name\": \"pic001.png\",\r\n \"contentBytes\": \"iVBORw0KGgo3oAAALG...TkSuQmCC\"\r\n }\r\n ]\r\n },\r\n \"saveToSentItems\": \"true\"\r\n}<\/pre>\nE-Mail über das JSON-Objektmodell zusammenstellen<\/h2>\n
Public Function <\/span>CreateEMail() As String<\/span>\r\n Dim <\/span>dicMail As <\/span>New<\/span> Dictionary, dicMessage As <\/span>New<\/span> Dictionary, dicBody As <\/span>New<\/span> Dictionary, \r\n Dim <\/span>colToRecipients As <\/span>New<\/span> Collection, colCcRecipients As <\/span>New<\/span> Collection, colBccRecipients As <\/span>New<\/span> Collection\r\n Dim <\/span>dicToRecipient As <\/span>New<\/span> Dictionary, dicCcRecipient As <\/span>New<\/span> Dictionary, dicBccRecipient As <\/span>New<\/span> Dictionary\r\n Dim <\/span>dicToEMailAddress As <\/span>New<\/span> Dictionary, dicCcEMailAddress As <\/span>New<\/span> Dictionary, dicBccEMailAddress As <\/span>New<\/span> Dictionary\r\n Dim <\/span>colAttachments As <\/span>