Mails mit Microsoft Graph API per Klasse versenden

1/2025, 2025, Interaktiv

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.

Bevor Sie die Lösung aus diesem Beitrag einsetzen, sollten Sie die folgenden Beiträge durchgearbeitet haben:

  • Outlook.com mit Access und VBA: Vorbereitungen (www.access-im-unternehmen.de/1531)
  • Konto bei Outlook.com anlegen und nutzen (www.access-im-unternehmen.de/1534)
  • Mails senden mit der Microsoft Graph API (www.access-im-unternehmen.de/1532)

Die hier vorgestellte Klasse bedienen wir hier mit einer kleinen Testprozedur. Ein etwas umfangreicheres Beispiel finden Sie im Beitrag Formular für den Mailversand (www.access-im-unternehmen.de/1536).

Hier stellen wir ein Formular vor, in das wir alle notwendigen Daten eintragen und mit dem wir den Mailversand starten können.

Benötige Elemente

Wenn Sie die Lösung in eine eigenen Anwendung übertragen wollen, sind einige Vorbereitungen erforderlich.

Zunächst einmal benötigen wir Verweise auf die beiden folgenden Bibliotheken:

  • Microsoft Scripting Runtime (wegen der Benutzung des Dictionary-Objekts)
  • Microsoft XML, v6.0 (für die Verwendung der Klasse XMLHTTP60, die wir für den Zugriff auf die Microsoft Graph API und weitere Funktionen benötigen)

Außerdem werden die folgenden beiden Module benötigt:

  • mdlJSON: Enthält Funktionen zum Parsen und Erstellen von JSON-Dokumenten.
  • mdlJSONDOM: Enthält Funktionen zum Analysieren von Objektmodellen auf Basis von JSON-Dokumenten.
  • mdlZwischenablage: Enthält Funktionen, um Inhalte aus Stringvariablen in die Zwischenablage zu kopieren. Ist hilfreich, wenn man größere JSON-Dokumente analysieren möchte.

Den Rest finden Sie im Klassenmodul clsMail und im Modul mdlSampleClass mit dem Code zum Verwenden des Klassenmoduls.

Erstellen des Klassenmoduls

Das Klassenmodul erstellen wir im VBA-Editor, indem wir den Menübefehl Einfügen|Klassenmodul aufrufen. Das neu erstellte Klassenmodul speichern wir direkt unter dem Namen clsMail.

Variablen mit Property Get- und Set-Methoden

Die Klasse enthält einige private Variablen, die wir über entsprechende Get– und Set-Prozeduren füllen wollen.

Hier sind zunächst die privaten Membervariablen:

Private m_Subject As String
Private m_TextContent As String
Private m_HTMLContent As String
Private m_ToRecipients As Collection
Private m_CcRecipients As Collection
Private m_BccRecipients As Collection
Private m_Attachments As Collection
Private m_Username As String
Private m_Importance As eImportance
Private m_ContentType As eContentType
Private m_ApplicationID As String
Private m_SecretID As String
Private m_TenantID As String

Für die Variable m_Importance haben wir eine Enumeration mit den verfügbaren Werten angelegt. Diese sieht wie folgt aus:

Public Enum eImportance
     eLow = -1
     eNormal = 0
     eHigh = 1
End Enum

Auch für die Variable ContentType, die angibt, ob wir den Inhalt der E-Mail als Text- oder HTML-Inhalt übergeben wollen, haben wir eine Enumeration hinzugefügt:

Public Enum eContentType
     eText = 0
     eHTML = 1
End Enum

Eigenschaften der Klasse

Für die einzelnen Variablen gibt es jeweils eine Property Let– und eine Property Get-Prozedur.

Diese ermöglichen es, dass wir der Klasse nach dem Initialisieren die gewünschten Werte zuweisen können. Die Property Let-Prozedur für die Variable m_ApplicationID heißt ApplicationID und erwartet ihren Wert als String-Parameter:

Public Property Let ApplicationID(str As String)
     m_ApplicationID = str
End Property

Auch wenn es vermutlich nicht so oft vorkommen wird, haben wir auch noch die passende Property Get-Prozedur hinzugefügt, mit der wir den aktuellen Wert dieser Variablen auslesen können:

Public Property Get ApplicationID() As String
     ApplicationID = m_ApplicationID
End Property

Die Eigenschaft ApplicationID 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:

  • SecretID: Geheimer Client-Schlüssel
  • TenantID: Verzeichnis-ID
  • ContentType: Gibt an, ob Text- oder HTML-Inhalt genutzt werden soll.
  • Importance: Priorität der E-Mail, angegeben durch einen Wert der Enumeration eImportance
  • Username: Name des Benutzerkontos, über das die E-Mail versendet werden soll
  • Attachments: Collection zum Erfassen der Pfade zu den einzufügenden Anlagen
  • ToRecipients: Collection zum Erfassen der To-Empfänger
  • CcRecipients: Collection zum Erfassen der Cc-Empfänger
  • BccRecipients: Collection zum Erfassen der Bcc-Empfänger
  • Subject: Betreff der E-Mail
  • TextContent: Inhalt der E-Mail im Textformat
  • HTMLContent: Inhalt der E-Mail im HTML-Format

