<\/p>\n
Outlook-Termine, die man über verschiedene Clients pflegt, möchte man vielleicht später einmal nach Access exportieren, um diese dort beispielsweise für die Erfassung der Projektzeiten beim Kunden heranzuziehen. Dafür gibt es verschiedene Methoden. Outlook selbst bietet einen Export an, mit dessen Ergebnis Sie arbeiten können. Oder Sie greifen direkt von Access aus per VBA auf das Objektmodell von Outlook zu, um die Termine Stück für Stück einzulesen. Dieser Beitrag zeigt, was es dabei zu beachten gibt und wie Sie auch benutzerdefinierte Felder in Terminen einlesen können.<\/b><\/p>\n
Export per Bordmittel<\/b><\/p>\n
Als Erstes schauen wir uns die Bordmittel zum Exportieren von Outlook-Terminen an, denn wir wollen ja keine aufwendige Access-Programmierung starten, wenn es auch einfach geht.<\/p>\n
Den notwendigen Befehl finden Sie in Outlook 2016 im Backstage-Bereich unter Öffnen und Exportieren<\/b>. Die benötigte Schaltfläche heißt Importieren\/Exportieren <\/b>(siehe Bild 1).<\/p>\n
![\"Befehl](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_001.png\")
<\/p>\n
Bild 1: Befehl zum Exportieren von Outlook-Daten<\/span><\/b><\/p>\n Nachdem wir diese Taste betätigt haben, finden wir den Dialog Import\/Export-Assistent <\/b>vor.<\/p>\n Dieser bietet nur einen für uns interessanten Eintrag in der Liste der Aktionen an, nämlich In Datei exportieren<\/b> (siehe Bild 2).<\/p>\n Bild 2: Import- und Export-Möglichkeiten<\/span><\/b><\/p>\n Der nach der Auswahl von In Datei exportieren <\/b>und dem Betätigen der Weiter<\/b>-Schaltfläche angezeigte Dialog bietet wiederum zwei Möglichkeiten an:<\/p>\n Hier wählen wir den Eintrag Durch Trennzeichen getrennte Werte <\/b>aus und klicken wiederum auf Weiter <\/b>(siehe Bild 3).<\/p>\n Bild 3: Export in eine Liste mit Trennzeichen<\/span><\/b><\/p>\n Das öffnet die nächste Seite des Dialogs und wir finden die Ordnerstruktur von Outlook vor (siehe Bild 4). Hier suchen wir nach dem Ordner Kalender <\/b>und markieren diesen, bevor wir zum nächsten Schritt wechseln.<\/p>\n Bild 4: Export der Kalenderdaten<\/span><\/b><\/p>\n Hier legen wir fest, in welche Datei die Termindaten exportiert werden sollen. Dazu geben Sie entweder Pfad und Datei ein oder wählen diese mit dem Dialog aus, den Sie über die Durchsuchen…<\/b>-Schaltfläche öffnen können (siehe Bild 5).<\/p>\n Bild 5: Angabe der Exportdatei<\/span><\/b><\/p>\n Danach wird es interessanter: Im nun erscheinenden Übersichtsdialog öffnen Sie über die Schaltlfäche Benutzerdefinierte Felder <\/b>zuordnen einen weiteren Dialog namens Benutzerdefinierte Felder zuordnen<\/b> öffnen.<\/p>\n Hier können Sie festlegen, welche der Felder überhaupt exportiert werden sollen und mit welcher Spaltenüberschrift diese versehen werden sollen (siehe Bild 6).<\/p>\n Bild 6: Zuordnen der Felder an die Spalten der Exportdatei<\/span><\/b><\/p>\n Haben Sie diese Liste nach Ihren Wünschen bearbeitet, schließen Sie den Dialog wieder und führen den Export mit einem Klick auf die Schaltfläche Fertigstellen <\/b>aus.<\/p>\n Danach erscheint noch ein abschließender Dialog namens Zeitraum festlegen<\/b> (siehe Bild 7). Hier können Sie den vom Export vorgeschlagenen Zeitraum anpassen. Außerdem erhalten Sie hier den Hinweis, dass von Termin- und Aufgabenserien, die in diesen Zeitraum fallen, nur die Termine dieses Zeitraums berücksichtigt werden.<\/p>\n Bild 7: Festlegen des Zeitraums<\/span><\/b><\/p>\n Danach geht der Export endlich los und Sie können den Fortschritt im Dialog aus Bild 8 verfolgen.<\/p>\n Bild 8: Exportfortschritt<\/span><\/b><\/p>\n Danach schauen wir uns die Export-Datei direkt in Excel an. Bild 9 zeigt nur zwei Termine an, die so aus Outlook in die .csv<\/b>-Datei exportiert wurden.<\/p>\n Bild 9: Export von zwei Terminen<\/span><\/b><\/p>\n Die erste Zeile enthält die Spaltenüberschriften, die zweite den ersten Termin, die folgenden Zeilen den zweiten Termin. Dieser erstreckt sich über mehrere Zeilen, weil der Inhalt des Feldes Beschreibung <\/b>mit Text gefüllt ist. Dies ist der Fall, wenn ein Termin erstellt wurde, indem der Benutzer eine Aufgabe in den Kalender gezogen hat.<\/p>\n Analyse des Ergebnisses<\/b><\/p>\n Wenn wir uns das Ergebnis anschauen, finden wir ein paar Nachteile vor. Der erste ist, dass wir unter anderem Termine haben, die mehrere Zeilen in Beschlag nehmen. Der zweite ist, dass wir hier sicher nicht alle Eigenschaften vorfinden, die ein Termin hat – zumindest die benutzerdefinierten Eigenschaften wurden nicht mitexportiert.<\/p>\n Zusammenfassend scheint es also praktischer zu sein, direkt per VBA auf die Termine und ihre Eigenschaften zuzugreifen.<\/p>\n Zugriff per VBA<\/b><\/p>\n Um von einer Access-Datenbank auf Outlook zuzugreifen, benötigen wir einen Verweis auf die entsprechende Objektbibliothek. Diese binden wir im VBA-Editor über den Menüeintrag Extras|Verweise <\/b>ein, der den Dialog Verweise <\/b>öffnet. Hier wählen wir den Eintrag Microsoft Outlook 16.0 Object Library <\/b>aus (für Office 2016 – sonst wählen Sie die verfügbare Version für die aktuelle Office-Installation). Das Ergebnis sieht dann im Verweise<\/b>-Dialog wie in Bild 10 aus.<\/p>\n Bild 10: Verweis auf die Outlook-Bibliothek<\/span><\/b><\/p>\n Outlook referenzieren<\/b><\/p>\n Als Erstes benötigen wir eine Objektvariable, mit der wir die geöffnete Outlook-Instanz referenzieren oder eine neue erstellen. Das realisieren wir, indem wir zunächst eine privat deklarierte Objektvariable in einem neuen Standardformular anlegen:<\/p>\n Diese füllen wir mit der Funktion GetOutlook<\/b>. Sie prüft, ob m_Outlook <\/b>den Wert Nothing <\/b>enthält. Falls ja, wird m_Outlook <\/b>mit einer mit dem New<\/b>-Schlüsselwort erzeugten neuen Instanz gefüllt. Danach liefert GetOutlook <\/b>den Wert von m_Outlook <\/b>als Funktionswert zurück. Damit braucht m_Outlook <\/b>nur beim ersten Aufruf gefüllt zu werden und die Funktion kann bei folgenden Aufrufen auf die bereits existierende Instanz zugreifen:<\/p>\n Das New<\/b>-Schlüsselwort holt übrigens nur eine neue Outlook-Instanz, wenn keine Instanz läuft.<\/p>\n Dies kann zum Beispiel in dem Fall schiefgehen, wenn eine Outlook-Instanz durch den Benutzer geöffnet wurde, die obige Prozedur m_Outlook <\/b>mit einem Verweis auf diese Instanz füllt, der Benutzer Outlook über die Benutzeroberfläche schließt und GetOutlook <\/b>dann nochmals auf m_Outlook <\/b>zugreift.<\/p>\n In diesem Fall löst der Zugriff auf eine der Eigenschaften des Outlook-Application<\/b>-Objekts den Fehler aus Bild 11 aus, weil die Objektvariable ein ungültiges Objekt enthält.<\/p>\n Bild 11: Fehler beim Zugriff auf eine leere Objektvariable<\/span><\/b><\/p>\n Also erweitern wir die Funktion ein wenig:<\/p>\n Hier versuchen wir nun, bei deaktivierter Fehlerbehandlung auf die Eigenschaft Name <\/b>von m_Outlook <\/b>zuzugreifen. Wenn m_Outlook <\/b>zu diesem Zeitpunkt nicht korrekt gefüllt, löst dies einen Fehler aus, den wir mir der folgenden If…Then<\/b>-Bedingung abfragen und m_Outlook <\/b>gegebenenfalls mit einer neuen Outlook-Instanz füllen.<\/p>\n Ordner mit Terminen referenzieren<\/b><\/p>\n Danach benötigen wir Zugriff auf den Ordner mit den Terminen. Wie bekommen wir diesen Dazu gibt es mehrere Möglichkeiten. Die gängigste ist, den Standardordner für die Termine aufzurufen. Das gelingt mit der folgenden Funktion:<\/p>\n Hier holen wir erst den MAPI<\/b>-Namespace über die GetNamespace<\/b>-Methode des mit GetOutlook <\/b>referenzierten Outlook.Application<\/b>-Objekts und referenzieren diesen mit der Variablen objMAPI<\/b>. Dann verwenden wir dessen Funktion GetDefaultFolder <\/b>mit dem Parameter olFolderCalendar<\/b>. Die Funktion gibt das erhaltene Objekt dann als Verweis des Typs Outlook.Folder <\/b>an die aufrufende Anweisung zurück.<\/p>\n Damit können Sie nun beispielsweise den Pfad zu diesem Ordner innerhalb von Outlook mit folgender Anweisung ausgeben:<\/p>\n <\/p>\n In einer aufrufenden Prozedur können wir den Verweis auf dieses Folder<\/b>-Objekt nun auch in einer Objektvariablen speichern und dann weiter damit arbeiten:<\/p>\n Ordner selbst auswählen<\/b><\/p>\n Sie können dem Benutzer auch die Möglichkeit geben, einen anderen Ordner als Kalenderordner auszuwählen. Das ist beispielsweise sinnvoll, wenn die zu untersuchenden Termine sich nicht im Standardordner befinden, sondern in einem anderen Termin-Ordner.<\/p>\n Die folgende Funktion öffnet einen entsprechenden Dialog:<\/p>\n Hier nutzen wir die Funktion PickFolder,<\/b> um den Dialog zum Öffnen des Dialogs Ordner auswählen <\/b>(siehe Bild 12).<\/p>\n Bild 12: Dialog zum Auswählen eines Outlook-Ordners<\/span><\/b><\/p>\n Hier ist leicht zu erkennen, dass Sie beliebige Ordner auswählen können. Wie also prüfen wir, ob der Benutzer auch einen Kalender-Ordner ausgewählt hat Wenn wir später auf die enthaltenen Elemente zugreifen, wollen wir ja keine Fehler auslösen, weil der Ordner E-Mails, Kontakte oder andere Elemente statt Terminen liefert.<\/p>\n Dazu erweitern wir die Funktion nach dem Einlesen des Ordners mit PickFolder <\/b>um eine Prüfung, ob das Standard-element ein Termin ist, was wir durch den Wert der Eigenschaft DefaultItemType <\/b>des Folder<\/b>-Objekts herausfinden. Dieser sollte olAppointmentItem <\/b>lauten. Anderenfalls soll die Funktion mit einer Meldung beendet werden:<\/p>\n Dementsprechend müssen wir auch beim Aufruf der Funktion GetUserdefinedCalendar<\/b> prüfen, ob diese überhaupt einen Wert zurückliefert:<\/p>\n Termine durchlaufen<\/b><\/p>\n Bevor Sie alle Termine durchlaufen, prüfen Sie erst einmal, wieviele Termine überhaupt im Kalender-Ordner enthalten sind. Bei vielen Terminen, die sich über Jahre angesammelt haben, kann dieser Prozess recht lange dauern. Also lassen wir erst einmal die Anzahl ausgeben:<\/p>\n Ist die Anzahl überschaubar, erweitern Sie die obige Prozedur um die folgenden Anweisungen. Hier durchlaufen wir in einer Schleife alle enthaltenen Elemente:<\/p>\n Termine nach Datum filtern<\/b><\/p>\n Wenn Sie die Termine filtern wollen, können Sie das mit der Restrict<\/b>-Funktion der Items<\/b>-Auflistung erledigen. Diese nimmt einen Ausdruck ähnlich dem Where<\/b>-Kriterium einer SQL-Abfrage entgegen und liefert als Ergebnis eine neue Items<\/b>-Auflistung. Damit verbunden ist somit der wichtige Hinweis, dass allein das Anwenden von Restrict <\/b>nicht die enthaltenen Elemente filtert, sondern dass sich dies lediglich auf die Ergebnismenge auswirkt!<\/p>\n Wir gehen davon aus, dass wir die beiden Parameter datStart <\/b>und datEnd <\/b>zuvor füllen. Dann stellen wir wie folgt den Filterausdruck in strFilter <\/b>zusammen:<\/p>\n Mit Datumsangaben erhalten wir so beispielsweise diesen Filterausdruck:<\/p>\n Das mag auf den ersten Blick okay aussehen, auf den zweiten aber vielleicht ungewohnt: Wir legen im ersten Teil fest, dass das Startdatum des Termins kleiner als das mit datEnd <\/b>übergebene Enddatum ist und das Enddatum größer als das mit datStart <\/b>übergebene Startdatum. Damit erhalten wir hier einen Ausdruck, der dafür sorgt, dass alle Termine erfasst werden, die auch nur teilweise in dem angegebenen Zeitraum liegen. Wenn ein Termin vor dem mit datStart <\/b>und datEnd <\/b>angegebenen Zeitraum liegt und in diesem Zeitraum endet (oder auch danach), wird er von diesem Kriterium erfasst.<\/p>\n Wenn Sie nur Termine erfassen wollen, die innerhalb des angegebenen Zeitraums beginnen und auch dort enden, müssen Sie die Bedingung umformulieren, und zwar so:<\/p>\n Schließlich deklarieren wir noch eine neue Variable des Typs Items<\/b>:<\/p>\n Diese füllen wir dann mit der mit strFilter <\/b>gefilterten Menge von AppointmentItem<\/b>-Elementen:<\/p>\n Ganztägige Termine berücksichtigen<\/b><\/p>\n Wenn Sie nur ganztägige Termine berücksichtigen wollen, können Sie die entsprechende VBA-Eigenschaft des AppointmentItem<\/b>-Elements ebenfalls in die Bedingung integrieren. Auch hier gehen wir davon aus, dass mit dem Parameter bolNurGanztaegig<\/b> angegeben wird, ob nur ganztägige Termine ermittelt werden sollen. Dann können wir die Bedingung wie folgt erweitern:<\/p>\n Wir stellen also schlicht einen Filter für die Eigenschaft AllDayEvent <\/b>auf den Wert True <\/b>ein und schließen somit alle Einträge aus, deren Feld AllDayEvent <\/b>den Wert False <\/b>aufweist.<\/p>\n Auf die gleiche Art können Sie nach weiteren Eigenschaften von Terminen suchen, die das gesuchte AppointmentItem<\/b>-Element kennzeichnen.<\/p>\n Nach benutzerdefinierten Eigenschaften filtern<\/b><\/p>\n Gegebenenfalls haben Sie, wie im Beitrag Benutzerdefinierte Felder in Outlook <\/b>(www.access-im-unternehmen.de\/1221<\/b>) beschrieben, benutzerdefinierte Felder für Outlook-Termine angelegt. Wir wollen auch nach diesen filtern können, um beispielsweise alle Termine ausfindig zu machen, die im Kontext eines bestimmten Mitarbeiters angelegt wurden. Wir wollen also nun nach Terminen suchen, deren benutzerdefiniertes Feld Mitarbeiter <\/b>den Wert Minhorst <\/b>enthält. Dazu erweitern wir das Kriterium wie folgt:<\/p>\n Und es ist tatsächlich so einfach – benutzerdefinierte Felder können Sie in dem Ausdruck für die Funktion Restrict <\/b>einfach wie eingebaute Felder angeben.<\/p>\n Mit Terminen arbeiten<\/b><\/p>\n Wenn Sie einmal einen Termin referenziert haben, also ein Element des Typs AppointmentItem<\/b>, wie sie in der Items<\/b>-Auflistung zu finden sind, wollen Sie auch seine Eigenschaften nutzen. Der Zugriff auf diese Eigenschaften erfolgt ganz einfach über die jeweiligen Eigenschaftsnamen. Sie können diese also abfragen und die enthaltenen Werte in neue Datensätze einer Tabelle zum Speichern von Outlook-Termindaten einfügen. Wie das gelingt, zeigen wir gleich – vorher schauen wir uns noch an, wie Sie auf benutzerdefinierte Felder zugreifen können.<\/p>\n Benutzerdefinierte Felder abfragen<\/b><\/p>\n Sind die benutzerdefinierten Felder eines Termin-Elements genauso einfach zu lesen, wie wir sie als Filterkriterium in der Restrict<\/b>-Methode nutzen konnten Nein, nicht ganz so leicht. Der Grund ist, dass man den VBA-Objekten nicht einfach neue Eigenschaften hinzufügen kann. Eine Abfrage etwa über objItem.Mitarbeiter <\/b>ist also nicht möglich. Es ist aber fast so einfach – wir brauchen lediglich die Auflistung UserProperties<\/b>, um auf die benutzerdefinierte Eigenschaft zuzugreifen:<\/p>\n Allerdings kann es sein, dass nicht alle Termin-Elemente auch diese benutzerdefinierte Eigenschaft enthalten. Was geschieht, wenn wir auf eine benutzerdefinierte Eigenschaft zugreifen, die gar nicht im untersuchten Element vorhanden ist Dann wird der Fehler aus Bild 13 ausgelöst.<\/p>\n Bild 13: Fehler beim Zugriff auf ein nicht vorhandenes benutzerdefiniertes Feld<\/span><\/b><\/p>\n Um dies zu verhindern, müssen wir also die Fehlerbehandlung aktivieren oder einfach abfragen, ob das benutzerdefinierte Feld vorhanden ist. Das erledigen wir wie folgt:<\/p>\n Outlook-Termine in Access speichern<\/b><\/p>\n Damit haben wir die Grundlagen geschaffen, um die Daten von Outlook-Terminen zu ermitteln. Nun müssen wir diese nur noch in einer Access-Tabelle speichern. Diese Tabelle soll im Entwurf wie in Bild 14 aussehen.<\/p>\n Bild 14: Entwurf der Tabelle zum Speichern der Outlook-Termine<\/span><\/b><\/p>\n Das Feld EntryID<\/b>, welches den eindeutigen Wert der gleichnamigen Eigenschaft des Appointment-Item<\/b>-Objekts aufnehmen soll, definieren wir mit einem eindeutigen Index. Darüberhinaus haben wir nur die Felder Betreff<\/b>, Inhalt<\/b>, Startzeit <\/b>und Endzeit <\/b>angelegt – wenn Sie weitere Informationen aus den Terminen benötigen, fügen Sie zusätzliche Felder hinzu und ergänzen den nachfolgend beschriebenen Code entsprechend.<\/p>\n Formular zum Einlesen und Anzeigen der Termine<\/b><\/p>\n Anschließend bauen wir uns ein komfortables Formular, mit dem wir die weiter oben vorgestellten Parameter eingeben können (siehe Bild 15).<\/p>\n Bild 15: Entwurf des Formulars zum Einlesen der Outlook-Termine<\/span><\/b><\/p>\n Dieses Formular enthält die folgenden Steuer-elemente:<\/p>\n Außerdem fügen wir ein Unterformular hinzu, das die Daten der Tabelle tblOutlooktermine <\/b>in der Datenblattansicht anzeigt.<\/p>\n Die Schaltfläche cmdImportStarten <\/b>löst die Prozedur aus Listing 1 aus. Diese ruft die Funktion TermineEinlesen <\/b>auf, welche weitgehend die bereits weiter oben beschriebenen Anweisungen zum Einlesen von Terminen aus einem Outlook-Terminkalender enthält. Dabei übergibt die Prozedur die Werte der Steuer-elemente txtStartdatum<\/b>, txtEnddatum<\/b>, chkGanztaegig <\/b>und txtMitarbeiter <\/b>als Parameter.<\/p>\n![\"Import-](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_002.png\")
<\/p>\n\n
![\"Export](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_003.png\")
<\/p>\n![\"Export](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_004.png\")
<\/p>\n![\"Angabe](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_005.png\")
<\/p>\n![\"Zuordnen](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_006.png\")
<\/p>\n![\"Festlegen](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_007.png\")
<\/p>\n![\"Exportfortschritt\"](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_008.png\")
<\/p>\n![\"Export](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_009.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_010.png\")
<\/p>\nPrivate <\/span>m_Outlook As <\/span>Outlook.Application<\/pre>\nPublic Function <\/span>GetOutlook() As <\/span>Outlook.Application\r\n If <\/span>m_Outlook Is Nothing Then<\/span>\r\n Set<\/span> m_Outlook = New<\/span> Outlook.Application\r\n End If<\/span>\r\n Set<\/span> GetOutlook = m_Outlook\r\nEnd Function<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_011.png\")
<\/p>\nPublic Function <\/span>GetOutlook() As <\/span>Outlook.Application\r\n Dim <\/span>strDummy As String<\/span>\r\n If <\/span>m_Outlook Is Nothing Then<\/span>\r\n Set<\/span> m_Outlook = New<\/span> Outlook.Application\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n strDummy = m_Outlook.Name\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Set<\/span> m_Outlook = New<\/span> Outlook.Application\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Set<\/span> GetOutlook = m_Outlook\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetDefaultCalendar() As <\/span>Outlook.Folder\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> objMAPI = GetOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = objMAPI.GetDefaultFolder(olFolderCalendar)\r\n Set<\/span> GetDefaultCalendar = objFolder\r\nEnd Function<\/span><\/pre>\n GetDefaultCalendar.FolderPath\r\n<\/font>OutlookKalender<\/pre>\n
Public Function <\/span>AppointmentsLesen()\r\n Dim <\/span>objAppointments As <\/span>Outlook.Folder\r\n Set<\/span> objAppointments = GetDefaultCalendar\r\n Debug.Print<\/span> objAppointments.FolderPath\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetCalenderFolder() As <\/span>Outlook.Folder\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> objMAPI = GetOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = objMAPI.PickFolder\r\n Set<\/span> GetCalenderFolder = objFolder\r\nEnd Function<\/span><\/pre>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_012.png\")
<\/p>\nPublic Function <\/span>GetUserdefinedCalendar() As <\/span>Outlook.Folder\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Set<\/span> objMAPI = GetOutlook.GetNamespace(\"MAPI\")\r\n Set<\/span> objFolder = objMAPI.PickFolder\r\n If <\/span>Not<\/span> objFolder.DefaultItemType = olAppointmentItem Then<\/span>\r\n MsgBox<\/span> \"Der gewählte Ordner ist kein Kalender.\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Set<\/span> GetUserdefinedCalendar = objFolder\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>AppointmentsLesenII()\r\n Dim <\/span>objAppointmentFolder As <\/span>Outlook.Folder\r\n Set<\/span> objAppointmentFolder = GetUserdefinedCalendar\r\n If <\/span>Not<\/span> objAppointmentFolder Is Nothing Then<\/span>\r\n Debug.Print<\/span> objAppointmentFolder.FolderPath\r\n Else<\/span>\r\n Debug.Print<\/span> \"Kein Ordner referenziert.\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>AlleTermineDurchlaufen()\r\n Dim <\/span>objAppointmentFolder As <\/span>Outlook.Folder\r\n Dim <\/span>objItem As <\/span>Outlook.AppointmentItem\r\n Set<\/span> objAppointmentFolder = GetDefaultCalendar\r\n Debug.Print<\/span> objAppointmentFolder.Items.Count\r\nEnd Sub<\/span><\/pre>\nFor Each objItem In objAppointmentFolder.Items\r\n Debug.Print<\/span> objItem.Subject, objItem.Start, objItem.End\r\nNext<\/span> objItem<\/pre>\nIf <\/span>datStart > 0 Then<\/span>\r\n strFilter = \" AND [Start] <= '\" & Format(datEnd, \"dd.mm.yyyy hh:mm\") & \"'\"\r\nEnd If<\/span>\r\nIf <\/span>datEnd > 0 Then<\/span>\r\n strFilter = strFilter & \" AND [End] >= '\" & Format(datStart, \"dd.mm.yyyy hh:mm\") & \"'\"\r\nEnd If<\/span>\r\nIf <\/span>Len<\/span>(strFilter) > 0 Then<\/span>\r\n strFilter = Mid<\/span>(strFilter, 5)\r\nEnd If<\/span><\/pre>\n[Start] <= '10.12.2019 00:00' AND [End] >= '30.11.2019 00:00'<\/pre>\n
If <\/span>datStart > 0 Then<\/span>\r\n strFilter = \" AND [Start] >= '\" & Format(datStart, \"dd.mm.yyyy hh:mm\") & \"'\"\r\nEnd If<\/span>\r\nIf <\/span>datEnd > 0 Then<\/span>\r\n strFilter = strFilter & \" AND [End] <= '\" & Format(datEnd, \"dd.mm.yyyy hh:mm\") & \"'\"\r\nEnd If<\/span><\/pre>\nDim <\/span>objItemsGefiltert As <\/span>Outlook.Items<\/pre>\nSet<\/span> objItemsGefiltert = objItems.Restrict(strFilter)<\/pre>\nIf <\/span>bolNurGanztaegig Then<\/span>\r\n strFilter = strFilter & \" AND [AllDayEvent] = True\"\r\nEnd If<\/span><\/pre>\nstrFilter = strFilter & \" AND [Mitarbeiter] = 'Minhorst'\"<\/pre>\n
Debug.Print<\/span> objItem.UserProperties(\"Mitarbeiter\")<\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_013.png\")
<\/p>\nIf <\/span>Not<\/span> objItem.UserProperties(\"Mitarbeiter\") Is Nothing Then<\/span>\r\n Debug.Print<\/span> objItem.UserProperties(\"Mitarbeiter\")\r\nElse<\/span>\r\n Debug.Print<\/span> \"Kein Mitarbeiter angegeben.\"\r\nEnd If<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_014.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_01\/pic_1222_016.png\")
<\/p>\n\n