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 2015: 00 to E2) 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).



903
904
905
 
# File 'lib/konto_check.rb', line 903

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.



976
977
978
 
# File 'lib/konto_check.rb', line 976

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.



893
894
895
 
# File 'lib/konto_check.rb', line 893

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.



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

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.



913
914
915
 
# File 'lib/konto_check.rb', line 913

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).



922
923
924
 
# File 'lib/konto_check.rb', line 922

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.



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

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.



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

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.



941
942
943
 
# File 'lib/konto_check.rb', line 941

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.



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

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.



931
932
933
 
# File 'lib/konto_check.rb', line 931

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.



872
873
874
 
# File 'lib/konto_check.rb', line 872

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.



883
884
885
 
# File 'lib/konto_check.rb', line 883

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.



1204
1205
1206
 
# File 'lib/konto_check.rb', line 1204

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.



1253
1254
1255
 
# File 'lib/konto_check.rb', line 1253

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])



1328
1329
1330
 
# File 'lib/konto_check.rb', line 1328

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.



1216
1217
1218
 
# File 'lib/konto_check.rb', line 1216

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.



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

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.



1240
1241
1242
 
# File 'lib/konto_check.rb', line 1240

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.



1266
1267
1268
 
# File 'lib/konto_check.rb', line 1266

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.



1279
1280
1281
 
# File 'lib/konto_check.rb', line 1279

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.



1292
1293
1294
 
# File 'lib/konto_check.rb', line 1292

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.



1308
1309
1310
 
# File 'lib/konto_check.rb', line 1308

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"



810
811
812
 
# File 'lib/konto_check.rb', line 810

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) 


821
822
823
 
# File 'lib/konto_check.rb', line 821

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"



1027
1028
1029
 
# File 'lib/konto_check.rb', line 1027

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"



1004
1005
1006
 
# File 'lib/konto_check.rb', line 1004

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



595
596
597
598
 
# File 'lib/konto_check.rb', line 595

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.



572
573
574
 
# File 'lib/konto_check.rb', line 572

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.



583
584
585
586
 
# File 'lib/konto_check.rb', line 583

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";



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

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

.free ⇒ Object

KontoCheck::free()

KontoCheckRaw::free()

Diese Funktion gibt allen allokierten Speicher wieder frei.



604
605
606
 
# File 'lib/konto_check.rb', line 604

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"



374
375
376
 
# File 'lib/konto_check.rb', line 374

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/ .



989
990
991
 
# File 'lib/konto_check.rb', line 989

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"



1047
1048
1049
 
# File 'lib/konto_check.rb', line 1047

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.



1079
1080
1081
 
# File 'lib/konto_check.rb', line 1079

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.



510
511
512
 
# File 'lib/konto_check.rb', line 510

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.



1104
1105
1106
 
# File 'lib/konto_check.rb', line 1104

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.



1094
1095
1096
 
# File 'lib/konto_check.rb', line 1094

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"



629
630
631
 
# File 'lib/konto_check.rb', line 629

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) 


650
651
652
 
# File 'lib/konto_check.rb', line 650

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"



689
690
691
 
# File 'lib/konto_check.rb', line 689

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) 


705
706
707
 
# File 'lib/konto_check.rb', line 705

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"



778
779
780
 
# File 'lib/konto_check.rb', line 778

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) 


790
791
792
 
# File 'lib/konto_check.rb', line 790

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ß.



561
562
563
 
# File 'lib/konto_check.rb', line 561

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”



533
534
535
 
# File 'lib/konto_check.rb', line 533

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

.pz_aenderungen_enable(*args) ⇒ Object

KontoCheck::pz_aenderungen_enable( set)

KontoCheckRaw::pz_aenderungen_enable( set)

Die Funktion pz_aenderungen_enable() dient dazu, den Status des Flags pz_aenderungen_aktivieren abzufragen bzw. zu setzen. Falls die Variable set 1 ist, werden die Änderungen aktiviert, falls sie 0 ist, werden die Änderungen deaktiviert. Beim Aufruf ohne Parameter oder mit einem anderen Wert wird das aktuelle Flag nicht verändert, sondern nur der Status zurückgegeben.