Nachfolgend die Property Let– beziehungsweise Property Set-Prozeduren (die Property Get-Prozeduren haben wir hier nicht abgebildet, da sie nicht genutzt werden):

Public Property Let SecretID(str As String)
     m_SecretID = str
End Property
Public Property Let TenantID(str As String)
     m_TenantID = str
End Property
Public Property Let ContentType(obj As eContentType)
     m_ContentType = obj
End Property
Public Property Let Importance(obj As eImportance)
     m_Importance = obj
End Property
Public Property Let Username(str As String)
     m_Username = str
End Property
Public Property Set Attachments(col As Collection)
     Set m_Attachments = col
End Property
Public Property Set ToRecipients(col As Collection)
     Set m_ToRecipients = col
End Property
Public Property Set CcRecipients(col As Collection)
     Set m_CcRecipients = col
End Property
Public Property Set BccRecipients(col As Collection)
     Set m_BccRecipients = col
End Property
Public Property Let Subject(str As String)
     m_Subject = str
End Property
Public Property Let TextContent(str As String)
     m_TextContent = str
End Property
Public Property Let HTMLContent(str As String)
     m_HTMLContent = str
End Property

Verwenden der Eigenschaften der Klasse

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.

Die folgende Prozedur erstellt ein Objekt auf Basis der Klasse clsMail und referenziert es mit der Variablen objMail. Danach weisen wir die gewünschten Informationen zu. Die drei Eigenschaften ApplicationID, SecretID und TenantID speisen wir aus drei entsprechenden Konstanten.

Sofern der Code nicht kompiliert wird (.accde), 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:

Public Const cStrApplicationID As String = "5bdd...b18cd"
Public Const cStrSecretValue As String = "6Ar8...ca2e"
Public Const cStrTenantID As String = "dcc8...4771"

Die übrigen Daten übergeben wir wie folgt, wobei wir hier eine E-Mail im HTML-Format erstellen, die nur an einen Empfänger geschickt wird:

Public Sub Test_Class_HTML()
     Dim objMail As New clsMail
     objMail.ApplicationID = cStrApplicationID
     objMail.SecretID = cStrSecretValue
     objMail.TenantID = cStrTenantID
     objMail.Username = _
         "andre@andreminhorstverlag.onmicrosoft.com"
     objMail.ToRecipients.Add "andre@minhorst.com"
     objMail.Subject = "Mein Betreff"
     objMail.ContentType = eHTML
     objMail.HTMLContent = _
         "<h1>Meine Überschrift</h1><p>Mein Text</p>"
     objMail.Importance = eHigh
     objMail.Send
End Sub

Lediglich die Methode Send haben wir noch nicht vorgestellt, und außerdem müssen wir die Collections noch initialisieren, bevor wir diese mit Daten füllen können.

Initialisieren der Collections beim Erstellen der Klasse

Die Variablen für die Collections, in denen wir die To-, Cc– und Bcc-Empfänger und die Pfade zu den einzufügenden Anlagen speichern, sollen direkt beim Erstellen der Klasse initialisiert werden.

Dazu legen wir die Ereignisprozedur Class_Initialize an, die wir mit den folgenden Befehlen füllen:

Private Sub Class_Initialize()
     Set m_ToRecipients = New Collection
     Set m_CcRecipients = New Collection
     Set m_BccRecipients = New Collection
     Set m_Attachments = New Collection
End Sub

Senden der E-Mail

Danach sind wir jedoch bereit, den Sendevorgang zu starten. Dazu rufen wir die Funktion Send auf, die wir in Listing 1 finden.

Public Function Send() As Boolean
     Dim objXMLHTTP As MSXML2.XMLHTTP60
     Dim strURL As String
     Dim strToken As String
     Dim strBody As String
     Dim strResponse As String
     
     If GetAccessToken(strToken, strResponse) = True Then
         strURL = "https://graph.microsoft.com/v1.0/users/" & m_Username & "/sendMail"
         strBody = CreateEMail
         Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")
         objXMLHTTP.Open "POST", strURL, False
         objXMLHTTP.setRequestHeader "Authorization", "Bearer " & strToken
         objXMLHTTP.setRequestHeader "Content-Type", "application/json"
         objXMLHTTP.Send strBody
         
         Select Case objXMLHTTP.status
             Case 202
                 MsgBox "E-Mail erfolgreich gesendet."
                 Send = True
             Case Else
                 MsgBox "Fehler beim Senden der E-Mail: " & objXMLHTTP.status & " - " & objXMLHTTP.responseText
                 Debug.Print objXMLHTTP.responseText
         End Select
     End If
End Function

Listing 1: Hauptprozedur zum Senden der E-Mail

Die Funktion haben wir bereits im Beitrag Mails senden mit der Microsoft Graph API (www.access-im-unternehmen.de/1532) in ähnlicher Form vorgestellt, daher hier eine komprimierte Beschreibung.

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.

Die Funktion Send ruft als Erstes die ebenfalls im obigen Beitrag vorgestellte Funktion GetAccessToken auf. Diese liefert im Erfolgsfall das Authentifizierungstoken mit dem Parameter strToken zurück.

Nur dann stellen wir die URL für das Versenden der E-Mail zusammen und rufen die Funktion CreateEMail 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.

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

den kompletten Artikel im PDF-Format mit Beispieldatenbank

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar