Module: KontoCheck

Defined in:
lib/konto_check.rb

Overview

This is a C/Ruby library to check the validity of German Bank Account Numbers. All currently defined test methods by Deutsche Bundesbank (April 2013: 00 to E0) are implemented.

ATTENTION: There are a few important changes in the API between version 0.0.2 (version by Peter Horn/Provideal), version 0.0.6 (jeanmartin) and this version:

  • The function KontoCheck::load_bank_data() is no longer used; it is replaced by KontoCheck::init() and KontoCheck::generate_lutfile().

  • The function KontoCheck::konto_check( blz,kto) changed the order of parameters from (kto,blz) to (blz,kto)

Another change affects only the version 0.0.6 by jeanmartin:

  • In KontoCheck::init( level,name,set) the order of the two first parameters is now free; the order is determined by the type of the variable (level is integer, filename string).

Because this class is inteded for german bank accounts, the rest of the documentation is in german too.

Diese Bibliothek implementiert die Prüfziffertests für deutsche Bankkonten. Die meisten Konten enthalten eine Prüfziffer; mit dieser kann getestet werden, ob eine Bankleitzahl plausibel ist oder nicht. Auf diese Weise können Zahlendreher oder Zifferverdopplungen oft festgestellt werden. Es ist natürlich nicht möglich, zu bestimmen, ob ein Konto wirklich existiert; dazu müßte jeweils eine Anfrage bei der Bank gemacht werden ;-).

Die Bibliothek ist in zwei Teile gesplittet: KontoCheckRaw bildet die direkte Schnittstelle zur C-Bibliothek und ist daher manchmal etwas sperrig; KontoCheck ist dagegen mehr Ruby-artig ausgelegt. KontoCheck gibt meist nur eine Teilmenge von KontoCheckRaw zurück, aber (hoffentlich) die Teile, die man unmittelbar von den jeweiligen Funktionen erwartet. Eine Reihe einfacher Funktionen sind auch in beiden Versionen identisch.

Die Bankleitzahldaten werden in einem eigenen (komprimierten) Format in einer sogenannten LUT-Datei gespeichert. Diese Datei läßt sich mit der Funktion KontoCheck::generate_lutfile bzw. KontoCheckRaw::generate_lutfile aus der Datei der Deutschen Bundesbank (online erhältlich unter www.bundesbank.de/zahlungsverkehr/zahlungsverkehr_bankleitzahlen_download.php) erzeugen. Die LUT-Datei hat den großen Vorteil, daß die Datenblocks (BLZ, Prüfziffer, Bankname, Ort, …) unabhängig voneinander gespeichert sind; jeder Block kann für sich geladen werden. In einer Datei können zwei Datensätze der Bundesbank mit unterschiedlichem Gültigkeitsdatum enthalten sein. Wenn bei der Initialisierung kein bestimmter Datensatz ausgewählt wird, prüft die Bibliothek aufgrund des mit jedem Datensatz gespeicherten Gültigkeitszeitraums welcher Satz aktuell gültig ist und lädt diesen dann in den Speicher.

Numerische Werte (z.B. Bankleitzahlen, Kontonummern, PLZ,…) können als Zahlwerte oder als String angegeben werden; sie werden automatisch konvertiert. Prüfziffermethoden können ebenfalls als Zahl oder String angegeben werden; die Angabe als Zahl ist allerdings nicht immer eindeutig. So kann z.B. 131 sowohl für D1 als auch 13a stehen; daher ist es besser, die Prüfziffermethode als String anzugeben (in diesem Beispiel würde 131 als 13a interpretiert).

Constant Summary collapse

SEARCH_KEYS =

mögliche Suchschlüssel für die Funktion KontoCheck::suche()

:ort, :plz, :pz, :bic, :blz, :namen, :namen_kurz

[:ort, :plz, :pz, :bic, :blz, :namen, :namen_kurz, :regel, :volltext, :multiple]
SEARCH_KEY_MAPPINGS =

:bankleitzahl, :city, :zip, :name, :kurzname, :shortname, :pruefziffer

{
  :bankleitzahl => :blz,
  :city         => :ort,
  :zip          => :plz,
  :name         => :namen,
  :kurzname     => :namen_kurz,
  :shortname    => :namen_kurz,
  :pruefziffer  => :pz,
  :regel        => :regel,
  :vt           => :volltext,
  :fulltext     => :volltext,
  :m            => :multiple,
  :x            => :multiple
}

Class Method Summary collapse

Class Method Details

.bank_aenderung(*args) ⇒ Object

KontoCheck::bank_aenderung( blz [,filiale])

KontoCheckRaw::bank_aenderung(blz [,filiale])

Diese Funktion liefert das ‘Änderung’ Flag einer Bank (als string). Mögliche Werte sind: A (Addition), M (Modified), U (Unchanged), D (Deletion).



823
824
825
 
# File 'lib/konto_check.rb', line 823

def bank_aenderung(*args)
  KontoCheckRaw::bank_aenderung(*args).first
end

.bank_alles(*args) ⇒ Object

KontoCheck::bank_alles( blz [,filiale])

KontoCheckRaw::bank_alles(blz [,filiale])

Dies ist eine Mammutfunktion, die alle vorhandenen Informationen über eine Bank zurückliefert. Das Ergebnis ist ein Array mit den folgenden Komponenten:

0:  Statuscode
1:  Anzahl Filialen
2:  Name
3:  Kurzname
4:  PLZ
5:  Ort
6:  PAN
7:  BIC
8:  Prüfziffer
9:  Laufende Nr.
10: Änderungs-Flag
11: Löeschung-Flag
12: Nachfolge-BLZ

Der Statuscode (Element 0) kann folgende Werte annehmen:

-40  (LUT2_NOT_INITIALIZED)       "die Programmbibliothek wurde noch nicht initialisiert"
-38  (LUT2_PARTIAL_OK)            "es wurden nicht alle Blocks geladen"
 -5  (INVALID_BLZ_LENGTH)         "die Bankleitzahl ist nicht achtstellig"
 -4  (INVALID_BLZ)                "die Bankleitzahl ist ungültig"
  1  (OK)                         "ok"

Anmerkung: Falls der Statuscode LUT2_PARTIAL_OK ist, wurden bei der Initialisierung nicht alle Blocks geladen (oder es sind nicht alle verfügbar); die entsprechenden Elemente haben dann den Wert nil.



896
897
898
 
# File 'lib/konto_check.rb', line 896

def bank_alles(*args)
  KontoCheckRaw::bank_alles(*args)
end

.bank_bic(*args) ⇒ Object

KontoCheck::bank_bic( blz [,filiale])

KontoCheckRaw::bank_bic(blz [,filiale])

Diese Funktion liefert den BIC (Bank Identifier Code) einer Bank. Im Fehlerfall wird nil zurückgegeben.



813
814
815
 
# File 'lib/konto_check.rb', line 813

def bank_bic(*args)
  KontoCheckRaw::bank_bic(*args).first
end

.bank_filialen(*args) ⇒ Object

KontoCheck::bank_filialen( blz)

KontoCheckRaw::bank_filialen(blz)

Diese Funktion liefert die Anzahl Filialen einer Bank (inklusive Hauptstelle). Die LUT-Datei muß dazu natürlich mit den Filialdaten generiert sein, sonst wird für alle Banken nur 1 zurückgegeben.



752
753
754
 
# File 'lib/konto_check.rb', line 752

def bank_filialen(*args)
  KontoCheckRaw::bank_filialen(*args).first
