Ein Kunde hatte neulich die Herausforderung, dass er Produkte bestehend aus einzelnen Bauteilen ausliefern möchte und dabei erfassen muss, welche Bauteile in welcher Menge in den verschiedenen Versandkartons landen. Der Verpackungsvorgang im Lager erfolgt individuell und in einer Weise, dass die Mitarbeiter die einzelnen Bauteile so in Kartons füllen, dass die Kartons optimal genutzt werden. Während des Verpackens sollen sie aufzeichnen, welcher Karton welche Bauteile enthält, damit diese beim Empfänger so ausgepackt werden können, wie die Bauteile benötigt werden. In diesem Beitrag beschreiben wir zunächst, wie das Datenmodell für dieses Vorhaben aussieht und erstellen basierend darauf die notwendigen Formulare. Schließlich geben wir auch noch die Stücklisten für die verschiedenen Kartons per Bericht aus.<\/b><\/p>\n
Bestellungen eingeben<\/h2>\n
Die Grundlage für diese Lösung sind Bestellungen. Diese bearbeiten wir in dem einfachen Formular aus Bild 1. Hier können wir im Hauptformular den Kunden auswählen und das Bestelldatum eingeben.<\/p>\n
![\"Einfaches](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_002.png\")
<\/p>\n
Bild 1: Einfaches Bestellformular<\/span><\/b><\/p>\n Außerdem wählen wir im Unterformular die Produkte aus, die dieser Bestellung zugeordnet werden sollen und fügen die gewünschte Menge hinzu.<\/p>\n Um Preise und andere Informationen kümmern wir uns in diesem Fall aus Gründen der Übersichtlichkeit nicht.<\/p>\n Wenn eine Bestellung eingegeben wurde, können wir mit dem Button Verpacken <\/b>zum nächsten Formular wechseln, dass die eigentliche Funktion dieses Beitrags abbildet.<\/p>\n Vorab noch die Information, dass jedes Produkt aus verschiedenen Bauteilen in unterschiedlicher Menge besteht, die im Hintergrund in Tabellen gespeichert sind.<\/p>\n Auf die genauen Zusammenhänge im Datenmodell gehen wir später ein.<\/p>\n Das Formular frmVerpackung <\/b>ist das eigentliche Arbeitstier (siehe Bild 2). Hier sehen wir verschiedene Bereiche:<\/p>\n Bild 2: Formular zum Protokollieren der Verpackung<\/span><\/b><\/p>\n Bild 3: Anlegen von Behältern<\/span><\/b><\/p>\n Auf diese Weise sieht der Mitarbeiter genau, wie viele Exemplare eines Bauteils noch gepackt werden müssen.<\/p>\n Nach dem Packen eines oder mehrerer Bauteile in einen Behälter braucht der Mitarbeiter nur das entsprechende Bauteil in der Liste Bauteile <\/b>zu markieren und entweder entsprechend der Menge der gepackten Bauteile mehrfach auf die Schaltfläche mit den einfachen Pfeil nach rechts zu klicken, oder er packt alle Exemplare eines Bauteils in einen Behälter und klickt direkt auf die Schaltfläche mit den zwei Pfeilen.<\/p>\n Auch wenn er bereits ein einzelnes Bauteil von mehreren mit einem Klick auf die Schaltfläche mit dem einfachen Pfeil zu einem Behälter hinzugefügt hat, kann er alle verbleibenden mit einem Klick auf die Schaltfläche mit dem doppelten Pfeil dem aktuell gewählten Behälter zuordnen.<\/p>\n Bevor wir in die Programmierung des Formulars einsteigen, wollen wir uns kurz das Datenmodell ansehen (siehe Bild 4). Die Tabellen, die mit dem Formular frmBestellungen <\/b>verwaltet werden, heißen tblKunden<\/b>, tblBestellungen <\/b>und tblBestellungProdukte<\/b>. <\/p>\n Bild 4: Datenmodell der Anwendung<\/span><\/b><\/p>\n Daneben gibt es noch weitere Stammdaten. Die Tabelle tblBauteile <\/b>enthält alle Bauteile, die über die Tabelle tblProdukteBauteile <\/b>dem jeweiligen Produkt zugewiesen werden. Das Feld Menge <\/b>dieser Tabelle gibt an, wie viele Exemplare eines Bauteils zu einem Produkt gehören.<\/p>\n Genau so, wie wir den Produktnamen bei Auswählen einer Bestellung in die Tabelle tblBestellungProdukte <\/b>schreiben, um diese unabhängig von den sich gegebenenfalls ändernden Stammdaten zu machen, wollen wir auch die Bauteile zu jeder Bestellposition in einer eigenen Tabelle historisieren.<\/p>\n Dazu verwenden wir die Tabelle tblBestellungProdukteBauteile<\/b>. Sie ist einerseits mit der Tabelle tblBestellungProdukte <\/b>verknüpft und andererseits mit der Tabelle tblBauteile<\/b>. Damit halten wir fest, woher die Bauteile ursprünglich stammen. In den Feldern Bauteilname<\/b>, Menge <\/b>und Gewicht <\/b>speichern wir die Eigenschaften zum Zeitpunkt dieser Bestellung. Die Menge wird berechnet aus dem Produkt des Feldes Menge <\/b>der Tabelle tblBestellungProdukte <\/b>und dem gleichnamigen Feld der Tabelle tblProdukteBauteile<\/b>.<\/p>\n Damit kommen wir zu einem weiteren Teil des Datenmodells, der die Zuordnung der Bauteile einer Bestellung zu den dafür angelegten Behältern speichert. Die Behälter werden in der Tabelle tblBehaelter <\/b>angelegt. Hier können wir über das Feld BehaeltertypID <\/b>den Typ des Behälters aus der Tabelle tblBehaeltertypen <\/b>auswählen. Jeder Behälter wird außerdem noch der jeweiligen Bestellung zugeordnet.<\/p>\n Die Tabelle tblBestellungBauteileBehaelter <\/b>schließlich speichert, wie viele Exemplare eines Bauteils eines Produkts in einem der Behälter gespeichert sind.<\/p>\n Wir haben bei den meisten mit referenzieller Integrität definierten Beziehungen auch die Löschweitergabe aktiviert. So werden beispielsweise beim Löschen von Bestellungen auch automatisch die damit verknüpften Produkte, Bauteile et cetera gelöscht. Auch beim Löschen von Behältern sollen die Zuordnungen von Bauteilen gelöscht werden.<\/p>\n Wenn der Benutzer im Formular frmBestellungen <\/b>ein Produkt im Unterformular auswählt, wird der Name des Produkts in das Feld Produktname <\/b>der Tabelle tblBestellungProdukte <\/b>eingetragen.<\/p>\n Damit stellen wir sicher, dass bei späteren Änderungen des Produktnamens der zum Zeitpunkt der Bestellung gültige Produktname in den Bestelldaten beibehalten wird. Das Formular sehen wir in Bild 5 in der Entwurfsansicht.<\/p>\n Bild 5: Entwurfsansicht des Formulars frmBestellungen<\/span><\/b><\/p>\n Wenn der Benutzer das Produkt ausgewählt hat, soll der Produktname aus der Tabelle tblProdukte <\/b>in die Tabelle tblBestellungProdukte <\/b>eingetragen werden. Das erledigen wir in der Vor Aktualisierung<\/b>-Ereignisprozedur:<\/p>\n Nachdem der Benutzer die Menge für die aktuelle Position eingetragen hat und den Datensatz gespeichert hat, tragen wir die Daten in die Tabelle tblBestellungProdukteBauteile <\/b>ein.<\/p>\n Das erledigen wir mit der Prozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Unterformulars ausgelöst wird (siehe Listing 1). Die Prozedur erstellt zwei Recordsets. rstBauteileQuelle <\/b>enthält eine Abfrage, die alle Bauteile enthält, die zu dem im Unterformular hinzugefügten Produkt gehören. Der zweite enthält die Tabelle tblBestellungProdukteBauteile<\/b>, also die Tabelle, in die wir die Bauteile für die aktuelle Bestellposition eintragen wollen.<\/p>\n Listing 1: Eintragen der Produkt- und Bauteildaten für die aktuelle Bestellung<\/span><\/b><\/p>\n In der folgenden Do While<\/b>-Schleife durchlaufen wir alle Datensätze des ersten Recordsets und tragen die benötigten Werte aus den Tabellen tblBauteile <\/b>und tblProdukteBauteile <\/b>in die Tabelle tblBestellungProdukteBauteile <\/b>ein. Dabei werden alle Daten übernommen – mit Ausnahme des Feldes Menge<\/b>. Hier multiplizieren wir die Menge der Produktposition mit der Menge der Bauteile für dieses Produkt.<\/p>\n Da wir nun in der Tabelle tblBestellungProdukteBauteile <\/b>alle Informationen über die zu verpackenden Bauteile haben, können wir uns dem Formular zum Verwalten des Packvorgangs zuwenden. Dieses heißt frmVerpackung <\/b>und sieht in der Entwurfsansicht wie in Bild 6 aus.<\/p>\n Bild 6: Entwurf des Formulars frmVerpackung<\/span><\/b><\/p>\n Das Formular selbst verwendet die Tabelle tblBestellungen <\/b>als Datensatzquelle. Es zeigt die beiden Felder BestellungID <\/b>und Bestelldatum <\/b>dieser Tabelle an.<\/p>\n Alle übrigen Daten werden überwiegend in Listenfeldern angezeigt. Einzige Ausnahme ist das Kombinationsfeld zur Auswahl des Behältertyps für das Anlegen eines neuen Behälters zur aktuellen Bestellung. Schauen wir uns also diese Listenfelder an.<\/p>\n Das erste Listenfeld heißt lstProdukte <\/b>und soll alle Produkte einer Bestellung inklusive Menge anzeigen. Damit das Listenfeld beim Anzeigen eines Datensatzes immer die zur aktuellen Bestellung gehörenden Produkte anzeigt, weisen wir die Datensatzherkunft im Ereignis Beim Anzeigen <\/b>des Formulars jeweils neu zu.<\/p>\n Dabei verwenden wir einen SQL-Ausdruck, der die benötigten Daten der Tabelle tblBestellungProdukte <\/b>liefert und diese nach der aktuell im Formular angezeigten Bestellung filtert. Außerdem erledigen wir dort noch weitere Schritte, indem wir Prozeduren zum Aktualisieren der übrigen Listenfelder und der Schaltflächen aufrufen (siehe Listing 2).<\/p>\n Listing 2: Füllen der Listenfelder beim Anzeigen eines Datensatzes<\/span><\/b><\/p>\n Wozu aber wollen wir dieses Listenfeld überhaupt nutzen? Es soll dazu dienen, die Anzeige der Bauteile im Listenfeld lstBauteile <\/b>nach dem jeweils ausgewählten Produkt zu filtern.<\/p>\n Wenn das Formular geöffnet wird, soll dieses Listenfeld zunächst alle Bauteile anzeigen, die zu den Produkten der Bestellung gehören. Vielleicht sollen die Bauteile zu einem Produkt aber jeweils in eigenen Behältern gepackt werden. Dann kann der Mitarbeiter auf das jeweilige Produkt klicken und erst einmal nur diese Bauteile packen, bevor er mit dem folgenden Produkt fortfährt.<\/p>\n Also haben wir auch zwei Prozeduren, die das Listenfeld lstBauteile <\/b>füllen – eine trägt alle Bauteile der aktuellen Bestellung ein, die andere ermittelt alle Bauteile zum aktuell markierten Produkt.<\/p>\n Wenn wir normalerweise einen Eintrag in einem Listenfeld anklicken, können wir diesen nicht wieder abwählen – außer, wir wählen einen anderen Eintrag aus. Wir wollen aber auch wieder alle Bauteile der aktuellen Bestellung anzeigen können, obwohl wir vielleicht gerade ein Produkt gewählt haben, um nur dessen Bauteile anzuzeigen. Also müssen wir uns einen kleinen Trick überlegen, um den aktuell markierten Eintrag im Listenfeld lstProdukte <\/b>wieder abzuwählen. <\/p>\n Dazu wollen wir beim Auswählen eines Produkts prüfen, ob dieses bereits zuvor selektiert war. Dies erfordert eine Variable außerhalb der Prozedur, um den zuletzt selektierten Eintrag zu speichern:<\/p>\n Für das Ereignis Nach Aktualisierung <\/b>des Listenfeldes lstProdukte <\/b>hinterlegen wir nun die folgende Ereignisprozedur:<\/p>\n Diese prüft, ob der aktuell angeklickte Eintrag dem in varProduktSelektiertVorher <\/b>gespeicherten Eintrag entspricht. Falls ja, will der Benutzer offensichtlich gerade den gewählten Listeneintrag abwählen. Also stellen wir das Listenfeld auf den Wert Null <\/b>ein, um die Selektion aufzuheben und leeren auch die Variable varProduktSelektiertVorher<\/b>. Außerdem rufen wir die Prozedur lstBauteileAktualisierenNachBestellungID <\/b>auf, um im Listenfeld lstBauteile <\/b>alle Bauteile anzuzeigen, die zur aktuellen Bestellung gehören.<\/p>\n Wenn der Benutzer ein Produkt ausgewählt hat, das zuvor nicht selektiert war, rufen wir die Prozedur lstBauteileAktualisierenNachProduktID <\/b>auf, um im Listenfeld lstBauteile<\/b> alle Bauteile der aktuellen Bestellung anzuzeigen. Außerdem legen wir den Wert von varProduktSelektiertVorher <\/b>auf den aktuell markierten Eintrag fest.<\/p>\n Das Listenfeld lstBauteile <\/b>soll, wie zuvor beschrieben, entweder die Bauteile für die aktuelle Bestellung anzeigen oder die Bauteile zu dem im Listenfeld lstProdukte <\/b>ausgewählten Produkt.<\/p>\n Wir schauen uns zuerst die Auflistung aller Bauteile zur aktuellen Bestellung an, da diese auch direkt beim Öffnen des Formulars erscheinen soll. Dazu verwenden wir die Abfrage qryProdukteBauteileNachBestellung <\/b>als Datensatzherkunft. <\/p>\n Diese Abfrage ist relativ kompliziert und sieht in der Entwurfsansicht wie in Bild 7 aus. Sie enthält Daten aus den Tabellen tblBestellungProdukte<\/b>, tblBestellungProdukteBauteile <\/b>und tblBestellungBauteileBehaelter<\/b>. Wir haben diese Tabellen mit den Alias-Bezeichnungen bp<\/b>, bpbt <\/b>und bbb <\/b>versehen.<\/p>\n Bild 7: Entwurf der Abfrage qryProdukteBauteileNachBestellung<\/span><\/b><\/p>\n Warum so kompliziert? Weil diese Abfrage gleich mehrere zusätzliche Informationen neben den eigentlichen Bauteilen berücksichtigen soll:<\/p>\n Die Abfrage ist gruppiert nach den Feldern BestellungBauteileID<\/b>, Produktname<\/b>, Bauteilname<\/b>, BauteilID <\/b>und BestellungID<\/b>. Warum eine Gruppierung? Weil zu jedem Bauteil mehrere Zuordnungen zu den verschiedenen Behältern vorkommen können und wir die gepackten Mengen aus den verschiedenen Behältern aufsummieren wollen. Diese Summen landen in den Feldern Gepackt <\/b>und Restmenge<\/b>.<\/p>\n Außerdem wollen wir vollständige gepackte Bauteile ausblenden können, wenn wir das Kombinationsfeld chkVollstaendigGepackteProdukteAusblenden <\/b>aktiviert haben. Dazu haben wir eine entsprechende Bedingung im Having<\/b>-Teil der Abfrage untergebracht, die wir in Bild 8 nochmal in der SQL-Ansicht dargestellt haben. Wir nutzen die beiden Parameter prmBestellungID <\/b>zum Filtern nach der anzuzeigenden Bestellung und prmAusblenden<\/b> zum Filtern nach den auszublendenden Bauteilen.<\/p>\n Bild 8: SQL-Ansicht der Abfrage qryProdukteBauteileNachBestellung<\/span><\/b><\/p>\n Warum nutzen wir Parameter? Weil wir sonst die vollständige SQL-Abfrage im VBA-Code unterbringen und dort mit den Werten für die Parameter füllen müssten, was es noch unübersichtlicher machen würde.<\/p>\n Also verwenden wir diese Abfrage als Grundlage für das Listenfeld lstBauteile<\/b>, indem wir ein Recordset auf Basis der Abfrage erstellen und dieses mit den erforderlichen Parameterwerten ausstatten. <\/p>\n Dazu referenzieren wir in der Prozedur lstBauteileAktualisierenNachBestellungID<\/b> (siehe Listing 3) das aktuelle Database<\/b>-Objekt über die Funktion CurrentDb <\/b>und speichern die Referenz in der Variablen db<\/b>.<\/p>\n Listing 3: Füllen des Listenfelds lstBauteile mit den Bauteilen einer Bestellung<\/span><\/b><\/p>\n Dann holen wir uns über die QueryDefs<\/b>-Auflistung einen Verweis auf die Abfrage qryProdukteBauteileNachBestellung<\/b> und tragen diesen in die Variable qdf <\/b>ein.<\/p>\n Mit den beiden Parameter<\/b>-Variablen prmBestellungID <\/b>und prmAusblenden <\/b>definieren wir die Parameter und weisen ihnen die aktuelle BestellungID <\/b>und den Wert des Kontrollkästchens chkVollstaendigGepackteProdukteAusblenden <\/b>zu.<\/p>\n Nun können wir mit OpenRecordset <\/b>ein Recordset auf Basis von qdf <\/b>öffnen und dieses der Eigenschaft Recordset <\/b>des Listenfelds lstBauteile <\/b>zuweisen.<\/p>\n Wenn der Benutzer auf eines der Produkte im Listenfeld lstProdukte <\/b>geklickt hat, sollen nur die Bauteile für dieses Produkt in lstBauteile<\/b> erscheinen.<\/p>\n Dazu nutzen wir eine ähnliche Vorgehensweise wie bei der Anzeige aller Bauteile der kompletten Bestellung.<\/p>\n Die Abfrage ist fast identisch aufgebaut, aber sie verwendet einen zusätzlichen Parameter namens prmProduktID<\/b> (siehe Bild 9).<\/p>\n Bild 9: SQL-Ansicht der Abfrage qryProdukteBauteileNachProdukt<\/span><\/b><\/p>\n In der Prozedur lstBauteileAktualisierenNachProduktID <\/b>gehen wir analog zu der zuvor vorgestellten Prozedur vor, allerdings bauen wir noch den Parameter prmProduktID<\/b> mit dem aktuellen Wert aus dem Listenfeld lstProdukte <\/b>in den Aufbau des Recordsets ein (siehe Listing 4).<\/p>\n Listing 4: Füllen des Listenfelds lstBauteile mit den Bauteilen eines Produkts<\/span><\/b><\/p>\n Wenn der Mitarbeiter auf das Kontrollkästchen chkVollstaendigGepackteProdukteAusblenden <\/b>klickt, sollen die Bauteile, die bereits vollständig einem der Behälter zugeordnet wurden, aus der Liste lstBauteile <\/b>ausgeblendet werden. Dazu hinterlegen wir für das Ereignis Nach Aktualisierung <\/b>des Listenfeldes die Prozedur aus Listing 5.<\/p>\n Listing 5: Aktualisieren von lstBauteile beim Betätigen des Kontrollkästchens<\/span><\/b><\/p>\n Die beiden Steuerelemente cboBehaeltertypen <\/b>und cmdBehaelterHinzufuegen <\/b>dienen dazu, einer Bestellung einen Behälter hinzuzufügen. Als Erstes wählt der Benutzer einen der Einträge aus dem Kombinationsfeld aus.<\/p>\n Dieses verwendet die folgende Abfrage als Datensatzherkunft:<\/p>\n Ein Mausklick auf die Schaltfläche cmdBehaelterHinzufuegen<\/b> löst die Prozedur aus Listing 6 aus.<\/p>\n Listing 6: Hinzufügen eines Behälters zu einer Bestellung<\/span><\/b><\/p>\n Diese prüft zuerst, ob ein Eintrag im Kombinationsfeld cboBehaeltertypen <\/b>ausgewählt ist. Fall ja, erscheint eine InputBox, mit welcher der Mitarbeiter den individuellen Namen für diesen Behälter einstellen kann. Als Standardwert wird dabei der Typ des Behälters vorgeschlagen. Danach wird ein neuer Datensatz in der Tabelle tblBehaelter <\/b>angelegt.<\/p>\n Dieser erhält den vom Mitarbeiter gewählten Behälternamen, die ID des Behältertyps aus der Tabelle tblBehaeltertypen <\/b>und die ID der Bestellung als Feldwerte.<\/p>\n Danach wird das Listenfeld lstBehaelter <\/b>über die Prozedur lstBehaelterAktualisieren <\/b>aktualisiert. Diese Prozedur weist dem Listenfeld eine Abfrage zu, welche die aktuelle BestellungID<\/b> in der WHERE<\/b>-Bedingung filtert (siehe Listing 7). Falls der Mitarbeiter keinen Behältertyp mit cboBehaeltertyp <\/b>ausgewählt hat, erscheint eine Meldung, die auf diese fehlende Information hinweist.<\/p>\n Listing 7: Aktualisieren des Listenfeldes lstBehaelter<\/span><\/b><\/p>\n Damit kommen wir zum Listenfeld lstBehaelter<\/b>. Dieses soll alle Behälter anzeigen, die der aktuellen Bestellung bereits hinzugefügt wurden. Wie dieses gefüllt wird, haben wir oben bereits gesehen.<\/p>\n Wenn der Benutzer einen der Behälter auswählt, wird das Ereignis Nach Aktualisierung <\/b>des Listenfeldes lstBehaelter <\/b>ausgelöst:<\/p>\n Diese aktualisiert den Inhalt des Listenfeldes lstInhalt <\/b>und aktualisiert anschließend die Schaltflächen zum Hinzufügen und Entfernen von Bauteilen in oder aus den Behältern.<\/p>\n Die erste Prozedur lstInhaltAktualisieren <\/b>sehen wir in Listing 8.<\/p>\n Listing 8: Aktualisieren des Listenfeldes lstInhalt<\/span><\/b><\/p>\n Diese weist dem Listenfeld alle Einträge einer Abfrage namens qryBestellungBauteileBehaelter <\/b>hinzu, deren Feld BestellungID <\/b>der aktuell angezeigten Bestellung entspricht (siehe Bild 10).<\/p>\n Bild 10: Entwurf der Abfrage qryBestellungBauteileBehaelter<\/span><\/b><\/p>\n Die Abfrage fasst die Daten der Tabellen tblBestellungBauteileBehaelter<\/b>, tblBestellungProdukteBauteile <\/b>und tblBestellungProdukte <\/b>zusammen. Die anzuzeigenden Daten stammen im Wesentlichen aus der Tabelle tblBestellungBauteileBehaelter<\/b>, die übrigen Tabellen sind nötig, damit wir nach dem Feld BestellungID <\/b>filtern können.<\/p>\n Nach dem Füllen soll der erste Eintrag dieses Listenfeldes markiert werden. Dies erledigt die folgende Prozedur:<\/p>\n Diese prüft, ob für das Listenfeld die Anzeige von Spaltenüberschriften aktiviert ist. Falls ja, ist der Index der ersten Zeile mit Daten 1<\/b>, anderenfalls 0<\/b>.<\/p>\n Davon abhängig wird entweder die Zeile mit dem Index 1 <\/b>oder 0 <\/b>markiert.<\/p>\n Damit haben wir alle Listenfelder mit den notwendigen Funktionen ausgestattet und kommen zum spannenden Teil: Dem Hinzufügen von Bauteilen zum jeweils markierten Behälter.<\/p>\n Zum Hinzufügen und Entfernen von Bauteilen nutzen wir die Schaltflächen cmdEinBauteilHinzufuegen<\/b>, cmdAlleBauteileHinzufuegen<\/b>, cmdEinBauteilEntfernen <\/b>und cmdAlleBauteileEntfernen<\/b>. Das Entfernen ist notwendig, weil es einmal sein kann, dass man bereits gepackte Bauteile noch einmal umpacken möchte.<\/p>\n Wir stellen zunächst sicher, dass immer nur die tatsächlich verfügbaren Schaltflächen aktiviert sind. Das erledigen wir mit der Prozedur SchaltflaechenAktualisieren<\/b>, die von verschiedenen Stellen aus aufgerufen wird – zum Beispiel nach dem Ändern verschiedener Listenfeldinhalte.<\/p>\n Ob die Schaltflächen zum Hinzufügen von Bauteilen aktiviert werden oder nicht, hängt davon ab, ob im Listenfeld lstBauteile <\/b>und im Listenfeld lstBehaelter<\/b> ein Eintrag ausgewählt ist. Ist das der Fall, untersucht die Prozedur den Wert der Spalte Restmenge<\/b>. Ist dieser größer als 0<\/b>, sollen die beiden Schaltflächen cmdAlleBauteileHinzufuegen <\/b>und cmdEinBauteilHinzufuegen <\/b>aktiviert werden, anderenfalls werden diese deaktiviert.<\/p>\n Danach untersucht die Prozedur, ob lstInhalt<\/b> einen markierten Eintrag enthält. Falls ja, werden die beiden Schaltflächen cmdAlleBauteileEntfernen <\/b>und cmdEinBauteilEntfernen <\/b>aktiviert. Anderenfalls werden die beiden Schaltflächen deaktiviert:<\/p>\nErfassung der verpackten Bauteile<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_003.png\")
<\/p>\n\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_004.png\")
<\/p>\nDatenmodell der Anwendung<\/h2>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_001.png\")
<\/p>\nLöschweitergaben im Datenmodell<\/h2>\n
Programmierung des Formulars frmBestellungen<\/h2>\n
![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_006.png\")
<\/p>\nPrivate Sub <\/span>ProduktID_BeforeUpdate(Cancel As Integer<\/span>)\r\n Me.Produktname = DLookup(\"Produktname\", _\r\n \"tblProdukte\", \"ProduktID = \" & Me.ProduktID)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstBauteileQuelle As <\/span>DAO.Recordset\r\n Dim <\/span>rstBauteileZiel As <\/span>DAO.Recordset\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstBauteileQuelle = db.OpenRecordset(\"SELECT tblProdukteBauteile.ProduktID, tblProdukteBauteile.Menge, \" _\r\n & \"tblBauteile.BauteilID, tblBauteile.Bauteilname, tblBauteile.Gewicht FROM tblBauteile \" _\r\n & \"INNER JOIN tblProdukteBauteile ON tblBauteile.BauteilID = tblProdukteBauteile.BauteilID WHERE ProduktID = \" _\r\n & Me.ProduktID, dbOpenDynaset)\r\n Set<\/span> rstBauteileZiel = db.OpenRecordset(\"SELECT * FROM tblBestellungProdukteBauteile WHERE 1=2\", dbOpenDynaset)\r\n \r\n Do While<\/span> Not<\/span> rstBauteileQuelle.EOF\r\n With<\/span> rstBauteileZiel\r\n .AddNew<\/span>\r\n !BestellungProduktID = Me.BestellungProduktID\r\n !BauteilID = rstBauteileQuelle!BauteilID\r\n !Bauteilname = rstBauteileQuelle!Bauteilname\r\n !Menge = rstBauteileQuelle!Menge * Me.Menge\r\n !Gewicht = rstBauteileQuelle!Gewicht\r\n .Update\r\n End With<\/span>\r\n rstBauteileQuelle.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nProgrammierung des Formulars frmVerpackung<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_007.png\")
<\/p>\nListenfeld zur Anzeige der Produkte einer Bestellung<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Me.lstProdukte.RowSource = \"SELECT BestellungProduktID, ProduktID AS ID, Produktname, Menge \" _\r\n & \"FROM tblBestellungProdukte WHERE BestellungID = \" & Me.BestellungID\r\n Call<\/span> lstBauteileAktualisieren\r\n Call<\/span> lstBehaelterAktualisieren\r\n Call<\/span> lstInhaltAktualisieren\r\n Call<\/span> SchaltflaechenAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>varProduktSelektiertVorher As Variant<\/span><\/pre>\nPrivate Sub <\/span>lstProdukte_AfterUpdate()\r\n If <\/span>Me.lstProdukte = Nz(varProduktSelektiertVorher, 0) Then<\/span>\r\n Call<\/span> lstBauteileAktualisierenNachBestellungID\r\n varProduktSelektiertVorher = Null\r\n Me.lstProdukte = Null\r\n Else<\/span>\r\n Call<\/span> lstBauteileAktualisierenNachProduktID\r\n varProduktSelektiertVorher = Me.lstProdukte\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListenfeld zur Anzeige der Bauteile einer Bestellung<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_008.png\")
<\/p>\n\n
![\"SQL-Ansicht](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_009.png\")
<\/p>\nPrivate Sub <\/span>lstBauteileAktualisierenNachBestellungID()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>prmBestellungID As <\/span>DAO.Parameter\r\n Dim <\/span>prmAusblenden As <\/span>DAO.Parameter\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryProdukteBauteileNachBestellung\")\r\n Set<\/span> prmBestellungID = qdf.Parameters(\"prmBestellungID\")\r\n prmBestellungID = Me.BestellungID\r\n Set<\/span> prmAusblenden = qdf.Parameters(\"prmAusblenden\")\r\n prmAusblenden = Me.chkVollstaendigGepackteProdukteAusblenden\r\n Set<\/span> rst = qdf.OpenRecordset\r\n Set<\/span> Me.lstBauteile.Recordset = rst\r\nEnd Sub<\/span><\/pre>\nListenfeld zur Anzeige der Bauteile einer Bestellung nur für ein Produkt<\/h2>\n
![\"SQL-Ansicht](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_010.png\")
<\/p>\nPrivate Sub <\/span>lstBauteileAktualisierenNachProduktID()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>prmBestellungID As <\/span>DAO.Parameter\r\n Dim <\/span>prmProduktID As <\/span>DAO.Parameter\r\n Dim <\/span>prmAusblenden As <\/span>DAO.Parameter\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(\"qryProdukteBauteileNachProdukt\")\r\n Set<\/span> prmBestellungID = qdf.Parameters(\"prmBestellungID\")\r\n prmBestellungID = Me.BestellungID\r\n Set<\/span> prmProduktID = qdf.Parameters(\"prmProduktID\")\r\n prmProduktID = Me.lstProdukte.Column(1)\r\n Set<\/span> prmAusblenden = qdf.Parameters(\"prmAusblenden\")\r\n prmAusblenden = Me.chkVollstaendigGepackteProdukteAusblenden\r\n Set<\/span> rst = qdf.OpenRecordset\r\n Set<\/span> Me.lstBauteile.Recordset = rst\r\nEnd Sub<\/span><\/pre>\nVollständig gepackte Bauteile ausblenden<\/h2>\n
Private Sub <\/span>chkVollstaendigGepackteProdukteAusblenden_AfterUpdate()\r\n Call<\/span> lstBauteileAktualisieren\r\nEnd Sub<\/span><\/pre>\nHinzufügen eines Behälters zu einer Bestellung<\/h2>\n
SELECT BehaeltertypID, Behaeltertyp, Gewicht FROM tblBehaeltertypen ORDER BY tblBehaeltertypen.Behaeltertyp;<\/pre>\n
Private Sub <\/span>cmdBehaelterHinzufuegen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strBehaeltername As String<\/span>\r\n \r\n Set<\/span> db = CurrentDb\r\n \r\n If <\/span>Not<\/span> IsNull(Me.cboBehaeltertypen) Then<\/span>\r\n strBehaeltername = InputBox(\"Behältername:\", \"Neuer Behälter\", Me.cboBehaeltertypen.Column(1))\r\n If <\/span>Not<\/span> Len<\/span>(strBehaeltername) = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblBehaelter(Behaeltername, BehaeltertypID, BestellungID) VALUES(''\" _\r\n & strBehaeltername & \"'', \" & Me.cboBehaeltertypen & \", \" & Me.BestellungID & \")\", dbFailOnError\r\n Call<\/span> lstBehaelterAktualisieren\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Kein Behältertyp ausgewählt.\", vbOKOnly + vbExclamation, \"Behältertyp fehlt\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstBehaelterAktualisieren()\r\n Me.lstBehaelter.RowSource = \"SELECT tblBehaelter.BehaelterID, tblBehaelter.Behaeltername, \" _\r\n & \"tblBehaeltertypen.Behaeltertyp FROM tblBehaelter INNER JOIN tblBehaeltertypen ON \" _\r\n & \"tblBehaelter.BehaeltertypID = tblBehaeltertypen.BehaeltertypID WHERE tblBehaelter.BestellungID = \" _\r\n & Me.BestellungID\r\nEnd Sub<\/span><\/pre>\nListenfeld zur Anzeige der Behälter einer Bestellung<\/h2>\n
Private Sub <\/span>lstBehaelter_AfterUpdate()\r\n Call<\/span> lstInhaltAktualisieren\r\n Call<\/span> SchaltflaechenAktualisieren\r\nEnd Sub<\/span><\/pre>\nListenfeld zur Anzeige der gepackten Bauteile<\/h2>\n
Private Sub <\/span>lstInhaltAktualisieren()\r\n Me.lstInhalt.RowSource = \"SELECT * FROM qryBestellungBauteileBehaelter WHERE BestellungID = \" & Me.BestellungID _\r\n & \" AND BehaelterID = \" & Nz(Me.lstBehaelter, 0)\r\n Call<\/span> ErstenEintragMarkieren(Me.lstInhalt)\r\nEnd Sub<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_05\/pic_1567_011.png\")
<\/p>\nPrivate Sub <\/span>ErstenEintragMarkieren(lst As <\/span>Access.ListBox)\r\n If <\/span>lst.ColumnHeads = True<\/span> Then<\/span>\r\n lst = lst.ItemData(1)\r\n Else<\/span>\r\n lst = lst.ItemData(0)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nSchaltflächen zum Hinzufügen und Entfernen von Bauteilen zu einem Behälter<\/h2>\n
Private Sub <\/span>SchaltflaechenAktualisieren()\r\n If Not<\/span> IsNull(Me.lstBauteile) _\r\n And Not<\/span> IsNull(Me.lstBehaelter) Then\r\n If <\/span>Me.lstBauteile.Column(5) > 0 Then<\/span>\r\n Me.cmdAlleBauteileHinzufuegen.Enabled = True<\/span>\r\n Me.cmdEinBauteilHinzufuegen.Enabled = True<\/span>\r\n Else<\/span>\r\n Me.cmdAlleBauteileHinzufuegen.Enabled = False<\/span>\r\n Me.cmdEinBauteilHinzufuegen.Enabled = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n Me.cmdAlleBauteileHinzufuegen.Enabled = False<\/span>\r\n Me.cmdEinBauteilHinzufuegen.Enabled = False<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> IsNull(Me.lstInhalt)