<\/p>\n
Im ersten Teil dieser Beitragsreihe haben wir die Grundlagen geschaffen, um die E-Mails aus den verschiedenen Ordnern von Outlook zu importieren. Im zweiten Teil schauen wir uns das notwendige Datenmodell an und schreiten zur Tat: Die E-Mails aus den ausgewählten Outlook-Ordnern sollen importiert und den einzelnen Kunden zugeordnet werden.<\/b><\/p>\n
Wenn Sie die E-Mails von Kunden importieren möchten, gibt es gleich mehrere Gründe, sich genauer um das Thema E-Mail-Adressen zu kümmern. Im einfachsten Fall haben Sie als Betreiber der Datenbank eine einzige E-Mail-Adresse, mit der Sie E-Mails an die Kunden verschicken. Über diese Adresse sollten optimalerweise auch die E-Mails der Kunden bei Ihnen eintreffen.<\/p>\n
Andersherum wird jeder Kunde mit einer einzigen E-Mail-Adresse in Ihrer Datenbank gespeichert – zum Beispiel mit der E-Mail-Adresse, die dieser beim Absenden der Bestellung über einen Internetshop angegeben hat.<\/p>\n
Dummerweise ist aber weder die eine noch die andere Annahme realitätsnah. Wenn Sie selbst tatsächlich nur eine einzige E-Mail-Adresse verwenden, sind Sie fein raus – dann kann der Kunde sich ja nur unter dieser Adresse bei Ihnen melden. Aber wenn Sie auch nur eine Adresse etwa namens info@minhorst.com <\/b>und eine namens support@minhorst.com <\/b>betreiben, können Sie davon ausgehen, dass es dem Kunden erstmal egal ist, wohin die Mail geht – Hauptsache, die Domain stimmt. Dementsprechend gibt es ja unter Outlook sogar schon die Möglichkeit, für jede einzelne Adresse eine eigene .pst<\/b>-Datei zu betreiten.<\/p>\n
Andersherum hat vielleicht nicht die Mehrzahl der Kunden mehrere E-Mail-Adressen, aber selbst wenn es nur ganz wenige sind, müssen Sie diesen Fall berücksichtigen (zum Beispiel eine private und eine berufliche E-Mail-Adresse – und die wirft man erfahrungsgemäß schnell mal durcheinander …).<\/p>\n
Also müssen Sie wohl oder übel nicht nur für sich selbst, sondern auch für die Kunden mehrere E-Mail-Adressen prüfen, wenn es um die Zuordnung der E-Mails zum entsprechenden Kunden geht.<\/p>\n
Wie aber läuft der Abgleich der vielen E-Mails in Outlook mit den vorhandenen Kunden überhaupt ab Hier gibt es zunächst zwei Möglichkeiten: Die erste geht vom Optimalfall aus und nimmt an, dass alle E-Mails, die Ihnen von Kunden zugesendet wurden, sich im oder unterhalb des Ordners Posteingang <\/b>befinden. Dementsprechend sollten alle E-Mails, die Sie verschickt haben, im Ordner Gesendete Objekte <\/b>enthalten sein.<\/p>\n
Dies ist aber in vielen Fällen nicht gegeben, weil Sie vielleicht bereits selbst ein wenig Struktur in in Ihre Mailordner gebracht haben und etwa alle E-Mails zum Thema Support oder zum Thema Buchhaltung in einem Ordner gespeichert haben – unabhängig davon, ob es sich um Ihre eigenen E-Mails handelt oder um die E-Mails Ihrer Kunden.<\/p>\n
Schauen wir uns zunächst an, wie die Beispiellösung die E-Mail-Adressen des Benutzers selbst verwaltet. Dazu gibt es zwei Tabellen – eine Optionentabelle namens tblOptionen <\/b>und eine Tabelle namens tblEMailAdressen<\/b>, die alle E-Mail-Adressen der kompletten Lösung speichert.<\/p>\n
Die Tabelle tblOptionen <\/b>enthält derzeit nur ein einziges Feld namens StandardEMailAdresseID<\/b>. Dieses ist ein Fremdschlüsselfeld und mit dem Feld EMailAdresseID <\/b>der Tabelle tblEMailAdressen <\/b>verknüpft. Diese Tabelle wiederum enthält das entsprechende Primärschlüsselfeld, das Feld EMailAdresse <\/b>zum Speichern der E-Mail-Adresse und ein Feld namens KundeID<\/b>, mit dem eine E-Mail-Adresse einem Kunden zugewiesen werden kann. Die beiden Tabellen und deren Beziehung sehen in der Übersicht wie in Bild 1 aus.<\/p>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic007.png\")
<\/p>\n
Bild 3: Das Formular frmOptionen in der Entwurfsansicht<\/span><\/b><\/p>\n Der Benutzer der Anwendung soll nun mehrere E-Mail-Adressen eingeben und eine davon als seine Standard-E-Mail-Adresse festlegen können. Diese soll standardmäßig beim Versenden von E-Mails eingesetzt werden. Dazu stellt die Lösung das Formular frmOptionen <\/b>mit dem Unterformular sfmEMailAdressen <\/b>zur Verfügung. Im Unterformular kann der Benutzer alle verfügbaren E-Mail-Adressen eintragen, mit dem Kombinationsfeld im oberen Bereich wählt er die aktuelle Standardadresse aus (s. Bild 2).<\/p>\n Bild 1: Beziehungsfenster mit den beiden Tabellen tblOptionen und tblEMailAdressen<\/span><\/b><\/p>\n Das Hauptformular frmOptionen <\/b>hat keine eigene Datenherkunft. Es enthält im oberen Bereich ein Kombinationsfeld namens cboEMailAdresseID<\/b> und darunter ein Unterformular (s. Bild 3).<\/p>\n Bild 2: Verwalten der eigenen E-Mail-Adressen<\/span><\/b><\/p>\n Das Kombinationsfeld verwendet eine Abfrage auf Basis der Tabelle tblEMailAdressen <\/b>als Datenherkunft, die alle Datensätze liefert, deren Fremdschlüsselfeld KundeID <\/b>den Wert NULL <\/b>enthält – also alle E-Mail-Adressen, die nicht anderweitig mit einem Kunden verknüpft sind (s. Bild 4).<\/p>\n Bild 4: Datensatzherkunft des Kombinationsfeldes zur Auswahl der Standard-E-Mail-Adresse<\/span><\/b><\/p>\n Das im Hauptformular befindliche Unterformular heißt sfmEMailAdressen <\/b>und verwendet die gleiche Datenherkunft wie das Kombinationsfeld cboEMailAdresseID<\/b>. Der Benutzer kann hier E-Mail-Adressen einfügen und die vorhandenen Einträge bearbeiten und löschen. Bei jeder Aktion sollen die Ónderungen jedoch in die Datenherkunft des Kombinationsfeldes cboEMailAdressen <\/b>übertragen werden. Dazu legen Sie für das Ereignis Nach Aktualisieren <\/b>des Unterformulars die folgende Ereignisprozedur an:<\/p>\n Die Requery<\/b>-Methode sorgt jeweils für die Aktualisierung der Datensatzherkunft des Kombinationsfeldes.<\/p>\n Kunden verwalten<\/b><\/p>\n Die Verwaltung der Kunden soll hier im Hintergrund stehen, es geht schließlich um die Kommunikation. Deshalb haben wir das Datenmodell für die Kundentabelle etwas knapper gehalten (s. Bild 5). Hier sind die Eigenschaften des Fremdschlüsselfeldes StandardEMailAdresseID<\/b> sichtbar. Ach, das Feld kennen Sie schon Stimmt: Neben dem Benutzer soll auch jeder Kunde eine Standard-E-Mail-Adresse erhalten, und die wird mit diesem Feld ausgewählt.<\/p>\n Bild 5: Entwurfsansicht der Kundentabelle<\/span><\/b><\/p>\n Die Datensatzherkunft und die übrigen Nachschlageeigenschaften haben wir nun schon eingestellt, damit das Feld beim Anlegen im Formular gleich als Kombinationsfeld ausgeführt wird. Später wird die Abfrage mit den E-Mail-Adressen natürlich nach dem Wert des Feldes KundeID <\/b>gefiltert.<\/p>\n Die Tabelle enthält noch ein Feld namens AnredeID<\/b>, mit dem die Anrede des jeweiligen Kunden eingestellt werden kann. Die möglichen Werte speichert die Tabelle tblAnreden<\/b>, die Auswahl erfolgt wiederum per Kombinationsfeld.<\/p>\n Formular zur Kundenverwaltung<\/b><\/p>\n Das Formular zur Verwaltung der Kunden verwendet die Tabelle tblKunden <\/b>als Datenherkunft und zeigt alle Felder dieser Tabelle an.<\/p>\n Daneben enthält das Formular genau wie das Formular frmOptionen<\/b> ein Unterformular, mit dem Sie die E-Mail-Adressen für den Kunden eintragen können. Genau genommen verwenden Sie dort fast genau das gleiche Formular als Unterformular. Das hier verwendete heißt sfmEMailAdressenKunden<\/b>. Ziehen Sie das Unterformular in das Hauptformular und prüfen Sie, ob die Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>automatisch von Access wie in Bild 6 eingerichtet wurden.<\/p>\n Bild 6: Prüfen der Verknüpfung von Haupt- und Unterformular<\/span><\/b><\/p>\n Der wesentliche Unterschied vom Unterformular sfmEMailAdressenKunden <\/b>zum Formular sfmEMailAdressen <\/b>ist die Datenherkunft. Das Unterformular zur Anzeige der E-Mail-Adressen des Kunden verwendet die Abfrage aus Bild 7 als Datenherkunft. Der entscheidende Unterschied ist hier, dass diese Abfrage nicht die Datensätze der Tabelle tblEMailAdressen <\/b>liefert, deren Feld KundeID <\/b>leer ist, sondern genau die übrigen Datensätze – nämlich jene, die im Feld KundeID <\/b>mit einem Wert ausgestattet sind.<\/p>\n Bild 7: Datenherkunft des Unterformulars sfmEMailAdressenKunden<\/span><\/b><\/p>\n Auch für das Unterformular sfmEMailAdressenKunden <\/b>legen Sie zwei Ereignisprozeduren an, und zwar für die Ereignisse Nach Aktualisierung <\/b>und Beim Löschen<\/b>. Die folgende Prozedur wird nach dem Aktualisieren eines Datensatzes ausgelöst, also beim Neuanlegen oder beim Óndern eines bestehenden Datensatzes:<\/p>\n Die Prozedur aktualisiert zunächst die Datenherkunft des Kombinationsfeldes cboStandardEMailID <\/b>im Hauptformular. Dann prüft sie, ob der geänderte Datensatz der einzige Datensatz im Unterformular ist, und stellt gegebenenfalls das Kombinationsfeld im Hauptformular auf diesen Datensatz ein. Dies ist hilfreich, wenn der Benutzer beispielsweise gerade den ersten Datensatz im Unterformular angelegt hat. Dieser wird dann direkt als Standard-E-Mail-Adresse angelegt.<\/p>\n Wenn der Benutzer einen oder mehrere Einträge im Unterformular löscht, löst dies die folgende Prozedur aus:<\/p>\n Auch diese Prozedur aktualisiert zunächst die Datenherkunft des Kombinationsfeldes cboStandardEMailID <\/b>im Hauptformular. Dann prüft sie, ob das Kombinationsfeld im Hauptformular die soeben gelöschte E-Mail-Adresse angezeigt hat, und aktualisiert gegebenenfalls das Kombinationsfeld im Hauptformular. Wurde der letzte Datensatz im Unterformular gelöscht, leert die Prozedur das Kombinationsfeld cboStandardEMailID <\/b>im Hauptformular, anderenfalls stellt sie dieses auf den ersten verfügbaren Wert ein.<\/p>\n Auch das Hauptformular statten wir noch mit zwei Ereignisprozeduren aus. Die erste wird durch das Ereignis Beim Anzeigen <\/b>ausgelöst. Sie sorgt schlicht und einfach dafür, dass das Kombinationsfeld cboStandardEMail <\/b>beim Anzeigen eines Datensatzes nur die E-Mails zur Auswahl anbietet, die auch mit dem aktuellen Kunden verknüpft sind:<\/p>\n Die zweite Ereignisprozedur wird ausgelöst, wenn der Benutzer einen noch nicht vorhandenen Eintrag in das Kombinationsfeld cboStandardEMailID <\/b>eingibt:<\/p>\n Die Prozedur füllt ein Database<\/b>-Objekt mit einem Verweis auf die aktuelle Datenbank und führt mit dessen Execute<\/b>-Anweisung eine INSERT INTO<\/b>-Aktionsabfrage aus, die einen neuen Datensatz zur Tabelle tblEMailAdressen <\/b>hinzufügt. Diese wird mit der frisch eingegebenen E-Mail-Adresse und dem Wert des Feldes KundeID <\/b>des aktuellen Kundendatensatzes im Hauptformular gefüllt.<\/p>\n Behandlung eingelesener E-Mails<\/b><\/p>\n Kommen wir zum Einlesen der E-Mails, die aufgrund der Absender- oder Empfängeradresse mit einem der Kunden in Zusammenhang gebracht werden können. Diesen Vorgang haben wir durch die Bereitstellung eines Formulars zum Auswählen der zu durchsuchenden Outlook-Ordner bereits gut vorbereitet.<\/p>\n Wir müssen nun noch eine Prozedur bereitstellen, welche in mehr oder weniger regelmäßigen Abständen die kundenrelevanten E-Mails aus Outlook importiert und in der Datenbank dem Kunden zuordnet. Dabei stellt sich zunächst die folgende Frage: Was geschieht mit einer einmal in die Datenbank eingelesenen E-Mail in Outlook Es gibt verschiedene Szenarien:<\/p>\n Welche Möglichkeiten gibt es, die Mails zu markieren und somit zu verhindern, dass diese erneut eingelesen werden beziehungsweise sowohl in der Datenbank als auch in Outlook vom Empfänger bearbeitet werden Die erste ist eine optische: Dabei erstellen Sie in Outlook eine eigene Kategorie für eingelesene E-Mails und weisen diese den entsprechenden E-Mails zu. In Outlook werden diese mit einer entsprechenden Farbe markiert (s. Bild 8).<\/p>\n Bild 8: Die gelb markierten E-Mails wurden bereits in die Datenbank eingelesen<\/span><\/b><\/p>\n Wenn man sich vorstellt, dass die bereits eingelesenen E-Mails zwar markiert werden, jedoch im Ordner Posteingang<\/b> verbleiben, ist bezüglich der Übersichtlichkeit in Outlook nur wenig gewonnen. Besser wäre es tatsächlich, die eingelesenen E-Mails auch gleich zu löschen oder in einen anderen Ordner zu verschieben. Das Löschen scheint etwas rabiat, also verschieben wir diese in einen speziell für bereits eingelesene E-Mails angelegten Ordner.<\/p>\n Flexibles Einlesen<\/b><\/p>\n Damit Sie die vorhergehenden Varianten beim Einlesen alle einsetzen können, haben wir die entsprechende Prozedur EMailsEinlesen<\/b> (s. Listing 1<\/a><\/span>) mit zwei entsprechenden Parametern ausgestattet:<\/p>\n Listing 1: Einlesen von E-Mails in die Tabelle tblKommunikation<\/p>\n <\/p>\n Wenn Sie beispielsweise die aktuell mit dem Formular frmMailordnerTree <\/b>festgelegten und in der Tabelle tblMailordner <\/b>gespeicherten Verzeichnisse nach E-Mails durchforsten wollen, deren Empfänger oder Absender in der Tabelle tblEMailAdressen <\/b>enthalten ist, verwenden Sie beispielsweise den folgenden Aufruf. Dabei geben Sie als ersten Parameter das Zielverzeichnis an, in das die eingelesenen E-Mails verschoben werden sollen, und als zweiten Parameter die Kategorie, mit der diese versehen werden sollen:<\/p>\n Die Prozedur EMailsEinlesen <\/b>legt zunächst ein Objekt zum Speichern einer Referenz auf eine Outlook-Instanz und eines mit einem Verweis auf die aktuelle Datenbank an. Dann öffnet sie eine Datensatzgruppe, die alle Datensätze der Tabelle tblMailOrdner <\/b>einliest – diese enthält alle Verzeichnisse, deren E-Mails geprüft und gegebenenfalls eingelesen werden sollen.<\/p>\n Sie können sowohl den Parameter strZielordner <\/b>als auch strKategorie <\/b>weglassen. Falls Sie keinen Zielordner angeben, werden die eingelesenen E-Mails schlicht nicht verschoben. Sollten Sie keine Kategorie angeben, trägt die Prozedur keine Kategorie zum Kennzeichnen der bereits eingelesenen E-Mails ein.<\/p>\n Beides wegzulassen ist ungünstig – die Prozedur kann einmal eingelesene E-Mails so nicht erkennen und liest diese einfach nochmals ein. Geben Sie also zumindest für einen der beiden Parameter einen Wert an.<\/p>\n Wenn strZielordner <\/b>angegeben wurde, ruft die Prozedur die Funktion GetFolder <\/b>auf. Diese prüft das Vorhandensein des Ordners und legt diesen gegebenenfalls an – mehr dazu weiter unten.<\/p>\n Als Ergebnis landet ein Verweis auf den Zielordner in der Variablen objZielordner<\/b>.<\/p>\n Anschließend öffnet die Prozedur ein Recordset auf Basis der Tabelle tblKommunikation<\/b>, in der schließlich die Daten der jeweiligen E-Mails landen sollen. Bevor es richtig losgeht, prüft die Prozedur noch, ob im Falle der Verwendung einer Kategorie zum Markieren der eingelesenen Mails die benötigte Kategorie bereits angelegt ist. Dies erledigt die Prozedur KategoriePruefen <\/b>(siehe weiter unten). Ist die Kategorie noch nicht vorhanden, muss der Benutzer diese zunächst manuell anlegen.<\/p>\n Wird keine Kategorie benötigt oder ist diese vorhanden, steigt die Prozedur in die Abarbeitung der ausgewählten Quellordner von Outlook ein. Dazu durchläuft sie alle Datensätze des Recordsets rstMailordner <\/b>in einer Do While<\/b>-Schleife.<\/p>\n Die Variable strMailordner <\/b>nimmt den Namen des Ordners auf und kürzt die vorn zu findenden Backslash-Zeichen weg (\\\\<\/b>). Die Funktion GetFolder <\/b>liefert schließlich einen Verweis auf das entsprechende Folder<\/b>-Objekt zu diesem Ordner.<\/p>\n Hier beginnt das Abarbeiten aller im Verzeichnis enthaltenen Elemente, und zwar innerhalb einer For…Next<\/b>-Schleife über die Anzahl der enthaltenen Elemente bis zum Wert 1 <\/b>mit einer Schrittweite von -1<\/b>. Die üblicherweise zum Durchlaufen von Auflistungen verwendete For Each<\/b>-Schleife könnte in diesem Fall Probleme machen, da die eingelesenen Mail-Elemente ja gegebenenfalls in einen anderen Ordner verschoben werden und somit die Indizes verschieben.<\/p>\n Das jeweilige Element mit dem Index i <\/b>wird mit der Objektvariablen obj <\/b>referenziert. Die Funktion TypeName <\/b>prüft, ob das Objekt den Typ MailItem <\/b>aufweist. In diesem Fall setzt die Prozedur das Einlesen fort, indem sie das Mail-Objekt mit der Objektvariablen objMail <\/b>referenziert. Dieses bietet gegenüber der Variablen obj <\/b>vom Typ Object <\/b>den Vorteil, dass die Eigenschaften des Mail-Objekts per IntelliSense angesprochen werden können.<\/p>\n Die Prozedur speichert nun den Absender und den Empfänger der E-Mail in den Variablen strEMail_From <\/b>und strEMail_To<\/b>. Der Absender wird mit der Eigenschaft SenderEMailAdress <\/b>ermittelt, der Empfänger mit der To<\/b>-Eigenschaft.<\/p>\n Ob die E-Mail überhaupt eingelesen werden soll, hängt nun davon ab, ob entweder die Absender- oder die Empfänger-Adresse in der Tabelle tblEMailAdressen <\/b>gefunden wird. Dies prüft ein entsprechender Aufruf der DLookup<\/b>-Funktion, die im Erfolgsfall den Wert des Feldes KundeID <\/b>des gefundenen Datensatzes zurückgibt. Dieser landet schließlich in der Variablen lngKundeID<\/b>. Die DLookup<\/b>-Funktion prüft übrigens nur diejenigen Adressen der Tabelle tblEMailAdressen<\/b>, die einem Kunden zugeordnet sind (die Einträge ohne Wert im Feld KundeID <\/b>gehören ja dem Benutzer). Ist lngKundeID <\/b>nicht 0 <\/b>und liefert die Funktion Einlesen <\/b>den Wert True<\/b>, wird die Mail eingelesen. Die Funktion Einlesen <\/b>(s. Listing 2<\/a><\/span>) prüft zunächst, ob ein Zielverzeichnis für eingelesene E-Mails angegeben wurde oder ob die aktuell bearbeitete E-Mail anderenfalls bereits mit der angegebenen Kategorie versehen wurde. Dazu erwartet die Funktion einen Verweis auf die E-Mail, den Zielordner und die Kategorie als Parameter.<\/p>\n Listing 2: Prüfen, ob eine E-Mail eingelesen werden soll<\/p>\n Ist in strZielordner <\/b>ein Zielordner angegeben, werden eingelesene Elemente verschoben – es kann also davon ausgegangen werden, dass sich keine eingelesenen Elemente im betroffenen Ordner befinden. Ist kein Ordner angegeben, soll die Funktion für die mit objMail<\/b> übergebene E-Mail prüfen, ob diese bereits mit der als Markierung für eingelesene E-Mails vorgesehenen Kategorie versehen wurde. Dazu durchläuft die Funktion alle Kategorien der E-Mail (meist sind keine vorhanden). Wird die entsprechende Kategorie nicht gefunden, wurde die E-Mail offensichtlich noch nicht eingelesen und die Funktion Einlesen<\/b> gibt den Wert True <\/b>zurück.<\/p>\n Die Prozedur legt nun im Recordset rstMails <\/b>einen neuen Datensatz an und trägt die Werte für die Felder EMail_From<\/b>, EMail_To<\/b>, Betreff, Inhalt<\/b>, DatumZeit <\/b>und KundeID <\/b>ein. Warum erledigen wir das per AddNew <\/b>und nicht mit einer einfachen INSERT INTO<\/b>-Aktionsabfrage Weil es vorkommen kann, dass der Inhalt der Mail länger als 65.536 Zeichen ist. Längere Zeichenketten können nur mit AddNew<\/b>\/Update <\/b>eingetragen werden, INSERT INTO <\/b>würde hier einen Fehler auslösen.<\/p>\n Wenn ein Wert für strKategorie <\/b>angegeben wurde, trägt die Prozedur die neue Kategorie für die Eigenschaft Categories <\/b>an – zusätzlich zum bereits vorhandenen Eintrag und von diesem durch ein Semikolon getrennt. Damit sich Outlook diese Ónderung merkt, müssen Sie anschließend die Save<\/b>-Methode des E-Mail-Objekts aufrufen.<\/p>\n Und sollte ein gültiger Zielordner angegeben und mit objZielordner <\/b>referenziert worden sein, verschiebt die Move<\/b>-Methode die E-Mail zum neuen Zielordner. Die Update<\/b>-Methode speichert die Daten des neuen Datensatzes und die MoveNext<\/b>-Methode springt zum folgenden Datensatz.<\/p>\n Dies wird so lange wiederholt, bis die Abbruchbedingung .EOF <\/b>der Do While<\/b>-Schleife den Wert True <\/b>liefert.<\/p>\n Nun schauen wir uns noch die beiden weiteren von dieser Prozedur aufgerufenen Funktionen an.<\/p>\n Folder-Objekte holen oder erstellen<\/b><\/p>\n Die Funktion GetFolder <\/b>aus Listing 3<\/a><\/span> erwartet drei Parameter:<\/p>\n Listing 3: Holen und\/oder Anlegen eines Verweises auf einen Ordner<\/p>\n Die Funktion schneidet zunächst die beiden Backslash-Zeichen zu Beginn des mit strFolder <\/b>übergebenen Verzeichnisses ab und speichert das Ergebnis wiederum in der Variablen strFolder<\/b>. Aus<\/p>\n wird so folgender Wert:<\/p>\n Dann ermittelt sie mit der InStr<\/b>-Funktion die Position des nächsten Backslash-Zeichens von links aus gesehen und ermittelt den Ausdruck links von dieser Position, in diesem Beispiel Outlook<\/b>. Dieser Ordner wird schließlich mit objFolder <\/b>referenziert.<\/p>\n Dann durchläuft die Prozedur alle verbleibenden Elemente, die durch Backslash-Zeichen getrennt sind. Dazu erzeugt sie zunächst mit der Split<\/b>-Funktion entsprechende Arrays, über deren mit LBound <\/b>und UBound <\/b>ermittelte Array-Grenzen dann eine For…Next<\/b>-Schleife ausgeführt wird. Innerhalb der Schleife greift dann eine Anweisung über den Index i <\/b>auf das jeweilige Element zu. Mit der Variablen objFolderTemp <\/b>referenziert die Prozedur dann das unterhalb von objFolder <\/b>liegende Objekt mit dem aus dem Array ermittelten Namen (hier erst Posteingang <\/b>und dann Test<\/b>).<\/p>\n Sollte eines der per String übergebenen Verzeichnisse nicht vorhanden sein, bleibt objFolderTemp <\/b>leer. Dies wird in der folgenden If…Then<\/b>-Bedingung geprüft. Ist objFolderTemp <\/b>leer und hat bolCreate <\/b>den Wert True<\/b>, erstellt die Prozedur das Unterverzeichnis in Outlook neu.<\/p>\n Dies erledigt die Prozedur mit der Add<\/b>-Methode der Folders<\/b>-Auflistung des zuletzt referenzierten Outlook-Mailordners aus objFolder<\/b>. Das Ergebnis landet wiederum in objFolder<\/b>, das nach dem Ermitteln oder Erstellen aller Ordner als Rückgabewert der Funktion festgelegt wird.<\/p>\n Prüfen, ob eine bestimmte Kategorie in Outlook angelegt wurde<\/b><\/p>\n Wenn Sie die eingelesenen Mails nicht in ein anderes Verzeichnis verschieben, können Sie diese mit einer Kategorie versehen, um diese später als bereits eingelesen zu erkennen.<\/p>\n Diese Kategorie muss jedoch zunächst einmal vorhanden sein. Um dies zu prüfen, verwendet die Prozedur EMailsEinlesen <\/b>die Funktion KategoriePruefen<\/b> (s. Listing 4<\/a><\/span>). Diese Funktion erwartet zwei Parameter:<\/p>\n Listing 4: Prüfen, ob eine bestimmte Kategorie in Outlook vorhanden ist<\/p>\n Die Prozedur durchläuft alle Elemente der Auflistung Categories <\/b>des MAPI-Namespace von Outlook. Dies geschieht nicht in einer For Each<\/b>-Schleife, sondern in einer For…Next<\/b>-Schleife über die Werte von 1 <\/b>bis zur Anzahl der Elemente der Auflistung Categories<\/b>.<\/p>\n Ist die mit strKategorie <\/b>übergebene Kategorie vorhanden, liefert die Funktion den Wert True <\/b>zurück.<\/p>\n Benutzeroberfläche zum Einlesen von E-Mails<\/b><\/p>\n Nun fehlt noch eine einigermaßen ergonomische Bedienoberfläche, um das Einlesen der E-Mails zu starten. Diese sieht zunächst wie in Bild 9 aus.<\/p>\n Bild 9: Formular zum Steuern des Einlesevorgangs<\/span><\/b><\/p>\n Das Formular dient der Auswahl der Parameter für die Prozedur EMailsEinlesen <\/b>und ruft diese per Schaltfläche auf.<\/p>\n Der Parameter Zielordner <\/b>soll in das Textfeld txtZielordner <\/b>eingetragen werden. Als Hilfe finden Sie rechts von diesem Textfeld eine Schaltfläche namens cmdOrdnerauswaehlen<\/b>, die per Mausklick die folgende Prozedur auslöst:<\/p>\n Diese wiederum ruft die Funktion OrdnerAuswaehlen<\/b> aus Bild 10 und liefert den Pfad des ausgewählten Verzeichnisses zurück.<\/p>\n Listing 5: Auswählen eines Outlook-Ordners<\/p>\n Bild 10: Auswählen eines Outlook-Ordners<\/span><\/b><\/p>\n Kategorien zur Auswahl bereitstellen<\/b><\/p>\n Das Kombinationsfeld cboKategorieFuerEingeleseneMails <\/b>soll alle in Outlook verfügbaren Kategorien zur Auswahl bereitstellen. Dazu stellen Sie zunächst die Eigenschaft Herkunftsart <\/b>auf Wertliste <\/b>ein.<\/p>\n Dann weisen Sie per VBA in der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, die Datensatzherkunft des Kombinationsfeldes zu. Die Prozedur Form_Load <\/b>aus Listing 6<\/a><\/span> erzeugt zunächst eine Outlook-Instanz beziehungsweise referenziert eine existierende Instanz mit der Variablen objOutlook<\/b>. Dann durchläuft die Prozedur alle Elemente der Auflistung Categories <\/b>des MAPI-Namespaces von Outlook und fügt mit jedem Durchlauf einer For…Next<\/b>-Schleife eine weitere Kategorie zur String-Variablen strKategorien <\/b>hinzu – getrennt durch ein Semikolon. Nach dem Einlesen aller Kategorien weist die Prozedur die Variable strKategorien <\/b>der Eigenschaft RowSource <\/b>des Kombinationsfeldes zu.<\/p>\n Listing 6: Füllen der Kategorien beim Laden des Formulars<\/p>\n Nun sollten die in die beiden Steuerelemente eingegebenen Daten auch noch gespeichert werden, damit der Benutzer diese nur einmal eingeben muss.<\/p>\n Kein Problem: Sie fügen einfach der Tabelle tblOptionen <\/b>zwei Textfelder namens Zielordner <\/b>und KategorieFuerEingeleseneMails <\/b>hinzu, stellen die Eigenschaft Datenherkunft <\/b>des Formulars auf diese Tabelle ein und die Eigenschaft Steuerelementinhalt <\/b>der beiden Steuerelemente auf die entsprechenden Felder (s. Bild 11).<\/p>\n Bild 11: Das Formular frmMailsEinlesen ist an die Tabelle tblOptionen gebunden.<\/span><\/b><\/p>\n Nun fehlt noch die Schaltfläche zum Starten des Einlesevorgangs. Diese heißt cmdEMailsEinlesen <\/b>und löst die folgende Prozedur aus:<\/p>\n Dabei übergibt sie die Werte der beiden Textfelder an die entsprechenden Parameter der Prozedur EMailsEinlesen<\/b>.<\/p>\n Quellordner auswählen<\/b><\/p>\n Im ersten Teil der Beitragsreihe haben wir bereits ein Formular erstellt, mit dem Sie die beim Einlesen zu berücksichtigenden Outlook-Ordner festlegen können. Dieses soll der Benutzer mit einer Schaltfläche vom Formular frmEMailsEinlesen <\/b>öffnen können. Dazu legen Sie eine Schaltfläche namens cmdQuellordnerAuswählen <\/b>an und fügen dieser die folgende Ereignisprozedur hinzu:<\/p>\n Wenn der Benutzer die Auswahl ändert, wird diese gleich beim nächsten Einlesen angewendet.<\/p>\n Kategorien zurücksetzen<\/b><\/p>\n Beim Experimentieren mit der Beispieldatenbank ist es oft passiert, dass E-Mails zu Kategorien hinzugefügt wurden, aber wieder entfernt werden sollten. Da dies bei mehreren hundert E-Mails von Hand etwas aufwendig ist, schien das Erstellen einer kleinen Hilfsprozedur sinnvoll zu sein. Den Aufruf dieser Prozedur packen Sie ebenfalls in eine Schaltfläche im Formular frmEMailsEinlesen<\/b>. Die Schaltfläche heißt cmdKategoriezuweisungEntfernen <\/b>und löst die Prozedur KategorienEntfernen <\/b>aus:<\/p>\n Die hier aufgerufene Prozedur KategorieEntfernen<\/b> finden Sie in Listing 7<\/a><\/span>. Die Prozedur erstellt zunächst ein Recordset auf Basis der Tabelle tblMailordner <\/b>und durchläuft alle zu berücksichtigenden Outlook-Mailordner in einer Do While<\/b>-Schleife.<\/p>\n Listing 7: Entfernen von E-Mails aus einer Kategorie<\/p>\n Dabei holt sie sich einen Verweis auf das zum Namen des Mailordners passende Folder<\/b>-Objekt und durchläuft alle enthaltenen Objekte. Handelt es sich bei dem Objekt um eines vom Typ MailItem<\/b>, ersetzt es den Namen der betroffenen Kategorie in der Eigenschaft Categories <\/b>dieser Mail durch eine leere Zeichenkette. Es könnte zu Problemen kommen, wenn Sie zum Markieren der eingelesenen E-Mails eine Kategorie verwenden, deren Name im Namen einer oder mehrerer weiterer Kategorien enthalten ist. Diese würden dann um die entsprechende Zeichenkette beschnitten. Dies müssen Sie jedoch nur berücksichtigen, wenn Sie ohnehin viel mit Kategorien arbeiten.<\/p>\n Kunden und Kommunikation anzeigen<\/b><\/p>\n Nun müssen wir noch das Formular zur Anzeige der Kundendetails mit der Tabelle tblKommunikation<\/b> und den darin passend zum jeweiligen Kunden gespeicherten E-Mails verdrahten. Um die Arbeiten am Formular frmEMailsEinlesen <\/b>abzuschließen, fügen Sie hier noch eine Schaltfläche ein, welche das Formular frmKundeDetail <\/b>öffnet – und zwar mit folgender Ereignisprozedur:<\/p>\n Danach erweitern wir das Formular frmKundeDetail <\/b>um ein Listenfeld, das alle zum aktuellen Kunden passenden E-Mails anzeigt.<\/p>\n Das Listenfeld soll folgende wichtige Informationen enthalten:<\/p>\n Gerade die letzte Information ist interessant. In der E-Mail-Liste unter Outlook können Sie den Absender und den Empfänger anzeigen lassen. Dort sind aber auch beide Informationen wichtig, denn dort landen ja in der Regel auch E-Mails aller Kommunikationspartner.<\/p>\n Das Listenfeld, das die Kommunikation mit dem aktuell im Formular angezeigten Kunden liefern soll, enthält nur E-Mails, die entweder von Ihnen an den Kunden oder vom Kunden an Sie versendet wurden. Das heißt, dass Sie grundsätzlich nur wissen müssen, ob die Mail von Ihnen oder vom Kunden stammt. Dazu könnten Sie beispielsweise eine eigene Spalte reservieren und dort einen der beiden Ausdrücke Kunde <\/b>und Ich <\/b>eintragen. Noch platzsparender ist es jedoch, wenn Sie die Betreffzeile der E-Mails des Kunden normal darstellen und die Betreffzeilen Ihrer eigenen E-Mails etwas einrücken – beispielsweise um vier Zeichen.<\/p>\n Das Endergebnis soll wie in Bild 12 aussehen. Wir haben den Bereich zur Eingabe der E-Mail-Adressen eines Kunden rechts neben die Kundendaten verschoben und unten ein neues Listenfeld namens lstKommunikation <\/b>eingerichtet. Das Listenfeld soll das Datum und den Betreff der E-Mails anzeigen. Rechts daneben liefert ein Textfeld den Inhalt der aktuell markierten E-Mail. Ein Klick auf eine andere E-Mail liefert den jeweiligen Inhalt. Ein Doppelklick auf einen Eintrag im Listenfeld soll die E-Mail im entsprechenden Outlook-Fenster öffnen – zu diesem Zweck wurde die EntryID <\/b>der jeweiligen E-Mail in der Tabelle tblKommunikation <\/b>gespeichert.<\/p>\n Bild 12: Das Formular frmKundeDetail mit der Erweiterung zum Anzeigen der Kommunikation und der aktuell ausgewählten E-Mail<\/span><\/b><\/p>\n Datenherkunft des Listenfeldes<\/b><\/p>\n Das Listenfeld lstKommunikation <\/b>verwendet die Abfrage qryFrmKundeDetail_lstKommunikation <\/b>als Datensatzherkunft. Diese wird jedoch noch in Abhängigkeit vom jeweiligen Kunden gefiltert – dazu später mehr. Werfen wir zunächst einen Blick auf die Abfrage.<\/p>\n Diese sieht wie in Bild 13 aus und enthält die Tabelle tblKommunikation <\/b>als Datenquelle. Neben den Feldern KommunikationID<\/b>, DatumZeit<\/b>, KundeID <\/b>und EntryID <\/b>enthält sie ein berechnetes Feld mit folgendem Ausdruck:<\/p>\n Bild 13: Diese Abfrage dient als Basis der Datenherkunft des Listenfeldes lstKommunikation.<\/span><\/b><\/p>\n Dieser Ausdruck prüft, ob es in der Tabelle tblEMailAdressen <\/b>einen Eintrag gibt, dessen KundeID <\/b>nicht Null <\/b>ist (was nur bei den E-Mail-Adressen des Benutzers der Fall sein sollte) und dessen Feld EMailAdresse <\/b>mit der Absenderadresse des jeweiligen Datensatzes übereinstimmt.<\/p>\n Wenn diese Bedingung wahr ist, liefert die umschließende Wenn<\/b>-Bedingung eine leere Zeichenkette zurück, sonst eine Zeichenkette mit vier Leerzeichen. Diese Leerzeichen sorgen für die gewünschte Einrückung. An die leere Zeichenkette oder die vier Leerzeichen hängt der berechnete Ausdruck noch den eigentlichen Betreff der E-Mail an.<\/p>\n Damit das Listenfeld lstKommunikation <\/b>nur die beiden Felder DatumZeit <\/b>und Betreffzeile <\/b>anzeigt, das Primärschlüsselfeld und die beiden übrigen Felder KundeID <\/b>und EntryID <\/b>jedoch nicht, stellen Sie die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf die Werte 5 <\/b>und 0cm;3cm;7cm;0cm;0cm <\/b>ein.<\/p>\n Damit das Listenfeld seine Datensätze entsprechend dem aktuellen Kunden im Hauptformular filtert, erweitern Sie die Prozedur, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird, wie in Listing 8<\/a><\/span>.<\/p>\n Listing 8: Aktualisieren der Liste der E-Mails für den aktuellen Kunden<\/p>\n Die zweite Anweisung dieser Prozedur stellt die Datensatzherkunft des Listenfeldes auf die Abfrage qryfrmKundeDetail_lstKommunikation<\/b>, wobei diese noch nach dem aktuellen Wert von KundeID <\/b>gefiltert wird. Die dritte Anweisung markiert den ersten Eintrag des Listenfeldes, die vierte ruft die gleich im Anschluss beschriebene Ereignisprozedur auf, um den Inhalt der Mail des aktuell markierten Datensatzes anzuzeigen.<\/p>\n Damit das Textfeld txtMail <\/b>mit dem Inhalt der aktuell im Listenfeld ausgewählten E-Mail gefüllt wird, fügen Sie dem Listenfeld eine Ereignisprozedur hinzu, die durch das Ereignis Nach Aktualisierung <\/b>ausgelöst wird und wie folgt aussieht:<\/p>\n Fehlt noch das Öffnen einer E-Mail per Doppelklick. Dazu fügen Sie dem Listenfeld eine Ereignisprozedur für das Ereignis Beim Doppelklicken <\/b>hinzu (s. Listing 9<\/a><\/span>). Diese referenziert zuerst eine vorhandene oder neu zu erstellende Outlook-Instanz und danach den MAPI-Namespace. Schließlich ermittelt sie mit der Funktion GetItemFromID <\/b>unter Verwendung der in der fünften Spalte des Listenfeldes enthaltenen EntryID <\/b>einen Verweis auf die entsprechende E-Mail in Outlook und zeigt diese mit der Display<\/b>-Methode an.<\/p>\n Listing 9: Öffnen einer E-Mail in Outlook<\/p>\n Durch die Möglichkeit der Anzeige der in die Datenbank eingelesenen E-Mails im entsprechenden Outlook-Fenster werden die üblichen E-Mail-Funktionen wie etwa zum Beantworten, Weiterleiten et cetera bereitgestellt. Außerdem können Sie auf auf eventuell enthaltene Anhänge zugreifen, die beim Einlesen nicht berücksichtigt werden.<\/p>\n Bild 14 zeigt eine in Outlook geöffnete, bereits eingelesene E-Mail. Dies erkennen Sie an dem gelben Balken, der die beim Einlesen zugewiesene Kategorie anzeigt.<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic005.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic006.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic008.png\")
<\/p>\nPrivate Sub Form_AfterUpdate()\r\n Me.Parent!cboStandardEMailID.Requery\r\nEnd Sub<\/pre>\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic009.png\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic010.png\")
<\/p>\n![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic011.png\")
<\/p>\nPrivate Sub Form_AfterUpdate()\r\n Me.Parent!cboStandardEMailID.Requery\r\n If Me.Recordset.RecordCount = 1 Then\r\n Me.Parent!cboStandardEMailID = Me.Parent!cboStandardEMailID.ItemData(0)\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub Form_Delete(Cancel As Integer)\r\n Me.Parent!cboStandardEMailID.Requery\r\n If Me.Parent!cboStandardEMailID = Me!EMailAdresseID Then\r\n If Me.Recordset.RecordCount = 0 Then\r\n Me.Parent!cboStandardEMailID = Null\r\n Else\r\n Me.Parent!cboStandardEMailID = Me.Parent!cboStandardEMailID.ItemData(0)\r\n End If\r\n End If\r\n Me.Parent.Requery\r\nEnd Sub<\/pre>\n
Private Sub Form_Current()\r\n Me!cboStandardEMailID.RowSource = "SELECT EMailAdresseID, EMailAdresse " _\r\n "FROM tblEMailAdressen WHERE KundeID = " & Me!KundeID\r\nEnd Sub<\/pre>\n
Private Sub cboStandardEMailID_NotInList(NewData As String, Response As Integer)\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n db.Execute "INSERT INTO tblEMailAdressen(EMailAdresse, KundeID) VALUES(''" _\r\n & NewData & "'', " & Me!KundeID & ")"\r\n Me!sfmEMailAdressen.Form.Requery\r\n Set db = Nothing\r\n Response = acDataErrAdded\r\nEnd Sub<\/pre>\n\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic012.png\")
<\/p>\n\n
Public Sub EMailsEinlesen(Optional strZielordner As String, Optional strKategorie As String)\r\n Dim db As DAO.Database\r\n Dim rstMailordner As DAO.Recordset, rstMails As DAO.Recordset\r\n Dim objFolder As Outlook.MAPIFolder, objZielordner As Outlook.Folder\r\n Dim obj As Object, objMail As Outlook.MailItem\r\n Dim objOutlook As Outlook.Application\r\n Dim strMailordner As String, strEmail_From As String, strEMail_To As String\r\n Dim lngKundeID As Long, i As Integer\r\n Set objOutlook = New Outlook.Application\r\n Set db = CurrentDb\r\n Set rstMailordner = db.OpenRecordset("SELECT * FROM tblMailordner", dbOpenDynaset)\r\n If Len(strZielordner) > 0 Then\r\n Set objZielordner = GetFolder(objOutlook, strZielordner, True)\r\n End If\r\n Set rstMails = db.OpenRecordset("tblKommunikation", dbOpenDynaset)\r\n If Len(strKategorie) > 0 Then\r\n If KategoriePruefen(objOutlook, strKategorie) = False Then\r\n MsgBox "Richten Sie zunächst die Kategorie ''" & strKategorie & "'' unter Outlook ein."\r\n Exit Sub\r\n End If\r\n End If\r\n Do While Not rstMailordner.EOF\r\n strMailordner = rstMailordner!Mailordner\r\n Set objFolder = GetFolder(objOutlook, strMailordner, False)\r\n For i = objFolder.Items.Count To 1 Step -1\r\n Set obj = objFolder.Items(i)\r\n If TypeName(obj) = "MailItem" Then\r\n Set objMail = obj\r\n strEmail_From = objMail.SenderEmailAddress\r\n strEMail_To = Replace(objMail.To, "''", "")\r\n lngKundeID = Nz(DLookup("KundeID", "tblEmailadressen", "(EMailadresse = ''" _\r\n & strEmail_From & "'' OR EMailadresse = ''" & strEMail_To & "'') AND KundeID IS NOT NULL"), 0)\r\n If lngKundeID > 0 And Einlesen(objMail, strZielordner, strKategorie) Then\r\n With rstMails\r\n .AddNew\r\n !EMail_From = strEmail_From\r\n !EMail_To = strEMail_To\r\n !Betreff = Replace(objMail.Subject, "''", "''''")\r\n !Inhalt = Replace(objMail.Body, "''", "''''")\r\n !DatumZeit = objMail.SentOn\r\n !KundeID = lngKundeID\r\n !EntryID = objMail.EntryID\r\n If Len(strKategorie) > 0 Then\r\n objMail.Categories = objMail.Categories & ";" & strKategorie\r\n End If\r\n objMail.Save\r\n If Not objZielordner Is Nothing Then\r\n objMail.Move objZielordner\r\n End If\r\n .Update\r\n End With\r\n End If\r\n End If\r\n Next i\r\n rstMailordner.MoveNext\r\n Loop\r\n Set objOutlook = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\nPublic Sub EMailsEinlesen_Test()\r\n EMailsEinlesen "\\\\Outlook\\Posteingang\\Test", "Eingelesen"\r\nEnd Sub<\/pre>\n
Public Function Einlesen(objMail As Outlook.MailItem, strZielordner As String, strKategorie As String) As Boolean\r\n Dim i As Integer\r\n If Len(strZielordner) > 0 Then\r\n Einlesen = True\r\n Exit Function\r\n Else\r\n Einlesen = True\r\n If Len(strKategorie) > 0 Then\r\n For i = LBound(Split(objMail.Categories, ";")) To UBound(Split(objMail.Categories, ";"))\r\n If Split(objMail.Categories, ";")(i) = strKategorie Then\r\n Einlesen = False\r\n Exit Function\r\n End If\r\n Next i\r\n End If\r\n End If\r\nEnd Function<\/pre>\n
Public Function GetFolder(objOutlook As Outlook.Application, strFolder As String, _\r\n bolCreate As Boolean) As Outlook.MAPIFolder\r\n Dim i As Integer\r\n Dim objFolder As Outlook.MAPIFolder\r\n Dim objFolderTemp As Outlook.MAPIFolder\r\n On Error Resume Next\r\n strFolder = Mid(strFolder, 3)\r\n Set objFolder = objOutlook.GetNamespace("MAPI").Folders.Item(Left(strFolder, InStr(1, strFolder, "\\") - 1))\r\n For i = LBound(Split(strFolder, "\\")) + 1 To UBound(Split(strFolder, "\\"))\r\n Set objFolderTemp = Nothing\r\n Set objFolderTemp = objFolder.Folders.Item(Split(strFolder, "\\")(i))\r\n If objFolderTemp Is Nothing Then\r\n If bolCreate = True Then\r\n Set objFolder = objFolder.Folders.Add(Split(strFolder, "\\")(i))\r\n End If\r\n Else\r\n Set objFolder = objFolderTemp\r\n End If\r\n Next i\r\n Set GetFolder = objFolder\r\nEnd Function<\/pre>\n\n
\\\\Outlook\\Posteingang\\Test<\/pre>\n
Outlook\\Posteingang\\Test<\/pre>\n
\n
Public Function KategoriePruefen(objOutlook As Outlook.Application, strKategorie As String) As Boolean\r\n Dim objNamespace As Outlook.NameSpace\r\n Dim i As Integer\r\n Set objNamespace = objOutlook.GetNamespace("MAPI")\r\n For i = 1 To objNamespace.Categories.Count\r\n If objNamespace.Categories(i).Name = strKategorie Then\r\n KategoriePruefen = True\r\n Exit Function\r\n End If\r\n Next i\r\nEnd Function<\/pre>\n![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic013.png\")
<\/p>\nPrivate Sub cmdOrdnerAuswaehlen_Click()\r\n Me!txtZielordner = OrdnerAuswaehlen.FolderPath\r\nEnd Sub<\/pre>\n
Public Function OrdnerAuswaehlen() As Outlook.Folder\r\n Dim objOutlook As Outlook.Application\r\n Dim objFolder As Outlook.Folder\r\n Set objOutlook = New Outlook.Application\r\n Set objFolder = objOutlook.GetNamespace("MAPI").PickFolder\r\n If Not objFolder Is Nothing Then\r\n Set OrdnerAuswaehlen = objFolder\r\n End If\r\nEnd Function<\/pre>\n![\"pic014.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic014.png\")
<\/p>\nPrivate Sub Form_Load()\r\n Dim objOutlook As Outlook.Application\r\n Dim i As Integer\r\n Dim strKategorien As String\r\n Set objOutlook = New Outlook.Application\r\n For i = 1 To objOutlook.GetNamespace("MAPI").Categories.Count\r\n strKategorien = strKategorien & objOutlook.GetNamespace("MAPI").Categories(i) & ";"\r\n Next i\r\n Me!cboKategorieFuerEingeleseneMails.RowSource = strKategorien\r\nEnd Sub<\/pre>\n![\"pic015.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic015.png\")
<\/p>\nPrivate Sub cmdEMailsEinlesen_Click()\r\n Nz(EMailsEinlesen Me!txtZielordner), Nz(Me!cboKategorieFuerEingeleseneMails)\r\nEnd Sub<\/pre>\n
Private Sub cmdQuellordnerAuswaehlen_Click()\r\n DoCmd.OpenForm "frmMailordnerTree"\r\nEnd Sub<\/pre>\n
Private Sub cmdKategoriezuweisungEntfernen_Click()\r\n KategorienEntfernen Me!cboKategorieFuerEingeleseneMails\r\nEnd Sub<\/pre>\n
Public Sub KategorienEntfernen(strKategorie As String)\r\n Dim db As DAO.Database\r\n Dim rstMailordner As DAO.Recordset\r\n Dim objFolder As Outlook.MAPIFolder\r\n Dim obj As Object\r\n Dim objMail As Outlook.MailItem\r\n Dim objOutlook As Outlook.Application\r\n Dim strMailordner As String\r\n Set objOutlook = New Outlook.Application\r\n Set db = CurrentDb\r\n Set rstMailordner = db.OpenRecordset("SELECT * FROM tblMailordner", dbOpenDynaset)\r\n Do While Not rstMailordner.EOF\r\n strMailordner = rstMailordner!Mailordner\r\n Set objFolder = GetFolder(objOutlook, strMailordner, False)\r\n For Each obj In objFolder.Items\r\n If TypeName(obj) = "MailItem" Then\r\n Set objMail = obj\r\n objMail.Categories = Replace(objMail.Categories, strKategorie, "")\r\n objMail.Save\r\n End If\r\n Next obj\r\n rstMailordner.MoveNext\r\n Loop\r\n Set objOutlook = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\nPrivate Sub cmdKundendetails_Click()\r\n DoCmd.OpenForm "frmKundeDetail"\r\nEnd Sub<\/pre>\n
\n
![\"pic016.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic016.png\")
<\/p>\n![\"pic017.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic017.png\")
<\/p>\nBetreffzeile: Wenn(IstNull(DomWert("EMailAdresse";"tblEMailAdressen";"KundeID IS NULL AND EMailAdresse=''" & [Email_From] & "''"));"";" ") & [Betreff]<\/pre>\nPrivate Sub Form_Current()\r\n Me!cboStandardEMailID.RowSource = _\r\n "SELECT EMailAdresseID, EMailAdresse FROM tblEMailAdressen WHERE KundeID = " & Me!KundeID\r\n Me!lstKommunikation.RowSource = _\r\n "SELECT * FROM qryfrmKundeDetail_lstKommunikation WHERE KundeID = " & Me!KundeID\r\n Me!lstKommunikation = Me!lstKommunikation.ItemData(0)\r\n lstKommunikation_AfterUpdate\r\nEnd Sub<\/pre>\n
Private Sub lstKommunikation_AfterUpdate()\r\n Me!txtMail = DLookup("Inhalt", "tblKommunikation", "KommunikationID = "& Nz(Me!lstKommunikation.Column(0),0))\r\nEnd Sub<\/pre>\nPrivate Sub lstKommunikation_DblClick(Cancel As Integer)\r\n Dim objOutlook As Outlook.Application\r\n Dim objMAPI As Outlook.NameSpace\r\n Dim objMail As Outlook.MailItem\r\n Set objOutlook = New Outlook.Application\r\n Set objMAPI = objOutlook.GetNamespace("MAPI")\r\n Set objMail = objMAPI.GetItemFromID(Me!lstKommunikation.Column(4))\r\n objMail.Display\r\nEnd Sub<\/pre>\n![\"pic018.png\"](\"..\/fileadmin\/_temp_\/2013_02\/Kundenkommunikation_2-web-images\/pic018.png\")
<\/p>\n