end

.bank_loeschung(*args) ⇒ Object

KontoCheck::bank_loeschung( blz [,filiale])

KontoCheckRaw::bank_loeschung(blz [,filiale])

Diese Funktion liefert das Lösch-Flag für eine Bank zurück (als Integer; mögliche Werte sind 0 und 1); im Fehlerfall wird nil zurückgegeben.



833
834
835
 
# File 'lib/konto_check.rb', line 833

def bank_loeschung(*args)
  KontoCheckRaw::bank_loeschung(*args).first
end

.bank_nachfolge_blz(*args) ⇒ Object

KontoCheck::bank_nachfolge_blz( blz [,filiale])

KontoCheckRaw::bank_nachfolge_blz(blz [,filiale])

Diese Funktion liefert die Nachfolge-BLZ für eine Bank, die gelöscht werden soll (bei der das ‘Löschung’ Flag 1 ist).



842
843
844
 
# File 'lib/konto_check.rb', line 842

def bank_nachfolge_blz(*args)
  KontoCheckRaw::bank_nachfolge_blz(*args).first
end

.bank_name(*args) ⇒ Object

KontoCheck::bank_name( blz [,filiale])

KontoCheckRaw::bank_name(blz [,filiale])

Diese Funktion liefert den Namen einer Bank, oder nil im Fehlerfall.



761
762
763
 
# File 'lib/konto_check.rb', line 761

def bank_name(*args)
  KontoCheckRaw::bank_name(*args).first
end

.bank_name_kurz(*args) ⇒ Object

KontoCheck::bank_name_kurz( blz [,filiale])

KontoCheckRaw::bank_name_kurz(blz [,filiale])

Diese Funktion liefert den Kurznamen einer Bank, oder nil im Fehlerfall.



770
771
772
 
# File 'lib/konto_check.rb', line 770

def bank_name_kurz(*args)
  KontoCheckRaw::bank_name_kurz(*args).first
end

.bank_nr(*args) ⇒ Object

KontoCheck::bank_nr( blz [,filiale])

KontoCheckRaw::bank_nr(blz [,filiale])

Diese Funktion liefert die laufende Nummer einer Bank (internes Feld der BLZ-Datei). Der Wert wird wahrscheinlich nicht oft benötigt, ist aber der Vollständigkeit halber enthalten.



861
862
863
 
# File 'lib/konto_check.rb', line 861

def bank_nr(*args)
  KontoCheckRaw::bank_nr(*args).first
end

.bank_ort(*args) ⇒ Object

KontoCheck::bank_ort( blz [,filiale])

KontoCheckRaw::bank_ort(blz [,filiale])

Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Im Fehlerfall wird für den Ort nil zurückgegeben.



781
782
783
 
# File 'lib/konto_check.rb', line 781

def bank_ort(*args)
  KontoCheckRaw::bank_ort(*args).first
end

.bank_pan(*args) ⇒ Object

KontoCheck::bank_pan( blz [,filiale])

KontoCheckRaw::bank_pan(blz [,filiale])

Diese Funktion liefert den PAN (Primary Account Number) einer Bank.



851
852
853
 
# File 'lib/konto_check.rb', line 851

def bank_pan(*args)
  KontoCheckRaw::bank_pan(*args).first
end

.bank_plz(*args) ⇒ Object

KontoCheck::bank_plz( blz [,filiale])

KontoCheckRaw::bank_plz(blz [,filiale])

Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Im Fehlerfall wird für die PLZ nil zurückgegeben.



792
793
794
 
# File 'lib/konto_check.rb', line 792

def bank_plz(*args)
  KontoCheckRaw::bank_plz(*args).first
end

.bank_pz(blz) ⇒ Object

KontoCheck::bank_pz( blz)

KontoCheckRaw::bank_pz(blz)

Diese Funktion liefert die Prüfziffer einer Bank. Die Funktion unterstützt keine Filialen; zu jeder BLZ kann es in der LUT-Datei nur eine Prüfziffermethode geben.



803
804
805
 
# File 'lib/konto_check.rb', line 803

def bank_pz(blz)
  KontoCheckRaw::bank_pz(blz).first
end

.bank_suche_bic(*args) ⇒ Object

KontoCheck::bank_suche_bic( search_bic [,sort_uniq [,sort]])

