<\/p>\n
Zum Eingeben von Terminen gibt es mittlerweile verschiedene eingebaute und zusätzliche Techniken. Aber was ist, wenn der Benutzer in einer Anwendung gleich mehrere Termine anlegen möchte – beispielsweise, um gleich für ein ganzes Jahr eine Erinnerung an die Umsatzsteuervoranmeldung zu speichern oder um die Geburtstage seiner Bekannten in seiner Termindatenbank anzulegen Hier würde ein flexibel einsetzbares Tool eine Menge Arbeit sparen. Wie Sie solch ein Tool programmieren, erfahren Sie in diesem Beitrag.<\/b><\/p>\n
Der konkrete Anlass für die Erstellung der im vorliegenden Beitrag beschriebenen Lösung ist die Aufgabenmanagement-Datenbank aus dem Beitrag Tomatengetriebene Programmierung <\/b>(www.access-im-unternehmen.de\/791<\/b>). Dort soll der Benutzer gleich eine ganze Reihe von täglich, wöchentlich, monatlich oder jährlich wiederkehrenden Terminen anlegen können.<\/p>\n
Welche Anforderung gibt es an eine solche Lösung Sie sollte eine Benutzeroberfläche bieten, die dem Benutzer das Anlegen der gewünschten Termine erleichtert.<\/p>\n
Und sie sollte die Termine in einem Format liefern, das sich leicht weiterverarbeiten lässt. Am leichtgewichtigsten scheint hier ein Array zu sein, das einfach nur die ermittelten Termindaten enthält.<\/p>\n
Die Anforderungen an die Ermittlung der Termine sind schon vielfältiger. Die erste Auswahl betrifft die Art der Terminserie. Die vorliegende Lösung soll diese Varianten abdecken:<\/p>\n
Eine weitere Option betrifft Feiertage und Wochenenden. Sollen diese einfach als Termine zurückgegeben werden können oder soll die Lösung den vorherigen oder den folgenden Tag liefern, wenn der eigentlich gewünschte Termin auf einen Feiertag oder ein Wochenende fällt (wobei Wochenende noch auf Samstag und Sonntag aufzuteilen ist)<\/p>\n
Und was geschieht, wenn der Benutzer als monatliches Datum den 31. Tag auswählt Soll dann der vorherige oder der folgende Tag zurückgegeben werden, wenn der jeweilige Monat keine 31 Tage hat<\/p>\n
Schließlich wäre noch zu klären, ob die Termine innerhalb eines bestimmten Zeitraums gefunden werden sollen (etwa vom 1. Januar 2012 bis 30. Juni 2012) oder ob einfach eine bestimmte Anzahl an Terminen ermittelt werden soll.<\/p>\n
Dies alles deckt das Formular aus Bild 1 ab.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2011_04\/Terminserien-web-images\/pic001.png\")
<\/p>\n
Bild 1: Formular zur Definition von Terminserien<\/span><\/b><\/p>\n Eine Rahmenbedingung können wir jedenfalls schon festlegen: Der Benutzer soll schlicht eine Funktion namens Terminserie <\/b>aufrufen und von dieser ein Array mit den entsprechenden Datumsangaben zurückerhalten.<\/p>\n Wenn Termine auf ungünstige Daten fallen<\/b><\/p>\n Je nach der Art der zu ermittelnden Terminserie kann es sein, dass die Lösung Termine nicht auf bestimmte Tage setzen kann, beispielsweise bei Samstagen, Sonntagen oder Feiertagen oder wenn der Benutzer etwa den 31. Tag eines Monats als monatlichen oder jährlichen Termin angibt.<\/p>\n Bei ungültigen Terminen wie etwa dem 31. Februar soll die Anwendung den letzten Tag des jeweiligen Monats zurückliefern.<\/p>\n Die Vorgehensweise für Samstage, Sonntage und Feiertage hingegen behandelt der untere Teil des Formulars. Eigentlich sollte die Lösung maximale Flexibilität bieten, indem Sie für Samstage, Sonntage und Feiertage separat eine der folgenden Aktionen auswählen können:<\/p>\n Wenn Sie aber nun festlegen, dass Termine vom Sonntag auf den folgenden Tag verschoben werden, und angeben, dass Termine, die auf Feiertage fallen, ignoriert werden sollen, haben Sie ein Problem, wenn der Tag nach dem Sonntag zufällig ein Feiertag ist. Der zu verschiebende Sonntagstermin würde dann nämlich auf den Feiertag verschoben werden und somit wegfallen.<\/p>\n Also haben wir eine etwas weniger flexible Variante gewählt: Der Benutzer legt dort zunächst fest, ob er Termine, die auf Samstage, Sonntage und\/oder Feiertage fallen, gesondert behandeln möchte. Für alle gewählten Fälle gibt er dann an, ob die Termine auf den vorherigen oder den folgenden Tag fallen oder ob diese ignoriert werden sollen.<\/p>\n Formular zur Eingabe der Datumsinformationen<\/b><\/p>\n Bild 2 zeigt den Entwurf des Formulars zur Eingabe der Parameter für die Erstellung der Terminserie. Im oberen Bereich wählt der Benutzer zunächst die Art der Terminserie aus. Die dort verwendete Optionsgruppe heißt ogrSerienart<\/b>. Die Optionen erhalten von oben bis unten die Werte 1 <\/b>bis 4<\/b>.<\/p>\n Bild 2: Entwurf des einzigen Formulars der Lösung<\/span><\/b><\/p>\n Die Optionsgruppe hat standardmäßig den Wert 1 <\/b>(Täglich<\/b>). Bis der Benutzer eine andere Option auswählt, sollen die neben den Optionen angezeigten Steuerelemente zur Eingabe weiterer Parameter deaktiviert sein. Erst bei änderung des Wertes von ogrSerienart <\/b>werden die entsprechenden Steuerelemente aktiviert. Dafür sorgt die Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>der Optionsgruppe ausgelöst wird:<\/p>\n Dies ist eine etwas platzsparende Schreibweise, deren Funktion möglicherweise erst auf den zweiten Blick deutlich wird. Die folgende Zeile etwa sorgt dafür, dass ogrWoechentlich <\/b>aktiviert wird, wenn die Optionsgruppe ogrSerienart <\/b>den Wert 2 <\/b>hat (dann liefert Me!ogrSerienart = 2 <\/b>den Wert True<\/b>, was dazu führt, dass auch die Enabled<\/b>-Eigenschaft von ogrWoechentlich <\/b>auf True <\/b>eingestellt wird): <\/p>\n Festlegen des Datumsbereichs<\/b><\/p>\n Beim Laden des Formulars werden die beiden Textfelder zur Eingabe des Datumsbereichs, txtStart<\/b> und txtEnde<\/b>, mit dem aktuellen Datum bestückt.<\/p>\n Außerdem sollen diese mit den Funktionen zur einfachen Datumseingabe, wie im Beitrag Flexible Datumstextfelder <\/b>(www.access-im-unternehmen.de\/690<\/b>) beschrieben, bestückt werden. Dazu fügen Sie beiden Klassen clsDateboxes <\/b>und clsDatebox <\/b>aus der entsprechenden Beispieldatenbank hinzu. Im Kopf des Klassenmoduls des Formulars wird eine Variable zum Speichern der Referenz auf diese Klasse deklariert:<\/p>\n In der Prozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, wird eine entsprechende Instanz erzeugt. Dieser weisen Sie auch gleich die beiden Textfelder txtStart <\/b>und txtEnde <\/b>zu:<\/p>\n Aufruf des Formulars<\/b><\/p>\n Den Einstiegspunkt für die Lösung zum Erstellen von Terminserien bietet die VBA-Prozedur Terminserie<\/b>, die Sie im Modul mdlTerminserie <\/b>finden. Diese Prozedur können Sie von beliebigen anderen Modulen aus aufrufen. Sie öffnet das Formular frmTerminserie<\/b>, ermöglicht dem Benutzer die Eingabe der gewünschten Parameter und liest nach einem Klick auf die OK<\/b>-Schaltfläche des Formulars die ermittelten Termine aus der öffentlichen Variablen Termine <\/b>des Formulars aus.<\/p>\n Die Terminliste kommt als Array und kann anschließend entsprechend weiterverarbeitet werden. Wenn Sie die Termine einfach im Direktfenster ausgeben möchten, verwenden Sie beispielsweise den folgenden Aufruf:<\/p>\n <\/p>\n Die Funktion ruft die Funktion Terminserie <\/b>auf, die dafür sorgt, dass das Formular geöffnet wird und anschließend ein Array mit den gefundenen Daten zurückliefert.<\/p>\n In der folgenden Schleife gibt die Prozedur alle gefundenen Daten im Direktfenster aus. Sollte ein leeres Array zurückgeliefert werden, erzeugt der Zugriff auf die Methode LBound <\/b>einen Fehler – diesen behandeln wir aber entsprechend mit On Error Resume Next <\/b>und geben einen Hinweis auf das leere Array im Direktfenster aus.<\/p>\n Terminserie erstellen<\/b><\/p>\n Es gibt zwei Möglichkeiten, eine Terminserie zu erstellen. Ein Klick auf die OK<\/b>-Schaltfläche erstellt eine Terminserie und macht dann das Formular frmTerminserie <\/b>unsichtbar, damit die aufrufende Funktion Terminserie <\/b>die ermittelten Termine auslesen kann. Sie können aber auch auf die Schaltfläche Termine anzeigen <\/b>klicken.<\/p>\n Auch die Prozedur, die durch diese Schaltfläche ausgelöst wird, ruft die Funktion Terminserie <\/b>auf. Allerdings zeigt sie die ermittelten Termine gleich in einem Meldungsfenster an.<\/p>\n Auf diese Weise kann der Benutzer vor dem Schließen des Formulars prüfen, ob dieses die richtigen Termine zurückliefert (s. Bild 3).<\/p>\n Bild 3: Anzeige der gefundenen Termine im Meldungsfenster<\/span><\/b><\/p>\n Die wesentlichen Schritte beim Füllen des Termin-Arrays erledigt also die Funktion Terminserie<\/b> (s. Listing 1<\/a><\/span>). Diese Funktion ermittelt die Liste der Termine entsprechend den Einstellungen im Formular und speichert das resultierende Array in einer Variablen, die im Kopf des Moduls deklariert wird:<\/p>\n Listing 1: Diese Prozedur führt den eigentlichen Suchvorgang durch.<\/p>\n Diese Array-Variable wird gleich zu Beginn mit der Erase<\/b>-Anweisung geleert. Danach ruft die Routine eine weitere Funktion namens GueltigeTermine <\/b>auf (siehe weiter unten).<\/p>\n Die Funktion GueltigeTermine <\/b>liefert ein Collection<\/b>-Objekt mit allen Datumsangaben für den durch den Benutzer ausgewählten Zeitraum zurück.<\/p>\n Das Collection<\/b>-Objekt speichert das Datum als String in der Key<\/b>-Eigenschaft. In der Item<\/b>-Eigenschaft hingegen wird entweder der Wert True <\/b>oder False <\/b>gespeichert – je nachdem, ob Samstage, Sonntage und\/oder Feiertage bei der Terminfindung ausgeschlossen werden sollen.<\/p>\n Das Collection<\/b>-Objekt enthält also beispielsweise solche Werte (Key<\/b>\/Value<\/b>), wobei True <\/b>die möglichen Termine kennzeichnet und False <\/b>diejenigen, die wegen Feiertag\/Samstag\/Sonntag je nach Konfiguration im Formular nicht für die Terminserie zur Verfügung stehen, zum Beispiel 31.12.2011<\/b>\/True<\/b>, 1.1.2011<\/b>\/False<\/b> oder 2.1.2012<\/b>\/True<\/b>.<\/p>\n Dann beginnt die Prozedur mit dem Durchlaufen einer Schleife über alle Daten des im Formular angegebenen Zeitraums.<\/p>\n Innerhalb der Schleife wird nach der Art der Terminserie unterschieden, also nach täglichen, wöchentlichen, monatlichen oder jährlichen Terminen.<\/p>\n Bei den täglichen Terminen soll einfach für jedes Datum des gewählten Zeitraums ein Termin angelegt werden – mit Ausnahme solcher Termine, die in der Collection colGueltigeTermine <\/b>mit dem Wert False <\/b>gekennzeichnet sind.<\/p>\n Dies wird einfach durch den Ausdruck colGueltigeTermine(CStr(dat)) = True <\/b>geprüft. Ist der Ausdruck wahr, ruft die Prozedur die Funktion TerminHinzufuegen <\/b>auf und übergibt das Datum, das Array mit allen Daten der Terminserie sowie einen Zähler, der beim Anlegen eines Termins hochgezählt wird und den Index des Arrays markiert.<\/p>\n Der Code der Prozedur TerminHinzufuegen <\/b>ist überschaubar. Hier wird lediglich das Array neu dimensioniert, das Datum als neuer Wert hinzugefügt und der Zähler intCount <\/b>um 1 <\/b>erhöht:<\/p>\n Wöchentliche Termine hinzufügen<\/b><\/p>\n Ein wenig aufwendiger wird das Prozedere für die wöchentlichen Termine. Hier wird nicht gleich die Prozedur TerminHinzufuegen <\/b>aufgerufen, sondern zunächst die Routine TerminVerarbeiten<\/b>. Außerdem wird hier nicht jedes Datum im angegebenen Zeitraum verarbeitet, sondern nur solche, die auf den angegebenen Wochentag fallen. Dazu zieht die Prozedur die Funktion Weekday <\/b>heran und vergleicht den gefundenen Wert (beispielsweise 1 <\/b>für Montag<\/b>) mit dem in der Optionsgruppe ogrWoechentlich <\/b>ausgewählten Tag. Stimmen diese überein, übernimmt die Prozedur TerminVerarbeiten <\/b>das Steuer.<\/p>\n Die Prozedur TerminVerarbeiten <\/b>(s. Listing 2<\/a><\/span>) prüft zunächst anhand der Collection colGueltigeTermine<\/b>, ob das Datum auf einen unerwünschten Tag fällt, also je nach Einstellung des Formulars auf einen Samstag, Sonntag und\/oder Feiertag. Falls nicht, sorgt ein Aufruf der Prozedur TerminHinzufuegen <\/b>dafür, dass der Termin in das Terminserie-Array geschrieben wird.<\/p>\n Listing 2: Verarbeiten eines Datums durch direktes Hinzufügen oder vorheriges Verschieben<\/p>\n Fällt das Datum auf einen unerwünschten Termin, wird das Datum je nach der gewählten Option um einen Tag nach vorne oder hinten verschoben.<\/p>\n Dies erledigt die Prozedur TerminVerschieben<\/b> (s. Listing 3<\/a><\/span>). Sie speichert zunächst das zu prüfende Datum in der Variablen datVerschoben <\/b>zwischen. Dann durchläuft sie so lange eine Do While<\/b>-Schleife, bis das Datum einem gültigen Termin entspricht.<\/p>\n Listing 3: Verschieben und anlegen eines Termins<\/p>\n Dabei wird das Datum jeweils um einen Tag nach vorn oder hinten verschoben – je nach der Einstellung der Optionsgruppe ogrTerminverschiebung<\/b>. Dort nimmt die Option für den vorherigen Tag den Wert -1 <\/b>ein und die Option für den folgenden Tag den Wert 1<\/b>. Auf diese Weise braucht die Prozedur einfach nur den Wert von ogrTerminverschiebung <\/b>zum aktuellen Datum hinzuzuaddieren. Wurde ein gültiger Termin gefunden, wird dieser mit der Prozedur TerminHinzufuegen <\/b>zum Array der Terminserie hinzugefügt.<\/p>\n Monatliche oder jährliche Termine hinzufügen<\/b><\/p>\n Bei den monatlichen oder jährlichen Terminen werden die Daten auf ähnliche Weise zur Terminserie hinzugefügt. Es kommt jedoch noch die Schwierigkeit hinzu, dass durch die Angabe eines Tages auch ungültige Datumsangaben entstehen können (so etwa beim 31. – diesen Tag gibt es in der Hälfte der Monate nicht).<\/p>\n Wenn dies geschieht, wird die Tagesangabe so lange um 1 <\/b>verkleinert, bis sich zusammen mit dem Monat\/Jahr des aktuell durchlaufenen Datums ein gültiges Datum zusammensetzen lässt.<\/p>\n Erst mit diesem Datum wird dann die Prozedur TerminVerarbeiten <\/b>aufgerufen und der Termin in das Terminserien-Array eingearbeitet.<\/p>\n Schließlich wird das resultierende Array mit dem Rückgabewert TerminserieErstellen <\/b>an die aufrufende Prozedur zurückgegeben.<\/p>\n Gültige Termine ermitteln<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2011_04\/Terminserien-web-images\/pic002.png\")
<\/p>\nPrivate Sub ogrSerienart_AfterUpdate()\r\n Me!ogrWoechentlich.Enabled =\r\n Me!ogrSerienart = 2\r\n Me!txtTag.Enabled = Me!ogrSerienart = 3\r\n Me!txtTagJaehrlich.Enabled =\r\n Me!ogrSerienart = 4\r\n Me!txtMonatJaehrlich.Enabled =\r\n Me!ogrSerienart = 4\r\nEnd Sub<\/pre>\n
Me!ogrWoechentlich.Enabled = Me!ogrSerienart = 2<\/pre>\n
Dim objDateboxes As clsDateboxes<\/pre>\n
Private Sub Form_Load()\r\n Me!txtStart = Date\r\n Me!txtEnde = Date\r\n Set objDateboxes = New clsDateboxes\r\n With objDateboxes\r\n .AddDatebox Me!txtStart\r\n .AddDatebox Me!txtEnde\r\n End With\r\nEnd Sub<\/pre>\n
Public Function Terminserie() As Variant\r\n Dim dat() As Date\r\n DoCmd.OpenForm "frmTerminserie",\r\n WindowMode:=acDialog\r\n If IstFormularGeoeffnet("frmTerminserie") Then\r\n dat = Forms!frmTerminserie.Termine\r\n DoCmd.Close acForm, "frmTerminserie"\r\n End If\r\n Terminserie = dat\r\nEnd Function<\/pre>\nPublic Sub Beispielaufruf()\r\n Dim intCount As Integer\r\n Dim datTermine() As Date\r\n Dim i As Integer\r\n datTermine = Terminserie\r\n On Error Resume Next\r\n For i = LBound(datTermine) To UBound(datTermine)\r\n Debug.Print datTermine(i)\r\n Next i\r\n If Err.Number = 9 Then\r\n Debug.Print "Keine Termine"\r\n End If\r\nEnd Sub<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2011_04\/Terminserien-web-images\/pic003.png\")
<\/p>\nPrivate Function TerminserieErstellen() As Variant\r\n Dim dat As Date\r\n Dim intCount As Integer\r\n Dim intTag As Integer\r\n Dim intMonat As Integer\r\n Dim db As DAO.Database\r\n Dim colGueltigeTermine As Collection\r\n Set db = CurrentDb\r\n Erase datTermine\r\n Set colGueltigeTermine = GueltigeTermine(Me!txtStart, Me!txtEnde, 1)\r\n For dat = Me!txtStart To Me!txtEnde\r\n Select Case Me!ogrSerienart\r\n Case 1\r\n If colGueltigeTermine(CStr(dat)) = True Then\r\n TerminHinzufuegen dat, datTermine, intCount\r\n End If\r\n Case 2\r\n If Weekday(dat, vbMonday) = Me!ogrWoechentlich Then\r\n TerminVerarbeiten dat, datTermine, intCount, colGueltigeTermine\r\n End If\r\n Case 3\r\n intTag = Nz(Me!txtTag, 0)\r\n Do While Not IsDate(intTag & "." & Month(dat) & "." & Year(dat))\r\n intTag = intTag - 1\r\n Loop\r\n If DateSerial(Year(dat), Month(dat), intTag) = dat Then\r\n TerminVerarbeiten dat, datTermine, intCount, colGueltigeTermine\r\n End If\r\n Case 4\r\n intTag = Nz(Me!txtTagJaehrlich, 0)\r\n intMonat = Nz(Me!txtMonatJaehrlich, 0)\r\n Do While Not IsDate(intTag & "." & intMonat & "." & Year(dat))\r\n intTag = intTag - 1\r\n Loop\r\n If DateSerial(Year(dat), intMonat, intTag) = dat Then\r\n TerminVerarbeiten dat, datTermine, intCount, colGueltigeTermine\r\n End If\r\n End Select\r\n Next dat\r\n TerminserieErstellen = datTermine\r\nEnd Function\r\nDim datTermine() As Date<\/pre>\n
Private Sub TerminHinzufuegen(dat As Date, datTermine As Variant, intCount As Integer)\r\n ReDim Preserve datTermine(intCount)\r\n datTermine(intCount) = dat\r\n intCount = intCount + 1\r\nEnd Sub<\/pre>\n
Private Sub TerminVerarbeiten(dat As Date, datTermine As Variant, intCount As Integer, colGueltigeTermine As Collection)\r\n If colGueltigeTermine(CStr(dat)) = True Then\r\n TerminHinzufuegen dat, datTermine, intCount\r\n Else\r\n If Me!ogrSamstageSonntageFeiertage = 1 Then ''sonst ignorieren\r\n TerminVerschieben dat, datTermine, intCount, colGueltigeTermine\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n
Private Function TerminVerschieben(dat As Date, datTermine As Variant, intCount As Integer,\r\n colGueltigeTermine As Collection)\r\n Dim bolGueltigerTermin As Boolean\r\n Dim datVerschoben As Date\r\n bolGueltigerTermin = colGueltigeTermine(CStr(dat))\r\n datVerschoben = dat\r\n Do While Not bolGueltigerTermin = True\r\n datVerschoben = datVerschoben + Me!ogrTerminverschiebung\r\n bolGueltigerTermin = colGueltigeTermine(CStr(datVerschoben))\r\n Loop\r\n TerminHinzufuegen datVerschoben, datTermine, intCount\r\nEnd Function<\/pre>\n