{"id":55000351,"date":"2023-02-01T00:00:00","date_gmt":"2023-03-02T20:58:57","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=351"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Rechnungen_mit_Word_und_Access","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Rechnungen_mit_Word_und_Access\/","title":{"rendered":"Rechnungen mit Word und Access"},"content":{"rendered":"

Office bietet verschiedene Möglichkeiten, um Rechnungen zu erstellen. Du kannst ein Worksheet in Excel dazu nutzen, eine Rechnung zu erstellen, die Berichte unter Access eignen sich recht gut dafür, aber auch Word lässt sich prima zum Erstellen von Rechnungen nutzen. Alle haben Vor- und Nachteile: Unter Excel gerät das Berechnen von Beträgen zum Kinderspiel, während mehrseitige Rechnungen eher schwierig zu realisieren sind, unter Access können Berichte recht flexibel realisiert werden, während man sich gerade für mehrseitige Berichte etwas einarbeiten muss – und unter Word kann man das Layout sehr einfach anpassen, während hier die Berechnung nicht so intuitiv erfolgt. Wir schauen uns eine Kombination aus Access und Word an: Die Daten stammen aus Access-Tabellen, während wir die Rechnung selbst in Word erstellen. So lassen sich auch nach dem Erstellen noch Feinheiten anpassen.<\/b><\/p>\n

Rechnungsdaten von Access nach Word<\/h2>\n

Es gibt verschiedene Wege, wie wir Rechnungsdaten von Access aus in ein Word-Dokument bewegen können. Das eine Extrem wäre, das Word-Dokument aus der Access-Datenbank heraus von Grund auf neu zu erstellen und mit den gewünschten Inhalten zu füllen. Das andere Extrem lautet, das Word-Dokument so weit wie möglich vorzubereiten und mit Textmarken auszustatten, sodass wir nur noch die eigentlichen Texte aus der Datenbank heraus zum Word-Dokument schicken müssen.<\/p>\n

Der erste Weg wäre sicherlich eine schöne Herausforderung für einen Software-Entwickler. Allerdings wollen wir Lösungen entwickeln, mit denen der Benutzer der Anwendung optimal arbeiten kann. Und wenn wir das Word-Dokument mit einer Rechnung komplett per Code generieren, gäbe es für den Benutzer nur noch nachträglich die Möglichkeit, das Dokument überhaupt anzupassen. Wenn er jedoch Änderungen vornehmen möchte, die sich in jedem Dokument niederschlagen, dann müsste er diese für jedes Dokument nach dessen Erstellung erneut durchführen.<\/p>\n

Aus Benutzersicht wäre also der zweite Weg hilfreicher, denn je mehr Inhalte bereits in der zu verwendenden Word-Vorlage enthalten sind, desto mehr Elemente kann der Benutzer selbst direkt an der Vorlage anpassen – und wenn die Änderungen einmal durchgeführt sind, wirken sich diese auf alle Dokumente aus, die wir von Access aus erstellen. Auf diese Weise können wir dem Benutzer sogar ermöglichen, mehr als eine Vorlage zu erstellen und in der Access-Anwendung auszuwählen, welche Vorlage für welche Rechnung verwendet werden soll.<\/p>\n

Aber welche Elemente können wir überhaupt bereits in der Dokumentvorlage für die Rechnung unterbringen? Wir gehen davon aus, dass die Rechnungen nur im Namen einer einzigen Person oder eines einzigen Unternehmens gestellt werden.<\/p>\n

Dann können wir zumindest den Briefkopf und die Absenderadresse in dem Bereich, der später im Fenster des Briefumschlags sichtbar sein soll, anpassen.<\/p>\n

Außerdem kann der Benutzer die Anordnung der übrigen Elemente wie Betreff, Rechnungstext, Block mit den Rechnungspositionen und die Zahlungsbedingungen nach den eigenen Anforderungen festlegen – und damit auch die Formatierungen wir Schriftart, Schriftgröße et cetera definieren.<\/p>\n

Wir wählen also in diesem Artikel den zweiten Weg – wir wollen eine Dokumentvorlage mit möglichst vielen voreingestellten Elementen erzeugen und diese dann mit den Daten aus der Datenbank füllen.<\/p>\n

Daten in ein Word-Dokument schreiben<\/h2>\n

Wie aber soll das Übertragen der Daten aus den Tabellen der Access-Datenbank in das Word-Dokument genau erfolgen? Woher wissen wir, an welchen Positionen die jeweiligen Daten eingefügt werden sollen? Und wie gehen wir überhaupt mit der Tatsache um, dass jede Rechnung unterschiedlich viele Rechnungspositionen enthalten kann – und wir die Vorlage dementsprechend gar nicht für jeden Fall vorbereiten können?<\/p>\n

Um die Positionen zu markieren, an denen wir die Daten aus der Datenbank einfügen wollen, gibt es spezielle Elemente: die Textmarken. Warum reden wir in der Mehrzahl? Weil es zwei Typen von Textmarken gibt – offene und geschlossene Textmarken. Den Unterschied erläutern wir weiter unten. Allgemein betrachtet sind Textmarken Elemente, die eine Bezeichnung erhalten, anhand derer wir diese ansprechen und Texte oder andere Elemente an ihrer Position einfügen können.<\/p>\n

Verwendung einer Vorlage<\/h2>\n

Wir wollen die Daten allerdings nicht einfach in ein vorhandenes Dokument schreiben, sondern wir legen eine Dokumentvorlage an, auf deren Basis wir für jede Rechnung ein neues Dokument erzeugen. Diese Dokumentvorlage speichern wir zunächst unter der Dateiendung .dotx <\/b>(t <\/b>für Template<\/b>). Der komplette Name der zu erstellenden Datei lautet Rechnungsvorlage.dotx<\/b>. Wir speichern die Daten im gleichen Verzeichnis wie die Access-Datenbank, die wir gleich im Anschluss erstellen. Wichtig: Wir können nicht einfach ein Word-Dokument über den Explorer erstellen und dieses mit der Dateiendung .dotx <\/b>versehen – das Word-Dokument muss von Word aus mit dem Typ Word-Vorlage (*.dotx) <\/b>gespeichert werden.<\/p>\n

Erstellen der Access-Datenbank<\/h2>\n

Irgendwo müssen wir die Daten für die Rechnungen speichern, und dafür eignet sich eine Access-Datenbank am besten. Wir könnten zwar auch ein Excel-Workbook verwenden, in dem wir die verschiedenen Daten wie Anreden, Kunden, Rechnungen und Rechnungspositionen in verschiedenen Tabellen speichern, aber das ist eher nicht der eigentliche Anwendungszweck von Excel, sondern von Access.<\/p>\n

In einer neuen Access-Datenbank namens RechnungenMitWordUndAccess.accdb <\/b>legen wir vier Tabellen an, die später einmal das Datenmodell aus Bild 1 ergeben.<\/p>\n

\"Datenmodell<\/p>\n

Bild 1: Datenmodell der Access-Datenbank<\/span><\/b><\/p>\n

Wir haben die Tabellen dieser Datenbank einmal mit den notwendigsten Daten gefüllt – also mit ein paar Anreden, einem Kundendatensatz, einem Rechnungsdatensatz und zwei Rechnungspositionen (siehe Bild 2). Die Tabellen sind dabei so verknüpft und mit Nachschlagefeldern ausgestattet, dass wir für das Feld AnredeID <\/b>der Tabelle tblKunden <\/b>eine der Anreden aus der Tabelle tblAnreden <\/b>auswählen können.<\/p>\n

\"Beispieldaten<\/p>\n

Bild 2: Beispieldaten für die Erstellung einer Rechnung<\/span><\/b><\/p>\n

Für das Feld KundeID <\/b>der Tabelle tblRechnungen <\/b>wählen wir einen der Kunden aus der Tabelle tblKunden <\/b>aus. Und schließlich legen wir für die beiden Rechnungsdatensätze aus der Tabelle tblRechnungspositionen <\/b>über das Feld RechnungID <\/b>die Rechnung fest, zu der die Rechnungspositionen gehören sollen.<\/p>\n

Durch diesen Aufbau der Tabellen können wir beliebig viele Kunden, Rechnungsdatensätze und Rechnungspositionen anlegen.<\/p>\n

Eingabe der Rechnungsdaten<\/h2>\n

Wir wollen uns an dieser Stelle nicht lange mit der Beschreibung der Benutzeroberfläche der Access-Datenbank aufhalten, daher hier nur die notwendigsten Elemente und Techniken.<\/p>\n

Zur Verwaltung der Kunden haben wir an dieser Stelle kein eigenes Formular vorgesehen – diese kann man hilfsweise über die Tabelle eingeben (eine professionelle Anwendung sollte natürlich ein Formular zur Verwaltung der Kunden enthalten). Die Rechnungen zeigen wir in einem Formular mit Unterformular an. Das Hauptformular frmRechnungen <\/b>ist über die Eigenschaft Datensatzquelle an die Tabelle tblRechnungen <\/b>gebunden. Das Unterformular sfmRechnungen <\/b>zeigt die Daten der Tabelle tblRechnungspositionen <\/b>an.<\/p>\n

Damit das Unterformular nur die Rechnungspositionen anzeigt, die mit der aktuell im Hauptformular angezeigten Rechnung verknüpft sind, sind die beiden Eigenschaften Verknüpfen von <\/b>und Verknüpfen nach <\/b>des Unterformular-Steuerelements beide auf den Wert RechnungID <\/b>eingestellt. Dies erledigt Access in der Regel automatisch, wenn man das Unterformular aus dem Navigationsbereich von Access per Drag and Drop in den Formularentwurf des Hauptformulars zieht – das Vorhandensein einer entsprechenden Beziehung zwischen den Tabellen aus Haupt- und Unterformular vorausgesetzt.<\/p>\n

Im Hauptformular platzieren wir alle Steuerelemente der Tabelle tblRechnungen <\/b>– mit Ausnahme des Feldes RechnungID<\/b>. Da wir das Feld KundeID <\/b>bereits in der zugrunde liegenden Tabelle tblRechnungen <\/b>als Nachschlagefeld definiert haben, wird dieses beim Ziehen des Feldes aus der Feldliste in den Formularentwurf direkt als Kombinationsfeld angelegt.<\/p>\n

Im Unterformular platzieren wir die Felder Position<\/b>, Bezeichnung<\/b>, Menge<\/b>, Einheit<\/b>, EinzelpreisNetto <\/b>und Umsatzsteuersatz<\/b>. Damit diese Daten in der Datenblattansicht angezeigt werden, stellen wir die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein (siehe Bild 3). Im unteren Bereich des Formulars fügen wir noch zwei Steuerelemente ein:<\/p>\n

\"Entwurf<\/p>\n

Bild 3: Entwurf des Formulars für die Eingabe der Rechnungsdaten<\/span><\/b><\/p>\n