<\/p>\n
In der Beitragsreihe „Outlook-Mails in Access archivieren“ haben wir gezeigt, wie Sie die E-Mails aus kompletten und auch untergeordneten Outlook-Ordnern in eine Access-Datenbank importieren. Das ist die Lösung für den Start der Archivierung. Interessant wird es erst, wenn Sie diese Daten direkt nach dem Eingang in Outlook archivieren. Der vorliegende Beitrag zeigt, wie Sie Outlook so erweitern, dass jede in vorgegebenen Ordnern eingehenende E-Mail direkt in unsere Access-Mail-Archiv weitergeleitet wird.<\/b><\/p>\n
Um das vorgegebene Ziel zu erreichen, sind einige änderungen am VBA-Projekt von Outlook erforderlich. Sprich: Wir verwenden in diesem Beitrag Access nur zur Bereitstellung der Datenbank, in die wir die Outlook-Mails exportieren möchten. Diese Datenbank haben wir in der Beitragsreihe Outlook-Mails in Access archivieren <\/b>(www.access-im-unternehmen.de\/985<\/b>, 990 <\/b>und 997<\/b>) ausführlich vorgestellt.<\/p>\n
Von dort benötigen wir drei Tabellen (siehe auch Bild 1):<\/p>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2015_05\/pic_1007_001.png\")
<\/p>\n
Bild 1: Tabellen der Access-Seite der Lösung<\/span><\/b><\/p>\n Damit Sie von Outlook aus auf die Elemente der Access-Objektbibliothek sowie auf die DAO-Bibliothek zugreifen können (in diesem Fall die neuere Version der DAO-Bibliothek, nämlich die Microsoft Office x.0 Access Database Engine Object Library<\/b>), legen Sie im VBA-Projekt von Outlook zunächst zwei Verweise an. Der Verweise<\/b>-Dialog (VBA-Editor, Extras|Verweise<\/b>) sollte danach etwa wie in Bild 2 aussehen.<\/p>\n Bild 2: Verweise für den Export nach Access<\/span><\/b><\/p>\n Den VBA-Editor öffnen Sie unter Outlook übrigens über die Tastenkombination Alt + F11<\/b>. Die Kombination Strg + G <\/b>funktioniert im Gegensatz zu Access nicht.<\/p>\n Der VBA-Editor präsentiert, sofern der Projekt-Explorer sichtbar ist, unter dem Ordner Microsoft Outlook Objekte <\/b>die Klasse ThisOutlookSession<\/b>. In dieser Klasse landen die ersten Codezeilen dieser Lösung. Die erste lautet wie folgt und deklariert die Konstante zum Speichern des Verzeichnisses für die Ziel-Datenbank. Dazu ermitteln Sie zunäcsht den Speicherort der Datenbank, in der Sie die eingehenden E-Mails speichern wollen – zum Beispiel c:\\Outlook\\Outlook_III.accdb<\/b>. Legen Sie dann die folgende Zeile im Kopf der Klasse an:<\/p>\n Außerdem deklarieren wir hier noch eine Collection<\/b>, deren Sinn wir weiter unten erläutern werden:<\/p>\n Bevor wir weitermachen, benötigen wir ein paar theoretische Grundlagen. Wenn eine Mail abgerufen wird, landet diese in einem der Mail-Ordner in Outlook. Welcher das ist, hängt von den festgelegten Regeln ab. Normalerweise ist der Ordner Posteingang das Ziel einer neu eingetroffenen E-Mail.<\/p>\n Sie können jedoch festlegen, dass E-Mails mit bestimmten Eigenschaften direkt in einem anderen Ordner landen – beispielsweise solche mit bestimmten E-Mail-Adressen oder solche, die einen bestimmten Text im Betreff enthalten.<\/p>\n Um dies festzulegen, benötigen Sie eine sogenannte Regel. Zum Definieren dieser Regel suchen Sie sich am besten eine E-Mail, welche die betroffene Eigenschaft aufweist. Klicken Sie mit der rechten Maustaste auf die E-Mail und wählen Sie den Kontextmenü-Eintrag Regeln|Regel erstellen <\/b>aus. Nun erscheint der Dialog aus Bild 3. Dieser zeigt bereits einige möglichen Ausdrücke zum Formulieren der Regel an. In diesem Fall wollen wir, dass alle E-Mails, die wie die aktuelle das Schlüsselwort Outlooktest <\/b>im Betreff enthalten, von der Regel betroffen sind.<\/p>\n Bild 3: Anlegen einer neuen Regel für den Posteingang<\/span><\/b><\/p>\n Diese Mails sollen in einen bestimmten Outlook-Ordner verschoben werden, daher aktivieren Sie unten die Optioni Element in Ordner verschieben<\/b>. Nach einem Klick auf Ordner auswählen <\/b>erscheint nun der Dialog aus Bild 4, wo Sie den Zielordner festlegen. Ist diese Aufgabe erledigt, können Sie sich bereits eine Test-E-Mail mit genau diesem Betreff zusenden. Sie wird dann beim Abrufen wie erwartet in den angegebenen Ordner verschoben.<\/p>\n Bild 4: Auswählen des Zielordners<\/span><\/b><\/p>\n Nun landet eine Mail also in einem von mehreren Ordnern, die wir in der Datenbank in der Tabelle tblOptionen <\/b>festgelegt haben. All diese Ordner wollen wir nun ständig auf den Eingang von E-Mails überprüfen.<\/p>\n Dies gelingt nur, wenn wir herausfinden, welches Ereignis beim Maileingang ausgelöst wird, und dieses für die entsprechenden Elemente implementieren. Das Ganze muss natürlich dynamisch ausgelegt werden, da ja zuvor noch nicht feststeht, welche Ordner der Benutzer überhaupt für die überprüfung vorgesehen hat.<\/p>\n Um es vorwegzunehmen: Es ist nicht das Folder<\/b>-Objekt, das beim Maileingang ein Ereignis auslöst, sondern das Items<\/b>-Objekt, also das Objekt, das die in einem Folder enthaltenen Objekte auflistet.<\/p>\n Andererseits können Sie Ereignisprozeduren für Objekte wie etwa einen Mailordner oder eine Liste wie Items <\/b>nur innerhalb von Klassenprozeduren implementieren. Also wollen wir zu einer Technik greifen, die wir bereits in einigen anderen Beiträgen umgesetzt haben. Wir werden eine Klasse erstellen, welche einen Verweis auf ein Items<\/b>-Objekt aufnehmen kann. Diese implementiert genau für dieses Items<\/b>-Objekt, nennen wir es obj-Items<\/b>, das Ereignis ItemAdd<\/b>. Dieses Ereignis liefert ein Item<\/b>-Objekt, das in unserem Fall in der Regel den Typ MailItem <\/b>aufweisen sollte. Dies ist schon der Verweis auf die E-Mail, der wir nun die für das Archivieren in der Datenbank benötigten Daten entnehmen können.<\/p>\n Nun müssen wir nur noch ein oder mehrere dieser Klassen instanzieren, und zwar eine für jeden Ordner, der in der Tabelle tblOptionen <\/b>der Archivdatenbank für die E-Mails enthalten ist. Diese sollen nach dem Erstellen nicht im Nirvana verschwinden, daher verwenden wir ein Collection<\/b>-Objekt, um diese Objekte zu speichern – eben jenes, das wir weiter oben bereits deklariert haben.<\/p>\n Die Klassen mit den zu überwachenden Ordnern sollen direkt beim Start von Outlook erstellt werden. Dazu legen Sie eine Prozedur namens Application_Startup <\/b>in der Klasse ThisOutlookSession <\/b>an (s. Listing 1). Diese wird gleich beim öffnen von Outlook ausgeführt – vorausgesetzt, Sie haben die Ausführung von Makros nicht aus Sicherheitsgründen deaktiviert.<\/p>\n <\/p>\n Listing 1: Diese Prozedur wird beim Start von Outlook automatisch ausgelöst.<\/span><\/b><\/p>\n Die Prozedur erstellt zunächst eine Referenz auf das Database<\/b>-Objekt der Zieldatenbank zum Exportieren der E-Mails. Wir benötigen zwei besondere Variablen: objFolderArchiv <\/b>hat den Typ clsFolderArchiv<\/b>. Dies ist die Klasse, die wir gleich im Anschluss für jeden zu beobachtenden Mailordner erstellen und die das mit der anderen Variablen objFolder <\/b>referenzierte Folder<\/b>-Objekt entgegennehmen wird.<\/p>\n Um in Access auf die aktuell geöffnete Datenbank zuzugreifen, würden wir die Funktion CurrentDb <\/b>verwenden, aber von Outlook aus ist ein anderer Befehl nötig, nämlich die OpenDatabase<\/b>-Methode des DBEngine<\/b>-Objekts. Dieser übergeben Sie den Namen der gewünschten Datenbankdatei, den wir ja bereits für die Konstante cStrExportdatenbank <\/b>definiert haben.<\/p>\n Im Anschluss öffnet die Prozedur ein Recordset auf Basis der Tabelle tblOptionen<\/b>, die ja die Outlook-Ordner enthält, deren E-Mails archiviert werden sollen. Die Collection colFolders<\/b> müssen wir vor dem Hinzufügen des ersten Objekts instanzieren, was wir mit der New<\/b>-Anweisung erledigen.<\/p>\n Dann durchläuft die Prozedur in einer Do While<\/b>-Schleife alle Datensätze der Tabelle tblOptionen<\/b>. In der Schleife erstellt sie jeweils ein neues Objekt auf Basis der Klasse clsFolderArchiv<\/b>. Diese stellt, wie weiter unten beschrieben, einige Eigenschaften bereit.<\/p>\n Diese füllt die Prozedur mit den folgenden Anweisungen. Zuvor ermittelt sie jedoch noch das Outlook-Folder-Objekt für den Outlook-Ordner aus dem Feld Verzeichnis <\/b>des aktuellen Datensatzes. Dazu verwendet sie die Hilfsfunktion GetFolderByPath<\/b>, die Sie im Modul mdl-Outlook <\/b>finden.<\/p>\n Es kann aus verschiedenen Gründen geschehen, dass der in der Tabelle angegebene Ordner nicht gefunden wird. objFolder <\/b>kann dann natürlich nicht mit einem Verweis auf diesen Ordner gefüllt werden.<\/p>\n Diesem trägt die folgende If…Then<\/b>-Bedingung Rechnung, indem sie prüft, ob objFolder <\/b>gefüllt ist, und gegebenenfalls eine entsprechende Meldung ausgibt. Die Prozedur wird dann abgebrochen.<\/p>\n Anderenfalls übergibt die Prozedur das Objekt aus objFolder <\/b>an die Eigenschaft Folder <\/b>von objFolderArchiv<\/b>. Die Inhalte einiger weiterer Felder trägt die Prozedur ebenfalls für die entsprechenden Eigenschaften des Objekts auf Basis der Klasse clsFolderArchiv <\/b>ein.<\/p>\n So landen etwa die Inhalt der Felder AnlagenSpeichern<\/b>, NeuEinlesen <\/b>und Groesse <\/b>in den gleichnamigen Eigenschaften der Klasse.<\/p>\n Außerdem übergibt die Prozedur auch noch einen Verweis auf das Database<\/b>-Objekt an die Instanz der Klasse, da diese ja beim Eingang einer Mail auf die Datenbank zugreifen und dort einen neuen Datensatz anlegen soll.<\/p>\n Hier könnte man gegebenenfalls nur den Pfad zur Datenbank übergeben und beim Eingang einer Mail eine neue Verbindung aufbauen, um diese nicht ständig geöffnet zu haben.<\/p>\n Nach dem Erstellen des Objekts objFolderArchiv <\/b>für den aktuellen Ordner fügen wir dieses noch zur Collection colFolders <\/b>hinzu, damit es nach dem Beenden der Prozedur nicht im Nirwana verschwindet.<\/p>\n Schließlich kann es noch sein, dass der Benutzer für diesen Outlook-Ordner die Eigenschaft Rekursiv <\/b>auf True <\/b>eingestellt hat. In diesem Fall müssen wir natürlich auch noch die Unterordner des aktuellen Ordners berücksichtigen. Dazu prüft die Prozedur, ob rst!Rekursiv <\/b>den Wert True <\/b>enthält, und ruft dann die rekursiv definierte Prozedur UnterordnerInstanzieren <\/b>auf.<\/p>\n Diese Prozedur legen wir ebenfalls im Modul This-Out-look-Session <\/b>an (s. Listing 2). Die Prozedur erwartet einen Verweis auf den übergeordneten Ordner (objParent) und auf das Database<\/b>-Objekt sowie die für den Hauptordner festgelegten Eigenschaften als Parameter.<\/p>\n Listing 2: Rekursives Hinzufügen untergeordneter Verzeichnisse<\/span><\/b><\/p>\n Auch hier deklarieren wir wieder objFolder <\/b>und objFolder-Archiv<\/b>. Diesmal durchlaufen wir allerdings nicht die Datensätze der Tabelle tblOptionen<\/b>, sondern die Auflistung Folders <\/b>der Unterordner des mit objParent <\/b>übergebenen Folder<\/b>-Objekts.<\/p>\n Innerhalb dieser For Each<\/b>-Schleife erstellt die Prozedur jeweils wieder ein neues Objekt auf Basis der Klasse clsFolderArchiv <\/b>und füllt diese mit den relevanten Daten, bevor sie diese zur Collection colFolders <\/b>hinzufügt. Außerdem ruft sie sich selbst auf, und zwar für jedes in der Schleife durchlaufene Folder<\/b>-Objekt. Auf diese Weise gelangen wir in die hintersten Winkel noch so verschachtelter Ordner-Strukturen.<\/p>\n Damit ist es nun an der Zeit, einen Blick auf die so oft erwähnte Klasse zu werfen. Um diese zu erstellen, legen Sie im Outlook-VBA-Projekt mit Einfügen|Klassenmodul <\/b>ein neues Klassenmodul an, und ändern seinen Namen auf clsFolderArchiv<\/b>.<\/p>\n Die Klasse verwendet eine Reihe von Variablen, die von außen über entsprechende Eigenschaften gefüllt werden sollen. Diese Variablen kennzeichnen wir mit einem führenden m <\/b>plus Unterstrich:<\/p>\n Wie oben erläutert, übergeben wir der Klasse auch jeweils ein Folder<\/b>-Objekt. Dieses speichern wir aber nicht in einer Member-Variablen, sondern entnehmen dieser die Items<\/b>-Auflistung und speichern diese in der wie folgt deklarierten Variablen:<\/p>\n Diese Variable ist auch die, für die wir das Ereignis implementieren, das beim Eingang einer E-Mail ausgelöst wird – daher müssen wir das Schlüsselwort WithEvents <\/b>nutzen.<\/p>\n Schauen wir uns doch erst die Property Let<\/b>– und Property Get<\/b>-Methoden für die übergabe der Eigenschaften an. Diese nehmen jeweils den Eigenschaftswert entgegen und tragen diesen in die jeweilige Member-Variable ein:<\/p>\n Die Property Get<\/b>-Prozedur zum Entgegennehmen des Folder<\/b>-Objekts sieht etwas anders aus. Sie trägt den übergebenen Wert nicht in eine Variable gleichen Typs ein, sondern speichert einen Verweis auf die Items<\/b>-Auflistung des Folder<\/b>-Objekts in der Variablen objItems<\/b>:<\/p>\n Damit gelangen wir gleich zu der Prozedur, die durch das Ereignis ItemAdd <\/b>der Items<\/b>-Auflistung aus objItems <\/b>ausgelöst wird – also beim Eingang einer E-Mail.<\/p>\n Die Ereignisprozedur liefert mit dem Parameter Item<\/b> einen Verweis auf das eingegangene Element. Dieses untersuchen wir, indem wir die TypeName<\/b>-Methode auf das Objekt anwenden und es mit dem Ausdruck MailItem <\/b>vergleichen. Es ist zwar nicht anzunehmen, dass andere Objekttypen als MailItem <\/b>in diesen Ordnern landen, aber wir wollen mögliche Fehler ausschließen und wenden die folgenden Anweisungen nur auf Mail-Item<\/b>-Objekte an. Dazu weisen wir das mit Item <\/b>gelieferte Objekt zunächst der Objektvariablen objMailItem <\/b>zu und rufen damit dann die Prozedur MailEinlesen <\/b>auf, der wir einige Informationen per Parameter übergeben:<\/p>\n Wird dieses Ereignis ausgelöst, erledigt also die Prozedur MailEinlesen <\/b>die Hauptarbeit (s. Listing 3). Die Prozedur erwartet einen Verweis auf das zu archivierende Mail-Item<\/b>-Objekt, den Pfad zum Outlook-Ordner, die Zieldatenbank, die maximale Größe, bis zu der .msg<\/b>-Dateien als Anlage gespeichert werden sollen (alternativ im Dateisystem) und die Angabe, ob die Anlagen zusätzlich im Dateisystem landen sollen.<\/p>\n Listing 3: Archivieren einer E-Mail<\/span><\/b><\/p>\n Die Prozedur speichert zunächst den Inhalt der Eigenschaft SenderEMailAddress<\/b>, also die Absenderadresse, in der Variablen strAbsender<\/b>. Dann durchläuft sie alle Elemente der Auflistung Recipients<\/b>, wobei sie alle Adressen, deren Eigenschaft Type <\/b>den Wert olTo <\/b>(für An<\/b>) enthält, durch Semikola getrennt an die Zeichenkette strEmpfaenger <\/b>anhängt.<\/p>\n Danach stellt sie eine SQL-Abfrage zum Einfügen eines neuen Datensatzes in die Tabelle tblMailItems <\/b>zusammen, die alle vorhandenen Informationen in die entsprechenden Felder schreibt. Hier kann es geschehen, dass ein Fehler auftritt, weil der Inhalt der Mail zu lang ist, um ihn per INSERT INTO <\/b>in das Memo-Feld Body <\/b>einzufügen. Dies löst den Fehler mit der Nummer 3035 <\/b>aus (Nicht genügend Systemressourcen<\/b>). Zum Glück gibt es für diesen Fall eine Alternative, nämlich das Hinzufügen des Datensatzes über die DAO-Methoden AddNew <\/b>und Update<\/b>. Warum wir diese nicht gleich verwenden Weil es in der Regel mit INSERT INTO <\/b>schneller geht.<\/p>\n Wenn der Fehler nicht auftritt, ermittelt eine nachfolgende Anweisung über die Abfrage SELECT @@IDENTITY <\/b>den Wert des Primärschlüsselfeldes des neu hinzugefügten Datensatzes, im Falle des Fehlers liest die Prozedur diesen einfach über den Wert des Feldes MailItemID <\/b>des neu angelegten Recordset<\/b>-Objekts aus.<\/p>\n Wenn der Parameter bolAnlagenSpeichern <\/b>den Wert True <\/b>enthält, ruft die Prozedur eine weitere Routine namens MailAnlagenSpeichern <\/b>auf, welche sich um das Ablegen der Anlage im Dateisystem kümmert. Diese Prozedur entspricht der in den vorherigen Teilen der Beitragsreihe beschriebenen Version.<\/p>\n Außerdem soll auch die komplette E-Mail, sprich die .msg<\/b>-Datei, zwecks möglicher Wiederherstellung gespeichert werden. Dies erledigt die ebenfalls bereits bekannte Prozedur MailItemSpeichern<\/b>.<\/p>\n Der Download zu diesem Beitrag enthält die Module ThisOutlookSession<\/b>, mdlOutlook<\/b>, mdlTools <\/b>und clsFolder-Archiv<\/b>. Diese müssen Sie zum Outlook-VBA-Projekt hinzufügen – am einfachsten, indem Sie die entsprechenden Dateien einfach aus dem Windows Explorer in den Projekt-Manager ziehen.<\/p>\n Außerdem benötigen Sie noch die beiden Verweise, die Sie wie eingangs beschrieben anlegen.<\/p>\n Wichtig ist auch, dass Sie die Konstante für den Namen der Zieldatenbank im Modul ThisOutlookSession <\/b>an den von Ihnen gewählten Speicherort anpassen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n OutlookMailsNachEmpfangArchivieren.zip<\/p>\n\n
Outlook vorbereiten<\/h2>\n
![\"Verweise](\"..\/fileadmin\/_temp_\/2015_05\/pic_1007_002.png\")
<\/p>\nConst cStrExportdatenbank As String<\/span> = \"C:\\Outlook\\Outlook_III.accdb\"<\/pre>\nDim <\/span>colFolders As <\/span>Collection<\/pre>\nNeue Mails abfangen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2015_05\/pic_1007_003.png\")
<\/p>\n![\"Auswählen](\"..\/fileadmin\/_temp_\/2015_05\/pic_1007_004.png\")
<\/p>\nMaileingang erkennen<\/h2>\n
Ordner-Klassen instanzieren<\/h2>\n
Public Sub <\/span>Application_Startup()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Dim <\/span>objFolderArchiv As <\/span>clsFolderArchiv\r\n Set<\/span> db = DBEngine.OpenDatabase(cStrExportdatenbank)\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n Set<\/span> colFolders = New<\/span> Collection\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> objFolderArchiv = New<\/span> clsFolderArchiv\r\n With<\/span> objFolderArchiv\r\n Set<\/span> objFolder = GetFolderByPath(rst!Verzeichnis)\r\n If <\/span>objFolder Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Der in der Export-Datenbank ''\" & cStrExportdatenbank & \"'' angegebene Outlook-Ordner ''\" _\r\n & rst!Verzeichnis & \"'' ist nicht in Outlook vorhanden.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> .Folder = objFolder\r\n .AnlagenSpeichern = rst!AnlagenSpeichern\r\n Set<\/span> .Database = db\r\n .NeuEinlesen = rst!NeuEinlesen\r\n .Groesse = Nz(rst!Groesse)\r\n End With<\/span>\r\n colFolders.Add objFolderArchiv\r\n If <\/span>rst!Rekursiv Then<\/span>\r\n UnterordnerInstanzieren objFolder, db, Nz(rst!Groesse), rst!NeuEinlesen, rst!AnlagenSpeichern, colFolders\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>UnterordnerInstanzieren(objParent As <\/span>Outlook.Folder, db As <\/span>DAO.Database, lngSize As Long<\/span>, _\r\n bolNeuEinlesen As Boolean<\/span>, bolAnlagenSpeichern As Boolean<\/span>, colFolders As <\/span>Collection)\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Dim <\/span>objFolderArchiv As <\/span>clsFolderArchiv\r\n For Each objFolder In objParent.Folders\r\n Set<\/span> objFolderArchiv = New<\/span> clsFolderArchiv\r\n With<\/span> objFolderArchiv\r\n .AnlagenSpeichern = bolAnlagenSpeichern\r\n Set<\/span> .Database = db\r\n Set<\/span> .Folder = objFolder\r\n .Groesse = lngSize\r\n .NeuEinlesen = bolNeuEinlesen\r\n End With<\/span>\r\n colFolders.Add objFolderArchiv\r\n UnterordnerInstanzieren objFolder, db, lngSize, bolNeuEinlesen, bolAnlagenSpeichern, colFolders\r\n Next<\/span> objFolder\r\nEnd Sub<\/span><\/pre>\nDie Klasse clsFolderArchiv<\/h2>\n
Private <\/span>m_db As <\/span>DAO.Database\r\nPrivate <\/span>m_Groesse As Long<\/span>\r\nPrivate <\/span>m_NeuEinlesen As Boolean<\/span>\r\nPrivate <\/span>m_Verzeichnis As String<\/span>\r\nPrivate <\/span>m_AnlagenSpeichern As Boolean<\/span><\/pre>\nPrivate <\/span>WithEvents objItems As <\/span>Outlook.Items<\/pre>\nPublic Property Set<\/span> <\/span>Database(db As <\/span>DAO.Database)\r\n Set<\/span> m_db = db\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Groesse(lngGroesse As Long<\/span>)\r\n m_Groesse = lngGroesse\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>NeuEinlesen(bolNeuEinlesen As Boolean<\/span>)\r\n m_NeuEinlesen = bolNeuEinlesen\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>AnlagenSpeichern(m_AnlagenSpeichern _\r\n As Boolean<\/span>)\r\n m_AnlagenSpeichern = m_AnlagenSpeichern\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Folder(objFolder As <\/span>Outlook.Folder)\r\n Set<\/span> objItems = objFolder.Items\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>objItems_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n If <\/span>TypeName(Item) = \"MailItem\" Then<\/span>\r\n Set<\/span> objMailItem = Item\r\n MailEinlesen objMailItem, m_Verzeichnis, m_db, _\r\n m_Groesse, m_NeuEinlesen, m_AnlagenSpeichern\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nEinlesen einer E-Mail<\/h2>\n
Public Sub <\/span>MailEinlesen(objMailItem As <\/span>Outlook.MailItem, strFolderpath As String<\/span>, db As <\/span>DAO.Database, _\r\n lngSize As Long<\/span>, bolAnlagenSpeichern As Boolean<\/span>)\r\n Dim <\/span>strAbsender As String<\/span>, strEmpfaenger As String<\/span>, strSQL As String<\/span>\r\n Dim <\/span>objRecipient As <\/span>Outlook.Recipient\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngError As Long<\/span>, lngMailItemID As Long<\/span>\r\n With<\/span> objMailItem\r\n strAbsender = .SenderEmailAddress\r\n For i = 1 To .Recipients.Count\r\n Set<\/span> objRecipient = .Recipients(i)\r\n Select Case objRecipient.Type\r\n Case <\/span>olTo\r\n strEmpfaenger = strEmpfaenger & \";\" & objRecipient.Address\r\n Case Else<\/span>\r\n End Select<\/span>\r\n Next<\/span> i\r\n strSQL = \"INSERT INTO tblMailItems(EntryID, Betreff, Body, HTMLBody, Absender, " _\r\n & "Empfaenger, Pfad, Erhalten, Groesse) VALUES(''\" & .EntryID & \"'', ''\" _\r\n & Replace<\/span>(.Subject, \"''\", \"''''\") & \"'', ''\" & Replace<\/span>( .Body, \"''\", \"''''\") _\r\n & \"'', ''\" & Replace<\/span>(.HTMLBody, \"''\", \"''''\") & \"'', ''\" & Replace<\/span>(strAbsender, \"''\", \"''''\") _\r\n & \"'', ''\" & Replace<\/span>(strEmpfaenger, \"''\", \"''''\") & \"'', ''\" & strFolderpath & \"'', \" _\r\n & ISODatum( .ReceivedTime) & \", \" & .Size & \")\"\r\n On Error Resume Next<\/span>\r\n db.Execute strSQL, dbFailOnError\r\n lngError = Err.Number\r\n On Error GoTo<\/span> 0\r\n If <\/span>lngError = 3035 Then<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblMailItems WHERE 1 = 2\", dbOpenDynaset)\r\n rst.AddNew<\/span>\r\n rst!EntryID = .EntryID\r\n rst!Betreff = .Subject\r\n rst!Body = .Body\r\n rst!HTMLBody = .HTMLBody\r\n rst!Absender = strAbsender\r\n rst!Empfaenger = strEmpfaenger\r\n rst!Pfad = strFolderpath\r\n rst!Erhalten = .ReceivedTime\r\n rst!Groesse = .Size\r\n lngMailItemID = rst!MailitemID\r\n rst.Update\r\n Else<\/span>\r\n lngMailItemID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n End If<\/span>\r\n If <\/span>bolAnlagenSpeichern Then<\/span>\r\n MailAnlagenSpeichern objMailItem, db, strAbsender, lngMailItemID\r\n End If<\/span>\r\n MailItemSpeichern objMailItem, db, lngMailItemID, lngSize\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nIntegration in Outlook<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n