<\/p>\n
SEPA wird ab 1. Februar 2014 Standard beim Onlinebanking. Damit Sie gerüstet sind, zeigen wir Ihnen, wie Sie beispielsweise Kontostände abfragen, Buchungen einlesen und überweisungen durchführen. Grundlage ist die DDBAC-Bibliothek der Firma DataDesign. Die Bibliothek stellt die grundlegenden Funktionen zur Verfügung und kann zu Testzwecken kostenlos eingesetzt werden.<\/b><\/p>\n
Warum SEPA<\/b><\/p>\n
SEPA (Single Euro Payments Area<\/b>, einheitlicher Euro-Zahlungsverkehrsraum) ist die Bezeichnung für ein Projekt für die Vereinheitlichung und Erleichterung des bargeldlosen Zahlungsverkehrs von Zahlungen in Euro.<\/p>\n
Dies bezieht sich zum Beispiel darauf, dass der Zahlungsverkehr zwischen verschiedenen Ländern vereinfacht wird, dass Zahlungen schneller auf dem Zielkonto eingehen (bei Lastschriften sofort und bei überweisungen in einem Tag) und dass die Zahlungsinformationen in XML übertragen werden und somit weniger Probleme durch verschiedene Protokolle im internationalen Zahlungsverkehr auftreten.<\/p>\n
Konkrete änderungen sind, dass Kontonummer und Bankleitzahl für Zahlungen bald nicht mehr genutzt werden können und diese durch IBAN und BIC ersetzt werden.<\/p>\n
IBAN ist die International Bank Account Number und dient der Standardisierung der vielen verschiedenen Formate für Kontonummern in den verschiedenen Ländern. In Deutschland besteht die IBAN aus zwei Buchstaben für die Länderkennung (DE), zwei Zahlen für eine Prüfsumme, eine achtstellige Bankleitzahl und eine zehnstellige Kontonummer. In anderen Ländern variiert der Aufbau. BIC ist die Abkürzung für Business Identifier Code und dient prinzipiell als eine Art Bankleitzahl.<\/p>\n
Sie besteht mindestens aus acht Zeichen, wobei die ersten vier dem Bank-Code entsprechen, die folgenden zwei dem Ländercode und die letzten zwei dem Ort. Zusätzlich kann mit drei Zeichen eine Kennzeichnung einer Filiale oder Abteilung hinzugefügt werden.<\/p>\n
Voraussetzungen<\/b><\/p>\n
Voraussetzung zum Nachvollziehen der Beispiele dieses Beitrags ist die Installation des DDBAC Software Development Kits<\/b>, das Sie unter dem Link http:\/\/ddbac.de\/index.php\/menu-endanwender-user\/menu-e-u-updates-download <\/b>finden.<\/p>\n
Achtung: Sie dürfen diese Software ohne Lizenz ausschließlich zu Testzwecken oder für private Zwecke einsetzen. Ohne Lizenz darf die Funktionsbibliothek weder für geschäftliche Zwecke genutzt noch als Teil einer Anwendung weitergegeben werden.<\/p>\n
Wir arbeiten jedoch an einer günstigen Lizenzform für die Leser von Access im Unternehmen <\/b>– mehr dazu im Newsletter (Anmeldung: http:\/\/access-im-unternehmen.de\/index.phpid=380<\/b>).<\/p>\n
Nach der Installation des Pakets müssen Sie zunächst Ihre Bankverbindungen einrichten. Dies erledigen Sie zunächst noch völlig ohne Hilfe von Access, nämlich über die Systemsteuerung.<\/p>\n
Sie finden dort einen Eintrag namens Homebanking Kontakte<\/b>, der nach einem Doppelklick den Dialog aus Bild 1 anzeigt.<\/p>\n
![\"Der](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_001.png\")
<\/p>\n
Bild 1: Der noch leere Dialog der Banking-Kontakte<\/span><\/b><\/p>\n Mit der Schaltfläche Neu <\/b>legen Sie nun einen neuen Eintrag an. Ein Homebanking-Kontakt ist eine Zusammenfassung eines oder mehrerer Konten bei einem Kreditinstitut. Geben Sie hier zunächst die Bankleitzahl der Bank ein und klicken Sie dann auf Weiter<\/b> (s. Bild 2). Der Dialog ermittelt nun alle Zugangsarten für diese Bank und zeigt diese zwei Dialoge später an (s. Bild 3). <\/p>\n Bild 2: Auswahl einer Zugangsart<\/span><\/b><\/p>\n Bild 3: Anlegen eines neuen Banking-Kontakts<\/span><\/b><\/p>\n Wenn Sie sich wundern, dass beispielsweise die Option PIN\/TAN <\/b>nicht aktiviert ist, springen Sie nochmal einen Schritt zurück: Wenn Sie dort die Option Zugangsdaten manuell eingeben (für Experten) <\/b>aktivieren, werden gegebenenfalls weitere Zugangsoptionen angezeigt.<\/p>\n In Abhängigkeit von der gewählten Zugriffsart geben Sie in den folgenden Dialogen verschiedene Informationen an – bei Verwendung einer Schlüsseldatei müssen Sie etwa deren Speicherort angeben.<\/p>\n Oder Sie müssen sicherstellen, dass bei Verwendung eines Chipkartenlesers auch ein entsprechendes Gerät angeschlossen ist. Je nach der Zugangsart müssen Sie unter Umständen Informationen oder Geräte von Ihrem Kre-dit-in-stitut anfordern. Sind die für die Konfiguration der Zugangsart nötigen Schritte erledigt, wählen Sie eine der angebotenen HBCI-Versionen aus (s. Bild 4).<\/p>\n Bild 4: Auswahl der HBCI-Version<\/span><\/b><\/p>\n Schließlich geben Sie die Verbindungsdaten für das Kreditinstitut ein, die aber normalerweise schon vorhanden sein sollten (zum Beispiel hbci.commerzbank.de<\/b>).<\/p>\n Klicken Sie im Dialog aus Bild 5 dann auf die Schaltfläche Verbindung testen<\/b>, um die Funktion zu prüfen. Ein frisch erstellter Kontakt sieht schließlich wie in Bild 6 aus. Legen Sie die gewünschten Banking-Kontakte an und schließen Sie den Dialog – von nun an geht es mit Access weiter.<\/p>\n Bild 5: Verbindungsdaten des Kreditinsituts<\/span><\/b><\/p>\n Bild 6: Frisch erstellter Kontakt<\/span><\/b><\/p>\n Customers und Accounts<\/b><\/p>\n Unter VBA heißt das, was Sie soeben über den entsprechenden Dialog der Systemsteuerung angelegt haben, BACCustomer<\/b>.<\/p>\n Ein BACCustomer <\/b>kann jedoch ein oder mehrere Konten besitzen, die Sie über die Accounts<\/b>-Auflistung ermitteln. Ein Konto entspricht wiederum einem BACAccount<\/b>-Objekt. Konten können Giro-Konten sein, aber auch Tagesgeldkonten, Kreditkarten und mehr. übrigens: Der BACContact <\/b>kann in den hier vorgestellten Beispielen synonym zum BACCustomer <\/b>verwendet werden.<\/p>\n Wie verwalten<\/b><\/p>\n In einer Datenbankanwendung stellt sich immer die Frage, wie Daten in Tabellen verwaltet werden. Wenn die Basisdaten, also die Bankkonten, mit einer externen Anwendung verwaltet werden, muss man diese Daten dann noch zusätzlich in Tabellen vorhalten Tatsache ist: Es kann sein, dass Sie mit dem Assistenten ein Bankkonto anlegen.<\/p>\n Wenn Sie dieses zusätzlich in einer Tabelle speichern, liegen die Daten doppelt vor. Sie können dann allerdings die in Zusammenhang mit diesem Konto anfallenden Daten wie etwa die Buchungen in einer Tabelle speichern und von dieser Tabelle aus das entsprechende Konto referenzieren.<\/p>\n Damit würden Sie dem vorbeugen, dass ein Konto einmal gelöscht und nicht mehr über DDBAC zugreifbar ist oder dass sich Daten ändern, die mit dem Konto zusammenhängen. Aber letztlich benötigt man zum Speichern einer Buchung doch nur die üblicherweise anfallenden Metadaten – im Falle des eigenen Bankkontos die Kontonummer und die Bankleitzahl, unter welcher die Buchung durchgeführt wurde.<\/p>\n Was aber, wenn Sie beispielsweise mit Ihrer mit Access erstellten Homebanking-Lösung auf einen anderen Rechner ziehen, der die Bankverbindungen noch nicht kennt Von dort aus können Sie dann weder Kontostände noch -bewegungen abrufen noch Aktionen wie überweisungen initiieren.<\/p>\n Aber können Sie das, wenn die Bankdaten in einer Tabelle der Datenbank gespeichert sind Nein: Die Daten müssen der DDBAC-Komponente bekannt sein und an der entsprechenden Stelle in der Registry gespeichert sein. Die Kontakte lassen sich auch nicht einfach per VBA anlegen – Sie werden beim Umzug also die Kontakte neu anlegen müssen.<\/p>\n Oder Sie kopieren die Datei mit den benutzerdefinierten DDBAC-Daten, die Sie unter dem Namen ddusers.dat <\/b>im Verzeichnis C:\\Users\\ Kontakte und Konten auslesen<\/b><\/p>\n Listing 1 zeigt, wie Sie per VBA auf die Kontakte und Konten zugreifen, die DDBAC in der Datei ddusers.dat <\/b>gespeichert hat. Die Prozedur benötigt zunächst das Hauptobjekt des Typs BACBanking<\/b>. In einer äußeren For Each<\/b>-Schleife durchläuft die Prozedur nun die Elemente der Auflistung Customers<\/b>. Dieses liefert als Eigenschaften beispielsweise die übergeordnete Benutzernummer (die in manchen Fällen der Kontonummer plus weiteren Zahlen entspricht), die Bankleitzahl oder die Anzahl der in diesem Kontakt enthaltenen Konten.<\/p>\n Die Konten wiederum sprechen Sie über die Auflistung Accounts <\/b>des BACCustomer<\/b>-Objekts an. Das BACAccount<\/b>-Objekt liefert mit AcctName <\/b>die bankinterne Bezeichnung der Kontenart, mit AccountNumber <\/b>die Kontonummer und weitere Informationen.<\/p>\n SEPA oder nicht SEPA<\/b><\/p>\n Interessant ist in Zusammenhang mit dem vorliegenden Beitrag die Information, ob ein Account SEPA-fähig ist oder nicht. Dies bekommen Sie relativ einfach per VBA heraus – das BACAccount<\/b>-Objekt liefert nämlich mit einer Eigenschaft namens IsSepa <\/b>die Antwort. Hat diese den Wert True<\/b>, können Sie das Konto für SEPA <\/b>nutzen.<\/p>\n BIC und IBAN<\/b><\/p>\n Die bereits weiter oben vorgestellten Eigenschaften BIC <\/b>und IBAN <\/b>können Sie ebenfalls aus dem BACAccount<\/b>-Objekt auslesen, und zwar über die gleichnamigen Eigenschaften. Bevor wir zur SEPA-überweisung kommen, schauen wir uns jedoch noch an, was die Beispieldatenbank noch zu bieten hat.<\/p>\n Kontostand und Umsätze<\/b><\/p>\n Das Formular aus Bild 7 bietet die Möglichkeit, Bankverbindungen und Konten auszuwählen und den aktuellen Kontostand und die Umsätze einzulesen.<\/p>\n Bild 7: Anzeigen von Bankverbindungen, Konten, Kontostand und Umsätzen<\/span><\/b><\/p>\n Bankverbindungen eintragen<\/b><\/p>\n Das Eintragen der Bankverbindungen geschieht beim Laden des Formulars. Die Form_Load<\/b>-Ereignisprozedur liest dann die in der oben angegebenen Textdatei enthaltenen Bankverbindungs- und Kontodaten in das Kombinationsfeld cboContacts <\/b>ein.<\/p>\n Aus einer Tabelle namens tblOptionen<\/b> holt das Formular sich den zuletzt ausgewählten Datensatz für dieses Feld, soweit vorhanden. Falls ja, wird die Bankverbindung eingestellt und das Formular liest auf die gleiche Weise das zuletzt verwendete Konto ein. In diesem Fall werden auch gleich die bereits gespeicherten Umsätze eingelesen und im Unterformular angezeigt (s. Listing 2). Wählt der Benutzer eine neue Bankverbindung aus, liest das Formular alle Konten zu dieser Bankverbindung ein und bietet diese im unteren Kombinationsfeld zur Auswahl an (s. Listing 3). Anschließend muss er noch das Konto auswählen, damit die entsprechenden Umsätze im Unterformular erscheinen:<\/p>\n <\/p>\n Listing 1: Laden des Formulars frmHomebanking<\/span><\/b><\/p>\n Die Daten des Unterformulars stammen aus der Tabelle tblUmsaetze<\/b>. Das Unterformular wird durch die Prozedur UnterformularFiltern <\/b>gefüllt. Die Prozedur liest die Bankverbindung und das Konto aus den beiden Kombinationsfeldern cboContacts<\/b> und cboAccounts <\/b>ein und stellt einen entsprechenden Filter zusammen, der die gewünschten Datensätze der Tabelle tblUmsaetze <\/b>liefert (s. Listing 4).<\/p>\n Listing 3: Filtern der Umsätze nach dem gewählten Bankkonto<\/span><\/b><\/p>\n Kontostand einlesen<\/p>\n Ein Klick auf die Schaltfläche mit der Beschriftung Aktualisieren <\/b>liest den Kontostand für das aktuell ausgewählte Konto ein.<\/p>\n Den Großteil der Arbeit übernimmt dabei die Funktion Kontostand<\/b>, die als Parameter die Nummer des aktuell ausgewählten Kontakts im Kombinationsfeld cboContacts <\/b>und die Nummer des gewünschten Kontos aus cboAccounts <\/b>erwartet.<\/p>\n Die Funktion füllt einen benutzerdefinierten Typ, der die vier Elemente Datum<\/b>, Wert<\/b>, SollHaben <\/b>und Waehrung <\/b>enthält. Die Ergebnisse landen schließlich in den entsprechenden Textfeldern des Formulars (s. Listing 5). Die Funktion Kontostand <\/b>finden Sie im Modul mdlSEPA <\/b>der Beispieldatenbank.<\/p>\n Listing 4: Aktualisieren des Kontostands<\/span><\/b><\/p>\n Umsätze einlesen<\/b><\/p>\n Das Einlesen der Umsätze resultiert im Speichern der Umsatzdaten in der Tabelle tblUmsaetze<\/b>. Das Arbeitstier bei diesem Vorgang ist die Funktion Kontoauszug<\/b>, die wiederum den Index des Kontakts und des Kontos als Parameter erwartet.<\/p>\n Die Prozedur, die durch das Anklicken der Schaltfläche cmdUmsaetzeAbfragen <\/b>ausgelöst wird, ruft die Funktion Kontoauszug <\/b>mit diesen Parametern auf und erhält ein Objekt auf Basis der benutzerdefinierten Klasse clsTransactions <\/b>zurück. Dieses enthält für jeden Umsatz ein weiteres Objekt des Typs clsTransaction<\/b>. Die folgende For…Next<\/b>-Schleife durchläuft die einzelnen Buchungen und trägt für jede einen Datensatz in der Tabelle tblUmsaetze <\/b>ein.<\/p>\n Die neue Variante unterscheidet sich in einem praktischen Aspekt von den in früheren Beiträgen beschriebenen Versionen: Bislang wurde ein Startdatum vom Benutzer vorgegeben oder es wurden einfach alle vorhandenen Umsätze eingelesen. Die jeweilige Routine hat dann konsequent alle Umsätze eingelesen und diese nach bestimmten Kriterien (Datum, Betrag, Verwendungszweck) mit bereits vorhandenen Einträgen abgeglichen.<\/p>\n Wenn Sie nun am gleichen Tag zwei oder mehr überweisungen getätigt haben, deren Umsatz, Verwendungszweck und weitere Vergleichskriterien übereinstimmen, wurde der Umsatz nur einmal gespeichert.<\/p>\n Die neue Variante ermittelt nun zunächst das Datum des letzten Umsatzes für das angegebene Konto. Dieses Datum wird als Startdatum für das Einlesen der Umsätze verwendet – so spart man sich das Einlesen der kompletten Umsätze vorheriger Tage.<\/p>\n Allerdings kann es immer noch vorkommen, dass Sie einmal am 15.7.2013 um 16 Uhr die Umsätze einlesen und dann wieder an einem späteren Datum. Sollten dann am 15.7.2013 weitere Umsätze nach 16 Uhr hinzugekommen sein, gleicht die Prozedur diese wieder gegeneinander ab.<\/p>\n Ist dann ein Umsatz mit gleichen Daten dabei, wird dieser fälschlicherweise nicht erneut gespeichert. Deshalb löscht die Prozedur cmdUmsaetzeAbfragen <\/b>alle Umsätze, die am Tag der letzten Abfrage eingelesen wurden, und liest diesen Tag nun komplett neu ein. Eventuell vorhandene eindeutige Indizes, die verhindern, dass ein Umsatz mit gleichem Betrag, Datum und Verwendungszweck doppelt angelegt wird, können somit ebenfalls entfallen (s. Listing 6). <\/p>\n Listing 5: Umsätze abfragen<\/span><\/b><\/p>\n Die Funktion Kontoauszug<\/b>, welche alle Umsätze seit dem letzten Buchungstag liefert, finden Sie ebenfalls im Modul mdlSEPA<\/b>. Auch diese wurde in ähnlicher Art bereits in vorherigen Beiträgen beschrieben, sodass wir hier nicht mehr im Detail darauf eingehen.<\/p>\n Die Schaltfläche Neue überweisung<\/b><\/b><\/p>\n Wenn Sie einen Kontakt und ein Bankkonto ausgewählt haben, können Sie über die Schaltfläche cmdNeue-Ueber-weisung<\/b> den nachfolgend beschriebenen Dialog zum Durchführen einer überweisung aufrufen. Die beim Anklicken der Schaltfläche ausgelöste Prozedur öffnet das Formular und übergibt den Index des aktuell ausgewählten Bankkontos an das Formular. Dies verwendet dies direkt zum Einstellen der Bankverbindung des Ausführenden der überweisung:<\/p>\n überweisungsformular<\/b><\/p>\n Kommen wir nun zu den neuen SEPA-überweisungen, die sich von den in vorherigen Artikeln vorgestellten herkömmlichen überweisungen unterscheiden. Um die überweisung benutzerfreundlich zu gestalten, verwenden wir dazu natürlich ein geeignetes Formular, das im Entwurf wie in Bild 8 aussieht. Das Formular ist ungebunden. Beim öffnen des Formulars werden gleich einige Aktionen durchgeführt. Die Prozedur Form_Open <\/b>erstellt eine neue BACContacts<\/b>-Auflistung und füllt diese aus den gespeicherten Bankverbindungen (s. Listing 7). Dann durchläuft sie alle Elemente und alle im jeweiligen Kontakt enthaltenen BACAccount<\/b>-Elemente – jeweils in einer For Each<\/b>-Schleife. Dabei fügt sie nur für die SEPA-fähigen Konten jeweils einen Eintrag zu einer semikolaseparierten Liste hinzu, der aus dem Indexwert, der Bankleitzahl, der Kontonummer, IBAN und BIC besteht.<\/p>\n Bild 8: überweisungsformular<\/span><\/b><\/p>\n Das Ergebnis landet in einer Textvariablen namens strAccounts<\/b>, die anschließend als Datensatzherkunft eines als Wertliste ausgeführten Kombinationsfeldes landet.<\/p>\n Beim öffnen des Formulars kann der Indexwert für ein Konto per OpenArgs übergeben werden. Die Prozedur wählt dann entweder das per OpenArgs <\/b>angegebene Konto oder das erste Konto im Kombinationsfeld cboSender <\/b>aus. Mit diesem Kombinationsfeld kann der Benutzer das Konto auswählen, von dem aus die überweisung stattfinden soll.<\/p>\n Je nach gewähltem Eintrag zeigen die Textfelder txtIBANSender <\/b>und txtBICSender <\/b>die entsprechenden Spaltenwerte des Kombinationsfeldes an.<\/p>\n Sender einstellen<\/b><\/p>\n Wenn beim öffnen des Formulars kein Konto übergeben wurde, von dem aus die überweisung erfolgen soll, wird standardmäßig der erste Eintrag der Liste eingestellt. Der Benutzer kann dann einen anderen Eintrag auswählen.<\/p>\n Dies löst die Prozedur cboSender_AfterUpdate <\/b>aus, wodurch IBAN <\/b>und BIC<\/b> mit den Daten des ausgewählten Kontos gefüllt werden (Code siehe Modul Form_frmUeberweisung <\/b>der Beispieldatenbank).<\/p>\n Empfänger einstellen<\/b><\/p>\n Bei einer jungfräulichen Datenbank gibt es zu Beginn noch keine Empfänger. Erst, wenn Sie eine überweisung ausführen, speichert die Anwendung den Empfänger in der Tabelle tblEmpfaenger<\/b>, und zwar mit dem Werten Name1<\/b>, Name2<\/b>, IBAN <\/b>und BIC<\/b> – siehe weiter unten.<\/p>\n Sind bereits Empfänger in der Tabelle tblEmpfaenger <\/b>gespeichert, werden diese im Kombinationsfeld cboEmpfaenger <\/b>zur Auswahl angeboten. Wählt der Benutzer einen dieser Einträge aus, trägt die Prozedur cboEmpfaenger_AfterUpdate <\/b>die Werte der Felder Name1<\/b>, Name2<\/b>, IBAN <\/b>und BIC <\/b>in die Textfelder txtName1<\/b>, txtName2<\/b>, txtIBANEmpfaenger <\/b>und txtBICEmpfaenger <\/b>ein.<\/p>\n Die Prozedur finden Sie ebenfalls im Modul Form_frmUeberweisung <\/b>der Beispieldatenbank.<\/p>\n Aufruf der überweisungsfunktion<\/b><\/p>\n Die Schaltfläche cmdUeberweisen <\/b>löst schließlich die Prozedur aus Listing 8 aus, die zuerst die Daten des aktuellen Empfängers in die Tabelle tblEmpfaenger <\/b>einträgt.<\/p>\n Listing 7: Aufruf der überweisungs-Funktion mit den ermittelten Parametern<\/span><\/b><\/p>\n Dann ermittelt sie den Indexwert des ausgewählten Sender-Bankkontos aus dem Kombinationsfeld cboSender <\/b>und speichert ihn in der Variablen inContact<\/b>.<\/p>\n Informationen wie Name1<\/b>, Name2<\/b>, IBAN <\/b>und BIC <\/b>des Empfängers werden in vier entsprechenden String-Variablen gespeichert. Der Betrag aus dem Textfeld txtBetrag <\/b>landet in der Variablen curBetrag<\/b>, der Verwendungszweck in strVerwendungszweck<\/b>.<\/p>\n Dann erstellt die Funktion ein neues Objekt des Typs BACContact <\/b>für den ausgewählten Sender aus dem Kombinationsfeld cboSender<\/b> und speichert es in der Variablen objKontakt<\/b>. Die Variable objSender <\/b>vom Typ BACAccount <\/b>hingegen nimmt das zu verwendende Konto auf. objEmpfaenger <\/b>ist auch ein Objekt des Typs BACAccount<\/b>, muss aber neu erstellt werden – und zwar auf Basis der Daten des Empfängers. Dies erledigt die Funktion AccountErstellen<\/b>, die auf Basis der Werte Name1<\/b>, Name2<\/b>, IBAN <\/b>und BIC <\/b>ein neues BACAccount<\/b>-Objekt zurückliefert. Diese Funktion finden Sie im Modul mdlSEPA <\/b>der Beispieldatenbank.<\/p>\n Schließlich ruft die Routine die Funktion SEPAUeberweisung <\/b>auf, welche die überweisung auf Basis der übergebenen Daten durchführt. Die Funktion liefert die von der Bank gelieferte Antwort als Zeichenkette zurück, die gleich im entsprechenden Textfeld angezeigt wird.<\/p>\n SEPA-überweisung <\/b><\/p>\n Die Funktion SEPAUeberweisung<\/b> (s. Listing 9) erwartet einige Objekte und weitere Informationen als Parameter:<\/p>\n Listing 8: Ausführen einer Einzelüberweisung<\/span><\/b><\/p>\n Die Prozedur erstellt zunächst ein neues BACBanking<\/b>-Objekt, das für die Steuerung des Vorgangs nötig ist. Die Methode NewSegment <\/b>dieses Objekts liefert ein BACSegment<\/b>-Objekt des Typs HKCCS<\/b>.<\/p>\n Dies entspricht prinzipiell einem Schema für einen Geschäftsvorfall, hier einer SEPA-überweisung.<\/p>\n Damit die aktuellste Version des Segments verwendet wird, übergibt man der Funktion NewSegment <\/b>zusätzlich den Wert der Eigenschaft HBCIVersion <\/b>des BACContact<\/b>-Objekts.<\/p>\n Die Auftragsdaten werden in einem speziellen neuen Objekt des Typs BACSepaMessage <\/b>erfasst. Dieses erstellt die Funktion neu und füllt dann zunächst die Eigenschaft Segment <\/b>mit einem Verweis auf die Variable objSegment<\/b>. Das als Parameter übergebene Objekt objSender <\/b>mit den Sender-Daten weist die Funktion der Eigenschaft FromAccount <\/b>zu.<\/p>\n Die Empfängerdaten und die übrigen Informationen weisen Sie allerdings nicht dem BACSepaMessage<\/b>-Objekt hinzu. Dazu wird ein weiteres Objekt des Typs BACSepaOrder <\/b>benötigt.<\/p>\n Dieses wird über die Add<\/b>-Methode der Orders<\/b>-Auflistung des Objekts objSepaMessage <\/b>erstellt. Die Eigenschaft ToAccount <\/b>des neuen Objekts objSepaOrder <\/b>wird mit dem mit objEmpfaenger <\/b>übergebenen BACAccount<\/b>-Objekt mit den Empfängerdaten gefüllt.<\/p>\n Gleiches geschieht mit der Eigenschaft Recipient <\/b>des BACSepaMessage<\/b>-Objekts. Das BACSepaOrder<\/b>-Objekt wird nun noch mit den eigentlichen überweisungsdaten gefüllt – mit dem Betrag (Amount<\/b>), der Währung (CurrencyCode<\/b>) und dem Verwendungszweck (Purpose<\/b>).<\/p>\n Die Verify<\/b>-Methode prüft den Inhalt, danach beginnt der eigentliche überweisungsvorgang. Fehler können hier beispielsweise auftreten, wenn eine falsche Währung angegeben wird. Tritt ein Fehler auf, wird die Funktion mit einer entsprechenden Meldung beendet. Schließlich erstellt die Funktion ein neues Objekt des Typs BACDialog<\/b>. Dieser sorgt mit der Methode NewDialogUI<\/b> dafür, dass ein Dialog zur Authentifizierung angezeigt wird – zum Beispiel wie in Bild 9.<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_003.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_002.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_004.png\")
<\/p>\n![\"Verbindungsdaten](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_005.png\")
<\/p>\n![\"Frisch](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_006.png\")
<\/p>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_007.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>intLastContact As Integer<\/span>\r\n Dim <\/span>intLastAccount As Integer<\/span>\r\n Me!cboContacts.RowSource = GetContacts\r\n intLastContact = Nz(DLookup(\"LetzterBankkontakt\", \"tblOptionen\"), -1)\r\n If <\/span>Not<\/span> intLastContact = -1 Then<\/span>\r\n Me!cboContacts = Me!cboContacts.ItemData(intLastContact)\r\n Me!cboAccounts.RowSource = GetAccounts(intLastContact)\r\n intLastAccount = Nz(DLookup(\"LetztesKonto\", \"tblOptionen\"), -1)\r\n If <\/span>Not<\/span> intLastAccount = -1 Then<\/span>\r\n Me!cboAccounts = Me!cboAccounts.ItemData(intLastAccount)\r\n UnterformularFiltern\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboAccounts_AfterUpdate()\r\n If <\/span>IsNull(Me!cboAccounts) Then<\/span>\r\n UnterformularLeeren\r\n Else<\/span>\r\n UnterformularFiltern\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>UnterformularFiltern()\r\n Dim <\/span>strKontonummer As String<\/span>\r\n Dim <\/span>strKundennummer As String<\/span>\r\n strKundennummer = Me!cboContacts.Column(1)\r\n strKontonummer = Me!cboAccounts.Column(1)\r\n With<\/span> Me.sfmHomebanking.Form\r\n .Filter = \"Kundennummer = ''\" & strKundennummer & \"'' AND Kontonummer = ''\" _\r\n & strKontonummer & \"''\"\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdAktualisieren_Click()\r\n Dim <\/span>AktuellerKontostand As <\/span>tKontostand\r\n AktuellerKontostand = Kontostand(Me!cboContacts, Me!cboAccounts)\r\n With<\/span> AktuellerKontostand\r\n Me!txtKontostandDatum = .Datum\r\n Me!txtKontostandSaldo = .Wert\r\n Me!txtKontostandSollHaben = .SollHaben\r\n Me!txtKontostandWaehrung = .Waehrung\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdUmsaetzeAbfragen_Click()\r\n Dim <\/span>objTransactions As <\/span>clsTransactions\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intNeueUmsaetze As Integer<\/span>\r\n Dim <\/span>datStart As Date<\/span>\r\n Set<\/span> db = CurrentDb\r\n datStart = Nz(DMax(\"Buchungsdatum\", \"tblUmsaetze\", \"Kundennummer = ''\" & Me!cboContacts.Column(1) _\r\n & \"'' AND Kontonummer = ''\" & Me!cboAccounts.Column(1) & \"'' AND BLZ = ''\" & Me!cboContacts.Column(2) & \"''\"), 0)\r\n Set<\/span> objTransactions = Kontoauszug(Me!cboContacts, Me!cboAccounts, eUmsaetzeGebucht, datStart)\r\n db.Execute \"DELETE FROM tblUmsaetze WHERE Kundennummer = ''\" & Me!cboContacts.Column(1) & \"'' AND Kontonummer = ''\" _\r\n & Me!cboAccounts.Column(1) & \"'' AND BLZ = ''\" & Me!cboContacts.Column(2) & \"'' And Buchungsdatum >= \" _\r\n & SQLDatum(datStart), dbFailOnError\r\n For i = 1 To objTransactions.count\r\n With<\/span> objTransactions.Item(i)\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblUmsaetze(Kundennummer, Kontonummer, BLZ, Betrag, Waehrung, Buchungsdatum, \" _\r\n & \"Auftraggeber, Kontonummer_Partner, BLZ_Partner, Verwendungszweck) VALUES(''\" & .Kundennummer & \"'', ''\" _\r\n & .Kontonummer & \"'', ''\" & .BLZ & \"'', \" & Replace<\/span>(.Betrag, \",\", \".\") & \", ''\" & .Waehrung & \"'', \" _\r\n & SQLDatum(.Buchungsdatum) & \", ''\" & .Auftraggeber & \"'', ''\" & .Kontonummer_Partner & \"'', ''\" & .BLZ_Partner _\r\n & \"'', ''\" & .Verwendungszweck & \"'')\", dbFailOnError\r\n Select Case Err.Number\r\n Case <\/span>0\r\n intNeueUmsaetze = intNeueUmsaetze + 1\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler \" & Err.Number & \", ''\" & Err.Description & \"''\"\r\n End Select<\/span>\r\n End With<\/span>\r\n Next<\/span> i\r\n If <\/span>intNeueUmsaetze = 0 Then<\/span>\r\n MsgBox<\/span> \"Es wurden keine neuen Umsätze eingelesen.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Es wurden \" & intNeueUmsaetze & \" neue Umsätze eingelesen.\"\r\n Me!sfmHomebanking.Form.Requery\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeueUeberweisung_Click()\r\n DoCmd.OpenForm _\r\n \"frmUeberweisung\", _\r\n WindowMode:=acDialog, _\r\n OpenArgs:=Me!cboAccounts\r\nEnd Sub<\/span><\/pre>\n![\"überweisungsformular\"](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_008.png\")
<\/p>\nPrivate Sub <\/span>cmdUeberweisen_Click()\r\n Dim <\/span>intContact As Integer<\/span>\r\n Dim <\/span>strEmpfaengername1 As String<\/span>, strEmpfaengername2 As String<\/span>, strEmpfaengerIBAN As String<\/span>, strEmpfaengerBIC As String<\/span>\r\n Dim <\/span>curBetrag As Currency<\/span>\r\n Dim <\/span>strVerwendungszweck As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>objKontakt As <\/span>BACContact, objSender As <\/span>BACAccount, objEmpfaenger As <\/span>BACAccount\r\n Dim <\/span>datDatum As Date<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblEmpfaenger(Name1, Name2, IBAN, BIC) VALUES(''\" & Me!txtName1 & \"'', ''\" & Me!txtName2 _\r\n & \"'', ''\" & Me!txtIBANEmpfaenger & \"'', ''\" & Me!txtBICEmpfaenger & \"'')\"\r\n intContact = Me!cboSender\r\n strEmpfaengername1 = Me!txtName1\r\n strEmpfaengername2 = Nz(Me!txtName2)\r\n strEmpfaengerIBAN = Me!txtIBANEmpfaenger\r\n strEmpfaengerBIC = Me!txtBICEmpfaenger\r\n curBetrag = Me!txtBetrag\r\n strVerwendungszweck = Me!txtVerwendungszweck\r\n Set<\/span> objKontakt = objContacts(Me!cboSender)\r\n Set<\/span> objSender = objKontakt.Accounts(Me!cboSender)\r\n Set<\/span> objEmpfaenger = AccountErstellen(strEmpfaengername1, strEmpfaengername2, strEmpfaengerIBAN, strEmpfaengerBIC)\r\n Me!Meldung = SEPAUeberweisung(objKontakt, objSender, objEmpfaenger, curBetrag, strVerwendungszweck, datDatum)\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>SEPAUeberweisung(objContact As <\/span>BACContact, objSender As <\/span>BACAccount, objEmpfaenger As <\/span>BACAccount, _\r\n curBetrag As Currency<\/span>, strVerwendungszweck As String<\/span>) As String<\/span>\r\n Dim <\/span>objBanking As <\/span>BACBanking\r\n Dim <\/span>objSegment As <\/span>BACSegment\r\n Dim <\/span>objSepaMessage As <\/span>BACSepaMessage\r\n Dim <\/span>objSepaOrder As <\/span>BACSepaOrder\r\n Dim <\/span>strError As String<\/span>, strAntwort As String<\/span>, i As Integer<\/span>\r\n Dim <\/span>objMessage As <\/span>BACMessage\r\n Dim <\/span>objBACDialog As <\/span>BACDialog\r\n Dim <\/span>objTransaction As <\/span>BACTransaction\r\n Set<\/span> objBanking = New<\/span> BACBanking\r\n Set<\/span> objSegment = objBanking.NewSegment(\"HKCCS\", objContact(\"HBCIVersion\"))\r\n Set<\/span> objSepaMessage = New<\/span> BACSepaMessage\r\n objSepaMessage.Segment = objSegment\r\n objSepaMessage.FromAccount = objSender\r\n Set<\/span> objSepaOrder = objSepaMessage.Orders.Add\r\n objSepaOrder.ToAccount = objEmpfaenger\r\n objSepaMessage.Recipient = objEmpfaenger\r\n With<\/span> objSepaOrder\r\n .Amount = curBetrag\r\n .CurrencyCode = \"EUR\"\r\n .Purpose = strVerwendungszweck\r\n End With<\/span>\r\n objSepaMessage.Verify strError\r\n If <\/span>Len<\/span>(strError) > 0 Then<\/span>\r\n MsgBox<\/span> strError\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Set<\/span> objBACDialog = objContact.NewDialogUI\r\n objBACDialog.BeginDialog\r\n Set<\/span> objMessage = objBACDialog.ExecuteSegment(objSegment)\r\n objMessage.Acknowledgement.SaveAs CurrentProject.Path & \"\\result.txt\"\r\n Set<\/span> objTransaction = objMessage.Transactions(0)\r\n For i = 1 To 100\r\n If <\/span>Len<\/span>(objTransaction.Acknowledgement.Item(i, 3)) > 0 Then<\/span>\r\n strAntwort = strAntwort & objTransaction.Acknowledgement.Item(i, 3)\r\n End If<\/span>\r\n Next<\/span> i\r\n SEPAUeberweisung = strAntwort\r\n objBACDialog.EndDialog\r\nEnd Function<\/span><\/pre>\n\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2013_04\/pic_898_009.png\")
<\/p>\n