In den vorherigen Beiträgen haben wir uns bereits verschiedene Themen rund um die Versendung von E-Mails mit der Microsoft Graph API angeschaut. Dabei haben wir uns angesehen, wie wir einen Outlook-Account erstellen, wie wir dafür sorgen, dass wir per Microsoft Graph API auf diesen zugreifen, und wir damit E-Mails versenden. Die erarbeiteten Techniken werden wir in diesem Beitrag noch auf ein neues Level heben: Wir erstellen eine Klasse, die alle notwendigen Eigenschaften und Methoden enthält, um die Daten einer E-Mail hinzuzufügen und die E-Mail schließlich zu versenden.<\/b><\/p>\n
Bevor Sie die Lösung aus diesem Beitrag einsetzen, sollten Sie die folgenden Beiträge durchgearbeitet haben:<\/p>\n
Die hier vorgestellte Klasse bedienen wir hier mit einer kleinen Testprozedur. Ein etwas umfangreicheres Beispiel finden Sie im Beitrag Formular für den Mailversand<\/b> (www.access-im-unternehmen.de\/1536<\/b>).<\/p>\n
Hier stellen wir ein Formular vor, in das wir alle notwendigen Daten eintragen und mit dem wir den Mailversand starten können.<\/p>\n
Wenn Sie die Lösung in eine eigenen Anwendung übertragen wollen, sind einige Vorbereitungen erforderlich.<\/p>\n
Zunächst einmal benötigen wir Verweise auf die beiden folgenden Bibliotheken:<\/p>\n
Außerdem werden die folgenden beiden Module benötigt:<\/p>\n
Den Rest finden Sie im Klassenmodul clsMail <\/b>und im Modul mdlSampleClass <\/b>mit dem Code zum Verwenden des Klassenmoduls.<\/p>\nErstellen des Klassenmoduls<\/h2>\n
Das Klassenmodul erstellen wir im VBA-Editor, indem wir den Menübefehl Einfügen|Klassenmodul <\/b>aufrufen. Das neu erstellte Klassenmodul speichern wir direkt unter dem Namen clsMail<\/b>.<\/p>\nVariablen mit Property Get- und Set-Methoden<\/h2>\n
Die Klasse enthält einige private Variablen, die wir über entsprechende Get<\/b>– und Set<\/b>-Prozeduren füllen wollen.<\/p>\n
Hier sind zunächst die privaten Membervariablen:<\/p>\n
Private <\/span>m_Subject As String<\/span>\r\nPrivate <\/span>m_TextContent As String<\/span>\r\nPrivate <\/span>m_HTMLContent As String<\/span>\r\nPrivate <\/span>m_ToRecipients As <\/span>Collection\r\nPrivate <\/span>m_CcRecipients As <\/span>Collection\r\nPrivate <\/span>m_BccRecipients As <\/span>Collection\r\nPrivate <\/span>m_Attachments As <\/span>Collection\r\nPrivate <\/span>m_Username As String<\/span>\r\nPrivate <\/span>m_Importance As <\/span>eImportance\r\nPrivate <\/span>m_ContentType As <\/span>eContentType\r\nPrivate <\/span>m_ApplicationID As String<\/span>\r\nPrivate <\/span>m_SecretID As String<\/span>\r\nPrivate <\/span>m_TenantID As String<\/span><\/pre>\nFür die Variable m_Importance <\/b>haben wir eine Enumeration mit den verfügbaren Werten angelegt. Diese sieht wie folgt aus:<\/p>\nPublic <\/span>Enum eImportance\r\n eLow = -1\r\n eNormal = 0\r\n eHigh = 1\r\nEnd Enum<\/pre>\nAuch für die Variable ContentType<\/b>, die angibt, ob wir den Inhalt der E-Mail als Text- oder HTML-Inhalt übergeben wollen, haben wir eine Enumeration hinzugefügt:<\/p>\nPublic <\/span>Enum eContentType\r\n eText = 0\r\n eHTML = 1\r\nEnd Enum<\/pre>\nEigenschaften der Klasse<\/h2>\n
Für die einzelnen Variablen gibt es jeweils eine Property Let<\/b>– und eine Property Get<\/b>-Prozedur.<\/p>\n
Diese ermöglichen es, dass wir der Klasse nach dem Initialisieren die gewünschten Werte zuweisen können. Die Property Let<\/b>-Prozedur für die Variable m_ApplicationID <\/b>heißt ApplicationID <\/b>und erwartet ihren Wert als String<\/b>-Parameter:<\/p>\nPublic Property Let <\/span>ApplicationID(str As String<\/span>)\r\n m_ApplicationID = str\r\nEnd Property<\/span><\/pre>\nAuch wenn es vermutlich nicht so oft vorkommen wird, haben wir auch noch die passende Property Get<\/b>-Prozedur hinzugefügt, mit der wir den aktuellen Wert dieser Variablen auslesen können:<\/p>\nPublic Property Get <\/span>ApplicationID() As String<\/span>\r\n ApplicationID = m_ApplicationID\r\nEnd Property<\/span><\/pre>\nDie Eigenschaft ApplicationID <\/b>nimmt eine von drei Informationen entgegen, die wir für die Authentifizierung benötigen beziehungsweise um das Authentifizierungstoken zu holen. Hier sind die weiteren Eigenschaften, die wir verwenden:<\/p>\n\n- SecretID<\/b>: Geheimer Client-Schlüssel<\/li>\n
- TenantID<\/b>: Verzeichnis-ID<\/li>\n
- ContentType<\/b>: Gibt an, ob Text- oder HTML-Inhalt genutzt werden soll.<\/li>\n
- Importance<\/b>: Priorität der E-Mail, angegeben durch einen Wert der Enumeration eImportance<\/b><\/li>\n
- Username<\/b>: Name des Benutzerkontos, über das die E-Mail versendet werden soll<\/li>\n
- Attachments<\/b>: Collection zum Erfassen der Pfade zu den einzufügenden Anlagen<\/li>\n
- ToRecipients<\/b>: Collection zum Erfassen der To<\/b>-Empfänger<\/li>\n
- CcRecipients<\/b>: Collection zum Erfassen der Cc<\/b>-Empfänger<\/li>\n
- BccRecipients<\/b>: Collection zum Erfassen der Bcc<\/b>-Empfänger<\/li>\n
- Subject<\/b>: Betreff der E-Mail<\/li>\n
- TextContent<\/b>: Inhalt der E-Mail im Textformat<\/li>\n
- HTMLContent<\/b>: Inhalt der E-Mail im HTML-Format<\/li>\n<\/ul>\n
Nachfolgend die Property Let<\/b>– beziehungsweise Property Set<\/b>-Prozeduren (die Property Get<\/b>-Prozeduren haben wir hier nicht abgebildet, da sie nicht genutzt werden):<\/p>\nPublic Property Let <\/span>SecretID(str As String<\/span>)\r\n m_SecretID = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>TenantID(str As String<\/span>)\r\n m_TenantID = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>ContentType(obj As <\/span>eContentType)\r\n m_ContentType = obj\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Importance(obj As <\/span>eImportance)\r\n m_Importance = obj\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Username(str As String<\/span>)\r\n m_Username = str\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Attachments(col As <\/span>Collection)\r\n Set<\/span> m_Attachments = col\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>ToRecipients(col As <\/span>Collection)\r\n Set<\/span> m_ToRecipients = col\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>CcRecipients(col As <\/span>Collection)\r\n Set<\/span> m_CcRecipients = col\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>BccRecipients(col As <\/span>Collection)\r\n Set<\/span> m_BccRecipients = col\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Subject(str As String<\/span>)\r\n m_Subject = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>TextContent(str As String<\/span>)\r\n m_TextContent = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>HTMLContent(str As String<\/span>)\r\n m_HTMLContent = str\r\nEnd Property<\/span><\/pre>\nVerwenden der Eigenschaften der Klasse<\/h2>\n
An dieser Stelle wollen wir bereits einen Beispielaufruf der Klasse zeigen. Immerhin haben wir nun bereits alle Möglichkeiten der Eingabe von Daten programmiert, die wir benötigen.<\/p>\n
Die folgende Prozedur erstellt ein Objekt auf Basis der Klasse clsMail <\/b>und referenziert es mit der Variablen objMail<\/b>. Danach weisen wir die gewünschten Informationen zu. Die drei Eigenschaften ApplicationID<\/b>, SecretID <\/b>und TenantID <\/b>speisen wir aus drei entsprechenden Konstanten.<\/p>\n
Sofern der Code nicht kompiliert wird (.accde<\/b>), könnte man diese sensiblen Informationen auch an anderer Stelle speichern. Zu Beispielzwecken belassen wir diese jedoch in den Konstanten, die wir außerhalb der Klasse in einem anderen Modul wie folgt definieren:<\/p>\nPublic <\/span>Const cStrApplicationID As String<\/span> = \"5bdd...b18cd\"\r\nPublic <\/span>Const cStrSecretValue As String<\/span> = \"6Ar8...ca2e\"\r\nPublic <\/span>Const cStrTenantID As String<\/span> = \"dcc8...4771\"<\/pre>\nDie übrigen Daten übergeben wir wie folgt, wobei wir hier eine E-Mail im HTML-Format erstellen, die nur an einen Empfänger geschickt wird:<\/p>\n
Public Sub <\/span>Test_Class_HTML()\r\n Dim <\/span>objMail As <\/span>New<\/span> clsMail\r\n objMail.ApplicationID = cStrApplicationID\r\n objMail.SecretID = cStrSecretValue\r\n objMail.TenantID = cStrTenantID\r\n objMail.Username = _\r\n \"andre@andreminhorstverlag.onmicrosoft.com\"\r\n objMail.ToRecipients.Add \"andre@minhorst.com\"\r\n objMail.Subject = \"Mein Betreff\"\r\n objMail.ContentType = eHTML\r\n objMail.HTMLContent = _\r\n \"<h1>Meine Überschrift<\/h1><p>Mein Text<\/p>\"\r\n objMail.Importance = eHigh\r\n objMail.Send\r\nEnd Sub<\/span><\/pre>\nLediglich die Methode Send <\/b>haben wir noch nicht vorgestellt, und außerdem müssen wir die Collections noch initialisieren, bevor wir diese mit Daten füllen können.<\/p>\nInitialisieren der Collections beim Erstellen der Klasse<\/h2>\n
Die Variablen für die Collections, in denen wir die To<\/b>-, Cc<\/b>– und Bcc<\/b>-Empfänger und die Pfade zu den einzufügenden Anlagen speichern, sollen direkt beim Erstellen der Klasse initialisiert werden.<\/p>\n
Dazu legen wir die Ereignisprozedur Class_Initialize <\/b>an, die wir mit den folgenden Befehlen füllen:<\/p>\nPrivate Sub <\/span>Class_Initialize()\r\n Set<\/span> m_ToRecipients = New<\/span> Collection\r\n Set<\/span> m_CcRecipients = New<\/span> Collection\r\n Set<\/span> m_BccRecipients = New<\/span> Collection\r\n Set<\/span> m_Attachments = New<\/span> Collection\r\nEnd Sub<\/span><\/pre>\nSenden der E-Mail<\/h2>\n
Danach sind wir jedoch bereit, den Sendevorgang zu starten. Dazu rufen wir die Funktion Send <\/b>auf, die wir in Listing 1 finden.<\/p>\nPublic Function <\/span>Send() As Boolean<\/span>\r\n Dim <\/span>objXMLHTTP As <\/span>MSXML2.XMLHTTP60\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 strURL = \"https:\/\/graph.microsoft.com\/v1.0\/users\/\" & m_Username & \"\/sendMail\"\r\n strBody = CreateEMail\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 Send = True<\/span>\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Senden der E-Mail: \" & objXMLHTTP.status & \" - \" & objXMLHTTP.responseText\r\n Debug.Print<\/span> objXMLHTTP.responseText\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nListing 1: Hauptprozedur zum Senden der E-Mail<\/span><\/b><\/p>\nDie Funktion haben wir bereits im Beitrag Mails senden mit der Microsoft Graph API <\/b>(www.access-im-unternehmen.de\/1532<\/b>) in ähnlicher Form vorgestellt, daher hier eine komprimierte Beschreibung.<\/p>\n
Dort war die Funktion allerdings noch eine Prozedur. Hier haben wir uns für eine Funktion entschieden, weil wir einen Wert zurückliefern möchten, der angibt, ob die E-Mail erfolgreich versendet werden konnte.<\/p>\n
Die Funktion Send <\/b>ruft als Erstes die ebenfalls im obigen Beitrag vorgestellte Funktion GetAccessToken <\/b>auf. Diese liefert im Erfolgsfall das Authentifizierungstoken mit dem Parameter strToken <\/b>zurück.<\/p>\n
Nur dann stellen wir die URL für das Versenden der E-Mail zusammen und rufen die Funktion CreateEMail <\/b>auf, mit der wir die als Eigenschaften der Klasse übermittelten Informationen als Body unserer Anfrage an die Microsoft Graph API zusammenstellen – mehr dazu weiter unten -, und speichern diesen in der Variablen strBody<\/b>.<\/p>\n
Dann erfolgen die bereits im oben genannten Beitrag beschriebenen Schritte, in denen wir die Anfrage mit der E-Mail an die Microsoft Graph API senden.<\/p>\n
Im Erfolgsfall liefert die Funktion dann den Wert True<\/b> an die aufrufende Routine zurück.<\/p>\nDie Funktion GetAccessToken<\/h2>\n
Auch diese Funktion haben wir bereits im Beitrag Mails senden mit der Microsoft Graph API <\/b>(www.access-im-unternehmen.de\/1532<\/b>) vorgestellt, und auch hier haben wir einige Änderungen vorgenommen, damit sie innerhalb unserer Klasse optimal verwendet werden kann (siehe Listing 2).<\/p>\nFunction <\/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\/\" & m_TenantID & \"\/oauth2\/v2.0\/token\"\r\n strData = \"grant_type=client_credentials\" & _\r\n \"&client_id=\" & m_ApplicationID & _\r\n \"&client_secret=\" & m_SecretID & _\r\n \"&scope=https:\/\/graph.microsoft.com\/.default\"\r\n Debug.Print<\/span> strData\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 Debug.Print<\/span> strJSON\r\n Set<\/span> objJSON = ParseJson(strJSON)\r\n Debug.Print<\/span> GetJSONDOM(strJSON, True<\/span>)\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>\nListing 2: Die Funktion GetAccessToken holt das Token für den Zugriff auf die Microsoft Graph API.<\/span><\/b><\/p>\nDie wesentlichen Änderungen liegen darin, bestehen darin, dass nicht mehr, wie im genannten Artikel beschrieben, direkt auf die Konstanten für die ApplicationID<\/b>, SecretID <\/b>und TenantID <\/b>zugreifen, sondern auf die dafür angelegten privaten Variablen, die beim Aufruf über die entsprechenden Eigenschaften gefüllt werden.<\/p>\n
Das heißt, dass wir beim Zusammenstellen der URL direkt auf m_TenantID <\/b>zugreifen und beim Zusammenstellen der weiteren Daten in strData <\/b>auf m_ApplicationID <\/b>und m_SecretID<\/b>.<\/p>\nZusammenstellen der E-Mail<\/h2>\n
Den größten Teil der Arbeit erledigt die Funktion CreateEMail<\/b>, die eine Zeichenkette als Ergebnis zurückliefert (siehe Listing 3). Sie deklariert zunächst einige Dictionary<\/b>– und Collection<\/b>-Elemente, die im Folgenden zum Zusammenstellen eines Objektmodells dienen, das im weiteren Verlauf zum Erstellen des JSON-Dokuments mit den strukturierten E-Mail-Informationen verwendet wird.<\/p>\nPublic Function <\/span>CreateEMail() As String<\/span>\r\n Dim <\/span>dicMail As <\/span>New<\/span> Dictionary, dicMessage