<\/p>\n
Die Erfassung von Projektzeiten ist eine Aufgabe, die man gern etwas stiefmütterlich handhabt. Am Ende des Tages, der Woche oder auch des Monats muss man dann die für verschiedene Aufgaben verbrauchte Zeit aus dem Gedächtnis nachtragen. Dem wollen wir mit einer Lösung, die Outlook und Access nutzt, entgegenwirken. Damit legen Sie eine Tätigkeit einer bestimmten Dauer – in diesem Fall 25 Minuten – ganz einfach per Drag and Drop in den Outlook-Kalender an. Der Rest geschieht im Hintergrund: Die Tätigkeit wird samt Projekt und Aufgabe in einer Access-Datenbank gespeichert und kann anschließend bequem ausgewertet werden.<\/b><\/p>\n
Der Clou bei dieser Lösung ist, dass es wirklich nur weniger Vorbereitungen sowie einer Drag-and-Drop-Aktion bedarf, um schnell eine Tätigkeit zu dokumentieren. Die grundlegende Konfiguration erfordert Outlook und Access ab der Version 2007.<\/p>\n
Wenn Sie Outlook öffnen, stellen Sie zunächst die Ansicht der linken Leiste auf Ordner<\/b> um (s. Bild 1).<\/p>\n
![\"Wechsel](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_001.png\")
<\/p>\n
Bild 1: Wechsel auf die Ordner-Ansicht<\/span><\/b><\/p>\n Danach erscheint links eine übersicht der einzelnen Outlook-Elemente als Ordner – Posteingang<\/b>, Entwürfe<\/b>, Gesendete Elemente <\/b>und so weiter. Für uns ist der Ordner Aufgaben <\/b>interessant.<\/p>\n Dort legt die Lösung aus diesem Beitrag beim Starten von Outlook automatisch einen Unterordner namens Projekte <\/b>an. Mit dem Eintrag Neuer Ordner… <\/b>des Kontextmenüs dieses Eintrags legen Sie einen Unterordner an, der ein neues Projekt repräsentiert (s. Bild 2).<\/p>\n Bild 2: Anlegen eines neuen Projekt-Ordners<\/span><\/b><\/p>\n Zu Beispielzwecken wollen wir diesen Ordner Projekt 1 <\/b>nennen.<\/p>\n Ein Projekt soll eine oder mehrere Aufgaben aufnehmen. Damit Sie diese anlegen können, klicken Sie den frisch angelegten Ordner Projekt 1 <\/b>an. Dies blendet die aktuell für diesen Aufgabenordner vorhandenen Aufgaben im Hauptbereich von Outlook ein. Hier fügen Sie nun wie in Bild 3 die gewünschten Aufgaben hinzu – im Beispiel Aufgabe 1 <\/b>und Aufgabe 2<\/b>.<\/p>\n Bild 3: Hinzufügen von Aufgaben zu einem Projekt<\/span><\/b><\/p>\n Nun können wir schon zur Kalenderansicht wechseln. Dabei müssen Sie allerdings etwas beachten: Wenn Sie per Mausklick auf das Kalender-Icon unten links zum Kalender wechseln, verschwindet auch die Ordneransicht wieder – und die sollte angezeigt bleiben, damit wir auch während der Arbeit mit dem Kalender Zugriff auf die Projektordner haben. Also nutzen Sie für den Wechsel zur Kalenderansicht den Eintrag Kalender <\/b>aus der Ordnerliste.<\/p>\n Hier prüfen wir noch, ob der rechte Bereich die Aufgabenliste anzeigt. Ist dies nicht der Fall, können Sie dies etwa unter Outlook 2016 mit dem Ribbon-Eintrag An-sicht|Lay-out|Aufgabenliste|Aufgaben <\/b>einblenden (s. Bild 4). Hier sehen Sie auch, wie Sie dann eine der Aufgaben aus der Aufgabenliste in den Kalenderbereich ziehen. Die Aufgabe wird dann als neue Tätigkeit genau an der Stelle angelegt, die dem aktuellen Datum und der Uhrzeit entspricht. Fertig – für die nächsten 25 Minuten steht die anstehende Aufgabe nun fest und Sie können diese bearbeiten. Danach geht es auf die gleiche Weise weiter – legen Sie eine neue Aufgabe an und bearbeiten Sie diese oder bearbeiten Sie einfach eine der vorhandenen Aufgaben weiter.<\/p>\n Bild 4: Einblenden der Aufgabenleiste und Hinzufügen von Aufgaben als Tätigkeiten zum Kalender<\/span><\/b><\/p>\n Dies war der Teil der Lösung, der sich auf die Benutzeroberfläche bezieht. Im Hintergrund geschieht noch einiges mehr: Zum Beispiel gibt es eine Access-Datenbank namens Projektzeiterfassung.accdb<\/b>, welche die erfassten Daten in drei Tabelle speichert und die um Funktionen zum Auswerten der Projektzeiten erweitert werden kann.<\/p>\n Das Datenmodell dieser Datenbank sieht wie in Bild 5 aus. Die Tabelle tblProjekte <\/b>nimmt für jeden Ordner, den Sie unterhalb des Ordners Projekte anlegen, einen Datensatz auf und speichert dort die eingegebene Projektbezeichnung. Die übrigen Felder können nach Belieben genutzt werden, interessant ist lediglich noch das Feld GeloeschtAm<\/b>. Dieses wird gefüllt, wenn der Benutzer den Projektordner in Outlook löscht.<\/p>\n Bild 5: Datenmodell der Datenbank zur Projektzeiterfassung<\/span><\/b><\/p>\n Die Tabelle tblAufgaben <\/b>speichert die einzelnen Aufgaben, die Sie im mittleren Bereich von Outlook hinzufügen, wenn Sie einen der Projektordner markiert haben. Hier finden Sie das Fremdschlüsselfeld ProjektID<\/b>, das die Aufgabe einem Datensatz der Tabelle tblProjekte <\/b>zuordnet. Das Feld Aufgabe <\/b>ist für die Bezeichnung der Aufgabe wie in Outlook angegeben gedacht. Auch hier finden Sie wieder ein Feld namens Geloescht-Am<\/b>, das beim Löschen des entsprechenden Elements aus Outlook mit dem aktuellen Datum und der Zeit gefüllt wird. Das Feld ErledigtAm <\/b>schließlich wird gefüllt, wenn der Benutzer die Aufgabe in Outlook als erledigt markiert. Dies können Sie beispielsweise in der übersichtsliste der Aufgaben erledigen (s. Bild 6). Eine andere Möglichkeit bietet der Eintrag Als erledigt markieren <\/b>im Kontextmenü der Aufgabenliste in der Kalenderansicht.<\/p>\n Bild 6: Markieren einer Aufgabe als „Erledigt“<\/span><\/b><\/p>\n Die Tabelle tblTaetigkeiten <\/b>speichert schließlich die Aufgaben, die der Benutzer als Termine in den Kalender gezogen hat. Die Tabelle enthält einige Felder mehr als die zuvor vorgestellten Tabellen. Beim Anlegen einer Tätigkeit trägt die Lösung die Bezeichnung der Tätigkeit, die Startzeit, die Endzeit sowie den Wert des Primärschlüsselfeldes der Aufgabe, zu deren Erledigung die Tätigkeit dient, in die Tabelle ein. Außerdem gibt es auch hier wieder ein Feld namens GeloeschtAm<\/b>, welches das Löschdatum von entfernten Tätigkeiten aufnimmt. Das Feld KategorieID<\/b>, das Sie in der Abbildung des Datenmodells sehen, benötigen wir für eine Erweiterung der hier vorgestellten Lösung aus dem Beitrag Kanban mit Outlook und Access <\/b>(www.access-im-unternehmen.de\/1017<\/b>, siehe folgende Ausgabe).<\/p>\n Bild 7 zeigt die drei Tabellen mit den Beispieldatensätzen, die wir weiter oben angelegt haben, in der Datenblattansicht und deutet die Verknüpfungen der vorhandenen Datensätze durch rote Pfeile an.<\/p>\n Bild 7: Tabellen der Lösung mit einigen Beispieldaten<\/span><\/b><\/p>\n Der Teil der Lösung, der in diesem Beitrag beschrieben wird, spielt sich VBA-technisch komplett in Outlook ab – die Access-Datenbank stellt nur die Tabellen zum Speichern der Projektzeiten bereit. In einem weiteren Beitrag namens Projektzeiten auswerten <\/b>(www.access-im-unternehmen.de\/1018<\/b>) zeigen wir in der folgenden Ausgabe, wie Sie die gespeicherten Daten auswerten können.<\/p>\n Hier schauen wir uns nun an, wie die in Outlook erstellten Projekte, Aufgaben und Tätigkeiten ihren Weg in die Tabellen der Access-Datenbank finden.<\/p>\n Ich weiß nicht, wie es Ihnen geht, aber ich öffne den VBA-Editor unter Access immer mit der Tastenkombination Strg + G <\/b>und lande damit sofort im Direktbereich. Unter Outlook funktioniert diese nicht. Dort gelangen Sie am schnellsten über die Tastenkombination Alt + F11 <\/b>in den VBA-Editor (dies funktioniert unter Access und den übrigen Office-Anwendungen übrigens auch).<\/p>\n Je nachdem, wie Ihre Sicherheitseinstellungen unter Outlook aussehen, können Sie keine VBA-Prozeduren im VBA-Projekt von Outlook ausführen. Aber keine Sorge – dies ändern Sie ganz schnell. öffnen Sie den Optionen-Dialog von Outlook, wechseln Sie dort zum Bereich Trust Center <\/b>und klicken Sie auf Einstellungen für das Trust Center<\/b>. Hier übernehmen Sie die Option für den Bereich Makroeinstellungen wie in Bild 8.<\/p>\n Bild 8: Einstellungen zum Ausführen von VBA-Code in Outlook<\/span><\/b><\/p>\n Achtung: Die änderungen wirken sich erst beim nächsten Start von Outlook aus.<\/p>\n Eine sehr wichtige Rolle spielen dabei die Ereignisse, die beim Anlegen von Projektordnern, Aufgaben und Terminen\/Tätigkeiten ausgelöst werden. Weitere Ereignisse, die wir tracken müssen, sind das Löschen dieser drei Objektarten sowie das Verschieben, also das ändern der Eigenschaften von Objekte – in diesem Fall betrifft das nur die Termine\/Tätigkeiten. Die Tätigkeiten sollen ja, wenn der Benutzer diese auf den Kalender zieht, immer genau für das aktuelle Datum und die entsprechende Zeit angelegt werden. Manchmal vergisst man jedoch, eine Tätigkeit vor Beginn in Outlook anzulegen und fügt diese nachträglich hinzu. Diese muss dann natürlich nach dem Anlegen noch an die der gewünschten Zeit entsprechende Stelle verschoben werden, üblicherweise per Drag and Drop oder durch manuelles Einstellen der Zeit nach dem öffnen des Termins per Doppelklick.<\/p>\n Eine solche änderung muss ebenfalls ein Ereignis auslösen, damit die neuen Zeiten die beim Anlegen in der Tabelle gespeicherten Zeiten überschreiben können. Aber auch die Projekt-ordner und die Aufgaben sind änderungen unterworfen. Diese beziehen sich jedoch nur auf die jeweilige Bezeichnung.<\/p>\n Damit wir die Ereignisse der drei Objektarten durch entsprechende Ereignisprozeduren implementieren können, benötigen wir jeweils entsprechende Objektvariablen, die wir mit dem Schlüsselwort WithEvents <\/b>deklarieren. Da nach dem öffnen von Outlook nicht immer nur neue Projekte, Aufgaben und Tätigkeiten angelegt, bearbeitet und gelöscht werden, sondern auch die bestehenden Elemente potenziell änderungen unterworfen sind, müssen wir für alle infrage kommenden Elemente Objektvariablen anlegen und diese mit den entsprechenden Ereignisprozeduren ausstatten.<\/p>\n Wir benötigen also beim Start von Outlook zunächst eine Prozedur, die alle vorhandenen Elemente in Form von Objektvariablen referenziert. Diese Prozedur heißt Application_Startup <\/b>und landet im standardmäßig im VBA-Projekt von Outlook vorhandenen Klassenmodul ThisOutlookSession<\/b> (s. Listing 1).<\/p>\n Listing 1: Diese Prozedur wird bei Start von Outlook automatisch ausgelöst.<\/span><\/b><\/p>\n Bezüglich des VBA-Projekts von Outlook müssen Sie ein wenig von der Access-Denkweise abweichen: Unter Access hat ja jede Datenbankdatei ein eigenes VBA-Projekt – genau wie die Dokumente in Word oder Excel. Unter Outlook gibt es nur ein VBA-Projekt, das der Anwendung Outlook selbst zugeteilt ist.<\/p>\n Die Prozedur enthält eine Fehlerbehandlung, die alle Fehler in Form einer entsprechenden Meldung behandelt. Dies dient primär dazu, die Lösung stabil zu gestalten. üblicherweise werden beispielsweise Objektvariablen bei nicht behandelten Fehlern geleert, was im Falle dieser Lösung natürlich katastrophal wäre: Wenn der Benutzer nach einem nicht behandelten Fehler fleißig weiter Projekte, Aufgaben und Tätigkeiten bearbeitet, wird nämlich keines der mit den Objektvariablen verbundenen Ereignisse mehr ausgelöst und die Daten werden nicht in der Datenbank gespeichert.<\/p>\n Die Prozedur Application_Startup <\/b>stellt nun zunächst die Variable objAppointments <\/b>des Typs Items <\/b>auf die im Kalender-Ordner enthaltenen Elemente ein. Die entsprechende Variable deklarieren wir wie folgt im Kopf des Klassenmoduls:<\/p>\n Um einen leichteren Zugriff auf die Elemente von Outlook zu schaffen, haben wir im Modul mdlOutlook <\/b>ein paar Hilfsfunktionen beigefügt. Hier kommen gleich mehrere zum Einsatz. Die erste heißt GetMAPINamespace <\/b>und liefert einen Verweis auf das MAPI-Namespace-Objekt von Outlook, über das wir auf alle Elemente von Outlook zugreifen können (siehe unten). Das von GetMAPINamespace <\/b>gelieferte Objekt bietet die Methode GetDefaultFolder<\/b>, die mit dem Parameter olFolderCalendar <\/b>einen Verweis auf den Standard-Kalenderordner von Outlook holt und speichert ihn in objAppointments<\/b>.<\/p>\n Nun folgt ein Schritt, der dem Benutzer ein wenig Arbeit abnehmen soll: Wenn unterhalb des Aufgaben-Ordners in der Ordnerliste von Outlook noch kein Eintrag namens Projekte <\/b>vorhanden ist, soll die Prozedur diesen automatisch anlegen. Dazu referenziert die Prozedur bei deaktivierter Fehlerbehandlung diesen Ordner über das Element Projekte <\/b>der Folders<\/b>-Auflistung für den Aufgaben-Ordner.<\/p>\n Den Aufgaben-Ordner liefert ebenfalls eine unserer Hilfsfunktionen aus dem Modul mdlOutlook<\/b>, nämlich GetTaskfolder<\/b> (siehe unten). Führt dieser Zugriff auf den Ordner zu einem Fehler, ist offensichtlich, dass der Ordner noch nicht vorhanden ist. Die Prozedur verwendet dann die Add<\/b>-Methode der Folders<\/b>-Auflistung des mit GetTaskfolder <\/b>ermittelten Aufgaben-Ordners, um den Ordner namens Projekte <\/b>hinzuzufügen. Danach speichert sie einen Verweis auf die Folders<\/b>-Auflistung dieses Ordners in der Variablen objProjects<\/b>, die ebenfalls mit dem Schlüsselwort WithEvents <\/b>im Kopf des Klassenmoduls deklariert wird:<\/p>\n Die nächste auf diese Variable namens objAppointmentFolder <\/b>füllt die Prozedur mit einem Verweis auf den Kalender-Ordner:<\/p>\n Auch diesen erhalten wir mit der GetDefaultFolder<\/b>-Methode des mit Get-MAPI-Namespace <\/b>ermittelten MAPI-Namespace-Objekts.<\/p>\n Für die Implementierung weiterer Ereignisse benötigen wir auch noch Objekte auf Basis der Ordner, die der Benutzer unterhalb des Projekte<\/b>-Ordners anlegt und die jeweils ein Projekt repräsentieren. Dies ist etwas aufwendiger, da wir jeden einzelnen Ordner referenzieren müssen. Dies erledigen wir mit einer Hilfsklasse, die jeweils einen Ordner aufnimmt und die dann in einer Collection namens colProjects <\/b>landet. Diese deklarieren wir wie folgt im Kopf des Klassenmoduls:<\/p>\n Die Prozedur erzeugt diese Collection neu. Dann durchläuft sie alle Ordner im Folder Projekte <\/b>in einer For Each<\/b>-Schleife über die Elemente der Auflistung objProjects <\/b>und legt für jeden Ordner ein neues Objekt der Klasse clsTasks <\/b>an. Diese weist eine Eigenschaft namens Tasks <\/b>auf, die mit der Items<\/b>-Auflistung des aktuellen Projekte-Ordners gefüllt wird. Der Verweis auf den aktuellen Projekt-Ordner selbst landet in der Eigenschaft Project<\/b>. Schließlich wird das so präparierte Objekt der Collection colProjects <\/b>hinzugefügt.<\/p>\n Das waren bereits die Vorbereitungen. Nun müssen wir noch die zahlreichen Ereignisprozeduren implementieren, damit die in Outlook eingegebenen Projekte, Aufgaben und Tätigkeiten auch in den Tabellen der Datenbank landen.<\/p>\n Die drei Hilfsfunktionen aus Listing 2 finden Sie im Standardmodul mdlOutlook <\/b>im VBA-Projekt von Outlook – dort natürlich mit Fehlerbehandlung, die wir hier aus Platzgründen gekürzt haben. Die erste Funktion liefert einen Verweis auf das Outlook.Application<\/b>-Objekt. Dabei prüft sie, ob die lokale Variable mOutlook <\/b>bereits mit einem Verweis auf das Application<\/b>-Objekt gefüllt ist. Falls nicht, was eigentlich nur beim ersten Aufruf geschieht, füllt es diese Variable damit. Die Funktion gibt dann einen Verweis auf den Inhalt von mOutlook <\/b>zurück.<\/p>\n Listing 2: Hilfsfunktionen für den einfachen Zugriff auf Outlook-Objekte<\/span><\/b><\/p>\n Die Funktion GetMAPINamespace <\/b>erledigt dies mit der Variablen mNamespace <\/b>und nutzt dazu die GetNamespace<\/b>-Methode des Application<\/b>-Objekts, das es mit der Funktion GetOutlook <\/b>holt.<\/p>\n Fehlt noch die Funktion GetTaskfolder<\/b>, die einen Verweis auf den Aufgaben-Ordner von Outlook ermittelt und zurückgibt. Dabei nutzt diese die beiden zuvor beschriebenen Funktionen sowie die lokale Variable mTaskfolder<\/b>.<\/p>\n Diese Klasse haben Sie soeben bereits kennen gelernt, als wir für jedes Folder<\/b>-Objekt eine Instanz dieser Klasse erstellt und über die Eigenschaften Tasks <\/b>und Project <\/b>jeweils einen Verweis auf die Aufgaben-Auflistung und den Projekt-Ordner übergeben haben.<\/p>\n Diese beiden Eigenschaften stellt die Klasse über die beiden Property Set<\/b>-Prozeduren Tasks <\/b>und Project <\/b>bereit, die wie in Listing 3 aussehen.<\/p>\n <\/p>\n Listing 3: Elemente der Klasse clsTasks<\/span><\/b><\/p>\n Damit die übergebenen Verweise in der Klasse gespeichert werden, tragen die Property Set<\/b>-Prozeduren diese in die beiden Variablen mTasks <\/b>und mProject <\/b>ein. Beide deklarieren wir wieder mit dem Schlüsselwort With-Events<\/b>, denn auch für diese wollen wir wieder Ereignisprozeduren anlegen. Diese stellen wir in den folgenden Abschnitten vor.<\/p>\n Damit hätten wir das Grundgerüst erstellt. Nun folgt eine Reihe von Ereignisprozeduren, mit denen wir die Benutzer-eingaben in Outlook abfangen und die dabei anfallenden Daten in der Access-Datenbank speichern. Diese schauen wir uns in der Reihenfolge an, wie sie beim Arbeiten mit der Lösung auftreten.<\/p>\n Spätestens jetzt, wo es an das Speichern von Daten in die Tabellen der Access-Datenbank geht, benötigen wir für das VBA-Projekt von Outlook einen Verweis auf die DAO-Bibliothek beziehungsweise auf die modernere Variante, die Microsoft Office x.0 Access database engine Object Library<\/b>. Diesen fügen Sie wie in Bild 9 hinzu (VBA-Editor, Menüeintrag Extras|Verweise<\/b>).<\/p>\n Bild 9: Verweis auf die DAO-Bibliothek<\/span><\/b><\/p>\n Die erste Ereignisprozedur wird ausgelöst, wenn der Benutzer einen neuen Unterordner zum Aufgaben-Ordner hinzufügt – üblicherweise über den entsprechenden Kontextmenü-Eintrag. Dies löst das Ereignis FolderAdd <\/b>des Objekts objProjects <\/b>auf, das im Klassenmodul ThisOutlookSession <\/b>deklariert ist. Dort legen Sie auch die Ereignisprozedur aus Listing 4 an.<\/p>\n Listing 4: Ereignisprozedur, die beim Hinzufügen eines Projekt-Ordners ausgelöst wird<\/span><\/b><\/p>\n Eine solche Ereignisprozedur erstellen Sie, indem Sie aus dem linken Kombinationsfeld des Codefensters den Namen des Objekts auswählen (hier objProjects<\/b>) und aus dem rechten den Eintrag für die gewünschte Ereignisprozedur (in diesem Fall FolderAdd<\/b>). Dies legt dann die nackte Prozedur an. Dem Prozedurkopf können wir dann schon entnehmen, dass die Prozedur als Parameter einen Verweis auf den neu angelegten Ordner liefert (Folder<\/b>). Die Prozedur prüft zunächst den Typ des neu angelegten Ordners. Dazu vergleicht sie in einer Select Case<\/b>-Bedingung den Wert von Folder.DefaultItemType <\/b>mit dem Wert der Konstanten olTaskItem<\/b>. Ist diese Bedingung erfüllt, führt die Prozedur die nachfolgenden Anweisungen aus. Die erste stellt eine SQL-Anweisung zusammen, welche einen neuen Datensatz in der Tabelle tblProjekte <\/b>anlegt und dem Feld Projektbezeichnung <\/b>den beim Anlegen angegebenen Ordnernamen zuweist. Diese führt die Prozedur mit der nachfolgenden Execute<\/b>-Methode eines Objekts namens CurrentDBC <\/b>aus. CurrentDBC <\/b>ist eine Funktion, die einen Verweis auf die Access-Datenbank Projektzeiterfassung.accdb <\/b>enthält. Die Funktion befindet sich im Modul mdlGlobal<\/b> und sieht wie folgt aus:<\/p>\n Wie bereits bei den Outlook-Hilfsfunktionen verwendet auch diese eine privat deklarierte Variable:<\/p>\n Diese wird beim ersten Aufruf der Funktion mit einem Verweis auf die mit der OpenDatabase<\/b>-Methode geöffnete Datenbank gefüllt und dann bei Bedarf von der Funktion zurückgegeben. Den Pfad der Datenbank speichern wir übrigens in der Konstanten sStrDB<\/b>:<\/p>\n Wenn Sie die Lösung selbst einsetzen wollen, müssen Sie also entweder die Datenbank an dem hier angegebenen Ort speichern oder aber den Pfad in der Konstanten cStrDB <\/b>anpassen.<\/p>\n Weiter in der Prozedur: Diese prüft mit der RecordsAffected<\/b>-Eigenschaft, wie viele Datensätze von dieser Aktionsabfrage betroffen sind. Ist es genau einer, war die Aktion erfolgreich. In diesem Fall folgt nun ein sehr wichtiger Schritt: Wir weisen der Eigenschaft Description <\/b>einen Ausdruck zu, der aus der Zeichenkette [project|xxx] <\/b>besteht, wobei der Platzhalter xxx <\/b>dem Primärschlüsselwert des soeben angelegten Datensatzes entspricht. Den gewünschten Primärschlüsselwert können wir leicht ermitteln, da wir als Primärschlüssel einen Autowert verwenden. Die Abfrage SELECT @@IDENTITY <\/b>liefert genau diesen Wert.<\/p>\n Wofür wir diesen Wert benötigen Weil wir ja gleich Aufgaben für dieses Projekt anlegen möchten. Dann müssen wir ja beim Anlegen des neuen Datensatzes in der Tabelle tblAufgaben <\/b>den Primärschlüsselwert des übergeordneten Datensatzes aus der Tabelle tblProjekte <\/b>angeben, damit die Zuordnung in der Datenbank stimmt. Außerdem kann es ja vorkommen, dass wir ein Projekt wieder aus Outlook löschen wollen. Dann benötigen wir den Primärschlüsselwert, um den entsprechenden Datensatz der Tabelle tblProjekte <\/b>als gelöscht zu markieren. Den Ausdruck [project|xxx] <\/b>können Sie auch im Eigenschaftsfenster des Ordners einsehen, das Sie mit dem Kontextmenü-Eintrag Eigenschaften… <\/b>öffnen (s. Bild 10).<\/p>\n Bild 10: Versteckte Referenz auf den Datensatz der Tabelle tblProjekte<\/span><\/b><\/p>\n Für den neuen Ordner müssen wir natürlich auch noch ein Objekt der Klasse clsTasks <\/b>anlegen – Sie erinnern sich, dass wir das in der Prozedur Application_Startup <\/b>bereits für alle bereits vorhandenen Ordner erledigt haben. Dazu legt die Prozedur das neue Objekt an, füllt die Eigenschaften Tasks <\/b>und Project <\/b>wie bereits weiter oben beschrieben und fügt die Objektvariable objTasks <\/b>zur Collection colProjects <\/b>hinzu. So funktionieren dann auch die weiter unten beschriebenen Ereignisprozeduren für das neu angelegte Folder<\/b>-Objekt.<\/p>\n Für das Objekt objProjects <\/b>legen wir gleich noch eine weitere Ereignisprozedur an, und zwar für das Ereignis FolderChange<\/b>. Dieses wird bei einer änderung der Eigenschaften des Ordners ausgelöst und sieht wie in Listing 5 aus. Die Prozedur prüft wieder, ob es sich tatsächlich um einen Ordner zum Speichern von Aufgaben handelt. Ist das der Fall, speichert die Prozedur die Beschreibung aus der Eigenschaft Description <\/b>(also einen Ausdruck wie [project|xxx]<\/b>) in der Variablen strDescription <\/b>zwischen. Dann ermittelt sie mit der Hilfsfunktion GetID <\/b>aus dem Inhalt von strDescription <\/b>den Primärschlüsselwert, unter dem der entsprechende Datensatz in der Tabelle tblProjekte <\/b>angelegt wurde, und speichert ihn in lngProjectID<\/b>.<\/p>\n Listing 5: Ereignisprozedur, die beim ändern eines Projekt-Ordners ausgelöst wird<\/span><\/b><\/p>\n Ist dieser Wert nicht 0<\/b>, stellt die Prozedur einen SQL-Ausdruck zusammen, der das Feld Projektbezeichnung <\/b>des Datensatzes mit diesem Primärschlüsselfeld auf den geänderten Wert einstellt und führt diese mit der Execute<\/b>-Methode von CurrentDBC <\/b>aus.<\/p>\n Die Hilfsfunktion GetID<\/b> ist in Listing 6 zu finden. Sie erwartet den zu verarbeitenden String sowie das Schlüsselwort für den Objekttyp (also etwa project<\/b>, task <\/b>oder action<\/b>), der im String enthalten ist. Sie ermittelt die Länge des Schlüsselworts und speichert diese in der Variablen intItemTypeLen<\/b>. Dann ermittelt sie die Startposition des Ausdrucks, also etwa von [project|<\/b>.<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_002.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_003.png\")
<\/p>\n![\"Einblenden](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_004.png\")
<\/p>\nDatenbank zum Speichern der Projektzeitdaten<\/h2>\n
Datenmodell der Datenbank<\/h2>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_005.png\")
<\/p>\n![\"Markieren](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_006.png\")
<\/p>\n![\"Tabellen](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_007.png\")
<\/p>\nProgrammierung der Lösung<\/h2>\n
VBA-Editor unter Outlook öffnen<\/h2>\n
Sicherheit<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_009.png\")
<\/p>\nWichtigstes Element: Ereignisse<\/h2>\n
Public Sub <\/span>Application_Startup()\r\n On Error GoTo<\/span> Application_Startup_Err\r\n Dim <\/span>objProject As <\/span>Outlook.Folder\r\n Dim <\/span>objTasks As <\/span>clsTasks\r\n Dim <\/span>lngError As Long<\/span>\r\n Set<\/span> objAppointments = GetMAPINamespace.GetDefaultFolder(olFolderCalendar).Items\r\n On Error Resume Next<\/span>\r\n Set<\/span> objProject = GetTaskfolder.Folders(\"Projekte\")\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n GetTaskfolder.Folders.Add \"Projekte\", olFolderTasks\r\n End If<\/span>\r\n Set<\/span> objProjects = GetTaskfolder.Folders(\"Projekte\").Folders\r\n On Error GoTo<\/span> Application_Startup_Err\r\n Set<\/span> objAppointmentFolder = GetMAPINamespace.GetDefaultFolder(olFolderCalendar)\r\n Set<\/span> colProjects = New<\/span> Collection\r\n For Each objProject In objProjects\r\n Set<\/span> objTasks = New<\/span> clsTasks\r\n Set<\/span> objTasks.Tasks = objProject.Items\r\n Set<\/span> objTasks.Project = objProject\r\n colProjects.Add objTasks\r\n Next<\/span>\r\nApplication_Startup_Exit:\r\n On Error Resume Next<\/span>\r\n Exit Sub<\/span>\r\nApplication_Startup_Err:\r\n Call<\/span> Fehlerbehandlung(\"Projekt1\/ThisOutlookSession\", \"Application_Startup\", _\r\n Erl, \"Bemerkungen: .\/.\")\r\n GoTo Application_Startup_Exit\r\nEnd Sub<\/span><\/pre>\nVBA-Projekt von Outlook<\/h2>\n
Fehlerbehandlung<\/h2>\n
Dim <\/span>WithEvents objAppointments As <\/span>Outlook.Items<\/pre>\nDim <\/span>WithEvents objProjects As <\/span>Outlook.Folders<\/pre>\nDim <\/span>WithEvents objAppointmentFolder As <\/span>Outlook.Folder<\/pre>\nDim <\/span>colProjects As <\/span>Collection<\/pre>\nDie Hilfsfunktionen GetOutlook, GetMAPINamespace und GetTaskFolder<\/h2>\n
Dim <\/span>mOutlook As <\/span>Outlook.Application\r\nDim <\/span>mNamespace As <\/span>Outlook.NameSpace\r\nDim <\/span>mTaskFolder As <\/span>Outlook.Folder\r\nPublic Property Get <\/span>GetOutlook() As <\/span>Outlook.Application\r\n If <\/span>mOutlook Is Nothing Then<\/span>\r\n Set<\/span> mOutlook = Application\r\n End If<\/span>\r\n Set<\/span> GetOutlook = mOutlook\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>GetMAPINamespace() As <\/span>Outlook.NameSpace\r\n If <\/span>mNamespace Is Nothing Then<\/span>\r\n Set<\/span> mNamespace = GetOutlook.GetNamespace(\"MAPI\")\r\n End If<\/span>\r\n Set<\/span> GetMAPINamespace = mNamespace\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>GetTaskfolder() As <\/span>Outlook.Folder\r\n If <\/span>mTaskFolder Is Nothing Then<\/span>\r\n Set<\/span> mTaskFolder = GetMAPINamespace.GetDefaultFolder(olFolderTasks)\r\n End If<\/span>\r\n Set<\/span> GetTaskfolder = mTaskFolder\r\nEnd Property<\/span><\/pre>\nDie Klasse clsTasks<\/h2>\n
Private <\/span>WithEvents mTasks As <\/span>Outlook.Items\r\nPrivate <\/span>WithEvents mProject As <\/span>Outlook.Folder\r\nPublic Property Set<\/span> <\/span>Tasks(objTasks As <\/span>Outlook.Items)\r\n Set<\/span> mTasks = objTasks\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Project(objProject As <\/span>Outlook.Folder)\r\n Set<\/span> mProject = objProject\r\nEnd Property<\/span><\/pre>\nAuf Outlook-Aktionen reagieren und Daten in Access speichern<\/h2>\n
Verweis auf die DAO-Bibliothek<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_008.png\")
<\/p>\nProjekt hinzufügen<\/h2>\n
Private Sub <\/span>objProjects_FolderAdd(ByVal Folder As <\/span>MAPIFolder)\r\n ... ''''Fehlerbehandlung nicht abgebildet\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>objTasks As <\/span>clsTasks\r\n Select Case Folder.DefaultItemType\r\n Case <\/span>olTaskItem\r\n strSQL = \"INSERT INTO tblProjekte(Projektbezeichnung) VALUES(''''\" & Folder.Name & \"'''')\"\r\n CurrentDBC.Execute strSQL, dbFailOnError\r\n If <\/span>CurrentDBC.RecordsAffected = 1 Then<\/span>\r\n Folder.Description = \"[project|\" & CurrentDBC.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0).Value & \"]\"\r\n End If<\/span>\r\n End Select<\/span>\r\n Set<\/span> objTasks = New<\/span> clsTasks\r\n Set<\/span> objTasks.Tasks = Folder.Items\r\n Set<\/span> objTasks.Project = Folder\r\n colProjects.Add objTasks\r\n ... ''''Fehlerbehandlung nicht abgebildet\r\nEnd Sub<\/span><\/pre>\nPublic Property Get <\/span>CurrentDBC() As <\/span>DAO.Database\r\n If <\/span>mCurrentDB Is Nothing Then<\/span>\r\n Set<\/span> mCurrentDB = DBEngine.OpenDatabase(cStrDB, False<\/span>)\r\n End If<\/span>\r\n Set<\/span> CurrentDBC = mCurrentDB\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>mCurrentDB As <\/span>DAO.Database<\/pre>\nPublic <\/span>Const cStrDB As String<\/span> = \"C:\\Projektzeiterfassung\\Projektzeiterfassung.accdb\"<\/pre>\n![\"Versteckte](\"..\/fileadmin\/_temp_\/2015_06\/pic_1016_010.png\")
<\/p>\nEreignisprozedur beim Umbenennen eines Projekt-Ordners<\/h2>\n
Private Sub <\/span>objProjects_FolderChange(ByVal Folder As <\/span>MAPIFolder)\r\n Dim <\/span>strDescription As String<\/span>\r\n Dim <\/span>lngProjectID As Long<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n Select Case Folder.DefaultItemType\r\n Case <\/span>olTaskItem\r\n strDescription = Folder.Description\r\n lngProjectID = GetID(strDescription, \"project\")\r\n If <\/span>Not<\/span> lngProjectID = 0 Then<\/span>\r\n strSQL = \"UPDATE tblProjekte SET Projektbezeichnung = ''''\" & Folder.Name & \"'''' WHERE ProjektID = \" & lngProjectID\r\n CurrentDBC.Execute strSQL, dbFailOnError\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>GetID(str