Parameter:

set: 0 oder 1: Änderungen deaktivieren/aktivieren

anderer Wert: nur Abfrage des Status

Rückgabe:

Rückgabe: aktueller Status des Flags #



217
218
219
 
# File 'lib/konto_check.rb', line 217

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

.rebuild_blzfile(*args) ⇒ Object

KontoCheck::rebuild_blzfile( inputfile,outputfile,set)

KontoCheckRaw::rebuild_blzfile( inputfile,outputfile,set)

Die Funktion rebuild_blzfile() war ursprünglich als Härtetest für die LUT2-Routinen konzipiert: mit ihr lässt sich die BLZ-Datei komplett aus einer LUT-Datei neu generieren. Die Funktion ist allerdings auch so interessant, so daß sie in alle Ports eingebunden wurde. Die generierte BLZ-Datei sollte (bis auf die Sortierung und die vier Testbanken) keinen Unterschied zur originalen BLZ-Datei aufweisen.

Falls der Parameter set 1 oder 2 ist, wird als Eingabedatei eine LUT- datei erwartet; bei einem set-Parameter von 0 eine Klartextdatei (Bundesbankdatei).

Copyright © 2014 Michael Plugge <[email protected]>

Aufruf:

retval=KontoCheck::rebuild_blzfile(inputname,outputname,set)

Parameter:

  • inputfile: Eingabedatei (LUT-Datei oder Textdatei der Deutschen Bundesbank)

  • outputfile: Name der Ausgabedatei

  • set: (0, 1 oder 2) 0: Die Eingabedatei ist eine Textdatei; es wird eine LUT-Datei generieret und diese wieder zurück umgewandlt.

    1. Das erste Set der LUT-Datei wird extrahiert

    2. Das zweite Set der LUT-Datei wird extrahiert

Rückgabe:

Rückgabe ist ein skalarer Statuscode, der die folgenden Werte annehmen kann:

Mögliche Statuscodes:

-112  (KTO_CHECK_UNSUPPORTED_COMPRESSION) "die notwendige Kompressions-Bibliothek wurde beim Kompilieren nicht eingebunden"
 -64  (INIT_FATAL_ERROR)           "Initialisierung fehlgeschlagen (init_wait geblockt)"
 -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)"
 -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"
 -32  (LUT2_COMPRESS_ERROR)        "Fehler beim Komprimieren eines LUT-Blocks"
 -31  (LUT2_FILE_CORRUPTED)        "Die LUT-Datei ist korrumpiert"
 -20  (LUT_CRC_ERROR)              "Prüfsummenfehler in der blz.lut Datei"
 -15  (INVALID_BLZ_FILE)           "Fehler in der blz.txt Datei (falsche Zeilenlänge)"
 -13  (FATAL_ERROR)                "schwerer Fehler im Konto_check-Modul"
 -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"
  -6  (NO_LUT_FILE)                "die blz.lut Datei wurde nicht gefunden"
   1  (OK)                         "ok"



432
433
434
 
# File 'lib/konto_check.rb', line 432

def rebuild_blzfile(*args)
  KontoCheckRaw::rebuild_blzfile(*args)
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).



310
311
312
 
# File 'lib/konto_check.rb', line 310

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.



320
321
322
 
# File 'lib/konto_check.rb', line 320

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.



276
277
278
 
# File 'lib/konto_check.rb', line 276

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.



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

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.



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

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.



330
331
332
 
# File 'lib/konto_check.rb', line 330

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

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



1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
 
# File 'lib/konto_check.rb', line 1173

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()



638
639
640
 
# File 'lib/konto_check.rb', line 638

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) 


659
660
661
 
# File 'lib/konto_check.rb', line 659

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



714
715
716
 
# File 'lib/konto_check.rb', line 714

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) 


723
724
725
 
# File 'lib/konto_check.rb', line 723

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)



1348
1349
1350
 
# File 'lib/konto_check.rb', line 1348

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