KontoCheckRaw::bank_suche_bic( search_bic [,sort_uniq [,sort]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, deren BIC mit dem angegebenen Wert <search_bic> beginnen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1124
1125
1126
 
# File 'lib/konto_check.rb', line 1124

def bank_suche_bic(*args)
  KontoCheckRaw::bank_suche_bic(*args)[1]
end

.bank_suche_blz(*args) ⇒ Object

KontoCheck::bank_suche_blz( blz1 [,blz2 [,sort_uniq [,sort]]])

KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,sort_uniq [,sort]]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, deren BLZ gleich <blz1> ist oder (bei Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1173
1174
1175
 
# File 'lib/konto_check.rb', line 1173

def bank_suche_blz(*args)
  KontoCheckRaw::bank_suche_blz(*args)[1]
end

.bank_suche_multiple(*args) ⇒ Object

Aufruf:

result=bank_suche_multiple(such_string [,such_cmd] [,uniq])



1248
1249
1250
 
# File 'lib/konto_check.rb', line 1248

def bank_suche_multiple(*args)
  KontoCheckRaw::bank_suche_multiple(*args)[1]
end

.bank_suche_namen(*args) ⇒ Object

KontoCheck::bank_suche_namen( name [,sort_uniq [,sort]])

KontoCheckRaw::bank_suche_namen( name [,sort_uniq [,sort]])

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Namen mit dem angegebenen Wert <name> beginnen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1136
1137
1138
 
# File 'lib/konto_check.rb', line 1136

def bank_suche_namen(*args)
  KontoCheckRaw::bank_suche_namen(*args)[1]
end

.bank_suche_namen_kurz(*args) ⇒ Object

KontoCheck::bank_suche_namen_kurz( name [,sort_uniq [,sort]])

KontoCheckRaw::bank_suche_namen_kurz( name [,sort_uniq [,sort]])

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Kurznamen mit dem angegebenen Wert <name> beginnen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1148
1149
1150
 
# File 'lib/konto_check.rb', line 1148

def bank_suche_namen_kurz(*args)
  KontoCheckRaw::bank_suche_namen_kurz(*args)[1]
end

.bank_suche_ort(*args) ⇒ Object

KontoCheck::bank_suche_ort( ort [,sort_uniq [,sort]])

KontoCheckRaw::bank_suche_ort( ort [,sort_uniq [,sort]])

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Sitz mit dem angegebenen Wert <ort> beginnen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1160
1161
1162
 
# File 'lib/konto_check.rb', line 1160

def bank_suche_ort(*args)
  KontoCheckRaw::bank_suche_ort(*args)[1]
end

.bank_suche_plz(*args) ⇒ Object

KontoCheck::bank_suche_plz( plz1 [,plz2 [,sort_uniq [,sort]]])

KontoCheckRaw::bank_suche_plz( plz1 [,plz2 [,sort_uniq [,sort]]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, deren PLZ gleich <plz1> ist oder (bei Angabe von plz2) die im Bereich zwischen <plz1> und <plz2> liegen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1186
1187
1188
 
# File 'lib/konto_check.rb', line 1186

def bank_suche_plz(*args)
  KontoCheckRaw::bank_suche_plz(*args)[1]
end

.bank_suche_pz(*args) ⇒ Object

KontoCheck::bank_suche_pz( pz1 [,pz2 [,sort_uniq [,sort]]])

KontoCheckRaw::bank_suche_pz( pz1 [,pz2 [,sort_uniq [,sort]]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Prüfziffer gleich <pz1> ist oder (bei Angabe von pz2) die im Bereich zwischen <pz1> und <pz2> liegen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1199
1200
1201
 
# File 'lib/konto_check.rb', line 1199

def bank_suche_pz(*args)
  KontoCheckRaw::bank_suche_pl(*args)[1]
end

.bank_suche_regel(*args) ⇒ Object

KontoCheck::bank_suche_regel( regel1 [,regel2 [,sort_uniq [,sort]]])

KontoCheckRaw::bank_suche_regel( regel1 [,regel2 [,sort_uniq [,sort]]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, deren IBAN-Regel gleich <regel1> ist oder (bei Angabe von regel2) die im Bereich zwischen <regel1> und <regel2> liegen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1212
1213
1214
 
# File 'lib/konto_check.rb', line 1212

def bank_suche_regel(*args)
  KontoCheckRaw::bank_suche_regel(*args)[1]
end

.bank_suche_volltext(*args) ⇒ Object

KontoCheck::bank_suche_volltext( suchwort [,sort_uniq [,sort]])

KontoCheckRaw::bank_suche_volltext( suchwort [,sort_uniq [,sort]])
KontoCheck::suche()

Diese Funktion sucht alle Banken, bei denen in Name, Kurzname oder Ort das angegebenen Wort <suchwort> vorkommt. Dabei wird immer nur ein einziges Wort gesucht; mehrere Worte führen zu einer Fehlermeldung in der KontoCheckRaw- Bibliothek. Eine solche Suche läßt sich durch die Funktion KontoCheck::bank_suche_multiple( ) bewerkstelligen. Die Rückgabe ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen.



1228
1229
1230
 
# File 'lib/konto_check.rb', line 1228

def bank_suche_volltext(*args)
  KontoCheckRaw::bank_suche_volltext(*args)[1]
end

.bank_valid(*args) ⇒ Object

KontoCheck::bank_valid( blz [,filiale])

KontoCheckRaw::bank_valid( blz [,filiale])
KontoCheck::bank_valid?( blz [,filiale])

Diese Funktion testet, ob eine gegebene BLZ gültig ist. Der Rückgabewert ist ein Statuscode mit den unten angegebenen Werten. Falls das Argument filiale auch angegeben ist, wird zusätzlich noch getestet, ob eine Filiale mit dem gegebenen Index existiert.

Mögliche Rückgabewerte sind:

-55  (LUT2_INDEX_OUT_OF_RANGE)    "Der Index für die Filiale ist ungültig"
-53  (LUT2_BLZ_NOT_INITIALIZED)   "Das Feld BLZ wurde nicht initialisiert"
 -5  (INVALID_BLZ_LENGTH)         "die Bankleitzahl ist nicht achtstellig"
 -4  (INVALID_BLZ)                "die Bankleitzahl ist ungültig"
  1  (OK)                         "ok"



730
731
732
 
# File 'lib/konto_check.rb', line 730

def bank_valid(*args)
  KontoCheckRaw::bank_valid(*args)
end

.bank_valid?(*args) ⇒ Boolean

KontoCheck::bank_valid?( blz [,filiale])

KontoCheckRaw::bank_valid( blz [,filiale])
KontoCheck::bank_valid( blz [,filiale])

Dies ist eine convenience function zu KontoCheck::bank_valid(). Es wird getestet, ob die gegebene BLZ (und evl. noch der Filialindex) gültig ist. Der Rückgabewert ist nur true oder false.

Returns:

  • (Boolean) 


741
742
743
 
# File 'lib/konto_check.rb', line 741

def bank_valid?(*args)
  KontoCheckRaw::bank_valid(*args)>0?true:false
end

.bic_check(*args) ⇒ Object

KontoCheck::bic_check( bic)

KontoCheckRaw::bic_check( bic)

Diese Funktion testet die Existenz eines (deutschen) BIC. Die Rückgabe ist ein skalarer Wert, der das Testergebnis für den BIC angibt. Der BIC muß mit genau 8 oder 11 Stellen angegeben werden. Intern wird dabei die Funktion lut_suche_bic() verwendet.

Die Funktion arbeitet nur für deutsche Banken, da für andere keine Infos vorliegen.

Mögliche Rückgabewerte sind:

-146  (INVALID_PARAMETER_TYPE)     "Falscher Parametertyp für die Funktion"
-145  (BIC_ONLY_GERMAN)            "Es werden nur deutsche BICs unterstützt"
-144  (INVALID_BIC_LENGTH)         "Die Länge des BIC muß genau 8 oder 11 Zeichen sein"
   0  (FALSE)                      "falsch"
   1  (OK)                         "ok"



947
948
949
 
# File 'lib/konto_check.rb', line 947

def bic_check(*args)
  KontoCheckRaw::bic_check(*args).first
end

.ci_check(*args) ⇒ Object

KontoCheck::ci_check( ci)

KontoCheckRaw::ci_check( ci)

Diese Funktion testet eine Gläubiger-Identifikationsnummer (Credit Identifier, ci)

Mögliche Rückgabewerte sind:

-146  (INVALID_PARAMETER_TYPE)     "Falscher Parametertyp für die Funktion"
   0  (FALSE)                      "falsch"
   1  (OK)                         "ok"



924
925
926
 
# File 'lib/konto_check.rb', line 924

def ci_check(*args)
  KontoCheckRaw::ci_check(*args)
end

.current_init_level ⇒ Object

KontoCheck::current_init_level()

KontoCheckRaw::current_lutfile_name()
KontoCheckRaw::current_lutfile_name()
KontoCheck::current_lutfile_set()

Diese Funktion bestimmt den aktuell benutzten Initialisierungslevel



515
516
517
518
 
# File 'lib/konto_check.rb', line 515

def current_init_level()
  raw_results = KontoCheckRaw::current_lutfile_name()
  raw_results[2]
end

.current_lutfile_name ⇒ Object

KontoCheck::current_lutfile_name()

KontoCheckRaw::current_lutfile_name()
KontoCheck::current_lutfile_set()
KontoCheck::current_init_level()

Diese Funktion bestimmt den Dateinamen der zur Initialisierung benutzten LUT-Datei.



492
493
494
 
# File 'lib/konto_check.rb', line 492

def current_lutfile_name()
  KontoCheckRaw::current_lutfile_name().first
end

.current_lutfile_set ⇒ Object

KontoCheck::current_lutfile_set()

KontoCheckRaw::current_lutfile_name()
KontoCheck::current_lutfile_name()
KontoCheck::current_init_level()

Diese Funktion bestimmt das Set der LUT-Datei, das bei der Initialisierung benutzt wurde.



503
504
505
506
 
# File 'lib/konto_check.rb', line 503

def current_lutfile_set()
  raw_results = KontoCheckRaw::current_lutfile_name()
  raw_results[1]
end

.dump_lutfile(filename) ⇒ Object

KontoCheck::dump_lutfile( lutfile)

KontoCheckRaw::dump_lutfile( lutfile)

Diese Funktion liefert detaillierte Informationen über alle Blocks, die in der LUT-Datei gespeichert sind, sowie noch einige Internas der LUT-Datei. Im Fehlerfall wird nil zurückgegeben.



132
133
134
 
# File 'lib/konto_check.rb', line 132

def dump_lutfile(filename)
  KontoCheckRaw::dump_lutfile(filename).first
end

.encoding(*args) ⇒ Object

KontoCheck::encoding( [mode])

KontoCheckRaw::encoding( [mode])
KontoCheck::encoding_str( [mode])
KontoCheckRaw::keep_raw_data( mode)

Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die Funktion KontoCheck::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 Funktion hängt von dem Flag keep_raw_data 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 KontoCheckRaw::keep_raw_data() kann das Flag gesetzt oder gelöscht werden.

Für den Parameter mode werden die folgenden Werte akzeptiert (die Strings sind nicht case sensitiv; Mi oder mI oder MI ist z.B. auch möglich; wird der Parameter nicht angegeben, wird die aktuelle Kodierung ausgegeben):

0:            aktuelle Kodierung ausgeben
1,  'i', 'I': ISO-8859-1
2,  'u', 'U': UTF-8
3,  'h', 'H': HTML
4,  'd', 'D': DOS CP 850
51, 'mi':     ISO-8859-1, Makro für Fehlermeldungen
52, 'mu':     UTF-8, Makro für Fehlermeldungen
53, 'mh':     HTML, Makro für Fehlermeldungen
54, 'md':     DOS CP 850, Makro für Fehlermeldungen

Rückgabewert ist die aktuelle Kodierung als Integer (falls zwei Kodierungen angegeben sind, ist die erste die der Statusmeldungen, die zweite die der LUT-Blocks):

0:  "noch nicht spezifiziert" (vor der Initialisierung)
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";



195
196
197
 
# File 'lib/konto_check.rb', line 195

def encoding(*args)
  KontoCheckRaw::encoding(*args)
end

.encoding_str(*args) ⇒ Object

KontoCheck::encoding_str( [mode])

KontoCheckRaw::encoding_str( [mode])
KontoCheck::encoding( [mode])
KontoCheckRaw::keep_raw_data( mode)

Diese Funktion entspricht der Funktion KontoCheck::encoding(). Allerdings ist der Rückgabewert nicht numerisch, sondern ein String, der die aktuelle Kodierung angibt. Die folgenden Rückgabewerte sind möglich (falls zwei Kodierungen angegeben sind, ist die erste die der Statusmeldungen, die zweite die der LUT-Blocks):

"noch nicht spezifiziert" (vor der Initialisierung)
"ISO-8859-1";
"UTF-8";
"HTML entities";
"DOS CP 850";
"ISO-8859-1/UTF-8";
"ISO-8859-1/HTML";
"ISO-8859-1/DOS CP 850";
"UTF-8/ISO-8859-1";
"UTF-8/HTML";
"UTF-8/DOS CP-850";
"HTML entities/ISO-8859-1";
"HTML entities/UTF-8";
"HTML entities/DOS CP-850";
"DOS CP-850/ISO-8859-1";
"DOS CP-850/UTF-8";
"DOS CP-850/HTML";
"Makro/ISO-8859-1";
"Makro/UTF-8";
"Makro/HTML";
"Makro/DOS CP 850";



232
233
234
 
# File 'lib/konto_check.rb', line 232

def encoding_str(*args)
  KontoCheckRaw::encoding_str(*args)
end

.free ⇒ Object

KontoCheck::free()

KontoCheckRaw::free()

Diese Funktion gibt allen allokierten Speicher wieder frei.



524
525
526
 
# File 'lib/konto_check.rb', line 524

def free()
  KontoCheckRaw::free()
end

.generate_lutfile(*args) ⇒ Object

KontoCheck::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])

KontoCheckRaw::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]])

Diese Funktion generiert eine neue LUT-Datei aus der BLZ-Datei der Deutschen Bundesbank. Die folgenden Parameter werden unterstützt:

  • inputfile: Eingabedatei (Textdatei) der Bundesbank

  • outputfile: Name der Ausgabedatei

  • user_info: Info-String der in die LUT-Datei geschrieben wird (frei wählbar; wird in den Info-Block aufgenommen)

  • gueltigkeit: Gültigkeit des Datensatzes im Format JJJJMMTT-JJJJMMTT. Diese Angabe wird benutzt, um festzustellen, ob ein Datensatz aktuell noch gültig ist.

  • felder: (0-9) Welche Daten aufgenommmen werden sollen (PZ steht in der folgenden Tabelle für Prüfziffer, NAME_NAME_KURZ ist ein Block, der sowohl den Namen als auch den Kurznamen der Bank enthält; dieser läßt sich besser komprimieren als wenn beide Blocks getrennt sind):

    1. BLZ,PZ

    2. BLZ,PZ,NAME_KURZ

    3. BLZ,PZ,NAME_KURZ,BIC

    4. BLZ,PZ,NAME,PLZ,ORT

    5. BLZ,PZ,NAME,PLZ,ORT,BIC

    6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC

    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ

    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG

    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG

    10. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR

  • filialen: (0 oder 1) Flag, ob nur die Daten der Hauptstellen (0) oder auch die der Filialen aufgenommen werden sollen

  • set (0, 1 oder 2): Datensatz-Nummer. Jede LUT-Datei kann zwei Datensätze enthalten. Falls bei der Initialisierung nicht ein bestimmter Datensatz ausgewählt wird, wird derjenige genommen, der (laut Gültigkeitsstring) aktuell gültig ist. Bei 0 wird eine neue LUT-Datei generiert, bei 1 oder 2 wird der entsprechende Datensatz angehängt.

  • iban_blacklist: Datei der Banken, die einer Selbstberechnung des IBAN nicht zugestimmt haben, bzw. von der IBAN-Berechnung ausgeschlossen werden sollen

Mögliche Rückgabewerte:

-112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
 -57  (LUT2_GUELTIGKEIT_SWAPPED)   "Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht"
 -56  (LUT2_INVALID_GUELTIGKEIT)   "Das angegebene Gültigkeitsdatum ist ungültig (Soll: JJJJMMTT-JJJJMMTT)"
 -32  (LUT2_COMPRESS_ERROR)        "Fehler beim Komprimieren eines LUT-Blocks"
 -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
 -30  (LUT2_NO_SLOT_FREE)          "Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei"
 -15  (INVALID_BLZ_FILE)           "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
 -11  (FILE_WRITE_ERROR)           "kann Datei nicht schreiben"
 -10  (FILE_READ_ERROR)            "kann Datei nicht lesen"
  -9  (ERROR_MALLOC)               "kann keinen Speicher allokieren"
  -7  (INVALID_LUT_FILE)           "die blz.lut Datei ist inkosistent/ungültig"
   1  (OK)                         "ok"
   7  (LUT1_FILE_GENERATED)        "ok; es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert"



352
353
354
 
# File 'lib/konto_check.rb', line 352

def generate_lutfile(*args)
  KontoCheckRaw::generate_lutfile(*args)
end

.iban2bic(*args) ⇒ Object

KontoCheck::iban2bic( iban)

KontoCheckRaw::iban2bic(iban)

Diese Funktion bestimmt zu einer (deutschen!) IBAN den zugehörigen BIC (Bank Identifier Code). Der BIC wird für eine EU-Standard-Überweisung im SEPA-Verfahren (Single Euro Payments Area) benötigt; für die deutschen Banken ist er in der BLZ-Datei enthalten. Nähere Infos gibt es z.B. unter www.bic-code.de/ .



909
910
911
 
# File 'lib/konto_check.rb', line 909

def iban2bic(*args)
  KontoCheckRaw::iban2bic(*args).first
end

.iban_check(*args) ⇒ Object

KontoCheck::iban_check( iban)

KontoCheckRaw::iban_check( iban)

Diese Funktion testet einen IBAN. Dabei wird sowohl die Prüfziffer des IBAN getestet als auch (bei deutschen Konten) die Prüfziffer der Bankverbindung (aus der Kontonummer). Diese Funktion gibt nur den globalen Status zurück; bei der Funktion KontoCheckRaw::iban_check() kann man zusätzlich noch den Status der Kontenprüfung abfragen.

Mögliche Rückgabewerte sind:

-67  (IBAN_OK_KTO_NOT)            "Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht"
-66  (KTO_OK_IBAN_NOT)            "Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht"
  0  (FALSE)                      "falsch"
  1  (OK)                         "ok"



967
968
969
 
# File 'lib/konto_check.rb', line 967

def iban_check(*args)
  KontoCheckRaw::iban_check(*args).first
end

.iban_gen(*args) ⇒ Object

KontoCheck::iban_gen( kto,blz)

KontoCheckRaw::iban_gen( kto,blz)

Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN.

Nachdem im Mai 2013 die IBAN-Regeln zur Berechnung von IBAN und BIC aus Kontonummer und BLZ veröffentlicht wurden, gibt es endlich ein verbindliches Verfahren zur Bestimmung der IBAN. Die definierten IBAN-Regeln wurden in der C-Datei eingearbeitet und werden automatisch ausgewertet, falls der Block mit den IBAN-Regeln in der LUT-Datei enthalten ist. Andere LUT-Dateien sollten für die IBAN-Berechnung möglichst nicht verwendet werden, da die Anzahl der BLZs mit Sonderregelungen doch sehr groß ist.

Es ist möglich, sowohl die Prüfung auf Stimmigkeit der Kontonummer als auch die “schwarze Liste” (ausgeschlossene BLZs) zu deaktivieren. Falls die IBAN ohne Test der Blacklist berechnet werden soll, ist vor die BLZ ein @ zu setzen; falls auch bei falscher Bankverbindung ein IBAN berechnet werden soll, ist vor die BLZ ein + zu setzen. Um beide Prüfungen zu deaktiviern, kann @+ (oder +@) vor die BLZ gesetzt werden. Die so erhaltenen IBANs sind dann u.U. allerdings wohl nicht gültig.

Rückgabewert ist der generierte IBAN oder nil, falls ein Fehler aufgetreten ist. Die genauere Fehlerursache läßt sich mit der Funktion KontoCheckRaw::iban_gen() feststellen.

Bei vielen Banken wird die BLZ und damit der BIC ebenfalls ersetzt. Der gültige BIC sowie viele andere Werte interessante Werte lassen sich durch die Funktion KontoCheckRaw::iban_gen() ermitteln.



999
1000
1001
 
# File 'lib/konto_check.rb', line 999

def iban_gen(*args)
  KontoCheckRaw::iban_gen(*args).first
end

.init(*args) ⇒ Object

KontoCheck::init( [p1 [,p2 [,set]]])

KontoCheckRaw::init( [p1 [,p2 [,set]]])

Die Variablen p1 und p2 stehen für level und lutfile (in beliebiger Reihenfolge); die Zuordnung der beiden Parameter erfolgt on the fly durch eine Typüberprüfung.

Diese Funktion initialisiert die Bibliothek und lädt die gewünschten Datenblocks in den Speicher. Alle Argumente sind optional; in konto_check.h werden die Defaultwerte definiert.

Die beiden ersten Parameter sind der Dateiname und der Initialisierungslevel. Der Dateiname ist immer als String anzugeben, der Initialisierungslevel immer als Zahl, ansonsten wird eine TypeError Exception geworfen. Auf diese Weise ist es problemlos möglich festzustellen, wie die Parameter p1 und p2 den Variablen lutfile und level zuzuordnen sind.

Für die LUT-Datei ist als Defaultwert sowohl für den Pfad als auch den Dateinamen eine Liste möglich, die sequenziell abgearbeitet wird; diese wird in konto_check.h spezifiziert (Compilerzeit-Konstante der C-Bibliothek). Die folgenden Werte sind in der aktuellen konto_check.h definiert:

DEFAULT_LUT_NAME blz.lut, blz.lut2f, blz.lut2
DEFAULT_LUT_PATH ., /usr/local/etc/, /etc/, /usr/local/bin/, /opt/konto_check/ (für nicht-Windows-Systeme)
DEFAULT_LUT_PATH ., C:\\, C:\\Programme\\konto_check  (für Windows-Systeme)

Der Defaultwert für level ist ebenfalls in konto_check.h definiert; in der aktuellen Version ist er 5. Bei diesem Level werden die Blocks BLZ, Prüfziffer, Name, Kurzname, PLZ, Ort und BIC geladen.

Falls der Parameter set nicht angegeben ist, wird versucht, das aktuell gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der LUT-Datei gespeicherten Sets zu bestimmen.

Hier noch einmal ein Überblick über die Parameter:

  • lutfile: die LUT-Datei, mit der initialisiert werden soll

  • level: (0-9) Welche Daten geladen werden sollen (PZ steht in der folgenden Tabelle für Prüfziffer, NAME_NAME_KURZ ist ein Block, der sowohl den Namen als auch den Kurznamen der Bank enthält; dieser läßt sich besser komprimieren als wenn beide Blocks getrennt sind):

    1. BLZ,PZ

    2. BLZ,PZ,NAME_KURZ

    3. BLZ,PZ,NAME_KURZ,BIC

    4. BLZ,PZ,NAME,PLZ,ORT

    5. BLZ,PZ,NAME,PLZ,ORT,BIC

    6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC

    7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ

    8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG

    9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG

    10. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,LOESCHUNG,PAN,NR

  • set (1 oder 2): Datensatz

Mögliche Rückgabewerte:

-112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
 -64  (INIT_FATAL_ERROR)        "Initialisierung fehlgeschlagen (init_wait geblockt)"
 -63  (INCREMENTAL_INIT_NEEDS_INFO)            "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
 -62  (INCREMENTAL_INIT_FROM_DIFFERENT_FILE)   "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
 -38  (LUT2_PARTIAL_OK)         "es wurden nicht alle Blocks geladen"
 -36  (LUT2_Z_MEM_ERROR)        "Memory error in den ZLIB-Routinen"
 -35  (LUT2_Z_DATA_ERROR)       "Datenfehler im komprimierten LUT-Block"
 -34  (LUT2_BLOCK_NOT_IN_FILE)  "Der Block ist nicht in der LUT-Datei enthalten"
 -33  (LUT2_DECOMPRESS_ERROR)   "Fehler beim Dekomprimieren eines LUT-Blocks"
 -31  (LUT2_FILE_CORRUPTED)     "Die LUT-Datei ist korrumpiert"
 -20  (LUT_CRC_ERROR)           "Prüfsummenfehler in der blz.lut Datei"
 -10  (FILE_READ_ERROR)         "kann Datei nicht lesen"
  -9  (ERROR_MALLOC)            "kann keinen Speicher allokieren"
  -7  (INVALID_LUT_FILE)        "die blz.lut Datei ist inkosistent/ungültig"
  -6  (NO_LUT_FILE)             "die blz.lut Datei wurde nicht gefunden"

   1  (OK)                      "ok"
   6  (LUT1_SET_LOADED)         "Die Datei ist im alten LUT-Format (1.0/1.1)"

Anmerkung: Falls der Statuscode LUT2_PARTIAL_OK ist, waren bei der Initialisierung nicht alle Blocks in der LUT-Datei enthalten.



430
431
432
 
# File 'lib/konto_check.rb', line 430

def init(*args)
  KontoCheckRaw::init(*args)
end

.ipi_check(zweck) ⇒ Object

KontoCheck::ipi_check( zweck)

KontoCheckRaw::ipi_check( zweck)

Die Funktion testet, ob ein Strukturierter Verwendungszweck gültig ist (Anzahl Zeichen, Prüfziffer). Der Rückgabewert ist true oder false.



1024
1025
1026
 
# File 'lib/konto_check.rb', line 1024

def ipi_check(zweck)
  KontoCheckRaw::ipi_check(zweck)>0?true:false
end

.ipi_gen(zweck) ⇒ Object

KontoCheck::ipi_gen( zweck)

KontoCheckRaw::ipi_gen( zweck)

Diese Funktion generiert einen “Strukturierten Verwendungszweck” für SEPA-Überweisungen. Der Rückgabewert ist der Strukturierte Verwendungszweck als String oder nil, falls ein Fehler aufgetreten ist.

Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang sein und nur alphanumerische Zeichen enthalten (also auch keine Umlaute). Die Funktion KontoCheckRaw::ipi_gen() gibt einen Statuscode zurück, der etwas nähere Infos im Fehlerfall enthält.



1014
1015
1016
 
# File 'lib/konto_check.rb', line 1014

def ipi_gen(zweck)
  KontoCheckRaw::ipi_gen(zweck).first
end

.konto_check(blz, kto) ⇒ Object

KontoCheck::konto_check( blz,kto)

KontoCheckRaw::konto_check( blz,kto)
KontoCheck::valid( blz,kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der Prüfung enthält. Mögliche Rückgabewerte sind:

-69  MISSING_PARAMETER       "Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
-40  LUT2_NOT_INITIALIZED    "die Programmbibliothek wurde noch nicht initialisiert"

-77  BAV_FALSE               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
-29  UNDEFINED_SUBMETHOD     "Die (Unter)Methode ist nicht definiert"
-12  INVALID_KTO_LENGTH      "ein Konto muß zwischen 1 und 10 Stellen haben"
 -5  INVALID_BLZ_LENGTH      "die Bankleitzahl ist nicht achtstellig"
 -4  INVALID_BLZ             "die Bankleitzahl ist ungültig"
 -3  INVALID_KTO             "das Konto ist ungültig"
 -2  NOT_IMPLEMENTED         "die Methode wurde noch nicht implementiert"
 -1  NOT_DEFINED             "die Methode ist nicht definiert"
  0  FALSE                   "falsch"
  1  OK                      "ok"
  2  OK_NO_CHK               "ok, ohne Prüfung"



549
550
551
 
# File 'lib/konto_check.rb', line 549

def konto_check(blz,kto)
  KontoCheckRaw::konto_check(blz,kto)
end

.konto_check?(blz, kto) ⇒ Boolean

KontoCheck::konto_check?( blz, kto)

KontoCheck::konto_check( blz,kto)
KontoCheckRaw::konto_check( blz,kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der Prüfung enthält. Mögliche Rückgabewerte sind einfach true und false (convenience function für konto_check()).

Returns:

  • (Boolean) 


570
571
572
 
# File 'lib/konto_check.rb', line 570

def konto_check?(blz,kto)
  KontoCheckRaw::konto_check(blz,kto)>0?true:false
end

.konto_check_pz(*args) ⇒ Object

KontoCheck::konto_check_pz (pz,kto [,blz])

KontoCheckRaw::konto_check_pz (pz,kto [,blz])
KontoCheck::valid_pz (pz,kto [,blz])

Diese Funktion testet, ob eine gegebene Prüfziffer/Kontonummer-Kombination gültig ist.

Der zusätzliche Parameter blz ist nur für die Verfahren 52, 53, B6 und C0 notwendig; bei diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein. Bei allen anderen Prüfzifferverfahren wird er ignoriert. Wird er bei einem dieser Verfahren nicht angegeben, wird stattdessen eine Test-BLZ eingesetzt.

Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der Prüfung enthält. Mögliche Rückgabewerte sind:

-69  (MISSING_PARAMETER)       "bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)"
-40  (LUT2_NOT_INITIALIZED)    "die Programmbibliothek wurde noch nicht initialisiert"

-77  (BAV_FALSE)               "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
-29  (UNDEFINED_SUBMETHOD)     "die (Unter)Methode ist nicht definiert"
-12  (INVALID_KTO_LENGTH)      "ein Konto muß zwischen 1 und 10 Stellen haben"
 -3  (INVALID_KTO)             "das Konto ist ungültig"
 -2  (NOT_IMPLEMENTED)         "die Methode wurde noch nicht implementiert"
 -1  (NOT_DEFINED)             "die Methode ist nicht definiert"
  0  (FALSE)                   "falsch"
  1  (OK)                      "ok"
  2  (OK_NO_CHK)               "ok, ohne Prüfung"



609
610
611
 
# File 'lib/konto_check.rb', line 609

def konto_check_pz(*args)
  KontoCheckRaw::konto_check_pz(*args)
end

.konto_check_pz?(*args) ⇒ Boolean

KontoCheck::konto_check_pz?( pz,kto [,blz])

KontoCheckRaw::konto_check_pz (pz,kto [,blz])
KontoCheck::valid_pz?( pz,kto [,blz])

Diese Funktion testet, ob eine gegebene Prüfziffer/Kontonummer-Kombination gültig ist. Der Rückgabewert dieser Funktion ist true oder false (convenience function für KontoCheck::konto_check_pz()).

Der zusätzliche Parameter blz ist nur für die Verfahren 52, 53, B6 und C0 notwendig; bei diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein. Bei allen anderen Prüfzifferverfahren wird er ignoriert. Wird er bei einem dieser Verfahren nicht angegeben, wird stattdessen eine Test-BLZ eingesetzt.

Returns:

  • (Boolean) 


625
626
627
 
# File 'lib/konto_check.rb', line 625

def konto_check_pz?(*args)
  KontoCheckRaw::konto_check_pz(*args)>0?true:false
end

.konto_check_regel(blz, kto) ⇒ Object

KontoCheck::konto_check_regel( blz,kto)

KontoCheck::konto_check_regel?( blz,kto)
KontoCheckRaw::konto_check_regel( blz,kto)
KontoCheckRaw::konto_check_regel_dbg( blz,kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Die Funktion gibt einen skalaren Statuswert zurück, der das Ergebnis der Prüfung enthält. Vor dem Test werden die IBAN-Regeln angewendet, dadurch werden u.U. Konto und BLZ ersetzt. Falls nicht alle für IBAN-Berechnung notwendigen Blocks geladen sind, werden diese automatisch noch nachgeladen. Dadurch tauchen hier auch die Rückgabewerte für die Initialisierung auf. Mögliche Rückgabewerte sind:

-135  FALSE_UNTERKONTO_ATTACHED "falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)"
-133  BLZ_MARKED_AS_DELETED     "Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig"
-128  IBAN_INVALID_RULE         "Die BLZ passt nicht zur angegebenen IBAN-Regel"
-127  IBAN_AMBIGUOUS_KTO        "Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)"
-125  IBAN_RULE_UNKNOWN         "Die IBAN-Regel ist nicht bekannt"
-124  NO_IBAN_CALCULATION       "Für die Bankverbindung ist keine IBAN-Berechnung erlaubt"
-112  KTO_CHECK_UNSUPPORTED_COMPRESSION "die notwendige Kompressions-Bibliothek wurden beim Kompilieren nicht eingebunden"
 -77  BAV_FALSE                 "BAV denkt, das Konto ist falsch (konto_check hält es für richtig)"
 -69  MISSING_PARAMETER         "Für die aufgerufene Funktion fehlt ein notwendiger Parameter"
 -64  INIT_FATAL_ERROR          "Initialisierung fehlgeschlagen (init_wait geblockt)"
 -63  INCREMENTAL_INIT_NEEDS_INFO "Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei"
 -62  INCREMENTAL_INIT_FROM_DIFFERENT_FILE "Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich"
 -40  LUT2_NOT_INITIALIZED      "die Programmbibliothek wurde noch nicht initialisiert"
 -38  LUT2_PARTIAL_OK           "es wurden nicht alle Blocks geladen"
 -36  LUT2_Z_MEM_ERROR          "Memory error in den ZLIB-Routinen"
 -35  LUT2_Z_DATA_ERROR         "Datenfehler im komprimierten LUT-Block"
 -34  LUT2_BLOCK_NOT_IN_FILE    "Der Block ist nicht in der LUT-Datei enthalten"
 -33  LUT2_DECOMPRESS_ERROR     "Fehler beim Dekomprimieren eines LUT-Blocks"
 -31  LUT2_FILE_CORRUPTED       "Die LUT-Datei ist korrumpiert"
 -29  UNDEFINED_SUBMETHOD       "Die (Unter)Methode ist nicht definiert"
 -20  LUT_CRC_ERROR             "Prüfsummenfehler in der blz.lut Datei"
 -12  INVALID_KTO_LENGTH        "ein Konto muß zwischen 1 und 10 Stellen haben"
 -10  FILE_READ_ERROR           "kann Datei nicht lesen"
  -9  ERROR_MALLOC              "kann keinen Speicher allokieren"
  -7  INVALID_LUT_FILE          "die blz.lut Datei ist inkosistent/ungültig"
  -6  NO_LUT_FILE               "die blz.lut Datei wurde nicht gefunden"
  -5  INVALID_BLZ_LENGTH        "die Bankleitzahl ist nicht achtstellig"
  -4  INVALID_BLZ               "die Bankleitzahl ist ungültig"
  -3  INVALID_KTO               "das Konto ist ungültig"
  -2  NOT_IMPLEMENTED           "die Methode wurde noch nicht implementiert"
  -1  NOT_DEFINED               "die Methode ist nicht definiert"
   0  FALSE                     "falsch"
   1  OK                        "ok"
   1  OK                        "ok"
   2  OK_NO_CHK                 "ok, ohne Prüfung"
   6  LUT1_SET_LOADED           "Die Datei ist im alten LUT-Format (1.0/1.1)"
  18  OK_KTO_REPLACED           "ok, die Kontonummer wurde allerdings ersetzt"
  21  OK_IBAN_WITHOUT_KC_TEST   "ok, die Bankverbindung ist (ohne Test) als richtig anzusehen"
  25  OK_UNTERKONTO_ATTACHED    "ok, es wurde ein (weggelassenes) Unterkonto angefügt"



698
699
700
 
# File 'lib/konto_check.rb', line 698

def konto_check_regel(blz,kto)
  KontoCheckRaw::konto_check_regel(blz,kto)
end

.konto_check_regel?(*args) ⇒ Boolean

KontoCheck::konto_check_regel?( blz,kto)

KontoCheck::konto_check_regel( blz,kto)
KontoCheckRaw::konto_check_regel( blz,kto)
KontoCheckRaw::konto_check_regel_dbg( blz,kto)

Diese Funktion testet, ob eine gegebene Prüfziffer/Kontonummer-Kombination gültig ist (mit IBAN-Regeln). Der Rückgabewert dieser Funktion ist nur true oder false (convenience function für KontoCheck::konto_check_regel()).

Returns:

  • (Boolean) 


710
711
712
 
# File 'lib/konto_check.rb', line 710

def konto_check_regel?(*args)
  KontoCheckRaw::konto_check_regel(*args)>0?true:false
end

.load_bank_data(*args) ⇒ Object

KontoCheck::load_bank_data( datafile)

KontoCheckRaw::load_bank_data( datafile)

Diese Funktion war die alte Initialisierungsroutine für konto_check; es ist nun durch die Funktionen KontoCheck::init() und KontoCheck::generate_lutfile() ersetzt. Zur Initialisierung benutzte sie die Textdatei der Deutschen Bundesbank und generiertge daraus eine LUT-Datei, die dann von der Initialisierungsroutine der C-Bibliothek benutzt wurde.

Die init() Funktion ist wesentlich schneller (7..20 mal so schnell) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwwei Datensätze mit unterschiedlichem Gültigkeitszeitraum in einer Datei zu halten und den jeweils gültigen Satz automatisch (nach der Systemzeit) auswählen zu lassen. Die einzelnen Datenblocks (Bankleitzahlen, Prüfziffermethoden, PLZ, Ort…) sind in der LUT-Datei in jeweils unabhängigen Blocks gespeichert und können einzeln geladen werden; die Bankdatei von der Deutschen Bundesbank enthält alle Felder in einem linearen Format, so daß einzelne Blocks nicht unabhängig von anderen geladen werden können.

Die Funktion load_bank_data() wird nur noch als ein schibbolet benutzt, um zu testen, ob jemand das alte Interface benutzt. Bei der Routine KontoCheck::konto_check() wurde die Reihenfolge der Parameter getauscht, so daß man in dem Falle den alten Code umstellen muß.



481
482
483
 
# File 'lib/konto_check.rb', line 481

def load_bank_data(*args)
   KontoCheckRaw::load_bank_data(*args)
end

.lut_blocks ⇒ Object

KontoCheck::lut_blocks( )

KontoCheckRaw::lut_blocks1( )
KontoCheckRaw::lut_blocks( mode)

Die Funktion gibt Auskunft, ob bei der Initialisierung alle angeforderten Blocks der LUT-Datei geladen wurden. Die korrespondierende Funktion KontoCheckRaw::lut_blocks( mode) gibt noch einige weitere Infos über die geladenen Blocks aus.

Aufruf:

ret=KontoCheck::lut_blocks( )

Rückgabe:

Rückgabe ist ein skalarer Wert, der Information über den Initialisierungsprozess gibt:

  • -136 LUT2_BLOCKS_MISSING “ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden”

  • -40 LUT2_NOT_INITIALIZED “die Programmbibliothek wurde noch nicht initialisiert”

  • -9 ERROR_MALLOC “kann keinen Speicher allokieren”

  • 1 OK “ok”



453
454
455
 
# File 'lib/konto_check.rb', line 453

def lut_blocks()
  KontoCheckRaw::lut_blocks1()
end

.lut_info ⇒ Object

KontoCheck::lut_info()

KontoCheckRaw::lut_info( [lutfile])
KontoCheck::lut_info1( lutfile)
KontoCheck::lut_info2( lutfile)

Diese Funktion liefert den Infoblock des Datensatzes zurück, der mittels init() in den Speichergeladen wurde. Weitere Infos über die LUT-Datei lassen sich mit der Funktion KontoCheckRaw::lut_info() sowie KontoCheck::dump_lutfile() erhalten.



94
95
96
 
# File 'lib/konto_check.rb', line 94

def lut_info()
  KontoCheckRaw::lut_info()[3]
end

.lut_info1(filename) ⇒ Object

KontoCheck::lut_info1( lutfile)

KontoCheck::lut_info()
KontoCheck::lut_info2()
KontoCheckRaw::lut_info()

Diese Funktion liefert den Infoblock des ersten Datensatzes der angegebenen LUT-Datei zurück. Weitere Infos über die LUT-Datei lassen sich mit der Funktion KontoCheckRaw::lut_info() sowie KontoCheck::dump_lutfile() erhalten.



107
108
109
 
# File 'lib/konto_check.rb', line 107

def lut_info1(filename)
  KontoCheckRaw::lut_info(filename)[3]
end

.lut_info2(filename) ⇒ Object

KontoCheck::lut_info2( lutfile)

KontoCheck::lut_info()
KontoCheck::lut_info1( lutfile)
KontoCheckRaw::lut_info( [lutfile])

Diese Funktion liefert den Infoblock des zweiten Datensatzes der angegebenen LUT-Datei zurück. Weitere Infos über die LUT-Datei lassen sich mit der Funktion KontoCheckRaw::lut_info() sowie KontoCheck::dump_lutfile() erhalten.



120
121
122
 
# File 'lib/konto_check.rb', line 120

def lut_info2(filename)
  KontoCheckRaw::lut_info(filename)[4]
end

.retval2dos(retval) ⇒ Object

KontoCheck::retval2dos( retval)

KontoCheckRaw::retval2dos( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Der benutzte Zeichensatz ist cp850 (DOS).



288
289
290
 
# File 'lib/konto_check.rb', line 288

def retval2dos(retval)
  KontoCheckRaw::retval2dos(retval)
end

.retval2html(retval) ⇒ Object

KontoCheck::retval2html( retval)

KontoCheckRaw::retval2html( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Für Umlaute werden HTML-Entities benutzt.



298
299
300
 
# File 'lib/konto_check.rb', line 298

def retval2html(retval)
  KontoCheckRaw::retval2html(retval)
end

.retval2iso(retval) ⇒ Object

KontoCheck::retval2iso( retval)

KontoCheckRaw::retval2iso( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Der benutzte Zeichensatz ist ISO 8859-1.



254
255
256
 
# File 'lib/konto_check.rb', line 254

def retval2iso(retval)
  KontoCheckRaw::retval2iso(retval)
end

.retval2txt(retval) ⇒ Object

KontoCheck::retval2txt( retval)

KontoCheckRaw::retval2txt( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Der benutzte Zeichensatz wird über die Funktion KontoCheck::encoding() festgelegt. Falls diese Funktion nicht aufgerufen wurde, wird der Wert des Makros DEFAULT_ENCODING aus konto_check.h benutzt.



244
245
246
 
# File 'lib/konto_check.rb', line 244

def retval2txt(retval)
  KontoCheckRaw::retval2txt(retval)
end

.retval2txt_short(retval) ⇒ Object Also known as: retval2txt_kurz

KontoCheck::retval2txt_short( retval)

KontoCheckRaw::retval2txt_short( retval)
KontoCheck::retval2txt_kurz( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen kurzen String. Die Ausgabe ist der Makroname, wie er in C benutzt wird.



265
266
267
 
# File 'lib/konto_check.rb', line 265

def retval2txt_short(retval)
  KontoCheckRaw::retval2txt_short(retval)
end

.retval2utf8(retval) ⇒ Object

KontoCheck::retval2utf8( retval)

KontoCheckRaw::retval2utf8( retval)

Diese Funktion konvertiert einen numerischen Rückgabewert in einen String. Der benutzte Zeichensatz ist UTF-8.



308
309
310
 
# File 'lib/konto_check.rb', line 308

def retval2utf8(retval)
  KontoCheckRaw::retval2utf8(retval)
end

.suche(options = {}) ⇒ Object Also known as: search 



1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
 
# File 'lib/konto_check.rb', line 1093

def suche(options={})
  search_cmd=value=key=""
  sort=uniq=1
  options.each{ |k,v|
     uniq=v if k.to_s=="uniq"
     sort=v if k.to_s=="sort"
     search_cmd=v if k.to_s=="such_cmd" or k.to_s=="search_cmd" or k.to_s=="cmd"
     if  SEARCH_KEYS.include?(k)
        key=k
        value=options[k]
     end
     if  SEARCH_KEY_MAPPINGS.keys.include?(k)
        key=SEARCH_KEY_MAPPINGS[k]
        value=options[k]
     end
  }
  raise 'no valid search key found' if key.length==0
  uniq=2 if uniq>0              # sortieren und uniq
  uniq=1 if sort>0 && uniq==0   # nur sortieren
  raw_results = KontoCheckRaw::send("bank_suche_#{key}",value,search_cmd,uniq)
  raw_results[1]
end

.valid(blz, kto) ⇒ Object

KontoCheck::valid( blz,kto)

KontoCheck::konto_check( blz,kto)
KontoCheckRaw::konto_check( blz,kto)

Dies ist ein Alias für die Funktion KontoCheck::konto_check()



558
559
560
 
# File 'lib/konto_check.rb', line 558

def valid(blz,kto)
  KontoCheckRaw::konto_check( blz,kto)
end

.valid?(blz, kto) ⇒ Boolean

KontoCheck::valid?( blz, kto)

KontoCheck::valid( blz, kto)
KontoCheckRaw::konto_check (blz, kto)

Dies ist einn Alias für die Funktion KontoCheck::konto_check?. Mögliche Rückgabewerte sind true oder false.

Returns:

  • (Boolean) 


579
580
581
 
# File 'lib/konto_check.rb', line 579

def valid?(blz,kto)
  KontoCheckRaw::konto_check(blz, kto)>0?true:false
end

.valid_pz(*args) ⇒ Object

KontoCheck::valid_pz( pz,kto [,blz])

KontoCheck::konto_check_pz( pz,kto [,blz])
KontoCheckRaw::konto_check_pz( pz,kto [,blz])

Diese Funktion ist ein Alias für KontoCheck::konto_check_pz



634
635
636
 
# File 'lib/konto_check.rb', line 634

def valid_pz(*args)
  KontoCheckRaw::konto_check_pz(*args)
end

.valid_pz?(*args) ⇒ Boolean

KontoCheck::valid_pz?( pz,kto [,blz])

KontoCheck::valid_pz( pz,kto [,blz])
KontoCheckRaw::konto_check_pz( pz,kto [,blz])

Diese Funktion ist ein Alias für KontoCheck::konto_check_pz?()

Returns:

  • (Boolean) 


643
644
645
 
# File 'lib/konto_check.rb', line 643

def valid_pz?(*args)
  KontoCheckRaw::konto_check_pz(*args)>0?true:false
end

.version(*args) ⇒ Object

KontoCheck::version( [mode] )

KontoCheckRaw::version( [mode] )

Diese Funktion gibt die Versions-Infos der C-Bibliothek zurück.

Mögliche Werte für mode:

  • 0 bzw. ohne Parameter: Versionsstring der C-Bibliothek

  • 1: Versionsnummer

  • 2: Versionsdatum

  • 3: Compilerdatum und -zeit

  • 4: Datum der Prüfziffermethoden

  • 5: Datum der IBAN-Regeln

  • 6: Klartext-Datum der Bibliotheksversion

  • 7: Versionstyp (devel, beta, final)



1268
1269
1270
 
# File 'lib/konto_check.rb', line 1268

def version(*args)
  KontoCheckRaw::version(*args)
end