![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_001.png\")
<\/p>\n<\/p>\n
Bild 1: Anlegen einer neuen Regel für eingehende Nachrichten<\/span><\/b><\/p>\n Für eingehende E-Mails gibt es unter Outlook die Regel-Funktion, mit der man einstellen kann, unter welchen Umständen eine E-Mail, die im Posteingang landet, in einen anderen Ordner verschoben werden soll. Das kann man beispielsweise nutzen, um immer wiederkehrende Rechnungen direkt in den entsprechenden Ordner zu verschieben. Wünschenswert wäre, wenn es eine solche Funktion auch für versendete E-Mails gäbe. Da Outlook hier aber keine eingebaute Funktion bereitstellt, schauen wir uns das Thema einmal genauer an und entwickeln VBA-Code, mit dem wir diese Aufgabe selbst steuern können. Dabei wollen wir sowohl über die Benutzeroberfläche gesendete E-Mails erfassen als auch E-Mails, die wir per VBA absenden.<\/b><\/p>\n Wenn wir in Outlook mit der rechten Maustaste auf eine E-Mail in einem beliebigen Ordner klicken, erscheint das Kontextmenü und offeriert uns den Eintrag Regeln|Regel erstellen …<\/b> (siehe Bild 1).<\/p>\n Bild 1: Anlegen einer neuen Regel für eingehende Nachrichten<\/span><\/b><\/p>\n Damit öffnen wir einen Dialog namens Regel erstellen, mit dem wir genauer festlegen können, wann die Regel ausgelöst werden soll und was wir damit bewirken wollen (siehe Bild 2). Wir können hier zum Beispiel angeben, dass nur E-Mails mit einem bestimmten Betreff, für einen bestimmten Empfänger oder von einem bestimmten Absender verarbeitet werden sollen. Außerdem geben wir an, was mit der E-Mail geschehen soll. Hier reichen die Möglichkeiten von einer Benachrichtigung über die Ausgabe eines Sounds bis hin zum Verschieben in einen bestimmten Ordner.<\/p>\n Bild 2: Dialog zum Erstellen einer Regel<\/span><\/b><\/p>\n Diese Regel gelten jedoch nur für Elemente, die frisch im Posteingang gelandet sind. Wenn wir also eine E-Mail erstellen und diese versenden, wird die Regel nicht ausgelöst. Genau diese fehlende Funktion wollen wir im vorliegenden Artikel nachreichen. Dabei gibt es zwei Ansätze:<\/p>\n Da die erste Lösung wesentlich einfacher zu programmieren ist, starten wir mit dieser. Die Programmierung erledigen wir der Einfachheit halber innerhalb des VBA-Projekts von Outlook. Wir verwenden jedoch die volle Referenzierung der Klassen, damit diese auch in anderen Anwendungen eingesetzt werden können. Dort müssen wir lediglich noch einen Verweis auf die Bibliothek Microsoft Outlook 16.0 Object Library <\/b>hinzufügen. Diesen Verweis legen wir im Verweise<\/b>-Dialog an, den wir im VBA-Editor der jeweiligen Anwendung mit dem Menübefehl Extras|Verweise <\/b>öffnen.<\/p>\n Das Versenden eine E-Mail per VBA ist keine Raketentechnik. Und spannenderweise benötigen wir nur noch eine kleine Änderung, damit die gesendete E-Mail nicht im Ordner Gesendete Elemente <\/b>landet, sondern in einem beliebigen anderen Ordner Deiner Wahl.<\/p>\n Dann verwenden wir die Prozedur aus Listing 1. Die Prozedur deklariert zunächst die benötigen Objektvariablen. objOutlook <\/b>füllen wir hier mit einem Verweis auf eine neue Instanz von Outlook, die bei Vorhandensein einer Instanz jedoch mit der bestehenden Instanz gefüllt wird. Mit objMAPI <\/b>referenzieren wir den MAPI-Namespace von Outlook.<\/p>\n Listing 1: Senden einer neuen E-Mail und Verschieben in einen zuvor gewählten Ordner<\/span><\/b><\/p>\n Dieser wiederum erlaubt uns, die PickFolder<\/b>-Funktion zu nutzen, um den Dialog aus aufzurufen, der uns die Auswahl eines beliebigen Ordners erlaubt. Hier wählen wir den Ordner Posteingang <\/b>aus (siehe Bild 3), der nun mit der Variablen objFolder <\/b>referenziert wird.<\/p>\n Bild 3: Auswahl des Zielordners<\/span><\/b><\/p>\n Anschließend erstellen wir ein neues MailItem<\/b>-Objekt mit der CreateItem<\/b>-Methode und dem Parameter olMailItem<\/b>. Für diese legen wir die üblichen Eigenschaften To<\/b>, Subject <\/b>und Body <\/b>fest. Außerdem stellen wir mit der Eigenschaft SaveSendMessageFolder <\/b>auf den zuvor ausgewählten und mit objFolder <\/b>referenzierten Ordner ein. Schließlich rufen wir die Send<\/b>-Methode auf und senden die E-Mail somit.<\/p>\n Sofern wir gerade den Posteingang angezeigt haben, erscheint dort umgehend die gesendete E-Mail (außer, es dauert in Deinem System etwas länger, bis E-Mails den Postausgang verlassen).<\/p>\n Normalerweise möchtest Du nicht immer erneut den Zielordner auswählen. Daher kannst Du diesen auch direkt angeben. Dazu sind zwei Schritte nötig:<\/p>\n Die erste Aufgabe können wir leicht mit der folgenden Prozedur erledigen:<\/p>\n Diese öffnet den bereits weiter oben vorgestellten Dialog zur Auswahl eines Ordners und gibt den Pfad zu dem gefundenen Order als Zeichenkette zurück. Falls der Benutzer die Auswahl durch Anklicken der Abbrechen<\/b>-Schaltfläche abbricht, wird eine leere Zeichenkette zurückgegeben.<\/p>\n Mit diesem Ausdruck, zum Beispiel \\\\Outlook\\Posteingang<\/b>, können wir mit der Funktion GetFolderFromPath <\/b>aus Listing 2 ein Folder<\/b>-Objekt ermitteln. Leider gibt es keine direkte Funktion etwa des NameSpace<\/b>-Objekts, um auf Basis eines Pfades ein Folder<\/b>-Objekt zurückzuliefern. Deshalb holen wir es uns mit einer selbst entwickelten Funktion.<\/p>\n Listing 2: Ermitteln eines Folder-Objekts auf Basis des Pfades<\/span><\/b><\/p>\n Wir übergeben dieser den Pfad zum gewünschten Ordner. Die Funktion deklariert zwei Arrays. Das erste Array benötigen wir für das Ergebnis der Split<\/b>-Funktion, die wir mit dem Trennzeichen \\ <\/b>auf den mit strPath <\/b>gelieferten Pfad anwenden. Damit erzeugen wir ein Array, dass die an den Backslash-Zeichen aufgesplittete Zeichenketten aus strPath <\/b>erhält. Bei \\\\Outlook\\Posteingang <\/b>ist das Element mit dem Index 0 <\/b>eine leere Zeichenkette, das mit dem Index 1 <\/b>auch, der Index 2 <\/b>enthält Outlook <\/b>und der Index 3 <\/b>enthält Posteingang<\/b>.<\/p>\n Das zweite Array soll alle Elemente des ersten Arrays erhalten, die keine leere Zeichenkette enthalten. Dazu durchlaufen wir eine For…Next<\/b>-Schleife über alle Elemente aus strFolders <\/b>und prüfen, ob das aktuelle Element eine leere Zeichenkette enthält. Falls nicht, dimensionieren wir das Array strFolderNames <\/b>in der entsprechenden Größe und hängen das aktuelle Element des ersten Arrays hinten an.<\/p>\n Nun können wir auf Outlook zugreifen, uns das MAPI-Namespace holen und erst einmal den Ordner referenzieren, der den Namen aus dem ersten Element von strFolderNames <\/b>enthält. Danach durchlaufen wir die übrigen Elemente des Arrays strFolderNames <\/b>und ermitteln das jeweils nächste untergeordnete Element aus der Folders<\/b>-Auflistung. Dieses weisen wir wieder der Variablen objFolder <\/b>zu. Auf diese Weise arbeiten wir uns bis zum untersten Folder<\/b>-Element durch und geben dieses schließlich als Funktionsergebnis zurück.<\/p>\n Damit ausgestattet können wir die eingangs beschriebene Prozedur wie folgt anpassen, wenn wir wollen, dass die versendete E-Mail direkt im Posteingang landet:<\/p>\n Statt dem Posteingangsordner können wir hier auch jeden anderen Ordner angeben.<\/p>\n Damit haben wir das Verschieben von per VBA erstellten E-Mails in den gewünschten Ordner bereits programmiert und können uns nun einer anspruchsvolleren Aufgabe zuwenden – dem Verschieben E-Mails, die wir über die Benutzeroberfläche von Outlook gesendet haben.<\/p>\n Warum ist das anspruchsvoller? Weil es nicht ausreicht, sich einfach nur in den Prozess reinzuhängen, mit dem die E-Mail verschickt wird. Sondern wir müssen irgendwie ein Ereignis abfangen, das ausgelöst wird, wenn der Benutzer die E-Mail versendet hat. Welches nutzen wir hier optimalerweise? Woran erkennen wir, dass eine E-Mail versendet wurde?<\/p>\n Offensichtlich ist eine E-Mail erst dann erfolgreich versendet worden, wenn sie im Ordner Gesendete Objekte <\/b>gelandet ist. Wir müssen also ein Ereignis definieren, das ausgelöst wird, wenn ein Element zu diesem Ordner hinzugefügt wird. Dann brauchen wir noch eine Möglichkeit, die Regeln festzulegen, nach denen wir bestimmte E-Mails vom Ordner Gesendete Objekte <\/b>in den gewünschten Ordner übertragen.<\/p>\n Wir schauen uns zunächst einmal die Basisversion ohne Regeln an. Während es beim ersten Beispiel keine Rolle spielte, ob wir den Code in einem Standardmodul oder einen Klassenmodul wie ThisOutlookSession <\/b>angelegt haben, kommt dies nun zum Tragen. Wir wollen eine Objektvariable mit dem Schlüsselwort WithEvents <\/b>deklarieren, damit wir seine Ereignisse implementieren wollen.<\/p>\n Deshalb fügen wir den Code in das Modul ThisOutlookSession <\/b>im VBA-Projekt von Outlook ein. Wenn Du diesen Code im VBA-Projekt einer anderen Anwendung nutzen möchtest, musst Du die folgenden Elemente in ein Klassenmodul einfügen, das Du dann initialisierst – wir zeigen später, wie das gelingt.<\/p>\n Wir deklarieren erst einmal die Objektvariable für eine Items<\/b>-Auflistung, über die wir die im Ordner Gesendete Elemente <\/b>enthaltenen Elemente referenzieren:<\/p>\n Dann rufen wir eine Prozedur namens Aktivieren auf. Diese referenziert die aktuelle Outlook-Instanz und darüber den MAPI-Namespace und den Ordner Gesendete Elemente<\/b>, den wir mit der Funktion GetDefaultFolder <\/b>mit dem Parameter olFolderSentMail <\/b>holen. Dessen Items<\/b>-Auflistung weisen wir schließlich der oben definierten Variablen objItems <\/b>zu:<\/p>\n Schließlich implementieren wir das Ereignis ItemAdd <\/b>der Objektvariablen objItems<\/b>. Dazu wählen wir objItems <\/b>im linken Listenfeld des VBA-Fensters aus und erhalten so automatisch eine neue, leere Ereignisprozedur für das Standardereignis ItemAdd <\/b>dieser Klasse. Diese füllen wir wie folgt:<\/p>\n Diese Ereignisprozedur liefert mit dem Parameter Item<\/b> einen Verweis auf das zum Ordner Gesendete Elemente <\/b>hinzugefügten Elements. Wir prüfen, ob es sich dabei um ein Element des Typs MailItem <\/b>handelt. Falls ja, referenzieren wir es mit der Variablen objMailItem <\/b>und ermitteln für objFolder <\/b>den Zielordner, in diesem Fall \\\\Outlook\\Posteingang <\/b>(nicht, dass dieser Zielordner sinnvoll wäre, aber wie sehen diesen beim Experimentieren direkt).<\/p>\n Dann rufen wir die Methode Move <\/b>auf und übergeben als Parameter den Verweis auf den Ordner, in den die E-Mail verschoben werden soll.<\/p>\n Wenn wir nun eine E-Mail senden, wird diese automatisch direkt in den Posteingang verschoben.<\/p>\n Nun wird die Objektvariable objItems <\/b>beim Beenden von Outlook automatisch geleert und beim Neustart nicht automatisch wieder gefüllt. Das können wir jedoch erreichen, indem wir die Funktion Aktivieren <\/b>automatisch beim Start von Outlook aufrufen. Das erledigen wir, indem wir den Aufruf einfach in die folgende Prozedur eintragen:<\/p>\n Diese Prozedur wird, wenn sie in der Klasse ThisOutlookSession <\/b>platziert ist, beim Start von Outlook gestartet.<\/p>\n Damit fehlt uns noch die Möglichkeit, verschiedene Bedingungen hinzuzufügen und festzulegen, in welchen Ordner die E-Mails je nach Bedingung landen sollen. <\/p>\n Hier müssen wir uns erst einmal überlegen, welche Bedingungen wir nutzen wollen. Typischerweise ist oft der Adressat der E-Mail interessant für eine solche Bedingung. Manche Adressaten sind mit speziellen Rollen verknüpft, in deren Kontext es oft entsprechende Ordner in Outlook gibt. Ein Beispiel: E-Mails an die Steuerberaterin sollen im Ordner Buchhaltung <\/b>landen. Oder E-Mails an Partner oder Partnerin in einem Ordner namens Privat<\/b>. Manchmal gibt es auch Ordner für den E-Mail-Austausch mit bestimmten Dienstleistern – auch hier ist es sinnvoll, diese E-Mails am Empfänger zu identifizieren und sie gleich in den entsprechenden Ordner zu verschieben.<\/p>\n Auch wenn wir die E-Mail-Adresse des Adressaten einer E-Mail mit der To<\/b>-Eigenschaft angegeben haben, können wir diese noch längst nicht über diese Eigenschaft auslesen. <\/p>\n Wenn wir die E-Mail-Adresse des Empfängers in die E-Mail eingeben, erscheinen in der Regel Vorschläge für dem Empfänger. Hier wird neben der E-Mail-Adresse manchmal auch noch eine weitere Information angezeigt (siehe Bild 4). Wenn wir diese auswählen oder die dort verwendete E-Mail-Adresse eingeben, stellt Outlook den Wert für To <\/b>automatisch auf den oben angezeigten Wert ein. Wir sollten die Bedingung also nicht so gestalten, dass wir das To<\/b>-Feld nach einer E-Mail durchsuchen. Tatsächlich kann To <\/b>sogar mehrere E-Mail-Adressen aufnehmen.<\/p>\n Bild 4: Ein Alias für die E-Mail-Adresse<\/span><\/b><\/p>\n Um an die tatsächlich hinter der Adresse steckende E-Mail-Adresse zu kommen, verwenden wir die Recipients<\/b>-Auflistung des MailItem<\/b>-Objekts. Wenn wir für To<\/b>\/An <\/b>mehrere Empfänger eingegeben haben, enthält die Recipients<\/b>-Auflistung entsprechend viele Einträge. Wir müssten also eigentlich alle Einträge durchlaufen und dann prüfen, ob die gesuchte E-Mail-Adresse in der Auflistung enthalten ist. Das lassen wir an dieser Stelle aus und prüfen stattdessen nur die erste darin enthaltene E-Mail-Adresse. Das sollte für unseren Fall ausreichen, denn die meisten E-Mails in Zusammen mit Buchhaltung oder bestimmten Geschäftspartnern werden meist an einen Ansprechpartner geschickt. Sollen noch weitere Personen informiert werden, nutzt man normalerweise das Feld Cc.<\/p>\n Betrachten wir nur diesen Fall, können wir die Version der Prozedur objItems_ItemAdd<\/b> aus Listing 3 verwenden. Hier untersuchen wir die verschiedenen Bedingungen in einer Select Case<\/b>-Bedingung. Da wir als Vergleichskriterium den Wert True <\/b>angegeben haben, können wir in die Case<\/b>-Zweige Bedingungen wie die folgende einfügen:<\/p>\n Listing 3: Verschieben von E-Mails mit verschiedenen Bedingungen<\/span><\/b><\/p>\n Wir prüfen hier zum Beispiel, ob innerhalb der Adresse des ersten angegebenen Empfängers die E-Mail-Adresse info@amvshop.de <\/b>befindet. Ist das der Fall, füllen wir die objFolder<\/b>-Variable mit dem Ordner, in den E-Mails mit dieser Empfängeradresse landen sollen.<\/p>\n Nach der Select Case<\/b>-Bedingung prüft die Prozedur, ob objFolder <\/b>einen Verweis auf einen Ordner enthält und verschiebt die E-Mail in diesen Ordner.<\/p>\n Auf die gleiche Weise haben wir noch einen Case<\/b>-Zweig für die E-Mail-Adresse andre@minhorst<\/b>.com hinzugefügt. Mails an diese Adresse sollen in den Ordner \\\\Outlook\\Posteingang\\Buchhaltung <\/b>verschoben werden.<\/p>\n Nun können wir sicher für unsere eigenen Zwecke die Bedingungen zum Verschieben versendeter E-Mails wie hier geschehen direkt im Quellcode verwalten. Unseren Benutzern sollten wir das aber nicht zumuten. Daher suchen wir nun nach einem Weg, um die Bedingungen anderweitig zu verwalten. Optimal wäre ein Formular, in das wir in einer Liste jeweils links die Empfänger-E-Mail-Adresse speichern könnten und rechts den Ordner, in den diese E-Mails nach dem Senden verschoben werden sollen.<\/p>\n Allerdings bietet Outlook keine einfache Möglichkeit, dies zu erledigen. Ein Kompromiss könnte eine Textdatei sein, in die der Benutzer die verschiedenen Kombinationen aus Empfängeradressen und Ordnern eintragen kann – getrennt durch ein Zeichen wie beispielsweise das Pipe-Zeichen (|<\/b>).<\/p>\n Diese Textdatei soll beispielsweise wie in Bild 5 aussehen. Nun benötigen wir noch zwei Dinge:<\/p>\n Bild 5: Textdatei mit den Zuordnungen der E-Mails zu den Ordnern<\/span><\/b><\/p>\n Wo wir diese Datei speichern, können wir dem Benutzer überlassen – er muss dann einmalig im Code in einer Konstanten den Speicherort festlegen. Diesen kann er dann nach Bedarf anpassen.<\/p>\n Damit haben wir allerdings noch keine Lösung dafür, wie der Benutzer diese Datei schnell öffnen kann. Dazu bieten wir am besten einen Ribbonbefehl an.<\/p>\n Wenn der Benutzer diesen anklickt, soll die Datei automatisch im jeweiligen Texteditor geöffnet werden. Um eine solche Schaltfläche hinzuzufügen, gibt es zwei Möglichkeiten:<\/p>\n Die erste Idee schauen wir uns gleich in diesem Artikel an, die zweite betrachten wir in einem eigenen Artikel namens Outlook: Gesendete Mails per COM-Add-In verschieben <\/b>(www.vbentwickler.de\/441<\/b>).<\/p>\n Wir legen eine Konstante zum Speichern des Pfades zur Konfigurationsdatei an:<\/p>\n Außerdem hinterlegen wir eine Prozedur, mit der wir diese Datei öffnen können:<\/p>\n Die hier verwendete API-Funktion hinterlegen wir gleich in zwei Versionen für die 64-Bit und die 32-Bit-Variante:<\/p>\n Außerdem benötigen wir die folgende Konstante:<\/p>\n Dies alles legen wir in einem Standardmodul an. Rufen wir nun die Prozedur OpenConfigurationFile <\/b>auf, erscheint die Textdatei im Texteditor.<\/p>\n Nun wollen wir diese Prozedur über das Ribbon verfügbar machen.<\/p>\n Dazu wechseln wir zum Hauptfenster von Outlook und klicken oben im Ribbon auf die Schaltfläche mit dem nach unten zeigenden Pfeil und wählen danach den Eintrag Weitere Befehle… <\/b>aus (siehe Bild 6).<\/p>\n Bild 6: Anzeigen der Ribbon-Optionen<\/span><\/b><\/p>\n Im nun erscheinenden Dialog Outlook-Optionen <\/b>wechseln wir zunächst zum Bereich Menüband anpassen<\/b>. Dann wählen wir unter Befehle auswählen den Eintrag Makros <\/b>aus (siehe Bild 7).<\/p>\n Bild 7: Erweitern des Ribbons um einen benutzerdefinierten Makroaufruf<\/span><\/b><\/p>\n In der Liste unter dem Auswahlfeld finden wir nun auch den Eintrag Project1.ThisOutlookSession.OpenConfigurationFile <\/b>vor (siehe Bild 8).<\/p>\n Bild 8: Die soeben erstellte Prozedur<\/span><\/b><\/p>\n Um diesen zum Ribbon hinzuzufügen, wollen wir zuvor noch einen guten Ort dafür finden. Da sich die hier programmierte Aktion auf die Ordner bezieht, halten wir das Tab Ordner <\/b>für einen guten Ort – am Besten im Bereich Eigenschaften<\/b> (siehe Bild 9). Allerdings können wir bestehenden Gruppen keine Elemente zuweisen. Wir haben an dieser Stelle zwei Möglichkeiten:<\/p>\n Bild 9: Hier wollen wir unsere Schaltfläche einfügen.<\/span><\/b><\/p>\n Wir haben nur die drei Elemente hinzugefügt, die wir auch im Ribbon sehen, und unseren benutzerdefinierten Befehl.<\/p>\n Diesen haben wir noch umbenannt, denn wir wollen dort nicht den Text Project1.ThisOutlookSession.OpenConfigurationFile<\/b> sehen, sondern beispielsweise Konfiguration für gesendete Elemente<\/b> (siehe Bild 10). Hier wählen wir außerdem aus den wenigen verfügbaren Icons das am sinnvollsten erscheinende aus.<\/p>\n Bild 10: Hinzufügen einer eigenen Gruppe<\/span><\/b><\/p>\n Nun klicken wir noch mit der rechten Maustaste auf die eingebaute Gruppe Eigenschaften <\/b>und wählen für diese den Befehl Entfernen<\/b> aus (siehe Bild 11).<\/p>\n Bild 11: Entfernen der eingebauten Gruppe<\/span><\/b><\/p>\n Nun schließen wir den Dialog Outlook-Optionen <\/b>und schauen uns das Ribbon im Bereich <\/p>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_002.png\")
<\/p>\n\n
Per VBA gesendete E-Mails in anderen Ordner verschieben<\/h2>\n
Public Sub <\/span>EMailSendenUndVerschieben()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n \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 \r\n Set<\/span> objMailItem = Application.CreateItem(olMailItem)\r\n With<\/span> objMailItem\r\n .To = \"Info@amvshop.de\"\r\n .Subject = \"Betreff der E-Mail\"\r\n .Body = \"Dies ist der Inhalt der E-Mail.\"\r\n Set<\/span> .SaveSentMessageFolder = objFolder\r\n .Send\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_003.png\")
<\/p>\nZielordner ohne Auswahldialog festlegen<\/h2>\n
\n
Public Function <\/span>GetPickFolderPath() As String<\/span>\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 GetPickFolderPath = objFolder.FolderPath\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetFolderFromPath(strPath As String<\/span>) As <\/span>Outlook.Folder\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 Dim <\/span>strFolders() As String<\/span>\r\n Dim <\/span>strFolderNames() As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n strFolders = Split<\/span>(strPath, \"\\\")\r\n For i = LBound<\/span>(strFolders) To UBound<\/span>(strFolders)\r\n If <\/span>Not<\/span> Len<\/span>(strFolders(i)) = 0 Then<\/span>\r\n ReDim Preserve strFolderNames(j)\r\n strFolderNames(j) = strFolders(i)\r\n j = j + 1\r\n End If<\/span>\r\n Next<\/span> i\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objMAPI = objOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = objMAPI.Folders(strFolderNames(0))\r\n For j = LBound<\/span>(strFolderNames) + 1 To UBound<\/span>(strFolderNames)\r\n Set<\/span> objFolder = objFolder.Folders(strFolderNames(j))\r\n Next<\/span> j\r\n Set<\/span> GetFolderFromPath = objFolder\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>EMailSendenUndVerschiebenNachPfad()\r\n ...\r\n Set<\/span> objFolder = _\r\n GetFolderFromPath(\"<\/font>Outlook\\Posteingang\\\")\r\n ...\r\nEnd Sub<\/span><\/pre>\nPer Outlook gesendete E-Mails in anderen Ordner verschieben<\/h2>\n
Public <\/span>WithEvents objItems As <\/span>Outlook.Items<\/pre>\nPublic Sub <\/span>Aktivieren()\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 = Application ''New<\/span> Outlook.Application\r\n Set<\/span> objMAPI = objOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = _\r\n objMAPI.GetDefaultFolder(olFolderSentMail)\r\n Set<\/span> objItems = objFolder.Items\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objItems_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>objMailitem As <\/span>Outlook.MailItem\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Select Case TypeName(Item)\r\n Case <\/span>\"MailItem\"\r\n Set<\/span> objMailitem = Item\r\n Set<\/span> objFolder = _\r\n GetFolderFromPath(\"<\/font>Outlook\\Posteingang\")\r\n objMailitem.Move objFolder\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nBeim Start automatisch aktivieren<\/h2>\n
Private Sub <\/span>Application_Startup()\r\n Call<\/span> Aktivieren\r\nEnd Sub<\/span><\/pre>\nE-Mail des Adressaten auslesen<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_004.png\")
<\/p>\nPrivate Sub <\/span>objItems_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>objMailitem As <\/span>Outlook.MailItem\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Select Case TypeName(Item)\r\n Case <\/span>\"MailItem\"\r\n Set<\/span> objMailitem = Item\r\n Select Case True<\/span>\r\n Case <\/span>Not<\/span> InStr<\/span>(1, objMailitem.Recipients(1).Address, \"info@amvshop.de\") = 0\r\n Set<\/span> objFolder = GetFolderFromPath(\"<\/font>Outlook\\Posteingang\\Bestellungen\")\r\n Case <\/span>Not<\/span> InStr<\/span>(1, objMailitem.Recipients(1).Address, \"andre@minhorst.com\") = 0\r\n Set<\/span> objFolder = GetFolderFromPath(\"<\/font>Outlook\\Posteingang\\Buchhaltung\")\r\n End Select<\/span>\r\n If <\/span>Not<\/span> objFolder Is Nothing Then<\/span>\r\n objMailitem.Move objFolder\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nNot<\/span> InStr<\/span>(1, objMailitem.Recipients(1).Address, _\r\n \"info@amvshop.de\") = 0<\/pre>\n![\"Textdatei](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_005.png\")
<\/p>\n\n
Konfigurationsdatei schnell verfügbar machen<\/h2>\n
\n
Prozedur zum Öffnen der Konfigurationsdatei<\/h2>\n
Private <\/span>Const cStrPath As String<\/span> = _\r\n \"C:\\...\\SentMailFolders.txt\"<\/pre>\nPublic Sub <\/span>OpenConfigurationFile()\r\n ShellExecuteA 0, \"Open\", cStrPath, vbNullString, vbNullString, SW_NORMAL\r\nEnd Sub<\/span><\/pre>\n#If Win64 Then\r\n Public <\/span>Declare PtrSafe Function ShellExecuteA Lib _\r\n \"Shell32\" (ByVal hWnd As Long<\/span>Ptr, ByVal _\r\n lpOperation As String<\/span>, ByVal lpFile As String<\/span>, _\r\n ByVal lpParameters As String<\/span>, ByVal lpDirectory _\r\n As String<\/span>, ByVal nCmdShow As Long<\/span>) As Long<\/span>\r\n#Else\r\n Public <\/span>Declare Function ShellExecuteA Lib \"Shell32\" _\r\n (ByVal hWnd As Long<\/span>, ByVal lpOperation As <\/span>_\r\n String, ByVal lpFile As String<\/span>, ByVal _\r\n lpParameters As String<\/span>, ByVal lpDirectory As <\/span>_\r\n String, ByVal nCmdShow As Long<\/span>) As Long<\/span>\r\n#End If<\/pre>\nPublic <\/span>Const SW_NORMAL = 1<\/pre>\nRibbon um Schaltfläche zum Öffnen der Textdatei erweitern<\/h2>\n
![\"Anzeigen](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_007.png\")
<\/p>\n![\"Erweitern](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_006.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_008.png\")
<\/p>\n![\"Hier](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_009.png\")
<\/p>\n\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_010.png\")
<\/p>\n![\"Entfernen](\"..\/fileadmin\/_temp_\/2024_05\/pic_440_011.png\")
<\/p>\n