Business::KontoCheck - Perl extension for checking German and Austrian Bank Account Numbers
Because the module is for use mainly in Germany, the following documentation language is german too.
use Business::KontoCheck; use Business::KontoCheck qw( kto_check lut_name lut_blz lut_ort %kto_retval [...] ); $retval=lut_init([$lut_name[,$required[,$set]]]); $retval=kto_check_init($lut_name[,$required[,$set[,$incremental]]]); $retval=lut_blocks([$mode[,$filename[,$blocks_ok[,$blocks_fehler]]]) $retval=kto_check($blz,$kto,$lut_name); $retval=kto_check_str($blz,$kto,$lut_name); $retval=kto_check_blz($blz,$kto) $retval=kto_check_pz($pz,$kto,$blz) $retval=kto_check_regel($blz,$kto) $retval=generate_lut($inputname,$outputname,$user_info,$lut_version); $retval=generate_lut2($inputname,$outputname[,$user_info[,$gueltigkeit[,$felder[,$filialen[,$slots[,$lut_version[,$set]]]]]]]); [$@]retval=lut_blz($blz[,$offset[,$ret]]) [$@]retval=lut_info($lut_name) [$@]retval=lut_filialen($blz[,$offset[,$ret]]) [$@]retval=lut_name($blz[,$offset[,$ret]]) [$@]retval=lut_name_kurz($blz[,$offset[,$ret]]) [$@]retval=lut_plz($blz[,$offset[,$ret]]) [$@]retval=lut_ort($blz[,$offset[,$ret]]) [$@]retval=lut_pan($blz[,$offset[,$ret]]) [$@]retval=lut_bic($blz[,$offset[,$ret]]) [$@]retval=lut_pz($blz[,$offset[,$ret]]) [$@]retval=lut_aenderung($blz[,$offset[,$ret]]) [$@]retval=lut_loeschung($blz[,$offset[,$ret]]) [$@]retval=lut_nachfolge_blz($blz[,$offset[,$ret]]) [$@]retval=lut_iban_regel($blz[,$offset[,$ret]]) $retval=lut_valid() $ret=pz2str($pz[,$ret]) [$@]ret=lut_suche_bic($bic[,$retval]) [$@]ret=lut_suche_namen($namen[,$retval]) [$@]ret=lut_suche_namen_kurz($namen_kurz]) [$@]ret=lut_suche_ort($ort[,$retval]) [$@]ret=lut_suche_blz($blz1[,$blz2[,$retval]]) [$@]ret=lut_suche_pz($pz1[,$pz2[,$retval]]) [$@]ret=lut_suche_plz($plz1[,$plz2[,$retval]]) [$@]ret=lut_suche_regel($regel1[,$regel2[,$retval]]) [$@]ret=lut_suche_volltext($suchworte[,$retval]) [$@]ret=lut_suche_multiple($suchworte[,$uniq[,$such_cmd[,$retval]]]) $retval=copy_lutfile($old_name,$new_name,$new_slots) $retval=dump_lutfile($outputname,$felder) $retval=lut_cleanup() $retval=ci_check($ci) $retval=iban_check($iban) [$@]retval=iban2bic($iban) [$@]retval=iban_gen($blz,$kto) $enc=kto_check_encoding($encoding) $enc_str=kto_check_encoding_str($encoding) $keep=keep_raw_data($flag) $retval=retval2txt($retval) $retval=retval2txt_short($retval) $retval=retval2iso($retval) $retval=retval2html($retval) $retval=retval2utf8($retval) $retval=retval2dos($retval) $retval=kto_check_retval2txt($retval) $retval=kto_check_retval2txt_short($retval) $retval=kto_check_retval2html($retval) $retval=kto_check_retval2utf8($retval) $retval=kto_check_retval2dos($retval) $retval_txt=$kto_retval{$retval}; $retval=kto_check_at($blz,$kto,$lut_name); $retval=kto_check_at_str($blz,$kto,$lut_name); $retval=generate_lut_at($inputname,$outputname,$plain_name,$plain_format);
Dies ist Business::KontoCheck, ein Programm zum Testen der Prüfziffern von deutschen und österreichischen Bankkonten. Dies ist die Perl- Version der C-Library (als XSUB Modul).
Es werden defaultmäßig die Funkionen kto_check und kto_check_str, (aus dem deutschen Modul), kto_check_at, kto_check_at_str (aus dem österreichischen Modul) sowie die Variable %kto_retval (für beide Module) exportiert.
Optional können auch eine Reihe weiterer Funktionen exportiert werden; diese müssen dann in der use Klausel anzugeben werden.
Funktion: kto_check() kto_check_str() Aufgabe: Testen eines Kontos Aufruf: $retval=kto_check($blz,$kto,$lut_name); $retval=kto_check_str($blz,$kto,$lut_name); Parameter: $blz: falls 2- oder 3-stellig: Prüfziffermethode (evl. mit Untermethode a, b, c... oder 1, 2, 3) falls 8-stellig: Bankleitzahl $kto: Kontonummer (wird vor der Berechnung linksbündig mit Nullen auf 10 Stellen aufgefüllt) $lut_name: Dateiname der Lookup-Tabelle mit Bankleitzahlen. Falls NULL oder ein leerer String übergeben wird, wird der Dateiname blz.lut benutzt. Diese Datei enthält die Prüfziffermethoden für die einzelnen Bankleitzahlen; sie kann mit der Funktion generate_lut() aus der Bundesbanktabelle generiert werden. Rückgabewerte: Die Funktion kto_check gibt einen numerischen Wert zurück, während die Funktion kto_check_str einen kurzen String zurückgibt. Mittels des assoziativen Arrays %kto_retval lassen sich die numerischen Rückgabewerte in einen etwas ausführlicheren Rückgabetext umwandeln: $retval_txt=$kto_retval{$retval};
-------------------------------------------------------------------------
Funktion: generate_lut() (LUT-Version 1.0 oder 1.1; obsolet) generate_lut2() (LUT-Version 1.0, 1.1 oder 2.0) Aufgabe: LUT-Datei generieren Aufruf: $retval=generate_lut($inputname,$outputname,$user_info,$lut_version); $retval=generate_lut2($inputname,$outputname[,$user_info[,$gueltigkeit [,$felder[,$filialen[,$slots[,$lut_version[,$set]]]]]]]); Parameter: inputname: Name der Bankleitzahlendatei der Deutschen Bundesbank (z.B. blz0303pc.txt) outputname: Name der Zieldatei (z.B. blz.lut) user_info: Info-Zeile, die zusätzlich in die LUT-Datei geschrieben wird. Diese Zeile wird von der Funktion get_lut_info() in zurückgegeben, aber ansonsten nicht ausgewertet. lut_version: Format der LUT-Datei. Mögliche Werte: 1: altes Format (1.0) 2: altes Format (1.1) mit Infozeile 3: neues Format (2.0). Die Werte 1 und 2 werden defaultmäßig nicht mehr unterstützt, da sie komplett obsolet sind; falls jemand eine Datei im alten Format generieren will, muß in konto_check.h das Makro GENERATE_OLD_LUTFILE auf 1 gesetzt werden. Andernfalls wird immer eine Datei im neuen Format generiert. Die folgenden Parameter gelten nur für generate_lut2(): gueltigkeit: Gültigkeitsbereich der LUT-Datei, im Format JJJJMMTT-JJJJMMTT, z.B. 20120305-20120603 felder: (Integer, 0-9) Felder, die in die LUT-Datei aufgenommen werden sollen. Folgende Felder werden in die Datei aufgenommen (nicht aufgeführt, aber immer dabei sind Infoblock, BLZ und Prüfziffer). Name+Kn. steht dabei für einen Block, der Name und Kurzname der Bank enthält; dieser läßt sich besser komprimieren, als wenn die beiden Blocks getrennt sind. Lfd.Nr. ist die laufende Nr. in der BLZ-Datei; praktisch wird sie wohl nicht benötigt, ist aber zur Vollständigkeit mit enthalten. 0: (nur die drei Defaultblocks) (3 Slots) 1: Name+Kn. (4 Slots) 2: Name+Kn.,BIC (5 Slots) 3: Name,PLZ,Ort (6 Slots) 4: Name,PLZ,Ort,BIC (7 Slots) 5: Name+Kn.,PLZ,Ort,BIC (7 Slots) 6: Name+Kn.,PLZ,Ort,BIC,Nachfolge-BLZ (8 Slots) 7: Name+Kn.,PLZ,Ort,BIC,Nachfolge-BLZ,Änderung (9 Slots) 8: Name+Kn.,PLZ,Ort,BIC,Nachfolge-BLZ,Änderung,Löschung (10 Slots) 9: Name+Kn.,PLZ,Ort,BIC,Nachfolge-BLZ,Änderung,Löschung,PAN,Lfd.Nr. (12 Slots) filialen: Flag (0 oder 1), ob die Filialdaten ebenfalls aufgenommen werden sollen. slots: Anzahl Slots (mögliche Verzeichniseinträge) der LUT-Datei. Für einen vollen Datensatz (felder=9) werden 12 Slots benötigt; falls die Datei zwei Datensätze enthalten soll, braucht man mindestens 24 Slots. In konto_check.h ist das Makro SLOT_CNT_MIN definiert, das die minimale Anzahl Slots angibt. Falls beim Aufruf dieser Funktion weniger Slots angegeben werden, erhält man den Rückgabewert OK_SLOT_CNT_MIN_USED, und die Anzahl der Slots wird auf den Minimalwert gesetzt. Falls nicht genügend Slots verfügbar sind, um die Datei zu generieren, wird der (Fehler-)Wert LUT2_NO_SLOT_FREE zurückgegeben. set: (Integer, 0, 1 oder 2) Angabe, ob das primäre Set (0 bzw. 1) oder sekundäre Datensatz (2) geschrieben werden soll. Falls für set 0 angegeben wird, wird eine neue Datei angelegt, bei 1 und 2 wird der Datensatz an eine vorhandene LUT-Datei angehängt. Das setzt natürlich voraus, daß noch genügend Verzeichnisslots vorhanden sind, um alle Blocks schreiben zu können. Bei Bedarf kann mittels copy_lutfile() die Anzahl der Verzeichnisslots auch erhöht werden.
Funktion: lut_blz() lut_filialen() lut_name() lut_name_kurz() lut_plz() lut_ort() lut_pan() lut_bic() lut_pz() lut_aenderung() lut_loeschung() lut_nachfolge_blz() lut_iban_regel() Aufgabe: Bestimmung von Feldern der BLZ-Datei Aufruf: [$@]ret=lut_blz($blz[,$filiale[,$ret]]) [$@]ret=lut_name($blz[,$filiale[,$ret]]) [$@]ret=lut_name_kurz($blz[,$filiale[,$ret]]) [$@]ret=lut_plz($blz[,$filiale[,$ret]]) [$@]ret=lut_ort($blz[,$filiale[,$ret]]) [$@]ret=lut_pan($blz[,$filiale[,$ret]]) [$@]ret=lut_bic($blz[,$filiale[,$ret]]) [$@]ret=lut_pz($blz[,$filiale[,$ret]]) [$@]ret=lut_aenderung($blz[,$filiale[,$ret]]) [$@]ret=lut_loeschung($blz[,$filiale[,$ret]]) [$@]ret=lut_nachfolge_blz($blz[,$filiale[,$ret]]) [$@]ret=lut_iban_regel($blz[,$filiale[,$ret]]) $ret=pz2str($pz[,$ret]) Die Funktionen bestimmen die diversen Felder der BLZ-Datei zu einer gegebenen BLZ. Falls der optionale Parameter $filiale angegeben wird, wird der Wert für eine Filiale bestimmt, ansonsten (und bei $filiale==0) der Wert der Hauptstelle. Die Anzahl der Filialen zu einer BLZ läßt sich mittels der Funktion $cnt=lut_filialen($blz) bestimmen. Die Funktion pz2str() wandelt eine numerische Prüfziffermethode (wie sie z.B. von lut_pz() zurückgegeben wird) in einen zweistelligen String um. Alle Funktionen (außer pz2str) lassen sich sowohl im skalaren als auch im Array-Kontext aufrufen. Bei Aufruf in skalarem Kontext wird der jeweilige Wert zurückgegeben; bei Aufruf im Array-Kontext wird außerdem noch der Rückgabestatus der Funktion als Zahl, String (lang) und String (kurz) zurückgegeben. Beispiel: $ret=lut_name("66090800") liefert für $ret den Wert "BBBank", @ret=lut_name("66090800") liefert ein Array mit den Werten @ret=("BBBank",1,"ok","OK") der Aufruf @ret=lut_name("660908") liefert ein Array mit den Werten @ret=("",-5,"die Bankleitzahl ist nicht achtstellig","INVALID_BLZ_LENGTH") Falls der Aufruf im Array-Kontext nicht gewünscht ist, gibt es noch alternative Funktionen, die nur in skalarem Kontext arbeiten: ------------------------------------------------------------------------- Funktion: keep_raw_data kto_check_encoding kto_check_encoding_str Aufgabe: Diese Funktionen setzen die Ausgabekodierung (sowohl für die Felder der LUT-Datei als auch für Statusmeldungen mit der Funktion kto_check_retval2txt()) fest. Aufruf: $flag=keep_raw_data($flag) $encoding=kto_check_encoding($mode) $encoding_str=kto_check_encoding_str($mode) Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die Funktion retval2txt() und einige Felder der LUT-Datei (Name, Kurzname, Ort) fest. Wenn die Funktion nicht aufgerufen wird, wird der Wert DEFAULT_ENCODING aus konto_check.h benutzt. _Achtung_: Das Verhalten der Funktionen hängt von dem Flag keep_raw_data_flag der C-Bibliothek ab. Falls das Flag gesetzt ist, werden die Rohdaten der Blocks Name, Kurzname und Ort im Speicher gehalten; bei einem Wechsel der Kodierung wird auch für diese Blocks die Kodierung umgesetzt. Falls das Flag nicht gesetzt ist, sollte die Funktion *vor* der Initialisierung aufgerufen werden, da in dem Fall die Daten der LUT-Datei nur bei der Initialisierung konvertiert werden. Mit der Funktion keep_raw_data() kann das Flag gesetzt oder gelöscht werden. Für den Parameter mode werden die folgenden Werte akzeptiert: 1: ISO-8859-1 2: UTF-8 3: HTML 4: DOS CP 850 51: ISO-8859-1, Makro für Fehlermeldungen 52: UTF-8, Makro für Fehlermeldungen 53: HTML, Makro für Fehlermeldungen 54: DOS CP 850, Makro für Fehlermeldungen Rückgabewert ist die aktuelle Kodierung als Integer oder (bei kto_check_encoding_str()) als String. Falls zwei Kodierungen angegeben sind, ist die erste die der Statusmeldungen, die zweite die der LUT-Blocks: 1: "ISO-8859-1"; 2: "UTF-8"; 3: "HTML entities"; 4: "DOS CP 850"; 12: "ISO-8859-1/UTF-8"; 13: "ISO-8859-1/HTML"; 14: "ISO-8859-1/DOS CP 850"; 21: "UTF-8/ISO-8859-1"; 23: "UTF-8/HTML"; 24: "UTF-8/DOS CP-850"; 31: "HTML entities/ISO-8859-1"; 32: "HTML entities/UTF-8"; 34: "HTML entities/DOS CP-850"; 41: "DOS CP-850/ISO-8859-1"; 42: "DOS CP-850/UTF-8"; 43: "DOS CP-850/HTML"; 51: "Makro/ISO-8859-1"; 52: "Makro/UTF-8"; 53: "Makro/HTML"; 54: "Makro/DOS CP 850"; Mit der Funktion keep_raw_data() läßt sich einstellen, ob die Rohwerte der LUT-Datei gespeichert werden sollen (das erfordert etwa 900 KB zusätzlichen Hauptspeicher, erlaubt aber das Umkodieren der LUT-Blocks nach der Initialisierung). ------------------------------------------------------------------------- Funktion: kto_check_retval2txt kto_check_retval2iso kto_check_retval2utf8 kto_check_retval2html kto_check_retval2dos kto_check_retval2txt_short Aufgabe: Ausgabe numerischer Statusmeldungen als Klartext. Aufruf: $retval_txt=kto_check_retval2txt($retval) $retval_txt=kto_check_retval2iso($retval) $retval_txt=kto_check_retval2utf8($retval) $retval_txt=kto_check_retval2html($retval) $retval_txt=kto_check_retval2dos($retval) $retval_txt=kto_check_retval2txt_short($retval) Diese Funktionen wandeln die numerischen Rückgabewerte in einen Klartext-String der gewünschten Kodierung um. Die Kodierung der Funktion kto_check_retval2txt() wird dabei durch die Funktion kto_check_encoding() (s.o.) festgelegt; die anderen Funktionen geben jeweils eine feste Kodierung zurück. ------------------------------------------------------------------------- Funktion: lut_blz1() lut_filialen1() lut_name1() lut_name_kurz1() lut_plz1() lut_ort1() lut_pan1() lut_bic1() lut_pz1() lut_aenderung1() lut_loeschung1() lut_nachfolge_blz1() Aufgabe: Bestimmung von Feldern der BLZ-Datei (skalarer Kontext) Aufruf: $ret=lut_blz1($blz[,$filiale[,$ret]]) $ret=lut_name1($blz[,$filiale[,$ret]]) $ret=lut_name_kurz1($blz[,$filiale[,$ret]]) $ret=lut_plz1($blz[,$filiale[,$ret]]) $ret=lut_ort1($blz[,$filiale[,$ret]]) $ret=lut_pan1($blz[,$filiale[,$ret]]) $ret=lut_bic1($blz[,$filiale[,$ret]]) $ret=lut_pz1($blz[,$filiale[,$ret]]) $ret=lut_aenderung1($blz[,$filiale[,$ret]]) $ret=lut_loeschung1($blz[,$filiale[,$ret]]) $ret=lut_nachfolge_blz1($blz[,$filiale[,$ret]]) $ret=pz2str1($pz[,$ret]) Die Funktionen entsprechen den Funktionen ohne die angehängte "1"; allerdings arbeiten sie ausschließlich im skalaren Kontext. Das ist z.B. vorteilhaft, wenn man den Rückgabewert der Funktion in einem anderen Funktionsaufruf benutzen will. Der Rückgabewert der Funktion kann mittels des optionalen Parameters $ret bestimmt werden.
Funktion: lut_suche_blz() lut_suche_bic() lut_suche_namen() lut_suche_namen_kurz() lut_suche_ort() lut_suche_pz() lut_suche_plz() lut_suche_regel() lut_suche_volltext() lut_suche_multiple() Aufgabe: Suche von Banken (nach Feldern der BLZ-Datei) Aufruf: [$@]ret=lut_suche_bic($bic[,$retval[,$uniq[,$sort]]]) [$@]ret=lut_suche_namen($namen[,$retval[,$uniq[,$sort]]]) [$@]ret=lut_suche_namen_kurz($namen_kurz[,$retval[,$uniq[,$sort]]]) [$@]ret=lut_suche_ort($ort[,$retval[,$uniq[,$sort]]]) [$@]ret=lut_suche_blz($blz1[,$blz2[,$retval[,$uniq[,$sort]]]]) [$@]ret=lut_suche_pz($pz1[,$pz2[,$retval[,$uniq[,$sort]]]]) [$@]ret=lut_suche_plz($plz1[,$plz2[,$retval[,$uniq[,$sort]]]]) [$@]ret=lut_suche_regel($plz1[,$plz2[,$retval[,$uniq[,$sort]]]]) [$@]ret=lut_suche_volltext($suchworte[,$retval[,$uniq[,$sort]]]) [$@]ret=lut_suche_multiple($suchworte[,$uniq[,$such_cmd[,$retval]]]) Mit diesen Funktionen lassen sich Banken suchen, die bestimmte Kriterien erfüllen. Bei alphanumerischer Suche (BIC, Name, Kurzname, Ort, Volltext, multiple) kann ein vollständiger Name oder Namensanfang angegeben werden. So findet z.B. eine Suche lut_suche_ort("aa") die Banken in in Aach, Aachen, Aalen und Aarbergen, während eine Suche wie lut_suche_ort("aac") nur die Banken in Aach und Aachen findet. Soll die Suche exakt sein, d.h. das Suchwort nicht als Wortanfang verstanden werden, ist diesem ein ! voranzustellen. Eine Suche wie lut_suche_ort("!aach") findet dann nur Aach, nicht mehr Aachen. Diese Syntaxt läßt sich auch für lut_suche_multiple() anwenden. Bei numerischer Suche (BLZ, Prüfziffer oder PLZ) kann ein Bereich spezifiziert werden. Falls der zweite Suchparameter nicht angegeben wird (oder 0 ist), werden Banken gesucht, die genau auf den Parameter passen. Diese Funktionen können sowohl in skalarem als auch im Listenkontext aufgerufen werden. Bei Aufruf in skalarem Kontext geben sie eine Referenz auf ein Array mit Bankleitzahlen zurück, die die Kriterien erfüllen; bei Aufruf im Listenkontext werden zwei (bei lut_suche_multiple()) bzw. vier (bei allen anderen Suchfunktionen) Array-Referenzen sowie der Rückgabewert der Funktion zurückgegeben. Die erste zeigt auf das Array mit Bankleitzahlen, die zweite auf ein Array mit Indizes der jeweiligen Zweigstellen und die dritte (nicht lut_suche_multiple()!) auf ein Array mit den jeweiligen Werten des gesuchten Feldes. Der nächste Parameter ist der Statuscode; als letzter Parameter kommt bei allen Suchfunktionen (außer lut_suche_multiple()) noch eine Referenz auf ein Array, in dem zu jeder gefundenen BLZ die Anzahl der Zweigstellen zurückgegeben wird, falls der Parameter uniq auf 1 gesetzt war. In dem optionalen Parameter $retval wird ebenfalls der numerischer Rückgabewert der Funktion (wie im 4. Parameter bei Array-Kontext; 1 bei Erfolg, oder negative Statusmeldung) zurückgeliefert.. Mittels des assoziativen Arrays %kto_retval{$retval} können diese Rückgabewerte in Klartext konvertiert werden. Die Funktion lut_suche_multiple() sucht alle Banken, die mehreren Kriterien entsprechen. Dabei können bis zu 26 Teilsuchen definiert werden, die beliebig miteinander verknüpft werden können (additiv, subtraktiv und multiplikativ). Parameter: such_string: Dieser Parameter gibt die Felder an, nach denen gesucht wird. Er besteht aus einem oder mehreren Suchbefehlen, die jeweils folgenden Aufbau haben: [suchindex:]suchwert[@suchfeld] Der (optionale) Suchindex ist ein Buchstabe von a-z, mit dem das Suchfeld im Suchkommando (zweiter Parameter) referenziert werden kann. Falls er nicht angegeben wird, erhält der erste Suchstring den Index a, der zweite den Index b etc. Der Suchwert ist der Wert nach dem gesucht werden soll. Für die Textfelder ist es der Beginn des Wortes (aa passt z.B. auf Aach, Aachen, Aalen, Aarbergen), für numerische Felder kann es eine Zahl oder ein Zahlbereich in der Form 22-33 sein. Das Suchfeld gibt an, nach welchem Feld der BLZ-Datei gesucht werden soll. Falls das Suchfeld nicht angegeben wird, wird eine Volltextsuche (alle Einzelworte in Name, Kurzname und Ort) gemacht. Die folgende Werte sind möglich: bl BLZ bi BIC k Kurzname n Name o Ort pl PLZ pr Prüfziffer pz Prüfziffer v Volltext In der obigen Tabelle der Suchfelder sind nur die Kurzversionen angegeben; eine Angabe wie aa@ort oder 57000-58000@plz ist auch problemlos möglich. such_cmd: Dieser Parameter gibt an, wie die Teilsuchen miteinander verknüpft werden sollen. Der Ausdruck abc bedeutet, daß die BLZs in den Teilsuchen a, b und c enthalten sein müssen; der Ausdruck a+b+c, daß sie in mindestens einer Teilsuche enthalten sein muß; der Ausdruck a-b, daß sie in a, aber nicht in b enthalten sein darf (Beispiel s.u.). Falls das Suchkommando nicht angegeben wird, müssen die Ergebnis-BLZs in allen Teilsuchen enthalten sein. uniq: Falls dieser Parameter 1 ist, wird für jede Bank nur eine Zweigstelle ausgegeben; falls er 0 ist, werden alle gefundenen Zweigstellen ausgegeben. Falls der Parameter weggelassen wird, wird der Standardwert (UNIQ_DEFAULT_PERL aus konto_check.h) benutzt. sort: Falls dieser Parameter 1 ist, werden die Banken nach BLZ sortiert, nicht in der Reihenfolge der Suchbegriffe (Standard). Falls der Parameter uniq 1 ist, wird immer nach BLZ sortiert. Beispiele: $blz_p=lut_suche_ort("mannheim",$retval); @blz=@$blz_p; # Array mit allen Banken in Mannheim # $retval enthält den Rückgabestatus der Funktion ($blz_p,$idx_p)=lut_suche_ort("mannheim"); @blz=@$blz_p; # Array mit allen Banken in Mannheim @idx=@$idx_p; # Array der Zweigstellen ($blz_p,$idx_p,$ort_p)=lut_suche_ort("aa"); @blz=@$blz_p; # Array mit Banken in Städten, die mit "aa" beginnen @idx=@$idx_p; # Array der Zweigstellen @ort=@$ort_p; # Array der jeweiligen Orte ($blz_p,$idx_p,$ort_p,$retval,$cnt_p)=lut_suche_ort("aa",$rv,1); @blz=@$blz_p; # Array mit Banken in Städten, die mit "aa" beginnen @idx=@$idx_p; # Array der Zweigstellen @ort=@$ort_p; # Array der jeweiligen Orte @cnt=@$cpt_p; # Array mit Anzahl der gefundenen Zweigstellen (bei $uniq=1) # $retval enthält den Rückgabestatus der Funktion ($blz_p,$idx_p,$retval) =lut_suche_multiple("b:55000000-55100000@blz o:67000-68000@plz sparkasse","bo") # Bei diesem Aufruf werden nur die beiden ersten Teilsuchen (nach # BLZ und PLZ) benutzt; die Suche findet alle Banken mit einer BLZ # zwischen 55000000 und 55100000 im PLZ-Bereich 67000 bis 68000. ($blz_p,$idx_p,$retval) =lut_suche_multiple("b:55000000-55030000@blz o:67000-68000@plz sparkasse","co") # Ähnlicher Suche wie oben, allerdings werden nur die beiden # letzten Teilsuchen berücksichtigt. ($blz_p,$idx_p,$retval)=lut_suche_multiple("67000-68000@plz sparda",0) # Dieser Aufruf gibt alle Filialen der Sparda-Bank im PLZ-Bereich # 67000 bis 68000 zurück. ($blz_p,$idx_p,$retval)=lut_suche_multiple("skat") # Dieser Aufruf ist einfach eine Volltextsuche nach der Skat-Bank. # Der direkte Aufruf von bank_suche_volltext() ist intern # natürlich wesentlich leichtgewichtiger, aber die Suche so auch # möglich. Funktion: kto_check_at() kto_check_at_str() Aufgabe: Testen eines österreichischen Kontos Aufruf: $retval=kto_check_at($blz,$kto,$lut_name); $retval=kto_check_at_str($blz,$kto,$lut_name); Parameter: $blz: BLZ (5-stellig) oder Prüfparameter (mit vorangestelltem p) Falls der BLZ ein - vorausgestellt wird, werden auch gelöschte Bankleitzahlen geprüft. Falls der BLZ ein p vorausgestellt wird, wird der folgende Teil (bis zum Blank/Tab) als Prüfparameter angesehen. $kto: Kontonummer $lut_name: Name der Lookup-Datei oder Leerstring Falls für $lut_name ein Leerstring angegeben wird, versucht die Funktion, die Datei blz-at.lut zu lesen.
Funktion: generate_lut_at() Aufgabe: LUT-Datei für das österreichische Modul generieren Aufruf: $retval=generate_lut_at($inputname,$outputname,$plain_name,$plain_format); Parameter: $inputname: Name der INPAR-Datei (nur komplett, nicht inkrementell!) $outputname: Name der Zieldatei (z.B. blz-at.lut) $plain_name: (optional) Name einer Ausgabedatei für die Klartextausgabe. $plain_format: Format der Klartextausgabe (s.u.) Bugs: Diese Funktion sollte nicht von einem Programm aufgerufen werden, das zum Testen von Kontoverbindungen benutzt wird, da teilweise dieselben Variablen benutzt werden, und so falsche Ergebnisse erzeugt werden können. Die Funktion generate_lut_at() generiert aus der Institutsparameter- Datenbankdatei (5,3 MB) eine kleine Datei (8,3 KB), in der nur die Bankleitzahlen und Prüfziffermethoden gespeichert sind. Um die Datei klein zu halten, wird der größte Teil der Datei binär gespeichert. Falls der Parameter plain_name angegeben wird, wird zu jeder INPAR- Eintrag außerdem (in einem frei wählbaren Format) noch in eine Klartext- datei geschrieben. Das Format der Datei wird durch den 4. Parameter ($plain_format) bestimmt. Es sind die folgenden Felder und Escape- Sequenzen definiert (der Sortierparameter muß als erstes Zeichen kommen!): @i Sortierung nach Identnummern @b Sortierung nach Bankleitzahlen (default) %b Bankleitzahl %B Bankleitzahl (5-stellig, links mit Nullen aufgefüllt) %f Kennzeichen fiktive Bankleitzahl %h Kennzeichen Hauptstelle/Zweigstelle %i Identnummer der Österreichischen Nationalbank %I Identnummer der Österreichischen Nationalbank (7-stellig) %l Löschdatum (DD.MM.YYYY falls vorhanden, sonst nichts) %L Löschdatum (DD.MM.YYYY falls vorhanden, sonst 10 Blanks) %n1 Erster Teil des Banknamens %n2 Zweiter Teil des Banknamens %n3 Dritter Teil des Banknamens %N kompletter Bankname (alle drei Teile zusammengesetzt) %p Kontoprüfparameter %t Name der Prüftabelle %z zugeordnete BLZ (nur bei fiktiver BLZ, sonst nichts) %Z zugeordnete BLZ (5-stellig bei fiktiver BLZ, sonst 5 Blanks) %% das % Zeichen selbst \n Zeilenvorschub \r CR (für M$DOS) \t Tabulatorzeichen \\ ein \ @i (bzw. @b) muß am Anfang des Formatstrings stehen; falls keine Sortierung angegeben wird, wird @b benutzt. Nicht definierte Felder und Escape-Sequenzen werden (zumindest momentan noch) direkt in die Ausgabedatei übernommen. D.h., wenn man %x schreibt, erscheint in der Ausgabedatei auch ein %x, ohne daß ein Fehler gemeldet wird. Ob dies ein Bug oder Feature ist, sei dahingestellt; momentan scheint es eher ein Feature zu sein ;-))). Falls kein plain_format angegeben wird, wird "@B%I %B %t %N" benutzt. Die Datei ist (anders als die INPAR-Datei) nach Bankleitzahlen sortiert. Nähres zur Sortierung findet sich in der Einleitung zur Funktion cmp_blz(). Die Funktion ist **nicht** threadfest, da dies aufgrund der gewählten Implementierung nur schwer zu machen wäre, und auch nicht sehr sinnvoll ist (sie wird nur benötigt, um die blz-at.lut Datei zu erstellen).
Eine ausführliche Beschreibung der Prüfziffermethoden und das Format der LUT-Datei findet sich im C-Quellcode. Ein Link zur offiziellen Beschreibung der Prüfziffermethoden u.a. (von der Deutschen Bundesbank) findet sich auf der Webseite zu konto_check unter http://www.informatik.hs-mannheim.de/konto_check/konto_check.php?ausgabe=3
Auf SourceForge.net gibt es unter http://sourceforge.net/mail/?group_id=199719 auch eine Mailingliste. Der Traffic ist sehr gering, maximal meist ein bis zwei Emails/Monat.
Die aktuelle Version findet sich auf CPAN unter http://search.cpan.org/~michel/Business-KontoCheck oder auf Sourceforge unter http://sourceforge.net/projects/kontocheck/develop Dort ist auch ein SVN Repository, in dem die neuesten Versionen und Bugfixes zu finden sind.
Michael Plugge, <m.plugge@hs-mannheim.de>
Copyright (C) 2007-2012 by Michael Plugge
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.8 or, at your option, any later version of Perl 5 you may have available (perl and glue code).
The C library is covered by the GNU Lesser General Public License:
This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or download it from http://www.gnu.org/licenses/lgpl.html
To install Business::KontoCheck, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Business::KontoCheck
CPAN shell
perl -MCPAN -e shell install Business::KontoCheck
For more information on module installation, please visit the detailed CPAN module installation guide.