{"id":55000960,"date":"2014-12-01T00:00:00","date_gmt":"2020-05-22T21:13:36","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=960"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Mails_per_Drag_and_Drop_in_der_Datenbank_speichern","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Mails_per_Drag_and_Drop_in_der_Datenbank_speichern\/","title":{"rendered":"Mails per Drag and Drop in der Datenbank speichern"},"content":{"rendered":"

\"\"<\/p>\n

Mails landen gewöhnlicherweise im Posteingangsordner und werden dann, entweder automatisch oder manuell, in den jeweiligen Zielordner verschoben – wenn sie nicht gar gelöscht werden. Aber kann das schon alles sein Nein! In diesem Artikel zeigen wir Ihnen, wie Sie beim Verschieben einer Mail in einen bestimmten Ordner weitere Aktionen auslösen können, und zwar per VBA-Ereignis. Auf diese Weise können Sie dann beispielsweise den Inhalt der Mail und gegebenenfalls auch Anlagen direkt in einer dafür vorgesehenen Datenbank speichern.<\/b><\/p>\n

Welchen Sinn aber soll es haben, den Inhalt von E-Mails in einer Datenbank zu speichern Sie können auf diese Weise etwa die Mails zu bestimmten Kunden in einer entsprechenden Tabelle ablegen und dem Kunden in der Datenbank zuordnen.<\/p>\n

So brauchen Sie von der Kundendatenbank aus nicht immer noch Outlook zu öffnen, um die Kommunikation mit diesem Kunden einzusehen.<\/p>\n

Voraussetzungen<\/b><\/p>\n

Für die nachfolgend vorgestellten Techniken benötigen Sie Microsoft Office mit Outlook und Access in der Version 2007 oder neuer.<\/p>\n

Ordner anlegen<\/b><\/p>\n

Als Erstes wollen wir einen Ordner unter Outlook anlegen, dem Sie die in der Datenbank zu speichernden E-Mails hinzufügen. Diesen können Sie manuell anlegen, wir können dies aber auch per Code erledigen.<\/p>\n

Dazu öffnen Sie den VBA-Editor von Outlook (bei geöffnetem Outlook-Fenster mit Alt + F11<\/b>) und fügen dem bereits vorhandenen Klassenmodul ThisOutlookSession <\/b>über die beiden Kombinationsfelder im Kopf des Codefensters die Ereignisprozedur Application_Startup<\/b> hinzu (s. Bild 1). Dieses Ereignis wird bei jedem Start von Outlook ausgelöst.<\/p>\n

\"Anlegen<\/p>\n

Bild 1: Anlegen der Ereignisprozedur Application_Startup<\/span><\/b><\/p>\n

Hier können wir einen Code einfügen, der prüft, ob das gewünschte Verzeichnis sich bereits an Ort und Stelle befindet oder ob es noch angelegt werden soll. Letzteres führt die Prozedur dann gegebenenfalls noch durch.<\/p>\n

Um beim Starten von Outlook zu prüfen, ob bereits ein Verzeichnis namens Kundenmails <\/b>vorhanden ist, und dieses gegebenenfalls anzulegen, fügen Sie der Prozedur Application_Startup <\/b>noch die Zeilen aus Listing 1 hinzu. Diese Prozedur füllt ein Objekt namens objNamespace <\/b>mit dem MAPI<\/b>-Namespace-Objekt von Outlook. Dieses liefert über die GetDefaultFolder<\/b>-Eigenschaft mit dem Parameter olFolderInbox <\/b>einen Verweis auf den Posteingangsordner.<\/p>\n

Public Sub <\/span>Application_Startup()\r\n     Dim <\/span>objInbox As <\/span>Outlook.Folder\r\n     Dim <\/span>objKundenmails As <\/span>Outlook.Folder\r\n     Dim <\/span>objNamespace As <\/span>Outlook.NameSpace\r\n     Set<\/span> objNamespace = Outlook.GetNamespace(\"MAPI\")\r\n     Set<\/span> objInbox = objNamespace.GetDefaultFolder(olFolderInbox)\r\n     On Error Resume Next<\/span>\r\n     Set<\/span> objKundenmails = objInbox.Folders(\"Kundenmails\")\r\n     On Error GoTo<\/span> 0\r\n     If <\/span>objKundenmails Is Nothing Then<\/span>\r\n         Set<\/span> objKundenmails = objInbox.Folders.Add(\"Kundenmails\")\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Prüfen, ob das Verzeichnis Kundenmails schon vorhanden ist<\/span><\/b><\/p>\n
Dann versucht die Prozedur, einen darin enthaltenen Ordner namens Kundenmails <\/b>mit der Variablen objKundenmails <\/b>zu referenzieren. Gelingt dies nicht, bleibt objKundenmails <\/b>leer, was die nachfolgende If…Then<\/b>-Bedingung prüft.<\/p>\n
Ist objKundenmails <\/b>dann nicht gefüllt, legt die Prozedur diesen Ordner an und trägt einen Verweis auf diesen Ordner in die Variable objKundenmails <\/b>ein.<\/p>\n
Ereignis beim Hinzufügen einer Mail auslösen<\/b><\/p>\n
Das waren die Vorarbeiten. Tatsächlich müssen wir das Folder<\/b>-Objekt, mit dem wir das Verzeichnis Posteingang <\/b>referenzieren, aber außerhalb der Prozedur Application_Startup <\/b>referenzieren – und zwar mit der folgenden Anweisung:<\/p>\n
Dim <\/span>WithEvents objInbox As <\/span> Outlook.Folder<\/pre>\n
Das Schlüsselwort WithEvents <\/b>ist nötig, damit wir für die Variable objInbox <\/b>Ereignisprozeduren im Klassenmodul ThisOutlookSession <\/b>implementieren können. Dies erledigen Sie nun wiede-rum über die beiden Kombinationsfelder im Kopf des Codefensters. Wählen Sie dort links den nun verfügbaren Eintrag objInbox <\/b>aus und rechts den Eintrag BeforeItemMove <\/b>aus, sodass der VBA-Editor die Ereignisprozedur objInbox_BeforeItemMove <\/b>anlegt (s. Bild 2).<\/p>\n
\"Hinzufügen<\/p>\n
Bild 2: Hinzufügen einer Ereignisprozedur, die beim Verschieben einer Mail ausgelöst wird<\/span><\/b><\/p>\n
Hier hinterlegen Sie nun einige weitere Codezeilen, die wie in Listing 2 aussehen. Damit haben wir nun die Basis für weitere Funktionen geschaffen: Wir haben eine Ereignisprozedur, die durch das Verschieben einer E-Mail aus dem Verzeichnis Posteingang ausgelöst wird. Diese Prozedur prüft innerhalb einer Select Case<\/b>-Bedingung das Zielverzeichnis. Nur wenn dieses den Namen Kundenmails <\/b>trägt, wird ein Meldungsfenster angezeigt, das über die übermittlung der Mail in das Verzeichnis Kundenmails informiert.<\/p>\n
Private Sub <\/span>objInbox_BeforeItemMove(ByVal Item As Object<\/span>, ByVal MoveTo As <\/span>MAPIFolder, Cancel As Boolean<\/span>)\r\n     Select Case MoveTo.Name\r\n         Case <\/span>\"Kundenmails\"\r\n             MsgBox<\/span> \"Mail ist angekommen.\"\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Meldung ausgeben, wenn die Mail in den gewünschten Ordner verschoben wurde<\/span><\/b><\/p>\n
Statt des Meldungsfensters können wir dort nun weitere Anweisungen hinzufügen – etwa, um die Inhalte der E-Mail in der Tabelle einer Datenbank zu speichern.<\/p>\n
Tabelle zum Speichern der E-Mails<\/b><\/p>\n
In einer neuen Datenbankdatei namens Kundenmails.accdb <\/b>legen wir nun eine neue Tabelle mit der Bezeichnung tblKundenmails <\/b>an. Diese soll die Felder aus Bild 3 enthalten. Neben dem Primärschlüsselfeld KundenmailID <\/b>nimmt die Tabelle die grundlegenden Informationen und Inhalte der E-Mail auf – so den Absender, den Empfänger, den Betreff, den Inhalt und das Versanddatum.<\/p>\n
\"Die<\/p>\n
Bild 3: Die Tabelle tblKundenmails speichert die grundlegenden Informationen<\/span><\/b><\/p>\n
Die Anlagen speichern wir in einer weiteren Tabelle namens tblMailanlagen<\/b>. Diese finden Sie in Bild 4 vor. Die Tabelle enthält ein Fremdschlüsselfeld  namens KundenmailID <\/b>zum Verknüpfen der Datensätze dieser Tabelle mit denen der Tabelle tblKundenmails<\/b>. Außerdem speichert die Tabelle den Dateinamen der Anlage im Feld Anlagebezeichnung <\/b>sowie die Datei selbst im Feld Mailanlage<\/b>.<\/p>\n
\"Die<\/p>\n
Bild 4: Die Tabelle tblMailanlagen speichert die Mailanlagen<\/span><\/b><\/p>\n
Grundsätzlich hätten wir auch einfach nur ein Feld mit dem Datentyp Anlage <\/b>in der Tabelle tblKundenmails <\/b>anlegen können. Wir möchten da Anlage-Feld jedoch nicht dazu nutzen, mehrere Dateien zu speichern, da Informationen wie etwa der Dateiname dann nicht so einfach über die Benutzeroberfläche (etwa über Formulare) einsehbar sind.<\/p>\n
E-Mails und Anlagen speichern<\/b><\/p>\n
Listing 3 liefert zunächst zwei Konstanten namens cStrPath <\/b>und cStrDB<\/b>, die den Pfad und den Namen der Datenbank enthalten. Sicher gibt es elegantere Möglichkeiten, als Pfad und Dateiname hier fest zu verdrahten, aber aktuell reicht uns diese Variante aus.<\/p>\n
Const cStrPath As String<\/span> = \"Z:\\Dokumente\\Daten\\Fachmagazine\\AccessImUnternehmen\\2014\\06\\OutlookDrop\\\"\r\nConst cStrDB As String<\/span> = \"Kundenmails.accdb\"\r\nPrivate Sub <\/span>objInbox_BeforeItemMove(ByVal Item As Object<\/span>, ByVal MoveTo As <\/span>MAPIFolder, Cancel As Boolean<\/span>)\r\n     If <\/span>Not<\/span> MoveTo Is Nothing Then<\/span>\r\n         Select Case MoveTo.Name\r\n             Case <\/span>\"Kundenmails\"\r\n                 MailSpeichern Item\r\n         End Select<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
<\/p>\n
Listing 3: Konstanten mit Pfad und Datenbankname und die Ereignisprozedur objInbox_BeforeItemMove<\/span><\/b><\/p>\n
Die Ereignisprozedur objInbox_BeforeItemMove <\/b>prüft wiederum den Zielordner des Drag-and-Drop-Vorgangs und ruft im Falle des Ordners Kundenmails <\/b>die Prozedur MailSpeichern <\/b>auf. Dieser übergibt sie mit dem Parameter Item <\/b>einen Verweis auf das verschobene E-Mail-Objekt. Sicher haben Sie auch erkannt, dass wir der Prozedur noch eine If…Then<\/b>-Bedingung hinzugefügt haben. Diese prüft, ob MoveTo <\/b>überhaupt einen Wert enthält. Sollte der Benutzer nämlich eine E-Mail vollständig löschen (also bei gedrückter Umschalttaste und ohne Umweg über den Ordner Gelöschte Objekte<\/b>), dann ist das MoveTo<\/b>-Objekt gar nicht mehr mit einem Verweis auf das entsprechende MailItem<\/b>-Objekt gefüllt und die Prozedur kann beendet werden.<\/p>\n
Vorbereitungen für den Zugriff auf Access<\/b><\/p>\n
Das VBA-Projekt von Outlook kümmert sich normalerweise nicht um Access-Datenbanken. Dementsprechend wird auch der Zugriff auf die Tabellen einer Datenbank mit den Methoden der DAO-Bibliothek nicht nativ unterstützt. Damit wir beim Programmieren den gewohnten Komfort mit IntelliSense auch für die DAO-Objekte erhalten, fügen wir dem Projekt einen Verweis auf die Bibliothek Microsoft Office x.0 Access database engine Objects <\/b>hinzu – und zwar über den Verweise<\/b>-Dialog aus Bild 5, den Sie mit dem Menüeintrag Extras|Verweise <\/b>öffnen.<\/p>\n
\"Verweis<\/p>\n
Bild 5: Verweis auf die DAO-Bibliothek hinzufügen<\/span><\/b><\/p>\n
Speichern der E-Mail<\/b><\/p>\n
Das Speichern der E-Mail erledigt die Prozedur MailSpeichern<\/b>, die Sie in Listing 4 finden.<\/p>\n
Private Sub <\/span>MailSpeichern(objMail As <\/span>Outlook.MailItem)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>lngKundenmailID As Long<\/span>\r\n     Set<\/span> db = OpenDatabase(cStrPath & cStrDB)\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKundenmails WHERE 1 = 2\", dbOpenDynaset)\r\n     rst.AddNew<\/span>\r\n     rst!Absenderemail = objMail.SenderEmailAddress\r\n     rst!Empfaengeremail = objMail.Recipients.Item(1)\r\n     rst!Betreff = objMail.Subject\r\n     rst!Inhalt = objMail.Body\r\n     rst!GesendetAm = objMail.SentOn\r\n     lngKundenmailID = rst!KundenmailID\r\n     rst.Update\r\n     If <\/span>objMail.Attachments.Count > 0 Then<\/span>\r\n         AnlagenSpeichern db, lngKundenmailID, objMail.Attachments\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 4: Prozedur zum Speichern des Inhalts einer E-Mail in der Tabelle tblKundenmails<\/span><\/b><\/p>\n
Die Prozedur erstellt zunächst einen Verweis auf die Zieldatenbank namens Kundenmails.accdb <\/b>in dem angegebenen Zielordner. Dort, wo Sie sonst die CurrentDb<\/b>-Funktion verwenden, um auf die aktuelle Datenbank zuzugreifen, nutzen wir nun die Funktion OpenDatabase<\/b>, um von Outlook aus die Datenbank Kundenmails.accdb <\/b>zu nutzen. Dann erstellt die Prozedur ein Recordset-Objekt auf Basis der Tabelle tblKundenmails<\/b>, wobei allerdings keine Datensätze zurückgegeben werden sollen – daher die Bedingung 1=2<\/b>.<\/p>\n
Die Prozedur fügt einen neuen Datensatz hinzu und füllt einige Felder:<\/p>\n
Die Eigenschaft SenderEMailAddress <\/b>landet im Feld AbsenderEMail<\/b>, Subject <\/b>in Betreff<\/b>, Body <\/b>in Inhalt <\/b>und SentOn <\/b>im Feld GesendetAm<\/b>. Etwas komplizierter ist es mit der Empfängeradresse: Eine E-Mail kann natürlich mehrere Empfängeradressen enthalten. Diese finden Sie in der Recipients<\/b>-Auflistung des MailItem<\/b>-Objekts. Wir tragen hier daher einfach den ersten Wert dieser Auflistung in das Feld Empfaengeremail <\/b>ein (Item(1)<\/b>).<\/p>\n
Grundsätzlich könnte man dieses Feld auch weglassen – außer, Sie hätten mehrere E-Mail-Konten, über die Sie Nachrichten von verschiedenen Kundenkreisen erhalten. Dann müssten Sie sich Gedanken machen, wie Sie diese nach Kundenkreis filtern.<\/p>\n
Vor dem Speichern des neuen Datensatzes mit der Update<\/b>-Methode trägt die Prozedur noch den Primärschlüsselwert des neuen Datensatzes in die Variable lngKundenmailID <\/b>ein. Dann speichert die Prozedur den Datensatz und prüft, ob diese mindestens eine Anlage enthält. In diesem Fall ruft sie eine weitere Prozedur namens AnlagenSpeichern <\/b>auf, die sich um das Speichern der Anlagen der aktuellen E-Mail kümmert.<\/p>\n
Anlagen in Tabelle speichern<\/b><\/p>\n
Die Prozedur AnlagenSpeichern <\/b>aus Listing 5 erwartet drei Parameter: einen Verweis auf das Database<\/b>-Objekt mit dem Parameter db<\/b>, den Primärschlüsselwert des Eintrags in der Tabelle tblKundenmails<\/b> zu der die Anlagen gespeichert werden sollen, mit dem Parameter lngKundenmailID<\/b> sowie den Parameter objAnlage <\/b>mit der Auflistung der zu speichernden Anlagen.<\/p>\n
Private Sub <\/span>AnlagenSpeichern(db As <\/span>DAO.Database, lngKundenmailID As Long<\/span>, objAnlagen As <\/span>Outlook.Attachments)\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>rstAnlagen As <\/span>DAO.Recordset\r\n     Dim <\/span>objAnlage As <\/span>Outlook.Attachment\r\n     Dim <\/span>fldAnlage As <\/span>DAO.Field2\r\n     Dim <\/span>strAnlage As String<\/span>\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblMailanlagen WHERE 1 = 2\", dbOpenDynaset)\r\n     For Each objAnlage In objAnlagen\r\n         rst.AddNew<\/span>\r\n         rst!KundenmailID = lngKundenmailID\r\n         rst!Anlagebezeichnung = objAnlage.FileName\r\n         Set<\/span> rstAnlagen = rst!Mailanlage.Value\r\n         rstAnlagen.AddNew<\/span>\r\n         On Error Resume Next<\/span>\r\n         MkDir cStrPath & \"temp\"\r\n         strAnlage = cStrPath & \"temp\\\" & objAnlage.FileName\r\n         Kill strAnlage\r\n         On Error GoTo<\/span> 0\r\n         objAnlage.SaveAsFile strAnlage\r\n         Set<\/span> fldAnlage = rstAnlagen.Fields(\"FileData\")\r\n         fldAnlage.LoadFromFile strAnlage\r\n         Kill strAnlage\r\n         rstAnlagen.Update\r\n         rst.Update\r\n     Next<\/span> objAnlage\r\nEnd Sub<\/span><\/pre>\n
Listing 5: Speichern der Anlagen in der Tabelle tblMailanlagen<\/span><\/b><\/p>\n
Die Prozedur erstellt wieder ein Recordset<\/b>-Objekt, diesmal mit der Tabelle tblMailanlagen <\/b>als Datenherkunft. Auch hier soll das Recordset keine Datensätze liefern, sondern nur zur Neuanlage von Datensätzen dienen.<\/p>\n
Die Prozedur durchläuft in einer For Each<\/b>-Schleife alle Elemente der Auflistung objAnlagen <\/b>mit dem Typ Attachments<\/b>. Die Prozedur legt mit jedem Schleifendurchlauf zunächst einen neuen Datensatz in der Tabelle tblMailanlagen <\/b>an. Das Feld KundenmailID <\/b>als Fremdschlüsselfeld erhält den mit dem Parameter lngKundenmailID <\/b>übergebenen Wert, das Feld Anlagebezeichnung <\/b>füllen wir mit dem Dateinamen aus der Eigenschaft FileName<\/b>.<\/p>\n
Dann referenzieren wir das im Anlagefeld der Tabelle enthaltene Recordset über die Value<\/b>-Eigenschaft mit der Variablen rstAnlagen<\/b>.<\/p>\n
Diesem fügen wir mit der AddNew<\/b>-Methode einen neuen Datensatz hinzu und erledigen dann bei deaktivierter Fehlerbehandlung die folgenden Schritte:<\/p>\n