![\"Eine](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_001.png\")
<\/p>\n<\/p>\n
Bild 1: Eine zum Weiterleiten vorbereitete E-Mail<\/span><\/b><\/p>\n Manchmal kommen E-Mails in Postfächern an, wo man diese nicht optimal weiterverarbeiten kann. Ein Beispiel sind E-Mails von Kunden, die Fragen zur Buchhaltung haben, aber ihre E-Mails an die allgemeine info@-Adresse geschickt haben. Dann können wir diese E-Mail zwar an die Buchhaltungs-Adresse weiterleiten, aber wenn die Buchhaltung dann auf diese E-Mail antworten soll, enthält diese bereits die beim Weiterleiten automatisch eingefügten Elemente – das wirkt auf den Kunden nicht besonders professionell. Oder wir haben eine der vielen “Software As A Service”-Anwendung, die ein eigenes Postfach haben, über das wir Informationen direkt dorthin schicken können. Ein Beispiel ist die Projektverwaltung Trello, der man E-Mails an eine spezielle E-Mail-Adresse zusenden kann, die dann dort automatisch als Aufgaben angelegt werden. In diesem Artikel zeigen wir, wie wir mit wenigen Anweisungen eine Kopie dieser E-Mail an eine weitere Adresse schicken können. Das erledigen wir zunächst durch den Aufruf einer VBA-Prozedur. Anschließend schauen wir uns an, wie wir das auch über die Benutzeroberfläche erledigen können.<\/b><\/p>\n Es gibt verschiedene Gründe, warum man eine E-Mail nicht an eine andere Adresse weiterleiten sollte, sondern diese so dorthin schicken möchte, dass man nicht erkennt, dass es sich um eine Weiterleitung handelt. Wenn wir nämlich die Weiterleiten-Schaltfläche für eine E-Mail betätigen, sehen wir nicht nur das Kürzel WG:<\/b> im Betreff, sondern finden auch noch die Kopfdaten der ursprünglichen E-Mail über dem eigentlichen Inhalt der E-Mail (siehe Bild 1).<\/p>\n Bild 1: Eine zum Weiterleiten vorbereitete E-Mail<\/span><\/b><\/p>\n Wenn man selbst nicht der eigentliche Empfänger einer E-Mail ist und diese so an diesen weiterleiten möchte, dass er diese im Originalzustand erhält (abgesehen von der Empfängeradresse natürlich), gibt es in Outlook nur einen einzigen weg, der außerdem nicht durch einen entsprechenden VBA-Befehl abbildbar ist.<\/p>\n Um diesen Befehl aufzurufen, müssen wir die erneut zu sendende E-Mail zunächst in einem eigenen Inspektor-Fenster öffnen, beispielsweise per Doppelklick auf die E-Mail. Danach finden wir im Ribbon unter Nachricht|Verschieben|Weitere Verschiebeaktionen|Diese Nachricht erneut senden… <\/b>den entsprechenden Befehl (siehe Bild 2).<\/p>\n Bild 2: Erneutes Senden einer E-Mail<\/span><\/b><\/p>\n Dies öffnet die E-Mail so, als ob wir diese gerade erstellt und mit Inhalt gefüllt haben und erlaubt es uns, den Empfänger anzupassen und die E-Mail erneut zu senden.<\/p>\n Es gibt zwar eine 1:1-Entsprechung zu dem Ribbonbefehl Diese Nachricht erneut senden…<\/b> – allerdings können wir diesen Befehl auch nur aufrufen, wenn die erneut zu sendende E-Mail gerade geöffnet ist, also so, also ob wir die E-Mail gerade manuell erneut versenden wollen. Wenn wir die E-Mail einfach nur im Outlook-Hauptfenster markieren, finden wir den Befehl Diese Nachricht erneut senden… <\/b>nirgends im Ribbon.<\/p>\n Wir können auch in den Outlook-Optionen für das Ribbon des E-Mail-Inspektorfensters suchen und finden dort beim Überfahren mit der Maus den Namen des idMso<\/b>-Elements des Ribbons für diese Schaltfläche (siehe Bild 3).<\/p>\n Bild 3: Ermitteln der idMso des Ribbonbefehls Diese Nachricht erneut senden<\/span><\/b><\/p>\n Allerdings funktioniert der Aufruf wie folgt nicht:<\/p>\n Wir müssen uns also zwangsläufig einer anderen Methode behelfen.<\/p>\n Die Lösung ist so einfach wie elegant und erfordert nur wenige Zeilen Code. Die folgende Prozedur fügen wir einfach im Modul ThisOutlookSession <\/b>ein. Die ersten drei Zeilen deklarieren die benötigten Variablen. Die erste das Outlook-Application<\/b>-Objekt, das die Outlook-Anwendung repräsentiert, die beiden übrigen jeweils ein MailItem<\/b>-Objekt – die erste für die erneut zu versendende E-Mail, die zweite für eine Kopie dieser Mail, die wir schließlich an den gewünschten Empfänger senden können:<\/p>\n Danach weisen wir objOutlook <\/b>einen Verweis auf ein neues Outlook-Application<\/b>-Objekt zu. Wir könnten im Kontext des Outlook-VBA-Projekts auch einfach mit Application arbeiten, aber damit wir den Code auch in andere Anwendungen übernehmen können, legen wir dafür direkt eine Variable an. Der Verweis auf New Outlook.Application <\/b>holt entweder die bereits gestartete Instanz oder erstellt eine neue:<\/p>\n Wenn Du diese Prozedur innerhalb von Outlook nutzt, verwende diese Anweisung:<\/p>\n Dann referenzieren wir das erste Element der Selection<\/b>-Auflistung von ActiveExplorer<\/b> und referenzieren es mit objMailItem<\/b>. Sollte aktuell mehr als ein Element markiert sein, wird das erste Element zurückgeliefert:<\/p>\n Dieses Element kopieren wir nun mit der Copy<\/b>-Methode und referenzieren die Kopie mit objMailItemNew<\/b>:<\/p>\n Schließlich stellen wir den Empfänger mit der Eigenschaft To <\/b>auf die gewünschte Zieladresse ein und verwenden die E-Mail mit der Send<\/b>-Methode:<\/p>\n Das war es schon – die aktuell markierte E-Mail wird nun an den angegebenen Adressaten geschickt.<\/p>\n Aktuell müssen wir die erneut zu versendende E-Mail noch markieren und dann im VBA-Editor die Funktion SendAgain <\/b>aufrufen. Das ist schon für uns als Entwickler umständlich und einem einfachen Benutzer sollten wir eine solche Vorgehensweise gar nicht erst zumuten.<\/p>\n Wir haben zwei Ideen, wie wir dies vereinfachen können:<\/p>\n Für die erste Variante reicht es, wenn wir dem Ribbon über die Benutzeroberfläche einen neuen Button hinzufügen. Wir müssen nur noch entscheiden, wo wir diese Schaltfläche platzieren wollen. Wenn wir die erneut zu versendende E-Mail in der Liste der E-Mails markieren, wird kein besonderes Ribbon-Tab aktiviert. Da meist das Tab mit der Beschriftung Start <\/b>angezeigt wird, wollen wir unsere Schaltfläche hier hinzufügen. Ein Makel bei der Ribbonprogrammierung ist, dass wir die eingebauten Group<\/b>-Elemente nicht einfach erweitern oder anpassen können. Das heißt, dass wir entweder eine eingebaute Gruppe ausblenden und diese nachbauen – samt den von uns hinzugefügten Elementen. Oder wir fügen einfach eine eigene Gruppe für unseren Button hinzu.<\/p>\n Um dies zu erledigen, klicken wir oben im Ribbon auf die Schaltfläche mit dem Pfeil nach unten und wählen dort den Eintrag Weitere Befehle … <\/b>aus (siehe Bild 4).<\/p>\n Bild 4: Anzeigen des Editors für das Ribbon<\/span><\/b><\/p>\n Im nun erscheinenden Dialog Outlook-Optionen <\/b>klicken wir links auf Menüband anpassen<\/b>. Dann öffnen wir auf der rechten Seite unter Hauptregisterkarten <\/b>den Eintrag Start (E-Mail)<\/b>, sofern dieser noch nicht ausgeklappt ist. Hier klicken wir den Eintrag an, unter dem wir die neue Gruppe einfügen wollen, in diesem Fall Neu<\/b>. Dann betätigen wir unten die Schaltfläche Neue Gruppe <\/b>und fügen so die in Bild 5 gezeigte Gruppe hinzu.<\/p>\n Bild 5: Hinzufügen einer neuen Gruppe zum Ribbon-Tab Start<\/span><\/b><\/p>\n Diese Gruppe können wir nun nach Wunsch umbenennen, beispielsweise Weitere Verarbeitung<\/b>. Dann wählen wir in der Auswahlliste über der linken Liste den Eintrag Makros <\/b>aus und selektieren dort den Eintrag Projekt1.ThisOutlookSession.SendAgain<\/b>.<\/p>\n Durch Anklicken der Schaltfläche Hinzufügen >> <\/b>fügen wir die Schaltfläche nun zu der neu angelegten und markierten Gruppe hinzu.<\/p>\n Dann klicken wir diesen Befehl an und betätigen die Umbenennen…<\/b>-Schaltfläche ein weiteres Mal. Dies öffnet einen Dialog, der nicht nur die Möglichkeit zum Umbenennen der Schaltfläche anbietet, sondern mit dem wir auch noch ein Icon für die Schaltfläche auswählen können. Die Auswahl ist recht spärlich, dennoch finden wir mit dem eingekreisten Pfeil nach rechts ein passendes Symbol (siehe Bild 6).<\/p>\n Bild 6: Hinzufügen und Anpassen der Schaltfläche zum Aufrufen des Makros<\/span><\/b><\/p>\n Danach schließen wir den Dialog mit der OK<\/b>-Schaltfläche und probieren die neue Schaltfläche aus, die wir wie in Bild 7 vorfinden.<\/p>\n Bild 7: Die neue Schaltfläche im Start-Tab des Ribbons<\/span><\/b><\/p>\n Klicken wir diese Schaltfläche an, während eine E-Mail markiert ist, wird diese durch die Prozedur kopiert und an die angegebene Adresse gesendet. Wir können hier gegebenenfalls noch eine Meldung ausgeben, das die E-Mail erfolgreich neu versendet wurde.<\/p>\n In wenigen Fällen kann es hierbei nämlich zu einem Fehler kommen, der allerdings nicht angezeigt wird. Wenn wir beispielsweise gerade einen leeren Outlook-Ordner anzeigen, der keine E-Mails enthält, löst der Versuch, auf die erste markierte E-Mail zuzugreifen, einen Fehler aus. Das gleiche geschieht, wenn es sich bei dem Eintrag nicht um eine E-Mail, sondern beispielsweise einen Terminvorschlag handelt. Dazu erweitern wir die Prozedur wie folgt:<\/p>\n Wenn wir eine Methode benötigen, mit der wir die gewünschte E-Mail an verschiedene, zuvor festgelegte E-Mail-Adressen versenden können, dann gehen wir wie folgt vor:<\/p>\n Wir beginnen mit den Ordnern, in diesem Fall drei Stück. Wir fügen diese einem Unterordner namens Weiterleiten an… <\/b>hinzu. Dazu nutzen wir jeweils den Kontextmenübefehl Neuer Ordner… <\/b>aus Bild 8. Die Ordner heißen in diesem Fall Buchhaltung<\/b>, Entwicklung <\/b>und Info<\/b>.<\/p>\n Bild 8: Anlegen der Zielordner<\/span><\/b><\/p>\n Wenn wir eine E-Mail in einen dieser Ordner ziehen, soll diese nun automatisch erneut an eine bestimmte E-Mail-Adresse versendet werden. Allerdings haben wir bisher noch nicht festgelegt, wie diese E-Mail-Adresse für die einzelnen Ordner lautet. Wir könnten diese zwar auch als Ordnername angeben, aber wenn wir beispielsweise E-Mails als Aufgaben an eine Anwendung wie Trello schicken wollen, finden wir für jedes Zielboard eine recht kryptische Adresse vor.<\/p>\n Aus diesen können wir nicht entnehmen, in welches Board wir die E-Mails dann senden.<\/p>\n Also legen wir als Ordnernamen eine sprechende Bezeichnung fest und müssen die E-Mail-Adresse für den Ordner an einer anderen Stelle unterbringen, die wir später per VBA abrufen können. Dazu nutzen wir den Eigenschaftsdialog des jeweiligen Ordners, in dem wir die E-Mail-Adresse für die Eigenschaft Beschreibung<\/b> hinterlegen (siehe Bild 9).<\/p>\n Bild 9: Festlegen der Ziel-E-Mail für einen Ordner<\/span><\/b><\/p>\n Für die drei Ordner legen wir nun drei Objektvariablen fest, mit denen wir jeweils die Items<\/b>-Auflistung dieser Ordner referenzieren wollen. Um es vorwegzunehmen: Das Folder<\/b>-Objekt selbst liefert keine Methode, die beim Einfügen eines Elements ausgelöst wird. Allerdings hat jedes Folder<\/b>-Objekt eine Items<\/b>-Auflistung, die wiederum ein Ereignis namens ItemAdd <\/b>liefert, das zu dem von uns benötigten Zeitraum feuert. Die Objektvariablen sehen wir folgt aus:<\/p>\n Diese Items<\/b>-Variablen müssen wir nun mit Verweisen auf die Items<\/b>-Auflistungen unserer Outlook-Ordner füllen. Das erledigen wir in der Prozedur WeiterleitungsordnerAktivieren<\/b> aus Listing 1.<\/p>\n Listing 1: Diese Prozedur initialisiert die Objektvariablen für die Ordner.<\/span><\/b><\/p>\n Diese Prozedur deklariert Elemente für die Outlook-Anwendung, den MAPI-Namespace, in dem sich die Ordner befinden, sowie drei Ordner-Variablen des Typs Folder<\/b>.<\/p>\n Dann referenziert sie die aktuelle oder eine neue Outlook-Instanz und das enthaltene MAPI-Namespace. Danach stellt sie die Variable objFolderBuchhaltung <\/b>auf den Ordner Buchhaltung <\/b>ein. Dazu referenzieren wir über die Variable objMAPI <\/b>jeweils mit der Folders<\/b>-Auflistung die Ordner Outlook<\/b>, Posteingang<\/b>, Weiterleiten an … <\/b>und schließlich Buchhaltung<\/b>. Danach weisen wir der weiter oben deklarierten Variablen objItemsBuchhaltung <\/b>die Items<\/b>-Auflistung dieses Ordners zu. Das Gleiche erledigen wir auch noch für die übrigen beiden Ordner.<\/p>\n Nun können wir die Ereignisprozeduren für die drei Items<\/b>-Variablen implementieren. Dazu wählen wir im Codefenster im linken Kombinationsfeld beispielsweise den Eintrag objItemsBuchhaltung <\/b>aus und im rechten Kombinationsfeld den Eintrag ItemAdd<\/b>. Dies erstellt die Ereignisprozedur objItemsBuchhaltung_ItemAdd<\/b> (siehe Listing 2).<\/p>\n Listing 2: Die Ereignisse, die beim Hinzufügen einer E-Mail zu einem Ordner ausgelöst werden<\/span><\/b><\/p>\n Diese Prozedur liefert mit dem Parameter Item <\/b>einen Verweis auf das Element, das wir der Items<\/b>-Auflistung des mit objFolderBuchhaltung <\/b>referenzierten Ordners hinzufügen. Aus diesem lesen wir als Erstes den Wert der Eigenschaft Description <\/b>aus und schreiben diesen in die Variable strTo<\/b>. Diese Eigenschaft entspricht der Eigenschaft Beschreibung<\/b>, die wir weiter oben über die Benutzeroberfläche von Outlook für den Ordner gefüllt haben. Danach rufen wir die Prozedur SendAgainFolder <\/b>auf und übergeben dieser sowohl einen Verweis auf die verschobene E-Mail als auch die E-Mailadresse, an welche diese geschickt werden soll.<\/p>\n Die Prozedur SendAgainFolder <\/b>hat also die beiden Parameter objMailItem <\/b>und strTo<\/b> (siehe Listing 3).<\/p>\n Listing 3: Die Prozedur, die eine in einen Ordner verschobene E-Mail erneut versendet<\/span><\/b><\/p>\n Auch in dieser referenzieren wir die aktuelle Outlook-Instanz. Außerdem deklarieren wir eine Variable namens objMailItemNew<\/b>, mit der wir die anschließend erstellte Kopie der Original-E-Mail referenzieren.<\/p>\n Das Ganze erledigen wir bei deaktivierter, eingebauter Fehlerbehandlung.<\/p>\n Wenn kein Fehler auftritt, erhalten wir anschließend eine Meldung über den erfolgreichen Versand der E-Mail, ansonsten eine Meldung mit der Angabe des Fehlertextes. Damit ist die Lösung bereits einsatzbereit. Sobald wir einmal die Prozedur WeiterleitungsordnerAktivieren<\/b> aufgerufen haben, werden alle E-Mails, die wir während dieser Session in einen der dafür vorgesehenen Ordner verschieben, an die für diesen Ordner angegebene E-Mail-Adresse versendet.<\/p>\n Wir wollen nun noch dafür sorgen, dass diese Funktion automatisch mit Outlook gestartet wird. Dazu nutzen wir die Ereignisprozedur Startup <\/b>des Application<\/b>-Objekts. Diese können wir einfach wie folgt zum Modul ThisOutlookSession <\/b>hinzufügen:<\/p>\n Nun sind wir nur noch daran gebunden, dass wir für jeden Ordner, den wir unter den Hauptordner Weiterleiten an …<\/b> hinzufügen und zum schnellen Weitersenden von E-Mails nutzen wollen, auch den Code anpassen müssen.<\/p>\n Wir wollen den Code nun noch so anpassen, dass wir einfach nur Ordner hinzufügen und für die Beschreibung die Zieladresse angeben müssen. Den Rest soll der Code automatisch erledigen.<\/p>\n Der Unterschied zum vorherigen Ansatz ist nun, dass wir nicht für die Items<\/b>-Auflistung eines jeden Ordners eine eigene Objektvariable und dementsprechend legen wir auch nicht für jede dieser Variablen eine eigene ItemAdd<\/b>-Ereignisprozedur an. Stattdessen erstellen wir ein Klassenmodul, das beides erfasst, und dem wir auch die Prozedur zum Versenden der E-Mail hinzufügen.<\/p>\n Von diesem Klassenmodul erstellen wir für jeden Unterordner von Weiterleiten an … <\/b>eine Instanz, übergeben dieser einen Verweis auf die Items<\/b>-Auflistung für den aktuellen Ordner. Dann fügen wir die Klassenobjekte noch zu einer Collection hinzu, damit diese nicht aus dem Arbeitsspeicher verschwinden.<\/p>\n Die Collection deklarieren wir zunächst im Modul ThisOutlookSession<\/b>:<\/p>\n Die Prozedur WeiterleitungsordnerAktivieren <\/b>ändern wir wie folgt. Hier erstellen wir zunächst die Collection colItems<\/b>. Dann referenzieren wir den übergeordneten Ordner Weiterleiten an … <\/b>und referenzieren diesen mit objParentfolder<\/b>. Dann durchlaufen wir alle Unterordner von Weiterleiten an … <\/b>und legen für jeden Eintrag eine neue Instanz der Klasse clsItem <\/b>an, weisen der Items<\/b>-Eigenschaft, die wir später beschreiben, die Items<\/b>-Auflistung des aktuellen Ordners zu und fügen die neue Instanz von clsItem <\/b>der Collection colItems <\/b>hinzu:<\/p>\n In der Klasse clsItem<\/b>, die wir in Listing 4 sehen, deklarieren wir eine Variable für die Items<\/b>-Auflistung, und zwar wieder mit dem Schlüsselwort WithEvents<\/b>. Diese Variable füllen wir über eine öffentliche Property Set<\/b>-Eigenschaft, die wir ebenfalls Items<\/b> nennen. Für die Objektvariable m_Items <\/b>fügen wir wie im vorherigen Ansatz die Prozedur für das Ereignis ItemAd <\/b>hinzu. Die enthaltenen Zeilen sehen genauso aus wie die bereits bekannten.<\/p>\n<\/p>\n![\"Erneutes](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_002.png\")
<\/p>\nFunktionalität (fast) nachbauen<\/h2>\n
![\"Ermitteln](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_003.png\")
<\/p>\nApplication.CommandBars.ExecuteMso \"ResendThisMessage\"<\/pre>\n
Mail erneut senden per Kopieren und Senden<\/h2>\n
Public Sub <\/span>SendAgain()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n Dim <\/span>objMailItemNew As <\/span>Outlook.MailItem<\/pre>\n Set<\/span> objOutlook = New<\/span> Outlook.Application<\/pre>\n Set<\/span> objOutlook = Application<\/pre>\n Set<\/span> objMailItem = _\r\n objOutlook.ActiveExplorer.Selection(1)<\/pre>\n Set<\/span> objMailItemNew<\/span> = objMailItem.Copy<\/pre>\n With<\/span> objMailItemNew<\/span>\r\n .To = \"info@amvshop.de\"\r\n .Send\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nFunktion zum erneuten Versenden einfach aufrufen<\/h2>\n
\n
E-Mail schnell per Schaltfläche erneut versenden<\/h2>\n
Neuen Button zum Ribbon hinzufügen<\/h2>\n
![\"Anzeigen](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_004.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_005.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_006.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_007.png\")
<\/p>\nPublic Sub <\/span>SendAgain()\r\n ...\r\n On Error Resume Next<\/span>\r\n ...\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n MsgBox<\/span> \"Erfolgreich neu versendet.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Versenden.\" & vbCrLf<\/span> _\r\n & Err.Description\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nE-Mails durch Ziehen in einen Ordner erneut versenden<\/h2>\n
\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_008.png\")
<\/p>\n![\"Festlegen](\"..\/fileadmin\/_temp_\/2024_05\/pic_442_009.png\")
<\/p>\nCode zum automatischen Versenden von E-Mails beim Einfügen in einen Ordner<\/h2>\n
Public <\/span>WithEvents objItemsInfo As <\/span>Outlook.Items\r\nPublic <\/span>WithEvents objItemsBuchhaltung As <\/span>Outlook.Items\r\nPublic <\/span>WithEvents objItemsEntwicklung As <\/span>Outlook.Items<\/pre>\nAktivieren der Ordner zum erneuten Senden<\/h2>\n
Public Sub <\/span>WeiterleitungsordnerAktivieren()\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objFolderBuchhaltung As <\/span>Outlook.Folder\r\n Dim <\/span>objFolderEntwicklung As <\/span>Outlook.Folder\r\n Dim <\/span>objFolderInfo 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> objFolderBuchhaltung = objMAPI.Folders(\"Outlook\").Folders(\"Posteingang\").Folders(\"Weiterleiten an ...\"). _\r\n Folders(\"Buchhaltung\")\r\n Set<\/span> objItemsBuchhaltung = objFolderBuchhaltung.Items\r\n Set<\/span> objFolderEntwicklung = objMAPI.Folders(\"Outlook\").Folders(\"Posteingang\").Folders(\"Weiterleiten an ...\"). _\r\n Folders(\"Entwicklung\")\r\n Set<\/span> objItemsEntwicklung = objFolderEntwicklung.Items\r\n Set<\/span> objFolderInfo = objMAPI.Folders(\"Outlook\").Folders(\"Posteingang\").Folders(\"Weiterleiten an ...\"). _\r\n Folders(\"Info\")\r\n Set<\/span> objItemsInfo = objFolderInfo.Items\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objItemsBuchhaltung_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>strTo As String<\/span>\r\n strTo = Item.Parent.Description\r\n Call<\/span> SendAgainFolder(Item, strTo)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objItemsEntwicklung_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>strTo As String<\/span>\r\n strTo = Item.Parent.Description\r\n Call<\/span> SendAgainFolder(Item, strTo)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objItemsInfo_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>strTo As String<\/span>\r\n strTo = Item.Parent.Description\r\n Call<\/span> SendAgainFolder(Item, strTo)\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>SendAgainFolder(objMailItem As <\/span>Outlook.MailItem, strTo As String<\/span>)\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMailItemNew As <\/span>Outlook.MailItem\r\n On Error Resume Next<\/span>\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objMailItem = objOutlook.ActiveExplorer.Selection(1)\r\n Set<\/span> objMailItemNew<\/span> = objMailItem.Copy\r\n With<\/span> objMailItemNew<\/span>\r\n .To = strTo\r\n .Send\r\n End With<\/span>\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n MsgBox<\/span> \"Erfolgreich neu versendet.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Versenden.\" & vbCrLf<\/span> & Err.Description\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Application_Startup()\r\n WeiterleitungsordnerAktivieren\r\nEnd Sub<\/span><\/pre>\nUnterordner flexibel hinzufügen<\/h2>\n
Public <\/span>colItems As <\/span>Collection<\/pre>\nPublic Sub <\/span>WeiterleitungsordnerAktivieren()\r\n Dim <\/span>objItem As <\/span>clsItem\r\n Dim <\/span>objOutlook As <\/span>Outlook.Application\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objParentfolder As <\/span>Outlook.Folder\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> colItems = New<\/span> Collection\r\n Set<\/span> objOutlook = New<\/span> Outlook.Application\r\n Set<\/span> objMAPI = objOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objParentfolder = objMAPI.Folders(\"Outlook\"). _\r\n Folders(\"Posteingang\").Folders(\"Weiterleiten an ...\")\r\n For Each objFolder In objParentfolder.Folders\r\n Set<\/span> objItem = New<\/span> clsItem\r\n Set<\/span> objItem.Items = objFolder.Items\r\n colItems.Add objItem\r\n Next<\/span> objFolder\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents m_Items As <\/span>Outlook.Items\r\nPublic Property Set<\/span> <\/span>Items(objItems As <\/span>Outlook.Items)\r\n Set<\/span> m_Items = objItems\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>m_Items_ItemAdd(ByVal Item As Object<\/span>)\r\n Dim <\/span>strTo As String<\/span>\r\n strTo = Item.Parent.Description\r\n