<\/p>\n
Haben Sie auch manchmal den Eindruck, dass Sie zu viele Projekte gleichzeitig beackern und den überblick verlieren könnten Mir passierte das regelmäßig. Bis ich über Kanban gestolpert bin und Teile des Konzepts in meine eigenen Abläufe eingebaut habe. Kanban soll durch eine Visualisierung der aktuellen Projekte und ihres Fortschritts eine bessere übersicht bieten und vor allem die Anzahl der gleichzeitig begonnenen Projekte begrenzen. Dies baue ich in meine langjährige Praxis zur Zeiterfassung mit Outlook und Access ein. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Eines der Probleme der heutigen Zeit ist, dass wir immer mehr unter zeitlichem Druck stehen und scheinbar immer mehr Aufgaben zu bewältigen haben. In der Tat sieht man in vielen Bereichen des Lebens, dass Aufgaben viel lieber aufgeschoben als erledigt werden. Ich muss selbst gestehen, dass ich manche unklare Leseranfrage lieber mit einer Gegenfrage beantworte, um diese erstmal vom Tisch zu haben. Tatsache ist: Die Frage kommt wieder zurück, und irgendwann muss ich mich ohnehin darum kümmern.<\/p>\n
Die Anzahl der Aufgaben steigt allerdings kontinuierlich, solange man diese immer wieder in eine Warteschlange schiebt, statt sich abschließend um die Bearbeitung zu kümmern und die Aufgabe endlich von der Liste verschwinden lässt.<\/p>\n
Die Lösung aus Outlook, Access und Kanban, die dieser Beitrag präsentiert, zeigt, wie ich zuletzt meine Projekte bearbeitet habe. Sie setzt auf einer Projektzeiterfassung auf, die ich bereits seit einigen Jahren nutze, um meine Arbeitszeiten zu protokollieren (die Basis dazu finden Sie im Beitrag Projektzeiterfassung mit Outlook und Access<\/b>, www.access-im-unternehmen.de\/1016<\/b>). Dabei verwende ich Outlook, um Aufgabenordner synonym zu Projekten, Aufgaben zu Aufgaben und Termine zu Tätigkeiten einzutragen. Die Daten werden im Hintergrund in einer Access-Datenbank gespeichert. Was hat das mit Kanban zu tun, beziehungsweise mit der hier verwendeten Interpretation dieser Vorgehensweise<\/p>\n
Wir wollen den Kanban-Ansatz insoweit nutzen, als dass wir für unsere Aufgaben verschiedenen Status definieren, die diese dann durchlaufen (ja, Status ist der Plural von Status – ich war selbst anfangs überrascht …). <\/p>\n
Die bisherige Vorgehensweise bei der einfachen Variante der Projektzeiterfassung sieht wie in Bild 1 aus. Hier haben Sie unter dem Ordner Projekte <\/b>neue Projekte angelegt (zum Beispiel Beispielprojekt 1<\/b>), darin Aufgaben erstellt (Beispielaufgabe 1<\/b>) und diese als Tätigkeiten in den Kalender gezogen.<\/p>\n
![\"Bisherige](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_001.png\")
<\/p>\n
Bild 1: Bisherige Darstellung der Projekte und Aufgaben und Tätigkeiten in der Projektzeiterfassung<\/span><\/b><\/p>\n Nun wollen wir in die Liste mit den Aufgaben auf der rechten Seite noch Kategorien einfügen. Das gelingt über die Benutzeroberfläche ganz einfach, indem Sie den Aufgaben jeweils eine neue Kategorie hinzufügen. Dazu wählen Sie aus dem Kontextmenü einer der Aufgaben den Eintrag Kategorisieren <\/b>und die jeweilige Kategorie aus (s. Bild 2).<\/p>\n Bild 2: Hinzufügen einer Kategorie von Hand<\/span><\/b><\/p>\n Mit einem Klick auf den Eintrag Alle Kategorien <\/b>öffnen Sie den Dialog aus Bild 3. Hier legen Sie mit einem Mausklick auf die Schaltfläche Neu <\/b>weitere, benutzerdefinierte Kategorien an.<\/p>\n Bild 3: Anlegen einer neuen Kategorie<\/span><\/b><\/p>\n Nachdem Sie die gewünschten Kategorien angelegt und diese den Aufgaben zugewiesen haben, erhalten Sie das Bild aus Bild 4. Dies reicht uns allerdings noch nicht: Die Aufgaben sollen ja auch noch nach Kategorien gruppiert und möglichst mit der Kategorie als Gruppenüberschrift dargestellt werden. Um dies zu erreichen, ist allerdings nur noch ein kleiner Schritt nötig.<\/p>\n Bild 4: Aufgaben mit zugeordneten Kategorien<\/span><\/b><\/p>\n Dazu klicken Sie im Ribbon einfach auf den Eintrag Auf-gaben-liste|Anordnung|Kategorien<\/b>. Dies blendet die Kategorien als überschriften ein (s. Bild 5). Nun wollen wir die Kategorien natürlich nicht von Hand anlegen, sondern in einer Tabelle unserer Datenbank zur Projektzeiterfassung speichern und diese beim Start von Outlook dynamisch einlesen und anzeigen.<\/p>\n Bild 5: Einblenden der Kategorieüberschriften<\/span><\/b><\/p>\n Dazu wollen wir zunächst eine entsprechende Tabelle anlegen. Diese heißt tblKategorien <\/b>und sieht im Entwurf wie in Bild 6 aus. Das Feld Kategorie <\/b>ist mit einem eindeutigen Index versehen, damit jeder Kategoriename nur einmal eingegeben werden kann. Die Kategorienummer soll gegebenenfalls dem Kategorienamen vorangestellt werden können, damit die gewünschte Sortierung der Kategorien in der Aufgabenliste möglich ist.<\/p>\n Bild 6: Tabelle zum Speichern der Kategorien<\/span><\/b><\/p>\n Das Feld MaximaleElementzahl <\/b>nimmt die Anzahl der maximal in einer Kategorie enthaltenen Elemente aus. Dies ist einer der Kanban-Grundsätze: Für bestimmte Bearbeitungsschritte soll man nur eine begrenzte Anzahl von Elementen vorsehen können. Damit verhindere ich beispielsweise, dass ich mehr als zwei Artikel gleichzeitig schreibe – oder an der Programmierung der Beispieldatenbanken von mehr als zwei Artikeln arbeite. Wenn man in Outlook mehr als die vorgebenene Anzahl Elemente zu einer Kategorie hinzufügt, soll dies eine entsprechende Meldung auslösen.<\/p>\n Das Feld Farbe <\/b>legt den Index der Farbe für die Kategorie fest. Das Feld Standard <\/b>legt fest, welche Kategorie einer neu erstellten Aufgabe zugeordnet werden soll. Das gleich vorgestellte Formular zur Bearbeitung der Kategorien soll sicherstellen, dass nur eine Kategorie gleichzeitig als Standard einstellt werden kann.<\/p>\n Für die Verwaltung der Kategorien erstellen wir ein kleines Access-Formular in der Datenbank zur Projektzeiterfassung. Dieses verwendet die Tabelle tblKategorien <\/b>als Datenherkunft. Mit einem Listenfeld namens lstKategorien <\/b>sollen die vorhandenen Einträge ausgewählt werden können (s. Bild 8).<\/p>\n Bild 7: Dialog zum Verwalten der Kategorien in der Entwurfsansicht<\/span><\/b><\/p>\n Das Listenfeld verwendet die Abfrage aus Bild 7 als Datensatzherkunft. Diese liefert in eckigen Klammern die Nummer der Kategorie plus den Kategorienamen, also etwa so: [00] ToDo<\/b>. Zusätzlich sortiert sie die Datensätze nach dem Wert des Feldes Kategorienummer<\/b>.<\/p>\n Bild 8: Abfrage für die Datensatzherkunft des Listenfeldes lstKategorien<\/span><\/b><\/p>\n Damit das Listenfeld nicht die gebundene Spalte mit dem Feld KategorieID<\/b>, sondern nur das Feld Kategoriename <\/b>der Abfrage anzeigt, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf den Wert 2 <\/b>und Spaltenbreiten <\/b>auf 0 <\/b>ein.<\/p>\n Das Formular zeigt, wie üblich, standardmäßig den ersten Datensatz der Datenherkunft an. Damit das Listenfeld den gleichen Eintrag markiert, legen Sie für das Ereignis Beim Laden <\/b>des Formulars die folgende Ereignisprozedur an:<\/p>\n Andersherum soll das Formular immer den aktuell im Listenfeld ausgewählten Eintrag anzeigen. Dazu verwenden wir eine weitere Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Listenfeldes ausgelöst wird. Diese enthält nur einen einzigen Befehl, der das Recordset des Formulars auf den Datensatz mit dem Wert im Feld KategorieID <\/b>sucht, der gerade im Listenfeld markiert ist:<\/p>\n Nun soll der Benutzer natürlich auch neue Kategorien anlegen können. Dies erledigen wir über eine Schaltfläche namens cmdNeu<\/b>, die folgende Ereignisprozedur auslöst und so den Datensatzzeiger des Formulars auf einen neuen, leeren Datensatz verschiebt:<\/p>\n Damit der Benutzer nicht über das Formular von Datensatz zu Datensatz wechseln kann, sondern nur über die Auswahl eines Eintrags im Listenfeld, stellen Sie die Eigenschaft Zyklus <\/b>des Formulars auf Aktueller Datensatz <\/b>ein. Deshalb benötigen wir auch eine eigene Schaltfläche, damit der Benutzer einen neu hinzugefügten Datensatz speichern kann, ohne anderweitig zu einem anderen Datensatz zu wechseln. Diese löst die folgende Prozedur aus:<\/p>\n Nun kann der Speichervorgang natürlich auch durch andere Aktionen ausgelöst werden, beispielsweise durch das Wechseln des Datensatzes über die Auswahl eines anderen Eintrags im Listenfeld oder auch durch das Schließen des Formulars. Dies fangen wir mit dem Ereignis Nach Aktualisierung <\/b>ab, das wir wie folgt implementieren:<\/p>\n Die Prozedur aktualisiert die Datensatzherkunft des Listenfeldes und stellt dieses auf den aktuell im Formular ausgewählten Datensatz ein. Schließlich wollen wir auch noch Datensätze löschen können, was wir mit der Schaltfläche cmdLoeschen<\/b> realisieren. Diese löst folgende Prozedur aus:<\/p>\n Die Prozedur prüft, ob die zu löschende Kategorie bereits einer Aufgabe zugewiesen ist. Ist dies der Fall, wird der Löschvorgang nicht durchgeführt, sondern es erscheint eine entsprechende Meldung. Anderenfalls löscht die Prozedur den aktuellen Datensatz, aktualisiert die Datensatzherkunft des Listenfeldes und markiert dort den aktuell im Formular angezeigten Datensatz. Das Formular sieht schließlich wie in Bild 9 aus.<\/p>\n Bild 9: Verwalten der Kategorien per Formular<\/span><\/b><\/p>\n Nun wollen wir dafür sorgen, dass alle in der Tabelle gespeicherten Tabellen in Outlook vorhanden sind und mit den entsprechenden Farben angezeigt werden. Dazu benötigen wir eine Prozedur, die beim Starten von Outlook aufgerufen wird. Im Beitrag Projektzeiterfassung mit Outlook und Access <\/b>haben Sie ja bereits die Ereignisprozedur Application_Startup <\/b>kennen gelernt, die beim Start von Outlook automatisch ausgelöst wird. Dieser fügen wir den Aufruf unserer kleinen Routine zum Kontrollieren und Hinzufügen der Kategorien hinzu:<\/p>\n Die Prozedur KategorienKontrollieren <\/b>selbst finden Sie im Modul mdlKanban <\/b>(s. Listing 1). Die Prozedur verwendet ein Recordset<\/b>-Objekt namens rst<\/b>, um alle Datensätze der Tabelle tblKategorien <\/b>zu durchlaufen. Die Property Get<\/b>-Prozedur CurrentDBC <\/b>aus dem Modul mdlGlobal <\/b>liefert einen Verweis auf das Database<\/b>-Objekt der Datenbank Projektzeiterfassung.accdb<\/b>, deren Name in einer Konstanten im gleichen Modul verankert ist. Weiterhin füllt die Prozedur das Objekt objCategories <\/b>mit einer Liste der Kategorien des aktuellen Namespace<\/b>-Objekts von Outlook, das die Funktion GetMAPINamespace <\/b>liefert. Jede Kategorie wird in Outlook nämlich in einem eigenen Category<\/b>-Objekt vorgehalten. Nun durchläuft die Prozedur in einer äußeren Do While<\/b>-Schleife alle Datensätze der Tabelle tblKategorien<\/b>, also alle Kategorien, die eigentlich in Outlook sichtbar sein sollten. Dabei stellt sie die Variablen bolKategorie <\/b>und lngFarbe <\/b>auf die Werte False <\/b>und 0 <\/b>ein, um diese für den aktuellen Schleifendurchlauf zu initialisieren. Innerhalb der Schleife durchläuft sie dann alle Category<\/b>-Objekte der Auflistung in objCategories <\/b>und referenziert das aktuelle Objekt in der Variablen objCategory<\/b>. Sollte der Name der Kategorie aus objCategory.Name <\/b>mit dem aus den Feldern Kategorienummer <\/b>und Kategorie <\/b>zusammengesetzten Kategorienamen (etwa 01_Todo<\/b>) des aktuellen Datensatzes übereinstimmen, ist die Kategorie bereits vorhanden. Die Prozedur stellt dann bolKategorie <\/b>auf True <\/b>ein und verlässt die For<\/b>-Schleife.<\/p>\n <\/p>\n Listing 1: Prüfen und Aktualisieren der Kategorien in Outlook<\/span><\/b><\/p>\n Sollte der Name der Kategorie aus dem aktuellen Datensatz nicht in den Kategorien von Outlook gefunden werden, behält bolKategorie <\/b>den Wert False <\/b>bei.<\/p>\n Im Falle des Wertes True <\/b>prüft die Prozedur, ob das Feld Farbe <\/b>des aktuellen Datensatzes gefüllt ist. Anderenfalls trägt sie den Farbwert der Kategorie aus Outlook in das Feld ein und speichert die änderung. Das heißt, dass Sie die Farben für die verschiedenen Kategorien nach dem Erstellen in Outlook einstellen können, diese werden dann beim nächsten Start von Outlook in die Tabelle tblKategorien <\/b>übertragen.<\/p>\n Hat bolKategorie <\/b>den Wert False<\/b>, muss die Kategorie entsprechend der in der Tabelle gespeicherten Daten in Outlook angelegt werden. Dazu trägt die Prozedur zunächst den Farbwert aus dem Feld Farbe <\/b>in die Variable lngFarbe <\/b>ein. Danach legt sie die Kategorie mit der Add<\/b>-Methode der Auflistung objCategories <\/b>in Outlook an. Wenn Sie nun den Dialog Farbkategorien <\/b>öffnen, erscheinen dort auch prompt die Einträge der Tabelle tblKategorien<\/b> (s. Bild 10).<\/p>\n Bild 10: Die automatisch hinzugefügten Kategorien<\/span><\/b><\/p>\n Nun können Sie die hinzugefügten Kategorien auch direkt für die Aufgaben in der Aufgabenliste auswählen. Die gewählten Einträge werden dann auch direkt als überschrift der vorhandenen Aufgaben angezeigt. Nun möchten wir aber später alle Kategorien sehen und die Aufgaben auch von einer Kategorie zur nächsten verschieben – in meinem Fall also beispielsweise einen Artikel von 01_Lösung programmieren <\/b>zu 02_Artikel schreiben<\/b>. Dies gelingt dann aber nur, indem man die Kategorie für die jeweilige Aufgabe einzeln einstellt. Viel schöner wäre es doch, wenn man gleich alle Kategorien sehen und die Aufgaben von Kategorie zu Kategorie ziehen könnte! Dies sähe dann etwa wie in Bild 11 aus.<\/p>\n Bild 11: Alle Kategorien erscheinen in der Aufgabenliste<\/span><\/b><\/p>\n Hierfür ist allerdings ein gewisser Mehraufwand nötig, den wir nachfolgend beschreiben. Dabei gibt es zwei wichtige Elemente:<\/p>\n Die wichtigste Prozedur heißt KategoriePlatzhalter<\/b> und sieht wie in Listing 2 aus. Sie wird einmal beim Starten von Outlook ausgelöst und dann immer beim Verschieben einer Aufgabe von einer Kategorie zur nächsten oder auch beim Hinzufügen einer neuen Aufgabe – dazu später mehr.<\/p>\n Listing 2: Sichtbarmachen aller Kategorien in Outlook durch Hinzufügen einer Platzhalter-Aufgabe für die leeren Kategorien<\/span><\/b><\/p>\n Die Prozedur KategoriePlatzhalter <\/b>legt dabei nicht nur die Platzhalter an oder entfernt diese, sondern sie erstellt auch für jede Kategorie ein Objekt des Typs clsCategoryWrapper<\/b> und speichert dieses in einer Collection.<\/p>\n Die Prozedur initialisiert zunächst die Collection namens colCategoryWrappers<\/b>, welche die noch zu erstellenden clsCategoryWrapper<\/b>-Objekte aufnehmen soll. Dann füllt sie die Objektvariable objMAPI <\/b>mit einem Verweis auf den MAPI-Namespace und ermittelt den Aufgabenordner, den sie mit der Variablen objTaskfolder <\/b>referenziert. Dann durchläuft sie in einer For Each<\/b>-Schleife alle Category<\/b>-Objekte der Categories<\/b>-Auflistung.<\/p>\n Aufgrund der ersten beiden Zeichen des Namens der Kategorie prüft die Prozedur, ob es sich um eine der aus der Tabelle tblKategorien <\/b>hinzugefügten Kategorien handelt – diese heißen ja beispielsweise 01_ToDo<\/b>. Für jede dieser Kategorien erstellt die Prozedur ein neues Objekt auf Basis der Klasse clsCategoryWrapper <\/b>und weist der Eigenschaft CategoryName <\/b>dieser Klasse den Namen der Kategorie zu, also wiederum beispielsweise 01_ToDo<\/b>. Danach fügt sie dieses Objekt der Collection colCategoryWrappers <\/b>zu und gibt den Namen der Kategorie als Key <\/b>an.<\/p>\n Nun kommt ein wichtiger Schritt: Die rekursiv definierte Funktion AufgabenDurchlaufenRek <\/b>durchläuft alle Aufgaben innerhalb des Aufgabenordners und seiner Unterordner und prüft, ob die enthaltenen Aufgaben einer der Kategorien der Collection colCategoryWrapper <\/b>zugeordnet sind. Falls ja, werden weitere Objekte auf Basis der Klasse clsCategoryItem <\/b>erstellt und dem aktuellen Objekt objCategoryWrapper <\/b>in einer Auflistung hinzugefügt. Außerdem aktualisiert sie dabei die über zwei Eigenschaften namens ElementCount <\/b>und PlaceholderCount <\/b>verfügbaren Anzahlen der enthaltenen tatsächlichen Aufgaben-Elemente und der Platzhalter-Elemente – mehr dazu weiter unten.<\/p>\n Das Ergebnis des Aufrufs der Funktion AufgabenDurchlaufenRek <\/b>ist jedenfalls, dass jedes Objekt objCategoryWrapper <\/b>der Collection colCategoryWrappers <\/b>nun über entsprechende Eigenschaften die Anzahl der enthaltenen Aufgaben und der enthaltenen Platzhalter liefern kann. Dies macht sich die Prozedur in einer For Each<\/b>-Schleife über alle objCategoryWrapper<\/b>-Objekt zunutze. Hier prüft sie zunächst, ob die Eigenschaft ElementCount <\/b>des aktuellen Objekts 0 <\/b>ist. Dies bedeutet, dass die Kategorie keine Aufgabe enthält. Also prüft die Prozedur danach, ob die Kategorie auch keinen Platzhalter enthält – dafür muss die Eigenschaft PlaceholderCount <\/b>ebenfalls den Wert 0 <\/b>liefern. Enthält die Kategorie keine Aufgaben und auch keine Platzhalter-Aufgabe mit dem Text .\/.<\/b>, dann wird sie nicht in der Aufgabenliste angezeigt. Das soll sie aber, damit wir dieser Kategorie Aufgaben per Drag and Drop zuweisen können. Also fügt die Prozedur nun eine Platzhalter-Aufgabe mit dem Wert .\/. <\/b>für die Eigenschaft Subject <\/b>hinzu. Die Eigenschaft Categories<\/b>, welche die Namen der zugehörigen Kategorien als Text aufnimmt, füllt die Prozedur mit dem Namen der aktuell untersuchten Kategorie und speichert die Aufgabe.<\/p>\n Der ElseIf<\/b>-Teil der If<\/b>-Bedingung mit der Prüfung auf den Wert PlaceholderCount <\/b>prüft, ob die Kategorie mehr als eine Platzhalteraufgabe mit dem Text .\/. <\/b>enthält. Ist dies der Fall, durchläuft sie alle Aufgaben, die per Wrapper in der Auflistung Items <\/b>des Objekts objCategoryWrapper <\/b>gespeichert sind, rückwärts und löscht die entsprechenden Elemente aus der Aufgabenliste.<\/p>\n Wir haben noch nicht den Else<\/b>-Teil der If<\/b>-Abfrage für die Anzahl der enthaltenen Aufgaben-Elemente betrachtet. Dieser durchläuft ebenfalls alle Elemente, die in der Auflistung Items <\/b>des Objekts objCategoryWrapper <\/b>gespeichert sind, und löscht solche Aufgaben, deren Eigenschaft Subject <\/b>den Wert .\/.<\/b> enthält – also die Platzhalter, die ja aufgrund des Vorhandenseins echter Aufgaben nicht mehr benötigt werden.<\/p>\n Leider liefern die Category<\/b>-Objekte von Outlook keine Auflistung der enthaltenen Elemente, in diesem Fall also der Aufgaben, die wir einer Kategorie zugeordnet haben. Daher rührt auch die etwas kompliziert anmutende Vorgehensweise zum Ermitteln der Anzahl der Aufgaben einer Kategorie (und der Aufgaben mit dem Betreff .\/.<\/b>). Dies erledigt die Funktion AufgabenDurchlaufenRek <\/b>aus Listing 3. Sie erwartet einen Verweis auf den zu untersuchenden Outlook-Folder sowie die Collection colCategoryWrappers<\/b>. Diese enthält ja für jede Kategorie ein Element des Typs clsCategoryWrapper<\/b>.<\/p>\n Listing 3: Aufgaben durchlaufen und prüfen, in welcher Kategorie diese sich befinden<\/span><\/b><\/p>\n Die Funktion durchläuft alle Elemente der Items<\/b>-Auflistung des Aufgabenordners aus objParent<\/b> in umgekehrter Reihenfolge und referenziert das aktuelle Objekt mit der Variablen objTaskItem<\/b>. Sofern dieses nicht als erledigt gekennzeichnet ist (Complete = True<\/b>), prüft die Funktion, ob es sich bei der in der Eigenschaft Categories<\/b> gespeicherten Kategorie um eine der aus der Datenbank eingelesene Kategorie handelt (diese beginnen ja, wie schon beschrieben, mit zwei Ziffern). In diesem Fall fügt die Funktion der Auflistung ![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_002.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_003.png\")
<\/p>\n![\"Aufgaben](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_004.png\")
<\/p>\n![\"Einblenden](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_005.png\")
<\/p>\nSpeichern der Kategorien<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_006.png\")
<\/p>\nVerwalten der Kategorien<\/h2>\n
![\"Dialog](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_008.png\")
<\/p>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_007.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Me!lstKategorien = Me!KategorieID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstKategorien_AfterUpdate()\r\n Me.Recordset.FindFirst \"KategorieID = \" _\r\n & Me!lstKategorien\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeu_Click()\r\n DoCmd.GoToRecord Record:=acNewRec\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdSpeichern_Click()\r\n RunCommand acCmdSaveRecord\r\nEnd Sub<\/span> <\/pre>\nPrivate Sub <\/span>Form_AfterUpdate()\r\n Me!lstKategorien.Requery\r\n Me!lstKategorien = Me!KategorieID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdLoeschen_Click()\r\n If IsNull(DLookup(\"AufgabeID\", \"tblAufgaben\", _\r\n \"KategorieID = \" & Me!KategorieID)) Then\r\n RunCommand acCmdDeleteRecord\r\n Me!lstKategorien.Requery\r\n Me!lstKategorien = Me!KategorieID\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Kategorie kann nicht gelöscht werden, da sie bereits Einträge enthält.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Verwalten](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_009.png\")
<\/p>\nInitialisieren der Kategorieansicht<\/h2>\n
Public Sub <\/span>Application_Startup()\r\n ...\r\n KategorienKontrollieren\r\n ...\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>KategorienKontrollieren()\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>objCategory As <\/span>Outlook.Category\r\n Dim <\/span>objCategories As <\/span>Outlook.Categories\r\n Dim <\/span>bolKategorie As Boolean<\/span>\r\n Dim <\/span>lngFarbe As Long<\/span>\r\n Set<\/span> rst = CurrentDBC.OpenRecordset(\"SELECT * FROM tblKategorien\", dbOpenDynaset)\r\n Set<\/span> objCategories = GetMAPINamespace.Categories\r\n Do While<\/span> Not<\/span> rst.EOF\r\n bolKategorie = False<\/span>\r\n lngFarbe = 0\r\n For Each objCategory In objCategories\r\n If <\/span>objCategory.Name = rst!Kategorienummer & \"_\" & rst!Kategorie Then<\/span>\r\n bolKategorie = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> objCategory\r\n If <\/span>bolKategorie = True<\/span> Then<\/span>\r\n If <\/span>IsNull(rst!Farbe) Then<\/span>\r\n rst.Edit\r\n rst!Farbe = objCategory.Color\r\n rst.Update\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> IsNull(rst!Farbe) Then<\/span>\r\n lngFarbe = rst!Farbe\r\n End If<\/span>\r\n Set<\/span> objCategory = objCategories.Add(rst!Kategorienummer & \"_\" & rst!Kategorie, lngFarbe)\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_010.png\")
<\/p>\nKategorien in der Aufgabenliste anzeigen<\/h2>\n
![\"Alle](\"..\/fileadmin\/_temp_\/2016_01\/pic_1017_011.png\")
<\/p>\n\n
Public Sub <\/span>KategoriePlatzhalter()\r\n Dim <\/span>objCategory As <\/span>Outlook.Category\r\n Dim <\/span>objTaskItem As <\/span>Outlook.TaskItem\r\n Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\n Dim <\/span>objTaskfolder As <\/span>Outlook.Folder\r\n Dim <\/span>colCategoryWrappers As <\/span>Collection\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>objCategoryWrapper As <\/span>clsCategoryWrapper\r\n Set<\/span> colCategoryWrappers = New<\/span> Collection\r\n Set<\/span> objMAPI = Application.GetNamespace(\"MAPI\")\r\n Set<\/span> objTaskfolder = objMAPI.GetDefaultFolder(olFolderTasks)\r\n For Each objCategory In Application.GetNamespace(\"MAPI\").Categories\r\n If <\/span>IsNumeric(Left<\/span>(objCategory.Name, 2)) Then<\/span>\r\n Set<\/span> objCategoryWrapper = New<\/span> clsCategoryWrapper\r\n With<\/span> objCategoryWrapper\r\n .CategoryName = objCategory.Name\r\n End With<\/span>\r\n colCategoryWrappers.Add objCategoryWrapper, objCategory.Name\r\n End If<\/span>\r\n Next<\/span> objCategory\r\n AufgabenDurchlaufenRek objTaskfolder, colCategoryWrappers\r\n For Each objCategoryWrapper In colCategoryWrappers\r\n If <\/span>objCategoryWrapper.ElementCount = 0 Then<\/span>\r\n If <\/span>objCategoryWrapper.PlaceholderCount = 0 Then<\/span>\r\n Set<\/span> objTaskItem = Application.CreateItem(olTaskItem)\r\n With<\/span> objTaskItem\r\n .Subject = \".\/.\"\r\n .Categories = objCategoryWrapper.CategoryName\r\n .Save\r\n End With<\/span>\r\n Else<\/span>If objCategoryWrapper.PlaceholderCount > 1 Then\r\n For i = objCategoryWrapper.Items.Count To 1 Step -1\r\n If <\/span>objCategoryWrapper.Items(i).Subject = \".\/.\" Then<\/span>\r\n Set<\/span> objTaskItem = objMAPI.GetItemFromID(objCategoryWrapper.Items(i).EntryID)\r\n objTaskItem.Delete\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Else<\/span>\r\n For i = objCategoryWrapper.Items.Count To 1 Step -1\r\n If <\/span>objCategoryWrapper.Items(i).Subject = \".\/.\" Then<\/span>\r\n Set<\/span> objTaskItem = objMAPI.GetItemFromID(objCategoryWrapper.Items(i).EntryID)\r\n objTaskItem.Delete\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Next<\/span> objCategoryWrapper\r\nEnd Sub<\/span><\/pre>\nAufgaben und Platzhalter einer Kategorie ermitteln<\/h2>\n
Public Sub <\/span>AufgabenDurchlaufenRek(objParent As <\/span>Outlook.Folder, colCategoryWrappers As <\/span>Collection)\r\n Dim <\/span>objTaskItem As <\/span>Outlook.TaskItem\r\n Dim <\/span>objTaskfolder As <\/span>Outlook.Folder\r\n Dim <\/span>objCategoryWrapper As <\/span>clsCategoryWrapper\r\n Dim <\/span>i As Integer<\/span>\r\n For i = objParent.Items.Count To 1 Step -1\r\n Set<\/span> objTaskItem = objParent.Items(i)\r\n If <\/span>objTaskItem.Complete = False<\/span> Then<\/span>\r\n If <\/span>IsNumeric(Left<\/span>(objTaskItem.Categories, 2)) Then<\/span>\r\n Set<\/span> objCategoryWrapper = colCategoryWrappers.Item(objTaskItem.Categories)\r\n With<\/span> objCategoryWrapper\r\n .AddItem objTaskItem\r\n If <\/span>objTaskItem.Subject = \".\/.\" Then<\/span>\r\n .PlaceholderCount = .PlaceholderCount + 1\r\n Else<\/span>\r\n .ElementCount = .ElementCount + 1\r\n End If<\/span>\r\n End With<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n For Each objTaskfolder In objParent.Folders\r\n AufgabenDurchlaufenRek objTaskfolder, colCategoryWrappers\r\n Next<\/span> objTaskfolder\r\nEnd Sub<\/span><\/pre>\n