Das Anlegen von Lastschriften ist eine wichtige Funktion, wenn man Kunden neben Zahlungsarten wie Rechnung, PayPal, Kreditkarte et cetera auch noch die Möglichkeit geben möchte, die Bankverbindung anzugeben, um den Betrag zum Fälligkeitsdatum einfach abbuchen zu lassen. Das ist gerade für wiederkehrende Leistungen wie Abonnements praktisch. Dazu sind jedoch erstens einige Voraussetzungen zu erfüllen wie zum Beispiel das Aktivieren der Möglichkeiten zum Einziehen von Lastschriften und das Beantragen einer sogenannten Gläubiger-Identifikationsnummer. Schließlich benötigen wir noch den passenden VBA-Code. Allein damit kommen wir aber nicht aus: Wenn wir gemütlich von unserer Datenbankanwendung aus Lastschriften anlegen wollen, benötigen wir eine zusätzliche Bibliothek. Dabei handelt es sich um die in vielen Anwendungen verwendete DDBAC-Bibliothek. Wie wir die einzelnen Schritte erledigen, um unsere Anwendung zum Anlegen von Lastschriften verwenden zu können, zeigen wir in diesem Beitrag.<\/b><\/p>\n
Hinweis<\/h2>\n
Zum Umsetzen der Beispiele aus diesem Beitrag ist eine kostenpflichtige Lizenz der DDBAC-Komponenten Voraussetzung. Sie erhalten diese auf der folgenden Webseite:<\/p>\n
https:\/\/www.andreminhorst.de\/ddbac<\/pre>\nBenötigte Informationen für eine Lastschrift<\/h2>\n
Für eine SEPA-Lastschrift benötigen wir diese Informationen:<\/p>\n
Außerdem benötigen wir folgende Angaben: <\/p>\n
Zusätzliche Anforderungen:<\/p>\n
Wie bereits eingangs erwähnt, sind einige Schritte nötig, die wir uns in der folgenden Reihenfolge ansehen:<\/p>\n
Ein Bankkonto ist normalerweise nicht für den Einsatz von Lastschriften vorgesehen. Dies müssen wir zuerst aktivieren. In meinem Fall reichte es aus, meinen Ansprechpartner bei der Bank anzurufen und ihn zu bitten, dies einzurichten. Man muss dazu ein, zwei Formulare ausfüllen. Der Hintergrund ist, dass es bei einer Lastschrift nicht sichergestellt ist, dass das Geld auch auf dem Konto verbleibt. Der Kunde hat immer die Möglichkeit, eine Lastschrift zurückzuholen. Die Aktivierung von Lastschriften ging in unserem Fall recht schnell – es hängt aber von der jeweiligen Bank ab.<\/p>\n
Wie oben beschreiben, benötigen wir auch eine Gläubiger-Identifikationsnummer. Diese können wir bei der Deutschen Bundesbank beantragen. Die Startseite dort sieht beispielsweise wie in Bild 1 aus. Der Vorgang ist hier gut dokumentiert und es sind keine weiteren Voraussetzungen zu erfüllen, um diese ID zu erhalten. Der Erhalt sollte in der Regel innerhalb eines Werktages zu bewerkstelligen sein.<\/p>\n
![\"Start](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_001.png\")
<\/p>\n
Bild 1: Start der Beantragung einer Gläubiger-Identifikationsnummer<\/span><\/b><\/p>\n Wem dies zu lange dauert, der kann auch eine Gläubiger-Identifikationsnummer zum Testen holen. Diese finden wir auf der Seite mit den häufig gestellten Fragen zu der Gläubiger-Identifikationsnummer.<\/p>\n Die Test-ID lautet: DE98ZZZ09999999999<\/b><\/p>\n Wer mit Komponenten wie den DDBAC-Komponenten Onlinebanking betreiben möchte, benötigt dazu eine eigene Registrierungsnummer.<\/p>\n Diese kann hier beantragt werden (siehe Bild 2):<\/p>\n Bild 2: Seite zum Registrieren einer FinTS-Nummer<\/span><\/b><\/p>\n Hier finden wir unter dem Link Registrierungsprozess <\/b>ein Formular, in das wir die notwendigen Informationen eintragen können.<\/p>\n Die Vergabe dieser Nummer dauerte bei uns einige Tage, aber wir wissen nicht, wie schnell der Prozess aktuell durchgeführt wird.<\/p>\n Diese Nummer machen wir im VBA-Projekt beispielsweise über eine wie folgt angelegte Konstante verfügbar:<\/p>\n Schließlich benötigen wir die kostenpflichtigen DDBAC-Komponenten. Diese finden wir auf der folgenden Webseite:<\/p>\n Im Download der DDBAC-Komponenten befinden sich zwei Zip-Dateien. Wir installieren die aus der Zipdatei DDBACNetWrapper-Version-x-x-x-x.zip<\/b>.<\/p>\n Hier finden wir wiederum drei Verzeichnisse, von denen wir das Verzeichnis DDBACWrapper <\/b>auswählen. Hier installieren wir abhängig davon, ob das installierte Windows 32-Bit oder 64-Bit verwendet, die Datei DDBACSetup.msi <\/b>oder DDBACSetupx64.msi<\/b>.<\/p>\n Die meisten Windows-Versionen haben derzeit 64-Bit.<\/p>\n Ein sehr wichtiger Faktor ist, dass wir von dem Kunden, von dem wir Geld per Lastschrift einziehen wollen, ein Lastschriftmandat erhalten müssen. Zu beschreiben, wie dieser Vorgang abläuft, würde hier den Rahmen sprengen. Wichtig ist jedoch, dass die Lastschrift mit Zustimmung des Kunden geschieht.<\/p>\n Wenn die Onlinebanking-Komponenten installiert sind, benötigen wir vor dem eigentlichen Programmieren erst einmal eine Verbindung zum Bankserver.<\/p>\n Dazu starten wir eine Anwendung, die wir in der Systemsteuerung unter dem Namen Homebanking Administrator (32-Bit) <\/b>finden (siehe Bild 3).<\/p>\n Bild 3: Anlegen eines neuen Banking-Kontakts<\/span><\/b><\/p>\n Hier klicken wir auf die Schaltfläche Neu… <\/b>und finden einen weiteren Dialog namens HBCI\/FinTS-Kontakt <\/b>vor. Hier geben wir beispielsweise die Bankleitzahl oder den Banknamen ein, um die Bank zu finden. Nachdem wir die Bank ausgewählt haben, klicken wir auf Weiter<\/b> (siehe Bild 4).<\/p>\n Bild 4: Auswahl der Bank<\/span><\/b><\/p>\n Das Programm ermittelt dann die verfügbaren Zugangsdaten (siehe Bild 5).<\/p>\n Bild 5: Ermitteln der Zugangsdaten<\/span><\/b><\/p>\n Die verfügbaren Zugangsarten erscheinen dann im folgenden Dialog zur Auswahl. Hier wählt man in der Regel PIN\/TAN<\/b>, was üblicherweise auch alle aktuellen Zugangsarten wie photoTan <\/b>abdeckt (siehe Bild 6).<\/p>\n Bild 6: Auswahl der Zugangsart<\/span><\/b><\/p>\n Anschließend müssen wir den Benutzernamen beziehungsweise die Teilnehmernummer eingeben. Das ist die gleiche Nummer, unter der Sie sich vermutlich auch beim Onlinebanking anmelden (siehe Bild 7).<\/p>\n Bild 7: Angabe der Teilnehmernummer<\/span><\/b><\/p>\n Schließlich benötigen wir zum Synchronisieren mit diesem Bankkontakt noch die Eingabe der PIN (siehe Bild 8).<\/p>\n Bild 8: Eingabe des PIN<\/span><\/b><\/p>\n Danach folgen je nach Bank und Zugangsart noch weitere Abfragen beispielsweise zum Sicherheitsverfahren. Abschließend erhalten wir die Meldung über die erfolgreiche Synchronisierung (siehe Bild 9).<\/p>\n Bild 9: Erfolgsmeldung<\/span><\/b><\/p>\n Damit liegen die grundlegenden Daten nun auf dem aktuellen Rechner und wir können von Access aus per VBA auf die Informationen nicht nur des Bank Kontakts, sondern auch auf die darin enthaltenen Bankverbindungen zugreifen.<\/p>\n Bleiben wir noch kurz im Administrator für Homebanking Kontakte<\/b> und schauen uns an, wie wir die Konten zu diesem Kontakt einsehen können. Dazu klicken wir auf den Banking Kontakt und dann auf die Schaltfläche Bearbeiten<\/b> (siehe Bild 10).<\/p>\n Bild 10: Der neue Banking Kontakt in der Liste der Kontakte<\/span><\/b><\/p>\n Dies öffnet einen weiteren Dialog (siehe Bild 11). Hier finden wir neben einigen anderen Möglichkeiten, unseren Banking Kontakt zu bearbeiten, auch den Link Konten verwalten<\/b>.<\/p>\n Bild 11: Bearbeiten eines Banking Kontakts<\/span><\/b><\/p>\n Wenn wir diesen anklicken, landen wir auf einer weiteren Seite, die uns alle Konten anzeigt, die mit diesem Banking Kontakt verknüpft sind (siehe Bild 12).<\/p>\n Bild 12: Dialog zum Verwalten der Konten<\/span><\/b><\/p>\n Damit kommen wir zum eigentlichen Thema dieses Beitrags, nämlich dem Programmieren der Lastschrift.<\/p>\n Dazu wechseln wir in unserer Beispieldatenbank als Erstes zum VBA-Editor und fügen einen Verweis auf die benötigte Bibliothek der DDBAC-Komponenten hinzu.<\/p>\n Dabei handelt es sich um den Eintrag DataDesign DDBAC FinTS 4.0<\/b> (siehe Bild 13).<\/p>\n Bild 13: Verweis auf die DDBAC-Komponente<\/span><\/b><\/p>\n Für SEPA-Lastschriften gibt es zwei Verfahren: die SEPA-Basislastschrift und die SEPA-Firmenlastschrift.<\/p>\n Unabhängig vom Verfahren kann eine nicht autorisierte Lastschrift – also ein Lastschrifteinzug ohne gültiges Mandat – innerhalb von 13 Monaten nach der Kontobelastung vom Zahler zurückgegeben werden.<\/p>\n Damit wir von Access aus per VBA Lastschriften einreichen können, müssen wir auf die entsprechenden Banking Kontakte und die darin enthaltenen Konten zugreifen können.<\/p>\n Dabei handelt es sich um die Informationen, die wir soeben bereits über die Anwendung Homebanking Administrator <\/b>in der Systemsteuerung hinterlegt haben.<\/p>\n Die Banking Kontakte wollen wir in einem Formular in ein Kombinationsfeld einlesen. Der Benutzer kann dann einen der Einträge auswählen.<\/p>\n Nachdem dies geschehen ist, sollen die Accounts, also die Konten, dieses Banking Kontakts in einem zweiten Auswahlfeld bereitgestellt werden. Hat der Benutzer auch hier einen Wert selektiert, haben wir schon einmal die Informationen zu dem Konto, zu dessen Gunsten die Lastschrift ausfallen soll.<\/p>\n Dazu legen wir als Erstes ein neues, leeres Formular an. Diesem fügen wir ein Kombinationsfeld namens cboBankingkontakte <\/b>für die Banking Kontakte hinzu und ein weiteres Kombinationsfeld namens cboAccounts <\/b>für die Konten.<\/p>\n Für beide Kombinationsfelder stellen wir die Eigenschaft Datensatzherkunft <\/b>auf den Eintrag Wertliste <\/b>ein (siehe Bild 14).<\/p>\n Bild 14: Formular zur Auswahl der Banking Kontakte und Accounts<\/span><\/b><\/p>\n Beim Füllen der Banking Kontakte wollen wir direkt berücksichtigen, ob diese überhaupt das Hinzufügen von Lastschriften erlauben.<\/p>\n Dies können wir ebenfalls aus den Informationen abfragen, die für unsere Banking Kontakte gespeichert wurden.<\/p>\n Dazu nutzen wir die Funktion getContacts <\/b>aus Listing 1. Für die Liste der Bankkontakte stellen wir eine Variable namens m_Contacts <\/b>bereit, in der wir die Kontakte temporär speichern. Diese deklarieren wir wie folgt:<\/p>\n Listing 1: Einlesen aller Kontakte<\/span><\/b><\/p>\n Die Funktion GetContacts <\/b>prüft, ob m_Contacts <\/b>bereits eingelesen wurde. Falls nicht, füllen wir es mit einer neuen Instanz der Klasse BACContacts <\/b>und rufen ihre Populate<\/b>-Methode auf.<\/p>\n Sollte m_Contacts <\/b>bereits gefüllt sein, wird es einfach als Datenquelle verwendet – außer in dem Fall, dass wir den Parameter bolReset <\/b>der Funktion auf den Wert True <\/b>einstellen.<\/p>\n Dann rufen wir auch in diesem Fall die Populate<\/b>-Methode auf, um m_Contacts <\/b>erneut zu füllen.<\/p>\n Nun deklarieren wir eine Variable namens objContact <\/b>mit dem Datentyp BACContact<\/b>. Diesen verwenden wir als Laufvariable für die folgende For Each<\/b>-Schleife, in der wir alle Elemente der Auflistung aus m_Contacts <\/b>durchlaufen.<\/p>\n Anschließend weisen wir den Feldern ProductName <\/b>und Produktbezeichnung <\/b>den FinTS-Registrierungsschlüssel zu und geben den Inhalt von m_Contacts <\/b>an die aufrufende Prozedur zurück.<\/p>\n Zum Testen können wir die folgende Prozedur verwenden:<\/p>\n Dies gibt beispielsweise die Bankleitzahl und die Benutzerkennung für diesen Banking Kontakt im Direktbereich aus.<\/p>\n Wir wollen im Kombinationsfeld zur Anzeige der Banking Kontakte auch gleich anzeigen, ob der jeweilige Kontakt überhaupt die Möglichkeit bietet, Lastschriften anzulegen. Manchen Banken bieten diese Funktion grundsätzlich nicht an.<\/p>\n Dazu fügen wir die Funktion GetContactListWithFeature <\/b>hinzu, mit der wir das Segment, also die Funktion, angeben, auf die wir den Banking Kontakt untersuchen wollen (siehe Listing 2). Außerdem übergeben wir auch hier den Parameter bolReset<\/b>, um gegebenenfalls die Kontakte neu einlesen zu können.<\/p>\n Listing 2: Einlesen der Kontaktlisten für ein bestimmtes Feature<\/span><\/b><\/p>\n Hier legen wir erneut eine Variable des Typs BACContact<\/b> namens objContact <\/b>an, mit der wir die Kontakte aus objContacts <\/b>(Datentyp BACContacts<\/b>) durchlaufen. objContacts <\/b>füllen wir mit der oben beschriebenen Funktion GetContacts<\/b>.<\/p>\n Dann durchlaufen wir alle Elemente in einer For…Next<\/b>-Schleife von 0 <\/b>bis zur Anzahl der Elemente minus eins. Hier nutzen wir eine For…Next<\/b>-Schleife statt einer For Each<\/b>-Schleife, weil wir den Index des aktuellen Elements benötigen.<\/p>\n Innerhalb der Schleife weisen wir den aktuellen Kontakt der Variablen objContact <\/b>zu. Dann rufen wir die Funktion BACPDSegmentVorhanden <\/b>auf und übergeben dieser mit objContact <\/b>den Kontakt und mit strSegment <\/b>das zu untersuchende Segment. Liefert diese Funktion den Wert True <\/b>zurück, stellen wir die Variable bolFeature <\/b>auf den Wert True <\/b>ein – anderenfalls auf False<\/b>.<\/p>\n Nun stellen wir in der Variablen strContacts <\/b>eine per Semikola separierte Liste mit verschiedenen Informationen zusammen. Diese enthält den Wert der Zählervariablen i<\/b>, die Felder UserID <\/b>und BankCode <\/b>des Kontakts und einen aus diesen Informationen zusammengestellten Ausdruck. Das Ergebnis wird schließlich an die aufrufende Routine zurückgegeben und sieht beispielsweise wie folgt aus:<\/p>\n Die Funktion BACBPDSegmentVorhanden <\/b>erwartet einen Verweis auf den zu untersuchenden Banking Kontakt sowie das zu prüfende Segment als Parameter (siehe Listing 3).<\/p>\n Listing 3: Prüfen, ob ein Banking Kontakt eine bestimmte Funktion aufweist<\/span><\/b><\/p>\n Woher wissen wir, welche Funktion welche Segmentzeichenkette verwendet? Zum Beispiel für das Abfragen von Umsätzen oder Kontoständen oder zum Durchführen von Überweisungen oder zum Anlegen von Lastschriften? <\/p>\n Dies erfahren wir aus der Datei FinTS Segmente.html<\/b>, die wir nach dem Installieren der DDBAC-Komponenten etwa im Verzeichnis C:\\Program Files (x86)\\DataDesign\\DDBACSDK <\/b>vorfinden.<\/p>\n Hier können wir beispielsweise nach Lastschrift einreichen suchen.<\/p>\n Die Einträge mit HI… <\/b>sind jeweils die Antworten, die mit HK… <\/b>sind die zum Einreichen von Aufträgen.<\/p>\n Für das Einreichen einer terminierten SEPA Lastschrift verwenden wir also beispielsweise das Segment HKDSE <\/b>(siehe Bild 15).<\/p>\n Bild 15: Ermitteln des Segments für eine SEPA Lastschrift<\/span><\/b><\/p>\n Dieses untersuchen wir in der Funktion mit objContact.BankData.Segments.FindSegmentType(strSegment)<\/b>. Hier erhalten wir entweder den Wert True <\/b>oder False <\/b>als Ergebnis und dieses geben wir auch als Funktionswert zurück.<\/p>\n Hier sind einige verschiedene Lastschriftsegmente:<\/p>\n Weiter unten in diesem Dokument finden wir die entsprechenden Parameter, die wir später beschreiben.<\/p>\n Auf ähnliche Weise wollen wir nun die Daten für das zweite Kombinationsfeld laden. <\/p>\n Dazu verwenden wir zunächst eine Funktion namens GetAccounts<\/b>, die uns alle Accounts für einen bestimmten Banking Kontakt holt. Den Banking Kontakt ermitteln wir über den Index, den dieser in der Anwendung in der Systemsteuerung aufweist (siehe Listing 5).<\/p>\n Listing 4: Einlesen der Accounts<\/span><\/b><\/p>\n Zunächst wird die Variable namens BACContact deklariert, die wir über GetContacts.Item(intContact) <\/b>füllen. Die Funktion GetContacts <\/b>haben wir oben bereits beschrieben. Für diesen Banking Kontakt gibt die Funktion die Accounts<\/b>-Auflistung als Ergebnis zurück.<\/p>\n Ähnlich wie bei den Banking Kontakten verwenden wir auch für die Accounts eine Funktion, die uns die wichtigsten Informationen zum jeweiligen Account in einer Liste zusammenstellt (siehe Listing 4).<\/p>\n Listing 5: Erstellen einer Liste aus den Accounts<\/span><\/b><\/p>\n Diese heißt GetAccountList <\/b>und erwartet ebenfalls den Index des zu untersuchenden Banking Kontakts als Parameter.<\/p>\n Mit dem zweiten Parameter bolSepa <\/b>können wir angeben, ob wir nur SEPA-Konten zurückgeliefert bekommen wollen.<\/p>\n Die Funktion durchläuft alle BACAccount<\/b>-Einträge der mit GetAccounts <\/b>geholten Elemente in einer For Each<\/b>-Schleife.<\/p>\n Falls bolSepa <\/b>den Wert False <\/b>hat oder falls bolSepa <\/b>den Wert True <\/b>hat und die Eigenschaft IsSepa <\/b>des aktuellen Elements auch True <\/b>ist, fügen wir die Eigenschaften des Accounts zur Variablen strAccounts <\/b>hinzu.<\/p>\n Dazu gehören der Index i<\/b>, die Kontonummer (AccountNumber<\/b>), die BIC, die IBAN und nochmal alle wichtigen Informationen in einem Feld zur Anzeige.<\/p>\n Zum Testen dieser Funktion können wir folgende Prozedur nutzen:<\/p>\n Für das Testkonto der DDBAC-Hersteller finden wir dann folgende Ausgabe im Direktbereich:<\/p>\n Wenn wir mehrere Banking Kontakte und Accounts haben, wollen wir nach der Benutzung dafür sorgen, dass die zuletzt verwendete Kombination gespeichert und beim nächsten Öffnen wiederhergestellt wird. Deshalb legen wir eine Tabelle wie in Bild 16 in der Datenbank an.<\/p>\n Bild 16: Die Tabelle tblOptionen<\/span><\/b><\/p>\n Die beiden Felder LetzterBankkontakt <\/b>und LetztesKonto<\/b> speichern die Indizes der zuletzt verwendeten Einträge.<\/p>\n Bevor wir uns die Prozedur ansehen, mit der wir die Banking Kontakte und die Accounts in die Kombinationsfelder laden, erweitern wir das Formular noch um zwei Steuerelemente namens txtIBAN <\/b>und txtBIC<\/b>, die wir mit den entsprechenden Daten des ausgewählten Kontos füllen.<\/p>\n Außerdem stellen wir noch die Eigenschaften der Kombinationsfelder ein. Die Eigenschaft Herkunftsart <\/b>haben wir bereits auf Wertliste <\/b>eingestellt. Für cboBankingKontakte <\/b>stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 4 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm;0cm;0cm <\/b>ein.<\/p>\n Für cboAccounts <\/b>legen wir Spaltenanzahl <\/b>auf 5 <\/b>und Spaltenbreiten <\/b>auf 0cm;0cm;0cm;0cm <\/b>fest. Dies sieht nun wie in Bild 17 aus.<\/p>\n Bild 17: Einstellen der Kombinationsfeld-Eigenschaften<\/span><\/b><\/p>\n Danach können wir die Prozedur anlegen, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese finden wir in Listing 6.<\/p>\n Listing 6: Füllen der Steuerelemente beim Laden des Formulars<\/span><\/b><\/p>\n Sie deklariert die beiden Variablen intLastContact<\/b> und intLastAccount<\/b>. Dann ruft sie die Funktion GetContactListWithFeature <\/b>für das Segment HKDSE <\/b>auf und weist die Liste der Eigenschaft RowSource <\/b>des Kombinationsfeldes cboBankingKontakte <\/b>zu.<\/p>\n Wenn die Datensatzherkunft dieses Kombinationsfeldes danach leer sein sollte, erscheint eine Meldung, dass erst einmal Banking Kontakte angelegt werden müssen und die Prozedur wird verlassen.<\/p>\n Anderenfalls lesen wir per DLookup <\/b>den Wert des Feldes LetzterBankkontakt <\/b>der Tabelle tblOptionen <\/b>in die Variable intLastContact <\/b>ein.<\/p>\n Finden wir keinen Datensatz, erhält die Variable den Wert -1<\/b>.<\/p>\n Hat intLastContact <\/b>danach nicht den Wert -1<\/b>, stellen wir das Kombinationsfeld auf diesen Wert ein, damit es den entsprechenden Banking Kontakt anzeigt.<\/p>\n Außerdem lesen wir dann mit GetAccountList <\/b>die Accounts für diesen Banking Kontakt ein und weisen diesen der Datensatzherkunft des Kombinationsfeldes cboAccounts <\/b>zu.<\/p>\n Danach lesen wir den Wert der Option LetztesKonto <\/b>ein. Auch hier verwenden wir den Wert -1<\/b>, wenn dieses nicht angegeben ist. Liegt nun ein anderer Wert als -1 <\/b>vor, stellen wir das Kombinationsfeld cboAccounts <\/b>auf diesen Wert ein. Außerdem tragen wir die entsprechenden Werte aus dem Kombinationsfeld in die beiden Textfelder txtBIC <\/b>und txtIBAN <\/b>ein.<\/p>\n Wenn bereits kein zuletzt verwendeter Banking Kontakt angegeben war, stellen wir die Eigenschaft TimerInterval <\/b>auf 100 <\/b>ein. Dadurch wird 100 Millisekunden später die Prozedur Form_Timer <\/b>ausgelöst.<\/p>\n Diese stellt den Fokus auf das Kombinationsfeld cboBankingKontakte <\/b>ein und klappt dieses aus. Danach wird Me.TimerInterval <\/b>wieder auf 0 <\/b>eingestellt, damit das Ereignis nicht erneut ausgelöst wird.<\/p>\n Das Formular sieht anschließend wie in Bild 18 aus.<\/p>\n Bild 18: Ausgeklapptes Kombinationsfeld<\/span><\/b><\/p>\n Wenn der Benutzer mit dem ersten Kombinationsfeld einen Banking Kontakt ausgewählt hat, sollen die entsprechenden Accounts in das Kombinationsfeld cboAccounts <\/b>geladen werden.<\/p>\n Dazu hinterlegen wir eine Ereignisprozedur für das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes cboBankingKontakte<\/b> (siehe Listing 7).<\/p>\nBeantragen einer Registrierungsnummer für Onlinebanking <\/h2>\n
![\"Seite](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_002.png\")
<\/p>\nhttps:\/\/www.fints.org\/de\/hersteller\/produktregistrierung<\/pre>\n
Public <\/span>Const cstrFints As String<\/span> = \"XXXXXXXXXXXXXXXXXXXXX\"<\/pre>\nHolen der DDBAC-Komponenten<\/h2>\n
https:\/\/www.andreminhorst.de\/ddbac<\/pre>\n
Installieren der DDBAC-Komponenten<\/h2>\n
Holen des Lastschrift-Mandats<\/h2>\n
Herstellen einer Verbindung per Onlinebanking<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_003.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_004.png\")
<\/p>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_005.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_006.png\")
<\/p>\n![\"Angabe](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_007.png\")
<\/p>\n![\"Eingabe](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_008.png\")
<\/p>\n![\"Erfolgsmeldung\"](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_009.png\")
<\/p>\nBank Kontakt und Konten einsehen<\/h2>\n
![\"Der](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_010.png\")
<\/p>\n![\"Bearbeiten](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_011.png\")
<\/p>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_012.png\")
<\/p>\nProgrammieren der Lastschrift-Funktionen<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_013.png\")
<\/p>\nUnterschiede zwischen SEPA-Basislastschrift und SEPA-Firmenlastschrift<\/h2>\n
\n
Banking Kontakte und Accounts in Access einlesen<\/h2>\n
Formular anlegen<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_014.png\")
<\/p>\nBanking Kontakte füllen<\/h2>\n
Public Function <\/span>GetContacts(Optional<\/span> bolReset As Boolean<\/span>) As <\/span>BACContacts\r\n If <\/span>m_Contacts Is Nothing Then<\/span>\r\n Set<\/span> m_Contacts = New<\/span> BACContacts\r\n m_Contacts.Populate \"\"\r\n Else<\/span>\r\n If <\/span>bolReset = True<\/span> Then<\/span>\r\n m_Contacts.Populate \"\"\r\n End If<\/span>\r\n End If<\/span>\r\n Dim <\/span>objContact As <\/span>BACContact\r\n For Each objContact In m_Contacts\r\n objContact.Fields(\"ProductName\") = cstrFints\r\n objContact.Fields(\"Produktbezeichnung\") = cstrFints\r\n Next<\/span> objContact\r\n Set<\/span> GetContacts = m_Contacts\r\nEnd Function<\/span><\/pre>\nPrivate <\/span>m_Contacts As <\/span>BACContacts<\/pre>\nPublic Sub <\/span>Test_GetContacts()\r\n Dim <\/span>objContact As <\/span>BACContact\r\n For Each objContact In GetContacts\r\n Debug.Print<\/span> objContact.BankCode, objContact.UserID\r\n Next<\/span> objContact\r\nEnd Sub<\/span><\/pre>\nBanking Kontakte unter Berücksichtigung der Verfügbarkeit einer Funktion holen<\/h2>\n
Public Function <\/span>GetContactListWithFeature(strSegment As String<\/span>, Optional<\/span> bolReset As Boolean<\/span>) As String<\/span>\r\n Dim <\/span>objContact As <\/span>BACContact\r\n Dim <\/span>strContacts As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>bolFeature As Boolean<\/span>\r\n Dim <\/span>objContacts As <\/span>BACContacts\r\n Set<\/span> objContacts = GetContacts(bolReset)\r\n For i = 0 To objContacts.Count - 1\r\n Set<\/span> objContact = objContacts.Item(i)\r\n If <\/span>BACBPDSegmentVorhanden(objContact, strSegment) Then<\/span>\r\n bolFeature = True<\/span>\r\n Else<\/span>\r\n bolFeature = False<\/span>\r\n End If<\/span>\r\n strContacts = strContacts & i & \";\" & objContact.UserID & \";\" _\r\n & objContact.BankCode & \";\" _\r\n & IIf(bolFeature = True, \"[x] \", \"[-] \") _\r\n & objContact(\"Contact\") _\r\n & \"|\" & objContact.BankCode _\r\n & \"|\" & objContact.UserID & \";\"\r\n Next<\/span> i\r\n GetContactListWithFeature = strContacts\r\nEnd Function<\/span><\/pre>\n0;735160;70000997;[x] B+S Banksysteme Demobank FinTS3|70000997|735160;<\/pre>\n
Funktionen eines Banking Kontakts ermitteln<\/h2>\n
Public Function <\/span>BACBPDSegmentVorhanden(objContact As <\/span>BACContact, strSegment As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>intSegment As Integer<\/span>\r\n intSegment = objContact.BankData.Segments.FindSegmentType(strSegment)\r\n If <\/span>intSegment = -1 Then<\/span>\r\n BACBPDSegmentVorhanden = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_015.png\")
<\/p>\n\n
Accounts auslesen<\/h2>\n
Public Function <\/span>GetAccounts(intContact As Integer<\/span>) As <\/span>BACAccounts\r\n Dim <\/span>objContact As <\/span>BACContact\r\n Set<\/span> objContact = GetContacts.Item(intContact)\r\n Set<\/span> GetAccounts = objContact.Accounts\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetAccountList(intContact As Integer<\/span>, Optional<\/span> bolSepa As Boolean<\/span>) As String<\/span>\r\n Dim <\/span>objAccount As <\/span>BACAccount\r\n Dim <\/span>strAccounts As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n For Each objAccount In GetAccounts(intContact)\r\n If <\/span>bolSepa = False<\/span> Or (bolSepa = True<\/span> And objAccount.IsSepa) Then<\/span>\r\n strAccounts = strAccounts & i & \";\" _\r\n & objAccount.AccountNumber & \";\" _\r\n & objAccount.BIC & \";\" & objAccount.IBAN & \";\" _\r\n & objAccount.AccountNumber _\r\n & \"|\" & objAccount.AcctName & \";\"\r\n End If<\/span>\r\n i = i + 1\r\n Next<\/span> objAccount\r\n GetAccountList = strAccounts\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>Test_GetAccountList()\r\n Debug.Print<\/span> GetAccountList(1)\r\nEnd Sub<\/span><\/pre>\n0;1000735160;DDBADEMM002;DE43700009971000735160;1000735160|Girokonto;1;2000735160;DDBADEMM002;DE95700009972000735160;2000735160|Girokonto (verzögert);2;9000735160;DDBADEMM002;DE71700009979000735160;9000735160|Depot;<\/pre>\n
Tabelle zum Speichern der zuletzt verwendeten Daten<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_016.png\")
<\/p>\nBankdaten beim Laden ins Kombinationsfeld schreiben<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_017.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>intLastContact As Integer<\/span>\r\n Dim <\/span>intLastAccount As Integer<\/span>\r\n Me!cboBankingKontakte.RowSourceType = \"Value List\"\r\n Me!cboAccounts.RowSourceType = \"Value List\"\r\n Me.cboBankingKontakte.RowSource = GetContactListWithFeature(\"HKDSE\")\r\n If <\/span>Len<\/span>(Me!cboBankingKontakte.RowSource) = 0 Then<\/span>\r\n MsgBox<\/span> \"Es wurden noch keine Kontakte angelegt.\" & vbCrLf<\/span> & vbCrLf<\/span> & \"Dies können Sie über den Eintrag \" _\r\n & \"''Homebanking Kontakte'' in der Systemsteuerung erledigen.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n intLastContact = Nz(DLookup(\"LetzterBankkontakt\", \"tblOptionen\"), -1)\r\n If <\/span>Not<\/span> intLastContact = -1 Then<\/span>\r\n Me!cboBankingKontakte = intLastContact\r\n Me!cboAccounts.RowSource = GetAccountList(intLastContact, True<\/span>)\r\n intLastAccount = Nz(DLookup(\"LetztesKonto\", \"tblOptionen\"), -1)\r\n If <\/span>Not<\/span> intLastAccount = -1 Then<\/span>\r\n Me!cboAccounts = intLastAccount\r\n Me!txtBIC = Me!cboAccounts.Column(2)\r\n Me!txtIBAN = Me!cboAccounts.Column(3)\r\n End If<\/span>\r\n Else<\/span>\r\n Me.TimerInterval = 100\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Timer()\r\n Me!cboBankingKontakte.SetFocus\r\n Me!cboBankingKontakte.Dropdown\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\n![\"Ausgeklapptes](\"..\/fileadmin\/_temp_\/2025_02\/pic_1544_018.png\")
<\/p>\nNach der Auswahl eines Banking Kontakts<\/h2>\n