<\/p>\n
„Eine neue .pst-Datei ist wie ein neues Leben …“ – so fühlt es sich an, wenn man sich von einer Outlook-Installation voller Termine, Mails, Kontakte et cetera trennt und einfach einmal neu beginnt. Allerdings wird man einen Teil der Daten ohnehin übernehmen (die Kontakte), und zumindest die Mails sollte man sicherheitshalber noch eine Weile aufbewahren. Nur wo Wenn Sie die Inhalte von Mails archivieren und für den gelegentlichen Zugriff bereithalten wollen, bietet sich natürlich der Einsatz einer Access-Datenbank an. Dieser Beitrag beleuchtet, wie Sie die Mails archivieren, ein weiterer beschäftigt sich mit der Suche nach und der Wiederherstellung von archivierten E-Mails.<\/b><\/p>\n
Bevor man seine Outlook.pst <\/b>in die ewigen Jagdgründe verabschiedet oder die enthaltenen E-Mails löscht, sollte man die Inhalte gegebenenfalls sichern. Was bietet sich da mehr an als eine Access-Datenbank – plus gegebenenfalls eines Ordners, in dem Sie alle Anlagen der E-Mails speichern<\/p>\n
Für den Access-Entwickler ist das eine gute Idee, denn damit kann er, ein entsprechendes Datenmodell vo-rausgesetzt, später auch die E-Mails bestimmter Kunden herausfiltern und etwa mit der Kundendatenbank verknüpfen. Voraussetzung hierfür ist allein, dass die Absender und die Empfänger in der Tabelle mit den E-Mail-Daten gespeichert werden.<\/p>\n
Neben den Metadaten einer E-Mail wie Absender, Empfänger, Empfangsdatum, Betreff oder Inhalt wollen wir die Anlagen speichern. Außerdem soll vorsichtshalber auch die komplette Mail im Format .msg <\/b>in einem Attachment<\/b>-Feld des Datensatzes mit der E-Mail gespeichert werden. Dies stellt sicher, dass wir die E-Mail mit wenigen Zeilen Code erstens öffnen und zweitens in Outlook wiederherstellen können.<\/p>\nPlatzproblemen vorbeugen<\/h2>\n
Wenn Sie neben den E-Mail-Metadaten auch noch die E-Mail selbst im .msg<\/b>-Format in der Datenbank speichern wollen, ist diese vermutlich schnell genauso groß wie die .pst<\/b>-Datei. Meine ist aktuell rund drei Gigabyte groß – so viel passt leider nicht in eine Access-Datenbank. Also bauen wir eine Option ein, die es erlaubt, eine Größenbegrenzung für die in der Datenbank zu speichernden Mails anzugeben. Dann werden alle Mails, deren Größe diesen Wert nicht übersteigt, in der Datenbank gespeichert, die übrigen landen in Dateiform in einem Verzeichnis, das sich im gleichen Ordner wie die Datenbank selbst befindet.<\/p>\nAnlagen speichern<\/h2>\n
Gegebenenfalls möchten Sie auch die Anlagen schnell zugreifbar machen. In diesem Fall speichern Sie auch diese in einem separaten Verzeichnis und tragen nur den Pfad zur jeweiligen Datei in eine weitere Tabelle der Datenbank ein.<\/p>\n
Damit steht das Datenmodell auch schon fest: Wir benötigen zunächst eine Tabelle namens tblMailItems<\/b>, welche die Metadaten der eingelesenen E-Mails und gegebenenfalls die .msg<\/b>-Dateien in einem Anlagefeld speichert.<\/p>\n
Die zweite Tabelle heißt tblAnlagen<\/b>. Da jede E-Mail keine, eine oder mehrere Anlagen enthalten kann, können wir deren Speicherort nicht einfach in einem Feld der Tabelle tblMailItems <\/b>speichern, sondern müssen dafür eine per 1:n-Beziehung verknüpfte Tabelle anlegen. Diese soll tblAnlagen <\/b>heißen und ist über das Fremdschlüsselfeld MailItemID <\/b>mit der Tabelle tblMailItems <\/b>verknüpft.<\/p>\n
Schließlich benötigen wir noch eine dritte Tabelle namens tblOptionen<\/b>, mit der wir die Einstellungen für den Import sichern.<\/p>\n
Die Tabelle tblMailItems<\/b> sieht im Entwurf wie in Bild 1 aus. Die Tabelle nimmt die wesentlichen Informationen der jeweiligen E-Mail auf. Da wir die E-Mail ja entweder in der Tabelle oder aber im Dateisystem noch als .msg<\/b>-Datei speichern, die wir jederzeit wiederherstellen oder öffnen können, brauchen wir in der Tabelle nur die Daten zu speichern, nach denen wir die E-Mails durchsuchen wollen.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_003.png\")
<\/p>\n
Bild 1: Die Tabelle tblMailItems in der Entwurfsansicht<\/span><\/b><\/p>\n Die zweite Tabelle namens tblAnlagen <\/b>speichert zu jeder E-Mail die Speicherorte für die Anlagen. Die Datensätze werden dabei über das Feld MailItemID <\/b>mit der Tabelle tblMailItems <\/b>verknüpft (s. Bild 2).<\/p>\n Bild 2: Die Tabelle tblAnlagen in der Entwurfsansicht<\/span><\/b><\/p>\n Fehlt noch die Tabelle tblOptionen<\/b>. Diese sieht wie in Bild 3 aus. Die Bedeutung der einzelnen Felder wird gleich im Anschluss bei der Erläuterung des Einlesevorgangs deutlich werden.<\/p>\n Bild 3: Die Tabelle tblOptionen in der Entwurfsansicht<\/span><\/b><\/p>\n Das Formular frmMailimport <\/b>steuert den Einlesevorgang. Das heißt, dass Sie damit die Optionen einstellen und den Vorgang starten können.<\/p>\n Das Formular sieht im Entwurf wie in Bild 4 aus.<\/p>\n Bild 4: Das Formular frmMailImport in der Entwurfsansicht<\/span><\/b><\/p>\n Das Formular ist an die Tabelle tblOptionen <\/b>gebunden. Das Textfeld txtVerzeichnis<\/b> liefert den Wert des Feldes Verzeichnis. Diesen Wert können Sie manuell einstellen oder aber Sie verwenden die Schaltfläche mit den drei Punkten, um den dafür vorgesehenen Outlook-Dialog zu öffnen und den Mail-Ordner auszuwählen, dessen E-Mails eingelesen werden sollen.<\/p>\n Die Schaltfläche heißt cmdVerzeichnisWaehlen <\/b>und ruft die folgende Prozedur auf:<\/p>\n Dies zeigt den Dialog aus Bild 5 an. Damit wählt der Benutzer den Mail-Ordner aus, der als Basis für den Einlesevorgang dient. Den Pfad zu diesem Ordner ermittelt die Prozedur mit der Eigenschaft FolderPath <\/b>des Folder<\/b>-Objekts.<\/p>\n Bild 5: Dialog zum Auswählen des einzulesenden Mail-Ordners<\/span><\/b><\/p>\n Für das Formular haben wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf den Wert Nein <\/b>eingestellt.<\/p>\n Außerdem legen Sie für die Eigenschaft Zyklus <\/b>den Wert Aktueller Datensatz <\/b>fest. Der Benutzer kann dann nur den ersten Datensatz der Tabelle tblOptionen <\/b>bearbeiten und nicht zu einem neuen Datensatz wechseln – mehr benötigt er ja auch nicht.<\/p>\n Damit erscheint das ausgewählte Outlook-Mail-Verzeichnis nun wie in Bild 6.<\/p>\n Bild 6: Das Formular frmMailImport in der Formularansicht<\/span><\/b><\/p>\n Die übrigen Einstellungen der Tabelle tblOptionen <\/b>bildet das Formular wie in der Abbildung ab – also mit lauter Kontrollkästchen sowie einem Textfeld namens txtGroesse <\/b>für die Eingabe der maximalen Größe, mit der eine E-Mail direkt in der Tabelle gespeichert werden soll.<\/p>\n Ein Klick auf die Schaltfläche cmdImportStarten <\/b>initialisiert den Einlesevorgang. Dies löst die folgende Prozedur aus:<\/p>\n Die Prozedur blendet zunächst einen Text in der Statusleiste von Access ein, der darauf hinweist, dass die Anwendung nun die Anzahl der einzulesenden E-Mails liest. Diesen Wert benötigen wir, um in der Statusleiste den Fortschritt abbilden zu können.<\/p>\n Dann startet die Prozedur den Zählvorgang durch den Aufruf der Funktion MailsZaehlen<\/b>, der sie lediglich den Verweis auf den Outlook-Pfad sowie den Inhalt des Kon-trollkästchens chkRekursiv <\/b>übergibt.<\/p>\n Die Prozedur MailsZaehlen <\/b>ermittelt zunächst mit der Funktion GetFolderByPath <\/b>das Folder<\/b>-Objekt von Outlook für den übergebenen Pfad, also beispielsweise \\\\Outlook\\Posteingang<\/b>. GetFolderByPath <\/b>ist eine benutzerdefinierte Funktion, die das Folder<\/b>-Objekt für den angegebenen Pfad zurückliefert (s. Modul mdlImport<\/b>).<\/p>\n Die Count<\/b>-Eigenschaft der Items<\/b>-Auflistung dieses Folder<\/b>-Objekts liefert die Anzahl der enthaltenen Elemente. Gegebenenfalls befinden sich dort auch Elemente mit einem anderen Typ als MailItem<\/b>, aber dies sollte die Ausnahme sein und wir zählen diese einfach mit – sonst müssten wir hier noch eine weitere Prüfung einbauen, die Performance kostet.<\/p>\n Sollte der Benutzer im Formular frmMailimport <\/b>die Option chkRekursiv <\/b>gesetzt haben, ruft die Funktion eine weitere Funktion namens MailsZaehlenRek <\/b>auf und übergibt dieser das Folder<\/b>-Objekt sowie den Long<\/b>-Wert lngAnzahl <\/b>als Parameter. Letzterer ist bereits mit der aktuellen Anzahl gefüllt und soll um die Anzahl der Mails in den untergeordneten Verzeichnissen erhöht werden:<\/p>\n Die Funktion MailsZaehlenRek <\/b>ist eine rekursiv definierte Funktion, die sich selbst aufruft. Dies geschieht so lange, bis keine untergeordneten Verzeichnisse mehr gefunden werden. Die Variable lngAnzahl <\/b>wird durch alle Aufrufe geschleppt und jeweils um die Anzahl der E-Mails des aktuell in der For Each<\/b>-Schleife durchlaufenen Folder<\/b>-Objekts erhöht:<\/p>\n Auf diese Weise ermittelt die Funktion MailsZaehlen <\/b>die Gesamtzahl der E-Mails und liefert diese als Funktionswert an die aufrufende Prozedur cmdImportStarten <\/b>zurück.<\/p>\n Die Prozedur ruft dann die Routine Import <\/b>auf und übergibt dieser die Werte aller gebundenen Felder des Formulars frmMailimport<\/b> (s. Listing 1).<\/p>\n <\/p>\n Listing 1: Die Prozedur Import<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst das Folder<\/b>-Objekt für das Startverzeichnis in Outlook – dies wiederum mit der Funktion GetFolderByPath<\/b> -, und speichert es in der Variablen objFolder<\/b>. Sollte objFolder <\/b>den Wert Nothing <\/b>enthalten, wurde das Verzeichnis nicht gefunden und die Prozedur beendet.<\/p>\n Anderenfalls füllt die Prozedur die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Danach prüft die Prozedur, ob vorhandene E-Mails gelöscht werden sollen. Ist dies der Fall, erscheint zunächst eine neue Statusmeldung unten links im Access-Fenster, dann ruft die Prozedur die DELETE<\/b>-Anweisung zum Löschen des Inhalts der Tabelle tblMailItems <\/b>auf. Wenn Sie gerade testweise ein paar hundert Megabyte E-Mails eingelesen haben und diese wieder löschen wollen, kann dies übrigens ein paar Augenblicke dauern.<\/p>\n Danach leert die Prozedur das Verzeichnis, in das gegebenenfalls die Anlagen der E-Mails gespeichert wurden. Dies erledigt die Prozedur VerzeichnisLoeschen<\/b>, die als Parameter den Namen des Verzeichnisses der aktuellen Datenbank mit dem Unterverzeichnis Anlagen <\/b>erhält.<\/p>\n Diese Prozedur verwendet das FileSystemObject<\/b>, um zunächst das Verzeichnis zu ermitteln und mit einem Objekt des Typs Folder <\/b>zu referenzieren. Dann löscht es dieses Objekt:<\/p>\n Da wir nur dieses eine Mal auf die Bibliothek zugreifen, erstellen wir nicht extra einen Verweis, sondern verwenden Late Binding, um auf die enthaltenen Objekte und Methoden zuzugreifen.<\/p>\n Anschließend setzt die Prozedur Import <\/b>das Einlesen der E-Mails fort. Sie ermittelt die Anzahl der E-Mails des aktuellen Verzeichnisses und trägt diese in die Variable lngAnzahlEingelesen <\/b>ein. Diese wird uns noch länger begleiten und jeweils um die Anzahl der eingelesenen E-Mails auch der Unterformulare ergänzt.<\/p>\n Damit folgt der Aufruf der Prozedur MailsEinlesen<\/b>, welche die E-Mails des Ordners einliest – mehr dazu weiter unten. Das Ergebnis ist, dass die E-Mails des mit dem Objekt objFolder <\/b>übergebenen Outlook-Verzeichnisses eingelesen wurden.<\/p>\n Anschließend aktualisiert die Prozedur die Statusanzeige, damit der Benutzer erfährt, wie viele E-Mails mittlerweile eingelesen wurden.<\/p>\n Dann kümmert sich die Prozedur um die Unterformulare – aber nur, wenn der Benutzer den Wert des Kontrollkästchens chkRekursiv <\/b>auf True <\/b>eingestellt hat. Ist dies der Fall, hat auch bolRekursiv <\/b>den Wert True <\/b>und die folgende Anweisung wird ausgeführt. Dies erledigt die Prozedur UnterordnerEinlesen<\/b>, welche wiederum den Verweis auf den aktuellen Ordner und einige weitere Informationen per Parameter erhält.<\/p>\n Auch diese Prozedur sehen wir uns weiter unten an.<\/p>\n Zu guter Letzt leert die Prozedur die Statusanzeige von Access.<\/p>\n Das Einlesen erfolgt in zwei Schritten: Die erste Prozedur namens MailsEinlesen <\/b>durchläuft alle E-Mails eines Ordners, die zweite namens MailEinlesen <\/b>liest dann tatsächlich die Daten einer jeden E-Mail in die Datenbank beziehungsweise das Dateisystem ein (s. Listing 2).<\/p>\n Listing 2: Die Prozedur MailsEinlesen<\/span><\/b><\/p>\n Die Prozedur MailsEinlesen <\/b>erwartet als Parameter unter anderem den Outlook-Ordner, dessen E-Mails eingelesen werden sollen.<\/p>\n Außerdem landen dort ein Verweis auf das aktuelle Database<\/b>-Objekt sowie auf die maximale Größe der E-Mails (lngSize<\/b>), der Parameter bolNeuEinlesen<\/b>, der darauf hinweist, ob auch bereits eingelesene E-Mails erneut eingelesen werden sollen, und der Parameter bolAnlagenSpeichern<\/b>, der festlegt, ob die Anlagen nochmals separat gespeichert werden sollen, auch wenn diese ja bereits in den .msg<\/b>-Dateien in der Tabelle oder im Dateisystem gespeichert sind.<\/p>\n Die Prozedur durchläuft alle Elemente der Items<\/b>-Auflistung des übergebenen Folder<\/b>-Objekts und ruft für alle Elemente, deren Typ dem Wert MailItem <\/b>entspricht, die Prozedur MailEinlesen <\/b>auf. Diese erwartet prinzipiell die gleichen Parameter wie die Prozedur MailsEinlesen<\/b>.<\/p>\n Die Prozedur MailEinlesen <\/b>liest genau die mit dem Parametern objMailItem <\/b>übergebene E-Mail in die Datenbank ein – vorausgesetzt, diese wurde zuvor noch nicht eingelesen beziehungsweise es sollen ohnehin alle E-Mails nochmals eingelesen werden.<\/p>\n Der erste Teil der Prozedur (s. Listing 3) prüft zunächst, ob die Eigenschaft BillingInformation <\/b>des MailItem<\/b>-Objekts den Wert Saved <\/b>enthält. Dies ist immer der Fall, wenn die Mail noch nicht eingelesen wurde.<\/p>\n Listing 3: Die Prozedur MailEinlesen, Teil I<\/span><\/b><\/p>\n Wenn die Prozedur die Mail eingelesen hat, stellt sie diese Eigenschaft auf den Wert Saved <\/b>ein. Wurde die Mail bereits gespeichert, kann es immer noch sein, dass der Benutzer das Kontrollkästchen chkNeuEinlesen <\/b>aktiviert hat – in diesem Fall liest die Prozedur die Mail in jedem Fall neu ein.<\/p>\n Soll die E-Mail neu eingelesen werden, prüft die Prozedur noch, ob die Tabelle tblMailItems <\/b>bereits einen Eintrag mit der EntryID <\/b>der neu einzufügenden E-Mail enthält. Die EntryID <\/b>ist die eindeutige Eigenschaft einer E-Mail unter Outlook. Dazu speichert die Prozedur den Primärschlüsselwert eines eventuell gefundenen Eintrags in der Variablen lngMailItemID<\/b>. Ist lngMailItemID <\/b>danach nicht 0<\/b>, löscht die Prozedur den entsprechenden Datensatz per DELETE<\/b>-Aktionsabfrage aus der Tabelle tblMailItems<\/b>.<\/p>\n Außerdem löscht sie eventuell bereits für diese E-Mail angelegte .msg<\/b>-Dateien aus dem Verzeichnis MSG<\/b>. Danach liest sie den Absender aus der Eigenschaft SenderEmailAddress <\/b>in die Variable strAbsender <\/b>ein und durchläuft alle Empfänger über die Auflistung Recipients. Die Empfänger landen durch Semikola getrennt in der Variablen strEmpfaenger<\/b>. Das führende Semikolon wird anschließend entfernt.<\/p>\n Schließlich stellt die Prozedur in der Variablen strSQL <\/b>die SQL-Anweisung zusammen, die den neuen Datensatz mit den Daten der E-Mail in der Tabelle tblMailItems <\/b>speichern soll. Dort ersetzt die Prozedur in einigen String<\/b>-Elementen mit der Replace<\/b>-Funktion einfache Hochkommata durch doppelte Hochkommata, damit diese keinen Fehler auslösen. Der Inhalt der Eigenschaft ReceivedTime <\/b>wird mit der Funktion ISODatum <\/b>so formatiert, dass er SQL-kompatibel ist. Die Prozedur führt dann die SQL-Anweisung aus, stellt aber sicher, dass ein eventueller Fehler behandelt wird.<\/p>\n Die Prüfung auf einen bestimmten Fehler erfolgt dann in der Fortsetzung der Prozedur in Listing 4. Der Fehler 3035 <\/b>(Nicht genügend Systemressourcen<\/b>) trat auf einem Testsystem mit Windows 7 und Access 2010 auf – die Ursache ist möglicherweise, dass ein zu großer Inhalt in eines der Memofelder eingefügt wurde.<\/p>\n Listing 4: Die Prozedur MailEinlesen, Teil II<\/span><\/b><\/p>\n Tatsache ist, dass wir die Daten in diesem Fall dennoch durch Einfügen per DAO (AddNew<\/b>…Update<\/b>) in der Tabelle speichern konnten.<\/p>\n Dies geschieht dann in den folgenden Anweisungen, die nur im Falle des Auftretens von Fehler 3035 ausgeführt werden. Sie legen einen neuen Datensatz mit AddNew <\/b>im Recordset an, tragen die Werte aus den Eigenschaften der E-Mail ein und speichern den Datensatz mit der Update<\/b>-Methode. In beiden Fällen speichert die Prozedur den Wert des Primärschlüsselfeldes des neuen Datensatzes in der Variablen lngMailItemID<\/b>.<\/p>\n Wenn der Benutzer die Option chkAnlagenSpeichern <\/b>im Formular frmMailimport <\/b>aktiviert hat, ruft die Prozedur nun noch die Routine AnlagenSpeichern <\/b>für diese E-Mail auf. Anschließend folgt noch ein Aufruf der Routine MailItem <\/b>speichern, der sich um das Speichern der .msg<\/b>-Datei entweder in der Datenbank oder im Dateisystem kümmert.<\/p>\n Die Prozedur AnlagenSpeichern <\/b>aus Listing 5 sichert, wenn der Benutzer dies aktiviert hat, die Anlagen einer E-Mail noch separat im Dateisystem. Die Prozedur prüft zunächst anhand der Eigenschaft Count <\/b>der Attachments<\/b>-Auflistung des MailItem<\/b>-Objekts, ob die Mail überhaupt Anlagen enthält.<\/p>\n Listing 5: Die Prozedur AnlagenSpeichern<\/span><\/b><\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_004.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_005.png\")
<\/p>\nFormular zur Steuerung des Einlesevorgangs<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_002.png\")
<\/p>\nPrivate Sub <\/span>cmdVerzeichnisWaehlen_Click()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objMAPI = objOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = objMAPI.PickFolder\r\n If <\/span>Not<\/span> objFolder Is Nothing Then<\/span>\r\n Me!txtVerzeichnis = objFolder.FolderPath\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2015_03\/pic_985_007.png\")
<\/p>\nEinlesevorgang starten<\/h2>\n
Private Sub <\/span>cmdImportStarten_Click()\r\n Dim <\/span>lngAnzahl As Long<\/span>\r\n SysCmd acSysCmdSetStatus, _\r\n \"Einzulesende Mails werden gezählt\"\r\n lngAnzahl = MailsZaehlen(Me!txtVerzeichnis, _\r\n Me!chkRekursiv)\r\n Import Me!txtVerzeichnis, lngAnzahl, _\r\n Me!txtGroesse, Me!chkNeuEinlesen, _\r\n Me!chkRekursiv, Me!chkVorhandeneLoeschen, _\r\n Me!chkAnlagenSpeichern\r\nEnd Sub<\/span><\/pre>\nEinzulesende Mails zählen<\/h2>\n
Private Function <\/span>MailsZaehlen(strVerzeichnis As String<\/span>, _\r\n bolRekursiv As Boolean<\/span>) As Long<\/span>\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Dim <\/span>lngAnzahl As Long<\/span>\r\n Set<\/span> objFolder = GetFolderByPath(strVerzeichnis)\r\n lngAnzahl = objFolder.Items.Count\r\n If <\/span>bolRekursiv Then<\/span>\r\n MailsZaehlenRek objFolder, lngAnzahl\r\n End If<\/span>\r\n MailsZaehlen = lngAnzahl\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>MailsZaehlenRek(objParent As <\/span>_\r\n Outlook.Folder, lngAnzahl As Long<\/span>)\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n For Each objFolder In objParent.Folders\r\n lngAnzahl = lngAnzahl + objFolder.Items.Count\r\n MailsZaehlenRek objFolder, lngAnzahl\r\n Next<\/span> objFolder\r\nEnd Function<\/span><\/pre>\nDie Import-Routine<\/h2>\n
Public Sub <\/span>Import(strVerzeichnis As String<\/span>, lngAnzahl As Long<\/span>, lngSize As Long<\/span>, bolNeuEinlesen As Boolean<\/span>, _\r\n bolRekursiv As Boolean<\/span>, bolVorhandeneLoeschen As Boolean<\/span>, bolAnlagenSpeichern As Boolean<\/span>)\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngAnzahlEingelesen As Long<\/span>\r\n Set<\/span> objFolder = GetFolderByPath(strVerzeichnis)\r\n If <\/span>Not<\/span> objFolder Is Nothing Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n If <\/span>bolVorhandeneLoeschen Then<\/span>\r\n SysCmd acSysCmdSetStatus, \"Vorhandene Daten werden gelöscht\"\r\n db.Execute \"DELETE FROM tblMailItems\", dbFailOnError\r\n SysCmd acSysCmdSetStatus, \"Anlagenverzeichnis wird gelöscht\"\r\n VerzeichnisLoeschen CurrentProject.Path & \"\\Anlagen\"\r\n End If<\/span>\r\n lngAnzahlEingelesen = objFolder.Items.Count\r\n MailsEinlesen objFolder, db, lngSize, bolNeuEinlesen, bolAnlagenSpeichern\r\n SysCmd acSysCmdSetStatus, lngAnzahlEingelesen & \"\/\" & lngAnzahl\r\n If <\/span>bolRekursiv Then<\/span>\r\n UnterordnerEinlesen objFolder, db, lngAnzahl, lngAnzahlEingelesen, lngSize, bolNeuEinlesen, _\r\n bolAnlagenSpeichern\r\n End If<\/span>\r\n SysCmd acSysCmdClearStatus\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>VerzeichnisLoeschen(strVerzeichnis As String<\/span>)\r\n Dim <\/span>objFSO As Object<\/span>\r\n Dim <\/span>objFolder As Object<\/span>\r\n Set<\/span> objFSO = CreateObject( _\r\n \"Scripting.FileSystemObject\")\r\n On Error Resume Next<\/span>\r\n Set<\/span> objFolder = objFSO.GetFolder(strVerzeichnis)\r\n objFolder.Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> objFolder = Nothing\r\n Set<\/span> objFSO = Nothing\r\nEnd Sub<\/span><\/pre>\nMails einlesen<\/h2>\n
Public Sub <\/span>MailsEinlesen(objFolder As <\/span>Outlook.Folder, db As <\/span>DAO.Database, lngSize As Long<\/span>, bolNeuEinlesen As Boolean<\/span>, _\r\n bolAnlagenSpeichern As Boolean<\/span>)\r\n Dim <\/span>objItem As Object<\/span>\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n For Each objItem In objFolder.Items\r\n If <\/span>TypeName(objItem) = \"MailItem\" Then<\/span>\r\n MailEinlesen objItem, objFolder.FolderPath, db, lngSize, bolNeuEinlesen, bolAnlagenSpeichern\r\n End If<\/span>\r\n Next<\/span> objItem\r\nEnd Sub<\/span><\/pre>\nEine E-Mail einlesen<\/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>, bolNeuEinlesen As Boolean<\/span>, bolAnlagenSpeichern As Boolean<\/span>)\r\n Dim <\/span>strAbsender As String<\/span>\r\n Dim <\/span>strEmpfaenger As String<\/span>\r\n Dim <\/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>\r\n Dim <\/span>lngMailItemID As Long<\/span>\r\n With<\/span> objMailItem\r\n If <\/span>Not<\/span> .BillingInformation = \"saved\" Or bolNeuEinlesen = True<\/span> Then<\/span>\r\n lngMailItemID = Nz(DLookup(\"MailItemID\", \"tblMailItems\", \"EntryID = ''\" & .EntryID & \"''\"), 0)\r\n If <\/span>Not<\/span> lngMailItemID = 0 Then<\/span>\r\n db.Execute \"DELETE FROM tblMailItems WHERE EntryID = ''\" & .EntryID & \"''\", dbFailOnError\r\n On Error Resume Next<\/span>\r\n Kill CurrentProject.Path & \"\\MSG\\\" & lngMailItemID & \".msg\"\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\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 strEmpfaenger = Mid<\/span>(strEmpfaenger, 2)\r\n strSQL = \"INSERT INTO tblMailItems(EntryID, Betreff, Body, HTMLBody, Absender, Empfaenger, Pfad, \" _\r\n & \"Erhalten, Groesse) VALUES(''\" & .EntryID & \"'', ''\" & Replace<\/span>(.Subject, \"''\", \"''''\") & \"'', ''\" _\r\n & Replace<\/span>(.Body, \"''\", \"''''\") & \"'', ''\" & Replace<\/span>(.HTMLBody, \"''\", \"''''\") & \"'', ''\" _\r\n & Replace<\/span>(strAbsender, \"''\", \"''''\") & \"'', ''\" & Replace<\/span>(strEmpfaenger, \"''\", \"''''\") & \"'', ''\" _\r\n & strFolderpath & \"'', \" & 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<\/pre>\n ...\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 AnlagenSpeichern objMailItem, db, strAbsender, lngMailItemID\r\n End If<\/span>\r\n MailItemSpeichern objMailItem, db, lngMailItemID, lngSize\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nSpeichern der Anlagen<\/h2>\n
Public Sub <\/span>AnlagenSpeichern(objMailItem As <\/span>Outlook.MailItem, db As <\/span>DAO.Database, strAbsender As String<\/span>, _\r\n lngMailItemID As Long<\/span>)\r\n Dim <\/span>objAnlage As <\/span>Outlook.Attachment\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>strDateiname As String<\/span>\r\n If <\/span>objMailItem.Attachments.Count > 0 Then<\/span>\r\n strPfad = CurrentProject.Path & \"\\Anlagen\\\" & strAbsender & \"\\\" & lngMailItemID\r\n On Error Resume Next<\/span>\r\n MkDir CurrentProject.Path & \"\\Anlagen\\\"\r\n MkDir CurrentProject.Path & \"\\Anlagen\\\" & strAbsender\r\n MkDir CurrentProject.Path & \"\\Anlagen\\\" & strAbsender & \"\\\" & lngMailItemID\r\n MkDir strPfad\r\n On Error GoTo<\/span> 0\r\n For Each objAnlage In objMailItem.Attachments\r\n strDateiname = objAnlage.FileName\r\n objAnlage.SaveAsFile strPfad & \"\\\" & strDateiname\r\n db.Execute \"INSERT INTO tblAnlagen(MailItemID, Anlagepfad, Dateiname) VALUES(\" & lngMailItemID & \", ''\" _\r\n & strPfad & \"\\\" & Replace<\/span>(objAnlage.FileName, \"''\", \"''''\") & \"'', ''\" & Replace<\/span>(strDateiname, \"''\", \"''''\") _\r\n & \"'')\", dbFailOnError\r\n Next<\/span> objAnlage\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n