<\/p>\n
Die Projektzeiterfassung leidet meist darunter, dass man seinen Pflichten nicht nachkommt und seine Zeiten nicht pflegt. Das ist auch verständlich: Heutzutage muss sich der Anwender mit immer mehr Tools herumschlagen und ist beinahe mehr mit der Dokumentation seines Tuns als mit seiner Arbeit beschäftigt. Da wäre es doch schön, wenn man zwei Fliegen mit einer Klappe schlagen könnte – etwa, indem man die in Outlook eingetragenen Termine und mehr direkt in die Projektzeiterfassung überträgt.<\/b><\/p>\n
Outlook bietet grundsätzlich nicht alles, was eine Projektzeiterfassung ausmacht: So kann man dort eigentlich keine Projekte festlegen und auch keine Tätigkeiten mit Aufgaben verknüpfen. Diese drei Elemente machen nämlich i,m Kontext dieses Beitrags die Erfassung von Projektzeiten aus: Zu einem Projekt gibt es mehrere Aufgaben und jede Aufgabe kann mit einer oder mehreren Tätigkeiten erledigt werden. Na gut, unter Outlook gibt es immerhin das Aufgaben-Element. Aber was ist mit Projekten und Tätigkeiten Wie bildet man diese nach und vor allem: Wie verknüpfen Sie diese miteinander<\/p>\n
Kümmern wir uns zunächst um die Projekte. In einer Anwendung wie Outlook haben Projektinformationen eigentlich nichts zu suchen und auch der allgemeine Mitarbeiter braucht nur zu wissen, welche Aufgaben in Zusammenhang mit einem Projekt anfallen. Also reicht eine Möglichkeit aus, Projekte in irgendeiner Form aufzulisten und diesen Aufgaben zuzuweisen – denn die sind ja, wie oben besprochen, als einziges Element standardmäßig schon in Outlook vorhanden. Zu einem Projekt gehören mehrere Aufgaben. Welcher Analogieschluss lässt sich daraus für die Elemente von Outlook ziehen Aufgaben sind im Aufgabenordner enthalten. Ein Aufgabenordner kann aber, wie auch Mail- oder Kontaktordner, einen oder mehrere, auch hierarchisch verschachtelte Unterordner besitzen. Damit wäre das Projekte-Problem gelöst: Sie legen einfach im Aufgabenordner einen Unterordner namens Projekte an und in diesem für jedes Projekt einen weiteren Ordner.<\/p>\n
Das sieht dann in der Ordnerliste von Outlook, die sich für solche Ansichten am besten eignet, etwa wie in Bild 1 aus. Diese Ansicht erhalten Sie über Ansicht|Navigationsbereich|Normal <\/b>und anschließendes Anklicken des Eintrags Ordnerliste<\/b>.<\/p>\n Bild 1: Projektordner und darin enthaltene Aufgaben<\/span><\/b><\/p>\n<\/div>\n Hat man einmal ein paar Projektordner angelegt, kann man direkt die passenden Aufgaben – natürlich inklusive geplantem Fertigstellungsdatum – dort ablegen. Projekte, Aufgaben … fehlen noch die Tätigkeiten. Eine Tätigkeit ist ein Element, das durch die Beschreibung der Tätigkeit selbst sowie weitere Informationen, vornehmlich Start- und der Endzeit, gekennzeichnet ist. Richtig – die Beschreibung passt genau auf einen Outlook-Termin. Im Betreff legen Sie eine überschrift fest, in der Beschreibung gegebenenfalls weitere Informationen, und zwei weitere Felder dienen zum Eingeben des Start- und des Endzeitpunkts, aus denen man letztlich die Dauer ermittelt.<\/p>\n Das einzige Problem ist, dass sich ein Termin nicht so leicht einer Aufgabe zuordnen lässt wie eine Aufgabe einem Projektordner. Die Lösung dieses Problems betrachten wir jedoch weiter unten. Bis dahin sei zumindest verraten, wie der Benutzer Termine beziehungsweise Tätigkeiten anlegen kann, die mit einer bestimmten Aufgabe verknüpft sind: Er wechselt dazu von der in Bild 1 gezeigten Ansicht mit einem Klick auf die Schaltfläche Kalender <\/b>des Navigationsbereichs und aktiviert dann mit Ansicht|Aufgabenleiste|Normal <\/b>die Aufgabenleiste. Diese zeigt je nach Einstellung beispielsweise die demnächst fertig zu stellenden Aufgaben an, was in diesem Fall Voraussetzung ist (siehe Bild 2): Eine solche Aufgabe lässt sich nämlich per Drag & Drop mit der Maus auf den Zeitplan des aktuellen Tages ziehen und übernimmt einige Eigenschaften in Textform in die Terminbeschreibung (siehe Bild 3). Der Termin hat nun einen oberflächlichen Bezug, aber keine wirkliche Beziehung zu der Aufgabe, aus der er entstanden ist.<\/p>\n Bild 2: Bild 3: Ein Termin, der durch Ziehen einer Aufgabe in den Kalender erzeugt wurde.<\/span><\/b><\/p>\n<\/div>\n Synchronerfassung<\/b><\/p>\n Bis jetzt hat der Beitrag noch nicht viel mit Access zu tun, was sich nun ändern wird: Wie Sie vielleicht wissen, ist Outlook zwar gut in der Erfassung von Terminen, Kontakten et cetera, aber es bringt zum Beispiel keine Werkzeuge mit, um die im Verlauf eines Tages oder eines Projekts angefallenen Daten auszuwerten und gegebenenfalls in Druckform aufzubereiten (es kann prima Terminpläne und Telefonlisten drucken, aber das ist ein anderes Thema).<\/p>\n Hier kommt Access ins Spiel: Wenn man schon die ganzen Projektzeit-Daten in Outlook erfasst, muss es doch einen Weg geben, diese gleichzeitig in die Tabelle einer passenden Datenbank zu schreiben, die Sie unter dem Namen Projektzeiterfassung.mdb <\/b>in den Beispieldateien zu diesem Beitrag finden.<\/p>\n Voraussetzungen\/Vorbereitung<\/p>\n Outlook 2007 ist ein Muss für den Einsatz dieser Anwendung, da es einige Objekte und Ereigniseigenschaften mit sich bringt, ohne die das automatisierte Nachverfolgen der änderungen an Projektordnern, Aufgaben und Tätigkeiten und das damit verbundene Eintragen der Daten in eine Datenbank nicht möglich wäre. Es gibt aber noch weitere Voraussetzungen:<\/p>\n Outlook 2007 bietet immerhin einige Ereignisse, die mit den verschiedensten Ordnern und Elementen zusammenhängen und – so viel sei vorweggenommen – teilweise nicht ganz unkompliziert sind. Nun denn: Schauen wir uns an, was denn bei Verwendung des Projektzeiterfassungs-Frontends namens Outlook so alles erfasst werden müsste:<\/p>\n Dies sind die Aktionen, die beim Anlegen von Elementen zu beachten sind. Es gibt noch eine Reihe weiterer Aktionen, die etwa durch das ändern, Verschieben oder Löschen von Elementen ausgelöst werden. Dies sind im Einzelnen:<\/p>\n Ereignisreich<\/p>\n <\/p>\n Das schöne an Outlook gegenüber allen anderen Mail-Clients und PIM-Programmen ist, dass es mit VBA steuerbar ist und – noch viel besser – auch noch die Möglichkeit bietet, Ereignisse von Objekten abzufangen und mit eigenem Code zu versehen. Einen kleinen Eindruck davon haben Sie bereits im Beitrag Outlook-Objekte in Access speichern <\/b>(Shortlink 500) erhalten, nun geht es an den knallharten Praxiseinsatz.<\/p>\n Projektordner in Projektdatensätze Als Erstes kümmern Sie sich um die Projektordner: Jedesmal, wenn der Benutzer einen neuen Ordner anlegt, soll Outlook dessen Informationen in der Tabelle tblProjekte <\/b>speichern. Ein Projekt entspricht ja, wie weiter vorne erwähnt, einem Aufgabenordner in Outlook. Da die Benutzer vermutlich auch noch andere Aufgabenordner als die für Projekte benötigen, erstellen Sie für die Projektordner einen speziellen übergeordneten Aufgabenordner. Outlook sollte beim Start prüfen, ob der Projektordner schon vorhanden ist und ihn gegebenenfalls anlegen. Dazu benötigen Sie zunächst eine passende Objektvariable, die in diesem Fall mit dem Schlüsselwort WithEvents <\/b>deklariert wird. Auf diese Weise können Sie, ähnlich wie bei Formularen oder Steuerelementen, Ereignisprozeduren schreiben, die beim Arbeiten mit diesem Element ausgelöst werden:<\/p>\n Um diese Zeile einzugeben, müssen Sie zunächst den VBA-Editor mit dem passenden Outlook-VBA-Projekt öffnen, was unter Outlook am schnellsten mit Alt + F11 <\/b>erledigt ist. Sie finden dort ein Standardprojekt namens ThisOutlookSession <\/b>(deutsche Variante: DieseOutlookSitzung<\/b>) vor. Hier tragen Sie auch die folgende Routine ein, die mit dem AutoExec<\/b>-Makro von Access vergleichbar ist: Sie wird nämlich beim Start von Outlook automatisch aufgerufen. In diesem Falle belegt sie die oben deklarierte Objektvariable mit einem Aufgabenordner namens Projekte<\/b>. Beim ersten Aufruf ist dieser noch nicht vorhanden, was einen Fehler auslöst, den die Routine erkennt und mit dem Anlegen des benötigten Ordners ausbügelt – beim nächsten Versuch direkt im Anschluss wird die Folders<\/b>-Auflistung des Projekte<\/b>-Ordners dann zugewiesen (auch wenn sie zu diesem Zeitpunkt noch leer ist):<\/p>\n Was haben Sie nun davon Nun: Sie haben ein Objekt, für das Sie Ereignisprozeduren anlegen können, die etwa beim Hinzufügen oder ändern eines Ordners unterhalb des Projekte<\/b>-Ordners ausgelöst werden. Dies nutzen Sie nun zunächst für eine Routine, die beim Anlegen eines neuen Projektordners einen entsprechenden Datensatz in die Tabelle tblProjekte <\/b>der Projektzeiterfassungs-Datenbank einträgt (s. Listing 1). Die Routine prüft, ob der Ordner standardmäßig Aufgaben aufnimmt, und setzt dann eine SQL-Anweisung zusammen, die einen neuen Eintrag mit dem Namen des Ordners in die Tabelle tblProjekte <\/b>einträgt.<\/p>\n Listing 1: Eintragen eines neuen Projekts<\/p>\n Nun fehlt dem Projektordner noch eine Information, die das anschließende Zuordnen zum frisch angelegten Datensatz erlaubt. Geeignet wäre hierfür die Datensatznummer in der Datenbank. Diese müssen Sie dem Outlook-Ordner nun noch in geeigneter Weise zuweisen. üblicherweise verwendet man dafür die sonst nicht genutzte BillingInformation<\/b>-Eigenschaft oder eine benutzerdefinierte Eigenschaft. Beides steht aber nur für Elemente wie Mails, Termine et cetera zur Verfügung und nicht für Ordner. Also behilft man sich mit einer Notlösung und schreibt einen Ausdruck wie [project|125] <\/b>in die Eigenschaft Description <\/b>des Ordners. 125 <\/b>wäre hier die ProjektID <\/b>aus der Tabelle tblProjekte<\/b>, die Sie mit der @@IDENTITY<\/b>-Funktion von SQL ermitteln. Diese Funktion liefert den zuletzt in irgendeiner Tabelle der Datenbank eingefügten Autowert; die Verwendung eines Autowerts als Wert des Primärschlüsselfeldes ist hier also obligatorisch. Das Drumherum, also [project|…]<\/b>, dient der sicheren Identifizierung der Datensatznummer.<\/p>\n Wenn Sie nun Outlook neu starten und automatisch ein Projekte<\/b>-Ordner im Bereich Aufgaben <\/b>erscheint, können Sie das erste Projekt anlegen und einen ersten Blick in die Tabelle tblProjekte <\/b>werfen. Dort sollte der erste Eintrag nun ebenfalls zu finden sein. Legen Sie nun direkt die nächste Ereignisprozedur an, die beim ändern des Ordners durch das Ereignis FolderChange <\/b>ausgelöst wird (s. Listing 2). Diese Routine liest zunächst die ID des betroffenen Ordners aus – genau die ID, die Sie per [project|…] <\/b>in die Eigenschaft Description <\/b>eingebettet haben. Dafür sorgt die Funktion GetID<\/b>, die für das Ermitteln der IDs verschiedener Objekte wie Ordner, Aufgaben und Tätigkeiten verantwortlich ist. Für das Ermitteln der Projekt-ID übergeben Sie der Funktion den Description<\/b>-Wert sowie eine Zeichenfolge zur Charakterisierung des zu ermittelnden Wertes – hier project<\/b> (dies scheint hier doppelt gemoppelt, ist aber an anderer Stelle sinnvoll, wie Sie weiter unten lesen werden).<\/p>\n Listing 2: ändern der Eigenschaften eines Projekts<\/p>\n Die Routine prüft diesen Wert. Ist er 0<\/b>, bedeutet dies, dass der Ordner noch gar nicht vorhanden ist und neu in der Datenbank angelegt werden muss. Hat er einen anderen Wert, passt die Routine den entsprechenden Datensatz in der Tabelle tblProjekte <\/b>an. Woher aber kommt ein Ordner, der noch nicht in der Datenbank erfasst ist<\/p>\n Nun: Wenn der Benutzer direkt unterhalb des Aufgabenordners einen Ordner anlegt und diesen anschließend in den Projekte<\/b>-Ordner zieht, wird dieser – im Sinne der vorliegenden Anwendung – auch zum Projektordner und entsprechend erfasst und gekennzeichnet.<\/p>\n Aufgaben anlegen<\/b><\/p>\n Das Anlegen von Aufgaben eines Projekts soll erfolgen, wenn der Benutzer den passenden Ordner ausgewählt hat und der Aufgabenliste dieses Ordners einen neuen Eintrag hinzufügt. Eine Ereignisprozedur soll dann auch einen entsprechenden Eintrag zur Tabelle tblAufgaben <\/b>der Datenbank hinzufügen.<\/p>\n Das ist allerdings leichter gesagt als getan, denn es gibt ja beliebig viele Projektordner, deren Ereignisse Sie abfangen müssten. Und damit kommt hier nun die kniffligste Stelle der gesamten Anwendung – zumindest für Entwickler, die noch wenig Kontakt mit der Programmierung von Collections und Klassen hatten: Sie müssen nämlich dynamisch für jeden Projektordner ein Objekt anlegen, das dessen Eigenschaften aufnimmt und vor allem auf Ereignisse reagiert – wie etwa das Hinzufügen einer neuen Aufgabe sowie das Verschieben, ändern und Löschen bestehender Aufgaben. Da Sie beim Programmieren noch nicht wissen, welche Projektordner der Benutzer anlegen wird, können Sie natürlich auch keine entsprechenden Objekte vorproduzieren, sodass diese zur Laufzeit erzeugt werden müssen. Und das geht so: Sie erstellen zunächst eine Klasse namens clsTasks<\/b>, welche die Deklaration eines Folder<\/b>-Objekts und einer Items<\/b>-Auflistung enthält:<\/p>\n Zusätzlich erzeugen Sie einige Ereignisprozeduren, die durch bestimmte Aktionen ausgelöst werden. Für das Projektordner-Element wären das die folgenden Zwei:<\/p>\n Außerdem legen Sie in dieser Klasse einige Ereignisprozeduren für die Auflistung der im Ordner enthaltenen Aufgaben-Objekte fest:<\/p>\n Möglicherweise fehlt Ihnen hier ein Ereignis, das beim Löschen einer Aufgabe ausgelöst wird: Dies ist bereits durch BeforeItemMove <\/b>abgedeckt – das Löschen einer Aufgabe entspricht nämlich dem Verschieben in den Gelöschte Objekte<\/b>-Ordner. Die Ereignisprozeduren führen nichts kompliziertes aus: Sie prüfen lediglich, ob das jeweilige Objekt (also Projektordner oder Tätigkeit) im Mülleimer von Outlook gelandet ist, und tragen in diesem Fall einen Wert in das Feld GeloeschtAm <\/b>des passenden Datensatzes in der Datenbank ein. Alternativ werden neue oder geänderte Tätigkeiten samt Eigenschaften in die Datenbank geschrieben – für weitere Informationen sehen Sie sich einfach den Quellcode des Moduls clsTasks <\/b>an.<\/p>\n Jetzt aber zum schwierigen und vielleicht nicht so einfach nachvollziehbaren Teil: Sie müssen für jeden Projektordner ein Objekt auf Basis von clsTasks <\/b>instanzieren und ihm die passenden Objekte und Eigenschaften zuweisen. Dies geschieht ebenfalls in der Routine Application_Startup<\/b>, die Sie bereits weiter oben kennen gelernt haben. Zunächst deklarieren Sie im Modulkopf eine Variable für die Auflistung, die alle für die verschiedenen Projektordner angelegten clsTasks<\/b>-Objekte aufbewahren soll:<\/p>\n In Application_Startup <\/b>deklarieren Sie weiterhin folgende Variablen (wir führen hier nur die für das Erzeugen der Projektordner-Objekte notwendigen Schritte auf, die Routine Application_Startup <\/b>im Zusammenhang finden Sie in den Dateien ThisOutlookSession.cls <\/b>beziehungsweise clsTasks.cls<\/b>):<\/p>\n Die Variable objProjects <\/b>speichert den jeweils aktuellen Projektordner beim Durchlaufen aller im Projekte<\/b>-Ordner enthaltenen Ordner, objTasks <\/b>nimmt die im jeweiligen Ordner enthaltenen Aufgaben-Objekte auf. In Application_Startup <\/b>geschieht dann weiterhin Folgendes:<\/p>\n Zunächst wird also das Objekt colProjects <\/b>instanziert, damit es im Anschluss die aus clsTasks <\/b>erzeugten Objekte sowie die Ordner-Objekte aufnehmen kann.<\/p>\n Diese werden in einer For Each<\/b>-Schleife über alle in dem weiter oben angelegten Objekt objProjects <\/b>durchlaufen, das ja bereits weiter oben erzeugt wurde.<\/p>\n Dabei wird zunächst eine neue Instanz von clsTasks<\/b> erzeugt und dann seine Eigenschaft Project <\/b>mit dem aktuellen Projektordner-Objekt gefüllt – dazu gleich mehr.<\/p>\n Das Objekt objTasks <\/b>wird dann der Auflistung colProjects <\/b>hinzugefügt. Würde man das Objekt nicht auf diese Weise „wegspeichern“, würde es beim Erzeugen des nächsten objTasks<\/b>-Objekts von diesem überschrieben – die Collection ist also lediglich ein Container ohne weitere Funktion.<\/p>\n Die oben angesprochene Eigenschaft Project <\/b>sorgt dafür, dass man dem jeweiligen objTasks<\/b>-Objekt einen Verweis auf das den aktuellen Projektordner repräsentierende Objekt objProject <\/b>übergeben kann. Dazu brauchen Sie in der Klasse clsTasks <\/b>noch eine entsprechende Property Get<\/b>-Prozedur, welche die private Variable mProject <\/b>von außerhalb des Objekts änderbar macht:<\/p>\n Nachdem dadurch für jeden im Projekte<\/b>-Ordner enthaltenen Ordner ein objTasks <\/b>angelegt wurde, greifen nachfolgend auch die enthaltenen Ereignisse und lösen die passenden Prozeduren aus.<\/p>\n Von der Aufgabe zur Tätigkeit<\/b><\/p>\n Fehlt noch der letzte Schritt: Der Benutzer soll Einträge aus der Aufgabenliste in den Kalender ziehen und daraus Termine erzeugen können, die ja im Kontext dieser Anwendung als Tätigkeiten gelten. Das Problem dabei ist, dass, im Gegensatz zum Anlegen einer Aufgabe im Ordner eines Projekts, keinerlei Verbindung zwischen dem neuen Termin und der Aufgabe besteht – mit einer Ausnahme: einige Eigenschaften, die im Textformat in der Beschreibung des Termins zu finden sind, darunter in diesem Fall eben auch die in der Eigenschaft BillingInformation <\/b>enthaltenen (siehe Bild 4).<\/p>\n Bild 4: Diese Eigenschaften „vererbt“ eine Aufgabe einem daraus abgeleiteten Termin.<\/span><\/b><\/p>\n<\/div>\n Das reicht auch völlig aus: Die in der Form [task|271][project|89] <\/b>gespeicherten Informationen können Sie beim Anlegen des Termins auslesen und weiterverwenden. Doch so weit sind wir noch nicht: Zunächst brauchen Sie auch noch ein paar Ereignisse, die in Zusammenhang mit dem Erstellen, ändern und Löschen von Terminen ausgelöst werden – und das damit verbundene Objekt. Analog zu den Projektordnern\/Aufgaben teilen sich auch die hier benötigten Ereignisse auf den Terminordner – hier synonym mit „Outlook-Kalender“ – und die Termin-Objekte selbst auf. Die benötigten und im Kopf des Moduls ThisOutlookSession <\/b>deklarierten Objektvariablen sehen so aus:<\/p>\n Im Gegensatz zu den Projektordnern gibt es allerdings nur einen Terminordner, den Sie in der Routine Application_Startup <\/b>so instanzieren:<\/p>\n Die Auflistung der Elemente dieses Ordners referenzieren Sie per Objektvariable folgendermaßen:<\/p>\n Das Terminordner-Objekt objAppointmentFolder <\/b>steuert nur ein Ereignis bei. Es heißt BeforeItemMove <\/b>und prüft lediglich, ob ein verschobenes Termin-Objekt in den Mülleimer gewandert ist, um den Wert des Feldes GeloeschtAm <\/b>des betroffenen Datensatzes der Tabelle tblTaetigkeiten <\/b>auf den Löschzeitpunkt einzustellen. Dies schließt das Löschen beispielsweise mit einem Kontextmenüeintrag oder der Entfernen<\/b>-Taste mit ein – immerhin lösen Sie auch hiermit nur das Verschieben des betroffenen Elements aus.<\/p>\n Die Objektvariable objAppointments<\/b>, die alle im Terminordner enthaltenen Objekte umfasst, stellt die beiden Ereignisse ItemAdd<\/b> und ItemChange <\/span>zur Verfügung. ItemAdd <\/span>reagiert beim Hinzufügen eines Termins, etwa durch das Ziehen einer Aufgabe in den Kalender, aber auch bei anderen Vorgängen, die einen neuen Termin erzeugen. Ob der Termin auf einer Aufgabe basiert, prüft die Routine, indem sie den Inhalt der Eigenschaft Body <\/b>des neuen Termins auf Vorkommen eines Ausdrucks der Form [task|…] <\/b>prüft. Ist dieser vorhanden, stammt der Termin von einer Aufgabe ab und wird samt seiner Eigenschaften in der Tabelle tblTaetigkeiten <\/b>der Datenbank gespeichert. Die Routine fragt dann noch die ID des neu hinzugefügten Datensatzes ab und schreibt einen Ausdruck der Form [action|…][task|…] <\/b>in die BillingInformation<\/b>-Eigenschaft des neuen Termins, um diesen bei späteren änderungen mit seinem Pendant in der Datenbank synchronisieren zu können.<\/p>\n Dies ist zum Beispiel beim ändern der Fall. änderungen werden durch das Ereignis ItemChange <\/b>abgefangen; die in der Prozedur enthaltenen Vorgänge sind trivial: Prüfen, ob es sich um einen per Aufgabe erzeugten Termin handelt, Daten in die Datenbank übertragen – fertig.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die hier vorgestellte Anwendung lässt die neuen Möglichkeiten von Outlook und Access in der Version 2007 erahnen. Projektzeiten mit dem Standardinstrument Outlook zu erfassen – das dürfte der Traum vieler Projektleiter und Mitarbeiter sein, da komfortabler, als dies in einer weiteren Anwendung zu erledigen.<\/p>\n Möglichkeiten zur Optimierung beziehungsweise Erweiterung gibt es genug: Zum Beispiel könnten Sie eine hierarchische Projektstruktur erzeugen, damit man Projekten noch Unterprojekte hinzufügen kann. Noch nicht abgefragt wird in der aktuellen Version außerdem das Kopieren und Einfügen bestehender Tätigkeiten, und auch das Anlegen von Terminen ohne Bezug zu einer Aufgabe und damit zu einem Projekt alias Kostenstelle könnten Sie noch unterbinden. Für Benutzer, die mit dem Löschen von Elementen manchmal zu schnell bei der Sache sind, könnte man außerdem eine Möglichkeit realisieren, das Wiederherstellen eigentlich gelöschter Objekte zu tracken und entsprechend in die Datenbank zu übertragen.<\/p>\n Ach, und wenn Sie nicht gerade Ein-Mann-Unternehmen mit dieser Projektzeiterfassung versorgen möchten, wäre Mehrbenutzerfähigkeit sicher ganz hilfreich und nicht besonders aufwendig zu implementieren.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Projektzeiterfassung.zip<\/p>\n\n ![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookFrontend-web-images\/pic001_opt.jpeg\")
\n<\/div>\n\n\n ![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookFrontend-web-images\/pic002_opt.jpeg\")
\n<\/div>\n\n
Neue Tätigkeiten legen Sie durch Ziehen von Aufgaben in den Kalender an.<\/span><\/b><\/p>\n<\/div>\n\n ![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookFrontend-web-images\/pic003_opt.jpeg\")
\n<\/div>\n\n\n\n
\n
\n
umwandeln<\/b><\/p>\nDim WithEvents objProjects As Outlook.Folders<\/pre>\n
Private Sub Application_Startup() \r\nOn Error Resume Next\r\nSet objProjects = _
GetTaskfolder.Folders("Projekte").Folders\r\nIf Not Err.Number = 0 Then\r\n GetTaskfolder.Folders.Add "Projekte", _
olFolderTasks\r\nEnd If\r\nSet objProjects = _
GetTaskfolder.Folders("Projekte").Folders\r\n ...\r\nEnd Sub<\/pre>\n\nPrivate Sub objProjects_FolderAdd(ByVal Folder As MAPIFolder)\r\n Dim strSQL As String\r\n Dim objTasks As clsTasks\r\n Select Case Folder.DefaultItemType\r\n Case olTaskItem\r\n strSQL = "INSERT INTO tblProjekte(Projektbezeichnung) VALUES('" & Folder.Name & "')"\r\n CurrentDBC.Execute strSQL, dbFailOnError\r\n If CurrentDBC.RecordsAffected = 1 Then\r\n Folder.Description = "[project|" _
& CurrentDBC.OpenRecordset("SELECT @@IDENTITY").Fields(0).Value & "]"\r\n End If\r\n Case Else\r\n End Select\r\n ...\r\nEnd Sub<\/pre>\n<\/div>\n\nPrivate Sub objProjects_FolderChange(ByVal Folder As MAPIFolder)\r\n Dim strDescription As String\r\n Dim lngProjectID As Long\r\n Dim strSQL As String\r\n Select Case Folder.DefaultItemType\r\n Case olTaskItem\r\n strDescription = Folder.Description\r\n lngProjectID = GetID(strDescription, "project")\r\n If lngProjectID = 0 Then\r\n strSQL = "INSERT INTO tblProjekte(Projektbezeichnung) VALUES('" & Folder.Name & "')"\r\n CurrentDBC.Execute strSQL, dbFailOnError\r\n If CurrentDBC.RecordsAffected = 1 Then\r\n Folder.Description = "[project|" _
& CurrentDBC.OpenRecordset("SELECT @@IDENTITY").Fields(0).Value & "]"\r\n End If\r\n Else\r\n strSQL = "UPDATE tblProjekte SET Projektbezeichnung = '" & Folder.Name _
& "' WHERE ProjektID = " & lngProjectID\r\n CurrentDBC.Execute strSQL, dbFailOnError\r\n End If\r\n End Select\r\nEnd Sub<\/pre>\n<\/div>\nPrivate WithEvents mProject As Outlook.Folder\r\nPrivate WithEvents mTasks As Outlook.Items<\/pre>\n
\n
\n
Dim colProjects As Collection<\/pre>\n
Dim objProject As Outlook.Folder\r\nDim objTasks As clsTasks<\/pre>\n
Set colProjects = New Collection\r\nFor Each objProject In objProjects\r\n Set objTasks = New clsTasks\r\n Set objTasks.Project = objProject\r\n colProjects.Add objTasks\r\nNext<\/pre>\n
Public Property Set Project(objProject As _
Outlook.Folder)\r\n Set mProject = objProject\r\n Set mTasks = objProject.Items\r\nEnd Property<\/pre>\n\n ![\"pic004.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookFrontend-web-images\/pic004_opt.jpeg\")
\n<\/div>\n\nDim WithEvents objAppointmentFolder _
As Outlook.Folder\r\nDim WithEvents objAppointments As Outlook.Items<\/pre>\nSet objAppointmentFolder = GetMAPINamespace.GetDefaultFolder(olFolderCalendar)<\/pre>\n
Set objAppointments = objAppointmentFolder.Items<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n