<\/p>\n
Wenn Sie einen Adressblock etwa für die Anzeige in einem Bericht oder für anderweitige Nutzung zusammenstellen wollen, stoßen Sie mitunter auf eine anspruchsvolle Aufgabe. Dummerweise sind die Kundentabellen, aus denen die Adressen bezogen werden sollen, immer unterschiedlich aufgebaut. Noch dazu gibt es manchmal nicht nur eine einzige Adresse, sondern Liefer- und Rechnungsadresse. Dabei treten wiederum Unterschiede auf, wo die primäre Adresse eingetragen wird – also die Adresse, die als Rechnungs- und Lieferadresse genutzt wird, wenn nur eine Lieferadresse oder nur eine Rechnungsadresse vorliegt. Dieser Beitrag zeigt eine Funktion, mit der Sie die Adressblöcke für Ihren Einsatzzweck komfortabel zusammenstellen können.<\/b><\/p>\nBeispieltabelle<\/h2>\n
Ein Beispiel für eine Kundentabelle mit Rechnungs- und Lieferdaten sieht etwa wie in Bild 1 aus. Wenn für einen Kunden eine Lieferanschrift und eine Rechnungsanschrift vorliegt ist der Umgang mit den Daten in dieser Tabelle recht unkompliziert: Sie ermitteln die Lieferadresse aus den oberen Feldern und die Rechnungsadresse aus den unteren Feldern der Tabelle.<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_001.png\")
<\/p>\n
Bild 1: Beispiel für eine Kundentabelle<\/span><\/b><\/p>\n Etwas komplizierter wird es, wenn Liefer- und Rechnungsadresse identisch sind. Dann gilt es zunächst festzustellen, ob diese in den Feldern vorliegt, die mit Liefer… <\/b>beginnen, oder in denen, die mit Rechnung… <\/b>beginnen.<\/p>\n Sie als menschlicher Beobachter erkennen dies normalerweise mit einem Blick, aber wenn wir später automatisiert bestimmen wollen, welcher der beiden Blöcke mit Adressinformationen die gesuchten Informationen liefert, brauchen wir ein auswertbares Kriterium. Wir können an dieser Stelle festlegen, dass zumindest für deutsche Adressen mindestens eine PLZ oder ein Ort vorliegen müssen. Bei den anderen Daten kann es vorkommen, dass das eine oder andere Feld fehlt. Eine Adresse kann zwar Firma und Name einer Person enthalten, aber es kann auch nur eine Firma oder nur eine Person geben. Und auch die Straße muss nicht zwangsläufig angegeben werden, denn es gibt auch Adressen, die nur über Firma, Postleitzahl und Ort definiert werden.<\/p>\n Also legen wir an dieser Stelle fest, dass die PLZ unser Kriterium sein soll, ob in den Liefer…<\/b>-Feldern oder den Rechnung…<\/b>-Feldern eine Adresse vorliegen soll.<\/p>\n In der Tabelle tblKunden <\/b>finden Sie übrigens die beiden Felder LieferAnredeID <\/b>und RechnungAnredeID<\/b>, die mit einer weiteren Tabelle namens tblAnreden <\/b>verknüpft sind.<\/p>\n Im Folgenden wollen wir durch geeignete Konfigurationen und eine entsprechende VBA-Funktion sicherstellen, dass alle Varianten von Adressen wie in Bild 2 abgebildet in entsprechende Adressblöcke umgewandelt werden können. Das heißt, dass wir aus dem vollständigen Datensatz ganz oben die Lieferadresse aus den Liefer…<\/b>-Feldern zusammenstellen und die Rechnungsadresse aus den Rechnung…<\/b>-Feldern. Für den zweiten Datensatz wollen wir die Lieferadresse aus den Liefer…<\/b>-Feldern zusammenstellen – genau wie die Rechnungsadresse. Der dritte Datensatz enthält nur Daten in den Rechnung…<\/b>-Feldern, also sollen sowohl die Lieferadresse als auch die Rechnungsadresse aus diesen Feldern erstellt werden.<\/p>\n Bild 2: Verschiedene Konstellationen von Adressen<\/span><\/b><\/p>\n Der Benutzer\/Entwickler, der mit dieser Lösung arbeitet, soll es möglichst einfach haben, den Adressblock zu definieren. Daher wollen wir einige Daten in einer Konfigurationstabelle festlegen, die der Benutzer nach Wunsch bearbeiten kann.<\/p>\n Diese Tabelle sieht im Entwurf wie in Bild 3 aus. Das erste Feld enthält die Bezeichnung der jeweiligen Konfiguration. Das zweite und dritte Feld dienen der Eingabe eines Schemas für die Platzhalter, die in der Lieferadresse und der Rechnungsadresse verwendet werden sollen (mehr dazu weiter unten).<\/p>\n Bild 3: Konfigurationstabelle<\/span><\/b><\/p>\n Das Feld Standard <\/b>legt fest, ob die Quelltabelle standardmäßig die Lieferdaten enthält oder die Rechnungsdaten und dass, sofern die jeweils andere Adresse fehlt, die als Standard festgelegte Adresse angelegt wird. Dieses Feld legen wir als Nachschlagefeld aus, allerdings ohne fremde Tabelle als Datensatzherkunft. Stattdessen legen wir für die Eigenschaft Herkunftstyp <\/b>den Wert Wertliste <\/b>fest und geben für die Eigenschaft Datensatzherkunft <\/b>die folgende Liste an:<\/p>\n Dadurch zeigt das Feld diese beiden Einträge als mögliche Werte an. Das Feld Identifizierer <\/b>nimmt den Namen des Feldes auf, das entscheidet, ob die Daten der Liefer- oder Rechnungsadresse vorliegen oder nicht – wie oben beschrieben wollen wir hier das PLZ-Feld für die Liefer- oder die Rechnungsadresse verwenden. Wenn die Daten für die Lieferadresse immer eingetragen werden und die der Rechnungsadresse nur, wenn diese von der Lieferadresse abweicht, tragen wir etwa das Feld RechnungPLZ <\/b>in das Feld Identifizierer <\/b>ein, sonst das Feld LieferPLZ<\/b>.<\/p>\n Das Feld TabelleAbfrage <\/b>nimmt den Namen der Tabelle oder Abfrage auf, die als Datenquelle für die Adressblöcke verwendet werden soll. Primaerschluesselfeld <\/b>legt fest, welches Feld das Primärschlüsselfeld der in TabelleAbfrage <\/b>festgelegten Tabelle oder Abfrage ist. Die folgenden beiden Felder sind vor allem interessant, wenn der Versand nicht nur in das gleiche, sondern auch in andere Länder erfolgt. Wenn Sie etwa eine Sendung innerhalb Deutschlands verschicken, geben Sie nur Firma, Name, Straße, PLZ und Ort im Adressblock an. Wenn die Sendung hingegen in das Ausland geht, fügen Sie noch eine Zeile mit dem Zielland hinzu. Damit Sie definieren können, wann das Zielland angegeben werden soll und wann nicht, tragen Sie unter NichtAuszugebendeLaender <\/b>eine Liste der Länder ein, für die das Land nicht in die Zieladresse übernommen werden soll. Unter FelderMitLaendern <\/b>geben Sie dann ein, welche Felder die Länder enthalten, in unserem Beispiel also etwa LieferLand <\/b>und RechnungLand<\/b>. Bei mehreren Einträgen trennen Sie diese durch Semikola.<\/p>\n Diese Daten verwalten wir in einem Formular namens frmKonfiguration<\/b>. Es ist an die Tabelle tblKonfigurationen <\/b>gebunden und sieht in der Formularansicht wie in Bild 4 aus. Besonderheiten gibt es bei diesem Formular nicht – die Steuer-elemente werden nach dem Hineinziehen in den Detailbereich lediglich noch in der Größe und Position angepasst.<\/p>\n Bild 4: Formular zum Verwalten der Konfigurationen<\/span><\/b><\/p>\n Noch nicht beschrieben haben wir den Inhalt der beiden Felder KonfigurationLieferung <\/b>und KonfigurationRechnung<\/b>. Hier gibt es verschiedene Möglichkeiten, die Felder der unter TabelleAbfrage <\/b>als Datenquelle verwendeten Tabelle oder Abfrage einzutragen. Dazu schauen wir uns zunächst die Abfrage qryKunden <\/b>an, welche die Daten der Tabelle tblKunden <\/b>und tblAnreden <\/b>in eine für unsere Zwecke optimal nutzbare Form bringt. Die Abfrage sieht im Entwurf wie in Bild 5 aus. Um diese zu erstellen, fügen Sie zunächst die Tabelle tblKunden <\/b>und dann zwei Mal die Tabelle tblAnreden <\/b>zum Entwurf der Abfrage hinzu. Die erste Verknüpfung zwischen dem Feld LieferAnredeID <\/b>der Tabelle tblKunden <\/b>und dem gleichnamigen Feld der Tabelle tblAnreden <\/b>wird noch automatisch erstellt, die Verknüpfung zwischen dem Feld RechnungAnredeID <\/b>der Tabelle tblKunden <\/b>und dem Feld AnredeID <\/b>der zweiten Instanz der Tabelle tblAnreden <\/b>im Entwurf müssen Sie per Drag and Drop zwischen den beiden Feldern selbst hinzufügen.<\/p>\n Bild 5: Abfrage, welche die Daten der beteiligten Tabellen zusammenführt<\/span><\/b><\/p>\n Wichtig ist, dass Sie die Verknüpfungseigenschaften der beiden Verknüpfungen bearbeiten. Wenn Sie dies nicht tun und enthält beispielsweise das Feld RechnungAnredeID <\/b>eines Datensatzes der Tabelle tblKunden <\/b>keinen Wert und somit auch keine Verknüpfung zur Tabelle tblAnreden<\/b>, dann wird dieser Datensatz der Tabelle tblKunden <\/b>nicht als Ergebnis der Abfrage qryKunden <\/b>zurückgeliefert. Damit dies dennoch geschieht, stellen Sie in den Verknüpfungseigenschaften der Beziehung die folgende Option ein:<\/p>\n Dann werden auch Daten aus tblKunden <\/b>angezeigt, zu denen es nicht für beide Felder LieferAnredeID <\/b>und RechnungAnredeID <\/b>einen verknüpften Datensatz in der Tabelle tblAnreden <\/b>gibt.<\/p>\n Die beiden verknüpften Tabellen ziehen wir übrigens hinzu, um jeweils das Feld Anrede <\/b>statt der Felder LieferAnredeID <\/b>und RechnungAnredeID <\/b>für die Zusammenstellung der Adressblöcke bereitzustellen.<\/p>\n Damit diese dann später auch unterschieden werden können, obwohl sie den gleichen Feldnamen besitzen, stellen wir diesen noch jeweils den Alias LieferAnrede <\/b>beziehungsweise RechnungAnrede <\/b>voran, also etwa so:<\/p>\n Nun erstellen wir die Vorlage für die beiden Konfigurationen für die Liefer- und die Rechnungsadresse. Dazu geben Sie den Platzhalter für einen Feldnamen aus der Datenquelle grundsätzlich in eckigen Klammern an.<\/p>\n Wenn Sie also sicher sind, dass alle Felder der als Datenquelle verwendeten Tabelle ausgefüllt sind, können Sie eine Vorlage wie die folgende verwenden:<\/p>\n Für die Rechnungsadresse sieht dies analog so aus:<\/p>\n Nun kommt es allerdings vor, dass Informationen fehlen. Das ist kein Problem, wenn die komplette Zeile fehlt – diese wird dann von unserer Funktion einfach weggelassen. Fehlt also etwa die Zeile mit dem Platzhalter LieferZusatz<\/b>, weil das gleichnamige Feld für den aktuellen Datensatz keinen Wert enthält, dann wird die Zeile einfach weggelassen.<\/p>\n Aber was, wenn beispielsweise das Feld Firma <\/b>fehlt In diesem Fall würde ja die Zeile mit der Firma wegfallen – auch das wäre kein Problem. Aber in diesem Fall möchten wir zum Beispiel die Anrede in die erste Zeile holen, also etwa so:<\/p>\n Mit Firma soll der Adressblock so aussehen:<\/p>\n Dafür haben wir uns eine spezielle Notation für eine If…Then…Else<\/b>-Bedingung ausgedacht. Sie können in einer eckigen Klammer nicht nur den Namen eines Feldes angeben, sondern bis zu drei durch das Pipe-Zeichen (|<\/b>) getrennte Felder. Der erste Eintrag gibt dabei das Feld an, dessen Inhalt auf den Wert Null <\/b>beziehungsweise auf eine leere Zeichenfolge geprüft wird.<\/p>\n Der zweite Eintrag nimmt das Feld auf, das im Adressblock ausgegeben werden soll, wenn das im ersten Eintrag angegebene Feld nicht leer ist. Der dritte Eintrag nimmt das Feld auf, das im Adressblock erscheinen soll, wenn das im ersten Eintrag angegebene Feld leer bleibt. Der folgende Platzhalter sorgt also dafür, dass die Funktion prüft, ob das Feld LieferFirma <\/b>einen Wert enthält. Falls ja, wird der Inhalt dieses Feldes ausgegeben, falls nicht, der Wert des Feldes Anrede<\/b>:<\/p>\n Wenn wir im gleichen Zuge dafür sorgen wollen, dass, wenn das Feld LieferFirma <\/b>einen Wert enthält, die Anrede zusammen mit dem Vornamen und dem Nachnamen in die folgende Zeile gesetzt wird, verwenden wir die folgende Konstellation von Platzhaltern:<\/p>\n Für die Anwendung der Funktion namens Adressblock <\/b>finden Sie im Modul mdlTools <\/b>der Beispieldatenbank einige Beispiele. Die Funktion erwartet drei Parameter und liefert direkt den Adressblock als String zurück. Schauen wir uns den folgenden Aufruf an:<\/p>\n Dieser liefert die Lieferadresse für die Konfiguration mit dem Wert 1 <\/b>im Feld KonfigurationID <\/b>und für den Kunden mit dem Wert 1 <\/b>im Feld KundeID<\/b>:<\/p>\n Wenn Sie die Rechnungsadresse für den gleichen Datensatz mit der gleichen Konfiguration ausgeben möchten, verwenden Sie einfach Rechnungsadresse als ersten Parameter:<\/p>\n Das Ergebnis sieht dann so aus:<\/p>\n Auf die gleiche Weise können Sie durch Variation des zweiten und dritten Parameters andere Konfigurationen und natürlich auch andere Einträge der Kundentabelle zur Ausgabe der Adressblöcke verwenden.<\/p>\n Bei den beiden vorangegangenen Beispielen war als Land jeweils Deutschland <\/b>angegeben. Wie weiter oben festgelegt, soll der Wert Deutschland <\/b>für die beiden Felder LieferLand <\/b>und RechnungLand <\/b>ignoriert werden, was hier geschieht.<\/p>\n Wenn Sie beispielsweise den vierten Eintrag der Beispieltabelle tblKunden<\/b>, der das Land Schweiz <\/b>verwendet, als Adressblock ausgeben wollen, sieht der Aufruf so aus:<\/p>\n Dies ist der resultierende Adressblock:<\/p>\n Damit können wir uns nun an die Programmierung der Funktion machen, die aus der Tabelle tblKunden <\/b>mithilfe der Konfiguration aus tblKonfigurationen <\/b>einen Adressblock erstellt. Zunächst definieren wir eine Enumeration, welche die beiden Werte Lieferadresse <\/b>(0<\/b>) und Rechnungsadresse <\/b>(1<\/b>) festlegt:<\/p>\n Die Funktion Adressblock <\/b>legt die Enumeration für den Parameter lngAdressart <\/b>als Datentyp fest, sodass Sie per IntelliSense direkt bei der Definition des Aufrufs der Funktion auf die beiden bereitstehenden Werte zugreifen können (s. Bild 6). Die beiden übrigen Parameter lngKonfigurationID <\/b>und lngKundeID <\/b>haben jeweils den Datentyp Long<\/b>.<\/p>\n <\/p>\n Bild 6: IntelliSense beim Funktionsaufruf<\/span><\/b><\/p>\n Die Funktion sieht wie in Listing 1 aus und erstellt zunächst ein Recordset auf Basis der Tabelle tblKonfigurationen <\/b>für den mit dem Parameter lngKonfigurationID <\/b>übergebenen Primärschlüsselwert. Das Gleiche erledigt sie für die Tabelle tblKunden<\/b>, deren Datensatz mit dem Wert des Parameters lngKundeID <\/b>als Primärschlüsselwert in der Variablen rstKunde <\/b>landet. Eine erste Hilfsfunktion namens VorlageErmitteln <\/b>ermittelt die Vorlage für die angegebene Adressart aus lngAdressart<\/b>, die Konfiguration aus rst <\/b>und den Kunden aus rstKunde<\/b>. Diese Funktion liefert den Inhalt eines der beiden Felder KonfigurationRechnung <\/b>oder KonfigurationLieferung <\/b>aus der Tabelle tblKonfigurationen <\/b>zurück, die für die aktuelle Konstellation benötigt wird.<\/p>\n Listing 1: Die Funktion Adressblock<\/span><\/b><\/p>\n Die Funktion VorlageErmitteln <\/b>prüft in einer ersten If…Then<\/b>-Bedingung, ob der Wert von lngAdressart <\/b>mit dem Wert des Eintrags Lieferadresse <\/b>der Enumeration eAdressart <\/b>übereinstimmt (s. Listing 2). In diesem Fall soll die Vorlage für die Lieferadresse zurückgeliefert werden. Es folgt nun eine weitere If…Then<\/b>-Bedingung, die prüft, ob die Lieferadresse die Standardadresse der aktuellen Konfiguration ist, also ob diese immer gefüllt wird und die Rechnungsadresse nur ergänzt wird, wenn diese sich von der Lieferadresse unterscheidet. In diesem Fall trägt die Funktion einfach die Konfiguration aus dem Feld KonfigurationLieferung <\/b>in die Variable strVorlage <\/b>ein.<\/p>\n Listing 2: Die Funktion VorlageErmitteln<\/span><\/b><\/p>\n Falls es nicht die Standardadresse ist, prüft die Funktion, ob für diesen Adresstyp, hier die Lieferadresse, Daten hinterlegt sind, und zwar anhand des Feldes, das für das Feld Identifizierer <\/b>hinterlegt ist (hier RechnungPLZ<\/b>). Falls nicht, wird die Vorlage aus dem Feld KonfigurationRechnung <\/b>an strVorlage <\/b>übergeben, sonst KonfigurationLieferung<\/b>.<\/p>\n Sollte es sich bei dem zu erstellenden Adressblock um den für eine Rechnung handeln, wird dies im Else<\/b>-Teil der äußeren If…Then<\/b>-Bedingung abgehandelt. Hier erfolgt die Abarbeitung umgekehrt: Ist die Rechnungsadresse als Standard im Feld Standard <\/b>voreingestellt, dann verwenden wir in strVorlage <\/b>die Vorlage aus dem Feld KonfigurationRechnung<\/b>.<\/p>\n Anderenfalls prüfen wir wieder, ob das als Identifizierer angegebene Feld, hier nun beispielsweise LieferungPLZ<\/b>, der Datenquelle einen Wert enthält. Falls nicht, kommt der Adressblock aus dem Feld KonfigurationRechnung<\/b>, sonst aus dem Feld KonfigurationLieferung<\/b>.<\/p>\n Der Wert von strVorlage <\/b>wird nun als Funktionswert mit der Variablen VorlageErmitteln <\/b>an die aufrufende Funktion zurückgegeben.<\/p>\n Zurück zur aufrufenden Funktion Adressblock<\/b>. Hier landet das Ergebnis der Funktion VorlageErmitteln <\/b>nun in der Variablen strVorlage<\/b>. Die Split<\/b>-Funktion nimmt die in strVorlage <\/b>gespeicherte Vorlage und teilt diese in einzelne Zeilen auf, die in einem Array namens strZeilen() <\/b>landen.<\/p>\n Dieses durchlaufen wir in einer For…Next<\/b>-Schleife mit dem Laufparameter i<\/b>. Die Variable strZeile<\/b>, die später die mit den tatsächlichen Werten der Datenquelle gefüllte Zeile der Vorlage enthalten soll, wird zunächst geleert, da sie in der Schleife immer wieder neu gefüllt werden soll. <\/p>\n Wir ermitteln nun die Startposition des ersten Platzhalters, indem wir mit der InStr<\/b>-Funktion nach dem ersten Auftreten der öffnenden eckigen Klammer ([<\/b>) in der in strZeilen(i) <\/b>gespeicherten aktuellen Zeile suchen und diese in intStart <\/b>speichern.<\/p>\n Hat intStart <\/b>nicht den Wert 0<\/b>, was darauf hindeuten würde, dass sich in dieser Zeile kein Platzhalter befindet, lesen wir den Inhalt der Zeile vom ersten Zeichen bis zu dem mit intStart <\/b>markierten Zeichen in die Variable strZwischen <\/b>ein. Hat intStart <\/b>hingegen den Wert 0<\/b>, landet der gesamte Inhalt der Zeile in der Variablen strZwischen<\/b>.<\/p>\n Der Inhalt von strZwischen <\/b>wird dann an strZeile <\/b>angehängt. Dann durchlaufen wir eine Do While<\/b>-Schleife, die erst dann endet, wenn intStart <\/b>den Wert 0 <\/b>annimmt. Dies könnte schon der Fall sein, wenn die Zeile keinen Platzhalter enthält – dann wäre die Schleife vor dem ersten Durchlauf beendet und es würde der aktuelle Inhalt von strZeile <\/b>um führende und folgende Leerzeichen erleichtert und zur Variablen strAdressblock <\/b>hinzugefügt.<\/p>\n Anderenfalls steigen wir in die Abarbeitung der Do While<\/b>-Schleife ein, in der wir zunächst die Variable intEnde <\/b>mit der Position der ersten schließenden eckigen Klammer der Zeile füllen. Das erste Element ist nun der Bereich von der öffnenden eckigen Klammer (intStart<\/b>) bis zur schließenden eckigen Klammer (intEnde – intStart + 1<\/b>), also beispielsweise [LieferFirma]<\/b>. Dieser Ausdruck wird in der Variablen strElement <\/b>gespeichert.<\/p>\n Nun untersuchen wir, ob es sich um eines der Elemente handelt, die wie weiter oben beschrieben eine If…Then…Else<\/b>-Bedingung abbilden. Dazu prüfen wir, ob sich innerhalb des Elements ein Pipe-Zeichen befindet (|<\/b>). Falls ja, tragen wir den Inhalt von strElement <\/b>von hinter der öffnenden eckigen Klammer bis zum ersten Pipe-Zeichen in die Variable strVorhanden <\/b>ein. Sollte das in strVorhanden <\/b>gespeicherte Feld im Recordset rstKunde <\/b>keinen Wert enthalten, was wir in der folgenden If…Then<\/b>-Bedingung prüfen, dann tragen wir das Ergebnis der Funktion ElseFeldLesen <\/b>in die Variable strFeld <\/b>ein.<\/p>\n Die Funktion ermittelt den Wert des Recordsets rstKunde <\/b>für das Feld, das als Else<\/b>-Teil in strElement <\/b>eingetragen ist (bei [Liefer-Firma|LieferFirma|LieferAnrede] <\/b>also beispielsweise das Feld Anrede<\/b>. Anderenfalls greifen wir mit der Funktion ThenFeldLesen <\/b>auf das Then<\/b>-Feld zu, hier also LieferFirma<\/b>.<\/p>\n Die Funktion ThenFeldLesen <\/b>ermittelt aus einem String wie [LieferFirma|LieferFirma|LieferAnrede] <\/b>das mittlere Element, also LieferFirma<\/b>. Dazu erwartet sie lediglich die Zeichenfolge in eckigen Klammern (s. Listing 3). Sie ermittelt dann für die Variable intStart <\/b>die Position des ersten Pipe-Zeichens in der mit strElement <\/b>übergebenen Zeichenfolge, in diesem Fall also den Wert 13<\/b>. Dann liest sie die Position des zweiten Pipe-Zeichens ein, hier auf der Position 25<\/b>. Wenn es kein zweites Pipe-Zeichen gibt, enthält intEnde <\/b>nun den Wert 0<\/b>. In diesem Fall wird der Then<\/b>-Teil der folgenden If…Then<\/b>-Bedingung ausgeführt. Hier ermittelt die Funktion nun mit InStr <\/b>die Position der schließenden Klammer und speichert diese in intEnde<\/b>. Anschließend liest sie mit der Mid<\/b>-Funktion den Inhalt von der Position intStart <\/b>mit der Länge intEnde – intStart – 1 <\/b>ein und speichert das Ergebnis in der Variablen strFeld<\/b>. Dieser Wert dient dann auch als Rückgabewert der Funktion.<\/p>\n Listing 3: Die Funktion ThenFeldLesen<\/span><\/b><\/p>\n Die Funktion ElseFeldLesen<\/b> arbeitet etwas anders, da bei dieser auch eine leere Zeichenfolge zurückgegeben werden kann (s. Listing 4). Sie ermittelt zunächst die Position des ersten Pipe-Zeichens, das ja auf jeden Fall vorliegen muss, und speichert es in intStart<\/b>. Dann versucht sie, ein zweites Pipe-Zeichen zu finden, und speichert es in intEnde<\/b>. Hat intEnde <\/b>dann den Wert 0<\/b>, befindet sich nur ein Pipe-Zeichen in strElement<\/b>, was etwa so aussieht:<\/p>\n![\"Verschiedene](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_002.png\")
<\/p>\nEinfache Benutzerführung<\/h2>\n
![\"Konfigurationstabelle\"](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_003.png\")
<\/p>\n\"Lieferadresse\";\"Rechnungsadresse\"<\/pre>\n
Formular zur Verwaltung der Konfigurationen<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_004.png\")
<\/p>\nAnlegen einer Konfiguration<\/h2>\n
![\"Abfrage,](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_005.png\")
<\/p>\nBeinhaltet ALLE Datensätze aus ''tblKunden'' und nur die Datensätze aus ''tblAnreden'', bei denen die Inhalte der verknüpften Felder beider Tabellen gleich sind.<\/pre>\n
LieferAnrede: Anrede<\/pre>\n
[LieferFirma]\r\n[LieferAnrede] [LieferVorname] [LieferNachname]\r\n[LieferZusatz]\r\n[LieferStrasse]\r\n[LieferPLZ] [LieferOrt]\r\n[LieferLand]<\/pre>\n
[RechnungFirma]\r\n[RechnungAnrede] [RechnungVorname] [RechnungNachname]\r\n[RechnungZusatz]\r\n[RechnungStrasse]\r\n[RechnungPLZ] [RechnungOrt]\r\n[RechnungLand]<\/pre>\n
Herrn\r\nAndré Minhorst\r\nBorkhofer Str. 17\r\n47137 Duisburg<\/pre>\n
André Minhorst Verlag\r\nHerrn André Minhorst\r\nBorkhofer Str. 17\r\n47137 Duisburg<\/pre>\n
[LieferFirma|Lieferfirma|LieferAnrede]<\/pre>\n
[LieferFirma|LieferAnrede] [LieferVorname] [LieferNachname]<\/pre>\n
Anwendung der Funktion<\/h2>\n
Debug.Print<\/span> Adressblock(Lieferadresse, 1, 1)<\/pre>\nAndré Minhorst Verlag\r\nHerr André Minhorst\r\nLabor\r\nBorkhofer Str. 17\r\n47137 Duisburg<\/pre>\n
Debug.Print<\/span> Adressblock(Rechnungsadresse, 1, 1)<\/pre>\nFrau\r\nAnja Minhorst\r\nSchnüranstr. 25\r\n47138 Duisburg<\/pre>\n
Debug.Print<\/span> Adressblock(Lieferadresse, 1, 4)<\/pre>\nHeinz Müller AG\r\nHerr Heinz Müller\r\nTestweg 2\r\n2222 Luzern\r\nSchweiz<\/pre>\n
Programmierung der Funktion<\/h2>\n
Public <\/span>Enum eAdressart\r\n Lieferadresse = 0\r\n Rechnungsadresse = 1\r\nEnd Enum<\/pre>\n![\"IntelliSense](\"..\/fileadmin\/_temp_\/2017_03\/pic_1090_006.png\")
<\/p>\nPublic Function <\/span>Adressblock(lngAdressart As <\/span>eAdressart, lngKonfigurationID As Long<\/span>, lngID As Long<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database, rst As <\/span>DAO.Recordset, rstKunde As <\/span>DAO.Recordset\r\n Dim <\/span>strVorlage As String<\/span>, strZeilen() As String<\/span>, strFeld As String<\/span>, i As Integer<\/span>\r\n Dim <\/span>intStart As Integer<\/span>, intEnde As Integer<\/span>, strElement As String<\/span>, strZeile As String<\/span>\r\n Dim <\/span>strZwischen As String<\/span>, strVorhanden As String<\/span>, strAdressblock As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKonfigurationen WHERE KonfigurationID = \" _\r\n& lngKonfigurationID, dbOpenDynaset)\r\n Set<\/span> rstKunde = db.OpenRecordset(\"SELECT * FROM \" & rst!TabelleAbfrage & \" WHERE \" & rst!Primaerschluesselfeld _\r\n & \" = \" & lngID, dbOpenDynaset)\r\n strVorlage = VorlageErmitteln(lngAdressart, rst, rstKunde)\r\n strZeilen = Split<\/span>(strVorlage, vbCrLf<\/span>)\r\n For i = LBound<\/span>(strZeilen) To UBound<\/span>(strZeilen)\r\n strZeile = \"\"\r\n intStart = InStr<\/span>(1, strZeilen(i), \"[\")\r\n If <\/span>Not<\/span> intStart = 0 Then<\/span>\r\n strZwischen = Mid<\/span>(strZeilen(i), 1, intStart - 1)\r\n Else<\/span>\r\n strZwischen = strZeilen(i)\r\n End If<\/span>\r\n strZeile = strZeile & strZwischen\r\n Do While<\/span> Not<\/span> intStart = 0\r\n intEnde = InStr<\/span>(intStart + 1, strZeilen(i), \"]\")\r\n strElement = Mid<\/span>(strZeilen(i), intStart, intEnde - intStart + 1)\r\n If <\/span>InStr<\/span>(1, strElement, \"|\") > 0 Then<\/span>\r\n strVorhanden = Mid<\/span>(strElement, 2, InStr<\/span>(2, strElement, \"|\") - 2)\r\n If <\/span>Nz(rstKunde(strVorhanden), \"\") = \"\" Then<\/span>\r\n strFeld = ElseFeldLesen(strElement)\r\n Else<\/span>\r\n strFeld = ThenFeldLesen(strElement)\r\n End If<\/span>\r\n Else<\/span>\r\n strFeld = Mid<\/span>(strElement, 2, Len<\/span>(strElement) - 2)\r\n End If<\/span>\r\n strZeile = strZeile & WertLesen(rstKunde, strFeld, rst!FelderMitLaendern, rst!NichtAuszugebendeLaender)\r\n intStart = InStr<\/span>(intEnde + 1, strZeilen(i), \"[\")\r\n If <\/span>intStart > 0 Then<\/span>\r\n strZwischen = Mid<\/span>(strZeilen(i), intEnde + 1, intStart - intEnde - 1)\r\n End If<\/span>\r\n strZeile = strZeile & strZwischen\r\n Loop<\/span>\r\n strZeile = Trim<\/span>(strZeile)\r\n If <\/span>Len<\/span>(strZeile) > 0 Then<\/span>\r\n strAdressblock = strAdressblock & vbCrLf<\/span> & strZeile\r\n End If<\/span>\r\n Next<\/span> i\r\n strAdressblock = DoppelteLeerzeichenEntfernen(strAdressblock)\r\n Adressblock = strAdressblock\r\nEnd Function<\/span><\/pre>\nFunktion zum Ermitteln der Vorlage<\/h2>\n
Public Function <\/span>VorlageErmitteln(lngAdressart As Long<\/span>, rst As <\/span>DAO.Recordset, rstKunde As <\/span>DAO.Recordset) As String<\/span>\r\n Dim <\/span>strVorlage As String<\/span>\r\n If <\/span>lngAdressart = eAdressart.Lieferadresse Then<\/span>\r\n If <\/span>rst!Standard = \"Lieferadresse\" Then<\/span>\r\n strVorlage = rst!KonfigurationLieferung\r\n Else<\/span>\r\n If <\/span>Not<\/span> Nz(rstKunde(rst!Identifizierer), \"\") = \"\" Then<\/span>\r\n strVorlage = rst!KonfigurationRechnung\r\n Else<\/span>\r\n strVorlage = rst!KonfigurationLieferung\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>rst!Standard = \"Rechnungsadresse\" Then<\/span>\r\n strVorlage = rst!KonfigurationRechnung\r\n Else<\/span>\r\n If <\/span>Not<\/span> Nz(rstKunde(rst!Identifizierer), \"\") = \"\" Then<\/span>\r\n strVorlage = rst!KonfigurationRechnung\r\n Else<\/span>\r\n strVorlage = rst!KonfigurationLieferung\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n VorlageErmitteln = strVorlage\r\nEnd Function<\/span><\/pre>\nAbarbeiten der einzelnen Zeilen der Vorlage<\/h2>\n
Die Funktionen ThenFeldLesen und ElseFeldLesen<\/h2>\n
Public Function <\/span>ThenFeldLesen(strElement As String<\/span>)\r\n Dim <\/span>intStart As Integer<\/span>\r\n Dim <\/span>intEnde As Integer<\/span>\r\n Dim <\/span>strFeld As String<\/span>\r\n intStart = InStr<\/span>(1, strElement, \"|\")\r\n intEnde = InStr<\/span>(intStart + 1, strElement, \"|\")\r\n Debug.Print<\/span> strElement, intStart, intEnde\r\n If <\/span>intEnde = 0 Then<\/span>\r\n intEnde = InStr<\/span>(intStart, strElement, \"]\")\r\n End If<\/span>\r\n strFeld = Mid<\/span>(strElement, intStart + 1, intEnde - intStart - 1)\r\n ThenFeldLesen = strFeld\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>ElseFeldLesen(strElement As String<\/span>)\r\n Dim <\/span>intStart