Module: KontoCheckRaw

Defined in:: ext/konto_check_raw/konto_check_raw_ruby.c

Constant Summary collapse

IBAN_ONLY_GERMAN = (-147) Es werden nur deutsche IBANs unterstützt

INT2FIX(IBAN_ONLY_GERMAN)

INVALID_PARAMETER_TYPE = (-146) Falscher Parametertyp für die Funktion

INT2FIX(INVALID_PARAMETER_TYPE)

BIC_ONLY_GERMAN = (-145) Es werden nur deutsche BICs unterstützt

INT2FIX(BIC_ONLY_GERMAN)

INVALID_BIC_LENGTH = (-144) Die Länge des BIC muß genau 8 oder 11 Zeichen sein

INT2FIX(INVALID_BIC_LENGTH)

IBAN_CHKSUM_OK_RULE_IGNORED_BLZ = (-143) Die IBAN-Prüfsumme stimmt, die BLZ sollte aber durch eine zentrale BLZ ersetzt werden. Die Richtigkeit der IBAN kann nur mit einer Anfrage bei der Bank ermittelt werden

INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED_BLZ)

IBAN_CHKSUM_OK_KC_NOT_INITIALIZED = (-142) Die IBAN-Prüfsumme stimmt, konto_check wurde jedoch noch nicht initialisiert (Kontoprüfung nicht möglich)

INT2FIX(IBAN_CHKSUM_OK_KC_NOT_INITIALIZED)

IBAN_CHKSUM_OK_BLZ_INVALID = (-141) Die IBAN-Prüfsumme stimmt, die BLZ ist allerdings ungültig

INT2FIX(IBAN_CHKSUM_OK_BLZ_INVALID)

IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED = (-140) Die IBAN-Prüfsumme stimmt, für die Bank gibt es allerdings eine (andere) Nachfolge-BLZ

INT2FIX(IBAN_CHKSUM_OK_NACHFOLGE_BLZ_DEFINED)

LUT2_NOT_ALL_IBAN_BLOCKS_LOADED = (-139) es konnten nicht alle Datenblocks die für die IBAN-Berechnung notwendig sind geladen werden

INT2FIX(LUT2_NOT_ALL_IBAN_BLOCKS_LOADED)

LUT2_NOT_YET_VALID_PARTIAL_OK = (-138) Der Datensatz ist noch nicht gültig, außerdem konnten nicht alle Blocks geladen werden

INT2FIX(LUT2_NOT_YET_VALID_PARTIAL_OK)

LUT2_NO_LONGER_VALID_PARTIAL_OK = (-137) Der Datensatz ist nicht mehr gültig, außerdem konnten nicht alle Blocks geladen werdeng

INT2FIX(LUT2_NO_LONGER_VALID_PARTIAL_OK)

LUT2_BLOCKS_MISSING = (-136) ok, bei der Initialisierung konnten allerdings ein oder mehrere Blocks nicht geladen werden

INT2FIX(LUT2_BLOCKS_MISSING)

FALSE_UNTERKONTO_ATTACHED = (-135) falsch, es wurde ein Unterkonto hinzugefügt (IBAN-Regel)

INT2FIX(FALSE_UNTERKONTO_ATTACHED)

BLZ_BLACKLISTED = (-134) Die BLZ findet sich in der Ausschlussliste für IBAN-Berechnungen

INT2FIX(BLZ_BLACKLISTED)

BLZ_MARKED_AS_DELETED = (-133) Die BLZ ist in der Bundesbank-Datei als gelöscht markiert und somit ungültig

INT2FIX(BLZ_MARKED_AS_DELETED)

IBAN_CHKSUM_OK_SOMETHING_WRONG = (-132) Die IBAN-Prüfsumme stimmt, es gibt allerdings einen Fehler in der eigenen IBAN-Bestimmung (wahrscheinlich falsch)

INT2FIX(IBAN_CHKSUM_OK_SOMETHING_WRONG)

IBAN_CHKSUM_OK_NO_IBAN_CALCULATION = (-131) Die IBAN-Prüfsumme stimmt. Die Bank gibt IBANs nach nicht veröffentlichten Regeln heraus, die Richtigkeit der IBAN kann nur mit einer Anfrage bei der Bank ermittelt werden

INT2FIX(IBAN_CHKSUM_OK_NO_IBAN_CALCULATION)

IBAN_CHKSUM_OK_RULE_IGNORED = (-130) Die IBAN-Prüfsumme stimmt, es wurde allerdings eine IBAN-Regel nicht beachtet (wahrscheinlich falsch)

INT2FIX(IBAN_CHKSUM_OK_RULE_IGNORED)

IBAN_CHKSUM_OK_UNTERKTO_MISSING = (-129) Die IBAN-Prüfsumme stimmt, es fehlt aber ein Unterkonto (wahrscheinlich falsch)

INT2FIX(IBAN_CHKSUM_OK_UNTERKTO_MISSING)

IBAN_INVALID_RULE = (-128) Die BLZ passt nicht zur angegebenen IBAN-Regel

INT2FIX(IBAN_INVALID_RULE)

IBAN_AMBIGUOUS_KTO = (-127) Die Kontonummer ist nicht eindeutig (es gibt mehrere Möglichkeiten)

INT2FIX(IBAN_AMBIGUOUS_KTO)

IBAN_RULE_NOT_IMPLEMENTED = (-126) Die IBAN-Regel ist noch nicht implementiert

INT2FIX(IBAN_RULE_NOT_IMPLEMENTED)

IBAN_RULE_UNKNOWN = (-125) Die IBAN-Regel ist nicht bekannt

INT2FIX(IBAN_RULE_UNKNOWN)

NO_IBAN_CALCULATION = (-124) Für die Bankverbindung ist keine IBAN-Berechnung erlaubt

INT2FIX(NO_IBAN_CALCULATION)

OLD_BLZ_OK_NEW_NOT = (-123) Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht

INT2FIX(OLD_BLZ_OK_NEW_NOT)

LUT2_IBAN_REGEL_NOT_INITIALIZED = (-122) Das Feld IBAN-Regel wurde nicht initialisiert

INT2FIX(LUT2_IBAN_REGEL_NOT_INITIALIZED)

INVALID_IBAN_LENGTH = (-121) Die Länge der IBAN für das angegebene Länderkürzel ist falsch

INT2FIX(INVALID_IBAN_LENGTH)

LUT2_NO_ACCOUNT_GIVEN = (-120) Keine Bankverbindung/IBAN angegeben

INT2FIX(LUT2_NO_ACCOUNT_GIVEN)

LUT2_VOLLTEXT_INVALID_CHAR = (-119) Ungültiges Zeichen ( ()+-/&.,' ) für die Volltextsuche gefunden

INT2FIX(LUT2_VOLLTEXT_INVALID_CHAR)

LUT2_VOLLTEXT_SINGLE_WORD_ONLY = (-118) Die Volltextsuche sucht jeweils nur ein einzelnes Wort, benutzen Sie lut_suche_multiple() zur Suche nach mehreren Worten

INT2FIX(LUT2_VOLLTEXT_SINGLE_WORD_ONLY)

LUT_SUCHE_INVALID_RSC = (-117) die angegebene Suchresource ist ungültig

INT2FIX(LUT_SUCHE_INVALID_RSC)

LUT_SUCHE_INVALID_CMD = (-116) bei der Suche sind im Verknüpfungsstring nur die Zeichen a-z sowie + und - erlaubt

INT2FIX(LUT_SUCHE_INVALID_CMD)

LUT_SUCHE_INVALID_CNT = (-115) bei der Suche müssen zwischen 1 und 26 Suchmuster angegeben werden

INT2FIX(LUT_SUCHE_INVALID_CNT)

LUT2_VOLLTEXT_NOT_INITIALIZED = (-114) Das Feld Volltext wurde nicht initialisiert

INT2FIX(LUT2_VOLLTEXT_NOT_INITIALIZED)

NO_OWN_IBAN_CALCULATION = (-113) das Institut erlaubt keine eigene IBAN-Berechnung

INT2FIX(NO_OWN_IBAN_CALCULATION)

KTO_CHECK_UNSUPPORTED_COMPRESSION = (-112) die notwendige Kompressions-Bibliothek wurde beim Kompilieren nicht eingebunden

INT2FIX(KTO_CHECK_UNSUPPORTED_COMPRESSION)

KTO_CHECK_INVALID_COMPRESSION_LIB = (-111) der angegebene Wert für die Default-Kompression ist ungültig

INT2FIX(KTO_CHECK_INVALID_COMPRESSION_LIB)

OK_UNTERKONTO_ATTACHED_OLD = (-110) (nicht mehr als Fehler, sondern positive Ausgabe - Dummy für den alten Wert)

INT2FIX(OK_UNTERKONTO_ATTACHED_OLD)

KTO_CHECK_DEFAULT_BLOCK_INVALID = (-109) Ungültige Signatur im Default-Block

INT2FIX(KTO_CHECK_DEFAULT_BLOCK_INVALID)

KTO_CHECK_DEFAULT_BLOCK_FULL = (-108) Die maximale Anzahl Einträge für den Default-Block wurde erreicht

INT2FIX(KTO_CHECK_DEFAULT_BLOCK_FULL)

KTO_CHECK_NO_DEFAULT_BLOCK = (-107) Es wurde noch kein Default-Block angelegt

INT2FIX(KTO_CHECK_NO_DEFAULT_BLOCK)

KTO_CHECK_KEY_NOT_FOUND = (-106) Der angegebene Schlüssel wurde im Default-Block nicht gefunden

INT2FIX(KTO_CHECK_KEY_NOT_FOUND)

LUT2_NO_LONGER_VALID_BETTER = (-105) Beide Datensätze sind nicht mehr gültig, dieser ist aber jünger als der andere

INT2FIX(LUT2_NO_LONGER_VALID_BETTER)

DTA_SRC_KTO_DIFFERENT = (-104) Die Auftraggeber-Kontonummer des C-Datensatzes unterscheidet sich von der des A-Satzes

INT2FIX(DTA_SRC_KTO_DIFFERENT)

DTA_SRC_BLZ_DIFFERENT = (-103) Die Auftraggeber-Bankleitzahl des C-Datensatzes unterscheidet sich von der des A-Satzes

INT2FIX(DTA_SRC_BLZ_DIFFERENT)

DTA_CR_LF_IN_FILE = (-102) Die DTA-Datei enthält (unzulässige) Zeilenvorschübe

INT2FIX(DTA_CR_LF_IN_FILE)

DTA_INVALID_C_EXTENSION = (-101) ungültiger Typ bei einem Erweiterungsblock eines C-Datensatzes

INT2FIX(DTA_INVALID_C_EXTENSION)

DTA_FOUND_SET_A_NOT_C = (-100) Es wurde ein C-Datensatz erwartet, jedoch ein E-Satz gefunden

INT2FIX(DTA_FOUND_SET_A_NOT_C)

DTA_FOUND_SET_E_NOT_C = (-99) Es wurde ein C-Datensatz erwartet, jedoch ein E-Satz gefunden

INT2FIX(DTA_FOUND_SET_E_NOT_C)

DTA_FOUND_SET_C_NOT_EXTENSION = (-98) Es wurde ein C-Datensatzerweiterung erwartet, jedoch ein C-Satz gefunden

INT2FIX(DTA_FOUND_SET_C_NOT_EXTENSION)

DTA_FOUND_SET_E_NOT_EXTENSION = (-97) Es wurde ein C-Datensatzerweiterung erwartet, jedoch ein E-Satz gefunden

INT2FIX(DTA_FOUND_SET_E_NOT_EXTENSION)

DTA_INVALID_EXTENSION_COUNT = (-96) Die Anzahl Erweiterungen paßt nicht zur Blocklänge

INT2FIX(DTA_INVALID_EXTENSION_COUNT)

DTA_INVALID_NUM = (-95) Ungültige Zeichen in numerischem Feld

INT2FIX(DTA_INVALID_NUM)

DTA_INVALID_CHARS = (-94) Ungültige Zeichen im Textfeld

INT2FIX(DTA_INVALID_CHARS)

DTA_CURRENCY_NOT_EURO = (-93) Die Währung des DTA-Datensatzes ist nicht Euro

INT2FIX(DTA_CURRENCY_NOT_EURO)

DTA_EMPTY_AMOUNT = (-92) In einem DTA-Datensatz wurde kein Betrag angegeben

INT2FIX(DTA_EMPTY_AMOUNT)

DTA_INVALID_TEXT_KEY = (-91) Ungültiger Textschlüssel in der DTA-Datei

INT2FIX(DTA_INVALID_TEXT_KEY)

DTA_EMPTY_STRING = (-90) Für ein (alphanumerisches) Feld wurde kein Wert angegeben

INT2FIX(DTA_EMPTY_STRING)

DTA_MARKER_A_NOT_FOUND = (-89) Die Startmarkierung des A-Datensatzes wurde nicht gefunden

INT2FIX(DTA_MARKER_A_NOT_FOUND)

DTA_MARKER_C_NOT_FOUND = (-88) Die Startmarkierung des C-Datensatzes wurde nicht gefunden

INT2FIX(DTA_MARKER_C_NOT_FOUND)

DTA_MARKER_E_NOT_FOUND = (-87) Die Startmarkierung des E-Datensatzes wurde nicht gefunden

INT2FIX(DTA_MARKER_E_NOT_FOUND)

DTA_INVALID_SET_C_LEN = (-86) Die Satzlänge eines C-Datensatzes muß zwischen 187 und 622 Byte betragen

INT2FIX(DTA_INVALID_SET_C_LEN)

DTA_INVALID_SET_LEN = (-85) Die Satzlänge eines A- bzw. E-Satzes muß 128 Byte betragen

INT2FIX(DTA_INVALID_SET_LEN)

DTA_WAERUNG_NOT_EURO = (-84) als Währung in der DTA-Datei ist nicht Euro eingetragen

INT2FIX(DTA_WAERUNG_NOT_EURO)

DTA_INVALID_ISSUE_DATE = (-83) das Ausführungsdatum ist zu früh oder zu spät (max. 15 Tage nach Dateierstellung)

INT2FIX(DTA_INVALID_ISSUE_DATE)

DTA_INVALID_DATE = (-82) das Datum ist ungültig

INT2FIX(DTA_INVALID_DATE)

DTA_FORMAT_ERROR = (-81) Formatfehler in der DTA-Datei

INT2FIX(DTA_FORMAT_ERROR)

DTA_FILE_WITH_ERRORS = (-80) die DTA-Datei enthält Fehler

INT2FIX(DTA_FILE_WITH_ERRORS)

INVALID_SEARCH_RANGE = (-79) ungültiger Suchbereich angegeben (unten>oben)

INT2FIX(INVALID_SEARCH_RANGE)

KEY_NOT_FOUND = (-78) Die Suche lieferte kein Ergebnis

INT2FIX(KEY_NOT_FOUND)

BAV_FALSE = (-77) BAV denkt, das Konto ist falsch (konto_check hält es für richtig)

INT2FIX(BAV_FALSE)

LUT2_NO_USER_BLOCK = (-76) User-Blocks müssen einen Typ > 500 haben

INT2FIX(LUT2_NO_USER_BLOCK)

INVALID_SET = (-75) für ein LUT-Set sind nur die Werte 0, 1 oder 2 möglich

INT2FIX(INVALID_SET)

NO_GERMAN_BIC = (-74) Ein Konto kann kann nur für deutsche Banken geprüft werden

INT2FIX(NO_GERMAN_BIC)

IPI_CHECK_INVALID_LENGTH = (-73) Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten

INT2FIX(IPI_CHECK_INVALID_LENGTH)

IPI_INVALID_CHARACTER = (-72) Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen

INT2FIX(IPI_INVALID_CHARACTER)

IPI_INVALID_LENGTH = (-71) Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein

INT2FIX(IPI_INVALID_LENGTH)

LUT1_FILE_USED = (-70) Es wurde eine LUT-Datei im Format 1.0/1.1 geladen

INT2FIX(LUT1_FILE_USED)

MISSING_PARAMETER = (-69) Für die aufgerufene Funktion fehlt ein notwendiger Parameter

INT2FIX(MISSING_PARAMETER)

IBAN2BIC_ONLY_GERMAN = (-68) Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen

INT2FIX(IBAN2BIC_ONLY_GERMAN)

IBAN_OK_KTO_NOT = (-67) Die Prüfziffer der IBAN stimmt, die der Kontonummer nicht

INT2FIX(IBAN_OK_KTO_NOT)

KTO_OK_IBAN_NOT = (-66) Die Prüfziffer der Kontonummer stimmt, die der IBAN nicht

INT2FIX(KTO_OK_IBAN_NOT)

TOO_MANY_SLOTS = (-65) Es sind nur maximal 500 Slots pro LUT-Datei möglich (Neukompilieren erforderlich)

INT2FIX(TOO_MANY_SLOTS)

INIT_FATAL_ERROR = (-64) Initialisierung fehlgeschlagen (init_wait geblockt)

INT2FIX(INIT_FATAL_ERROR)

INCREMENTAL_INIT_NEEDS_INFO = (-63) Ein inkrementelles Initialisieren benötigt einen Info-Block in der LUT-Datei

INT2FIX(INCREMENTAL_INIT_NEEDS_INFO)

INCREMENTAL_INIT_FROM_DIFFERENT_FILE = (-62) Ein inkrementelles Initialisieren mit einer anderen LUT-Datei ist nicht möglich

INT2FIX(INCREMENTAL_INIT_FROM_DIFFERENT_FILE)

DEBUG_ONLY_FUNCTION = (-61) Die Funktion ist nur in der Debug-Version vorhanden

INT2FIX(DEBUG_ONLY_FUNCTION)

LUT2_INVALID = (-60) Kein Datensatz der LUT-Datei ist aktuell gültig

INT2FIX(LUT2_INVALID)

LUT2_NOT_YET_VALID = (-59) Der Datensatz ist noch nicht gültig

INT2FIX(LUT2_NOT_YET_VALID)

LUT2_NO_LONGER_VALID = (-58) Der Datensatz ist nicht mehr gültig

INT2FIX(LUT2_NO_LONGER_VALID)

LUT2_GUELTIGKEIT_SWAPPED = (-57) Im Gültigkeitsdatum sind Anfangs- und Enddatum vertauscht

INT2FIX(LUT2_GUELTIGKEIT_SWAPPED)

LUT2_INVALID_GUELTIGKEIT = (-56) Das angegebene Gültigkeitsdatum ist ungültig (Sollformat ist JJJJMMTT-JJJJMMTT)

INT2FIX(LUT2_INVALID_GUELTIGKEIT)

LUT2_INDEX_OUT_OF_RANGE = (-55) Der Index für die Filiale ist ungültig

INT2FIX(LUT2_INDEX_OUT_OF_RANGE)

LUT2_INIT_IN_PROGRESS = (-54) Die Bibliothek wird gerade neu initialisiert

INT2FIX(LUT2_INIT_IN_PROGRESS)

LUT2_BLZ_NOT_INITIALIZED = (-53) Das Feld BLZ wurde nicht initialisiert

INT2FIX(LUT2_BLZ_NOT_INITIALIZED)

LUT2_FILIALEN_NOT_INITIALIZED = (-52) Das Feld Filialen wurde nicht initialisiert

INT2FIX(LUT2_FILIALEN_NOT_INITIALIZED)

LUT2_NAME_NOT_INITIALIZED = (-51) Das Feld Bankname wurde nicht initialisiert

INT2FIX(LUT2_NAME_NOT_INITIALIZED)

LUT2_PLZ_NOT_INITIALIZED = (-50) Das Feld PLZ wurde nicht initialisiert

INT2FIX(LUT2_PLZ_NOT_INITIALIZED)

LUT2_ORT_NOT_INITIALIZED = (-49) Das Feld Ort wurde nicht initialisiert

INT2FIX(LUT2_ORT_NOT_INITIALIZED)

LUT2_NAME_KURZ_NOT_INITIALIZED = (-48) Das Feld Kurzname wurde nicht initialisiert

INT2FIX(LUT2_NAME_KURZ_NOT_INITIALIZED)

LUT2_PAN_NOT_INITIALIZED = (-47) Das Feld PAN wurde nicht initialisiert

INT2FIX(LUT2_PAN_NOT_INITIALIZED)

LUT2_BIC_NOT_INITIALIZED = (-46) Das Feld BIC wurde nicht initialisiert

INT2FIX(LUT2_BIC_NOT_INITIALIZED)

LUT2_PZ_NOT_INITIALIZED = (-45) Das Feld Prüfziffer wurde nicht initialisiert

INT2FIX(LUT2_PZ_NOT_INITIALIZED)

LUT2_NR_NOT_INITIALIZED = (-44) Das Feld NR wurde nicht initialisiert

INT2FIX(LUT2_NR_NOT_INITIALIZED)

LUT2_AENDERUNG_NOT_INITIALIZED = (-43) Das Feld Änderung wurde nicht initialisiert

INT2FIX(LUT2_AENDERUNG_NOT_INITIALIZED)

LUT2_LOESCHUNG_NOT_INITIALIZED = (-42) Das Feld Löschung wurde nicht initialisiert

INT2FIX(LUT2_LOESCHUNG_NOT_INITIALIZED)

LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED = (-41) Das Feld Nachfolge-BLZ wurde nicht initialisiert

INT2FIX(LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED)

LUT2_NOT_INITIALIZED = (-40) die Programmbibliothek wurde noch nicht initialisiert

INT2FIX(LUT2_NOT_INITIALIZED)

LUT2_FILIALEN_MISSING = (-39) der Block mit der Filialenanzahl fehlt in der LUT-Datei

INT2FIX(LUT2_FILIALEN_MISSING)

LUT2_PARTIAL_OK = (-38) es wurden nicht alle Blocks geladen

INT2FIX(LUT2_PARTIAL_OK)

LUT2_Z_BUF_ERROR = (-37) Buffer error in den ZLIB Routinen

INT2FIX(LUT2_Z_BUF_ERROR)

LUT2_Z_MEM_ERROR = (-36) Memory error in den ZLIB-Routinen

INT2FIX(LUT2_Z_MEM_ERROR)

LUT2_Z_DATA_ERROR = (-35) Datenfehler im komprimierten LUT-Block

INT2FIX(LUT2_Z_DATA_ERROR)

LUT2_BLOCK_NOT_IN_FILE = (-34) Der Block ist nicht in der LUT-Datei enthalten

INT2FIX(LUT2_BLOCK_NOT_IN_FILE)

LUT2_DECOMPRESS_ERROR = (-33) Fehler beim Dekomprimieren eines LUT-Blocks

INT2FIX(LUT2_DECOMPRESS_ERROR)

LUT2_COMPRESS_ERROR = (-32) Fehler beim Komprimieren eines LUT-Blocks

INT2FIX(LUT2_COMPRESS_ERROR)

LUT2_FILE_CORRUPTED = (-31) Die LUT-Datei ist korrumpiert

INT2FIX(LUT2_FILE_CORRUPTED)

LUT2_NO_SLOT_FREE = (-30) Im Inhaltsverzeichnis der LUT-Datei ist kein Slot mehr frei

INT2FIX(LUT2_NO_SLOT_FREE)

UNDEFINED_SUBMETHOD = (-29) Die (Unter)Methode ist nicht definiert

INT2FIX(UNDEFINED_SUBMETHOD)

EXCLUDED_AT_COMPILETIME = (-28) Der benötigte Programmteil wurde beim Kompilieren deaktiviert

INT2FIX(EXCLUDED_AT_COMPILETIME)

INVALID_LUT_VERSION = (-27) Die Versionsnummer für die LUT-Datei ist ungültig

INT2FIX(INVALID_LUT_VERSION)

INVALID_PARAMETER_STELLE1 = (-26) ungültiger Prüfparameter (erste zu prüfende Stelle)

INT2FIX(INVALID_PARAMETER_STELLE1)

INVALID_PARAMETER_COUNT = (-25) ungültiger Prüfparameter (Anzahl zu prüfender Stellen)

INT2FIX(INVALID_PARAMETER_COUNT)

INVALID_PARAMETER_PRUEFZIFFER = (-24) ungültiger Prüfparameter (Position der Prüfziffer)

INT2FIX(INVALID_PARAMETER_PRUEFZIFFER)

INVALID_PARAMETER_WICHTUNG = (-23) ungültiger Prüfparameter (Wichtung)

INT2FIX(INVALID_PARAMETER_WICHTUNG)

INVALID_PARAMETER_METHODE = (-22) ungültiger Prüfparameter (Rechenmethode)

INT2FIX(INVALID_PARAMETER_METHODE)

LIBRARY_INIT_ERROR = (-21) Problem beim Initialisieren der globalen Variablen

INT2FIX(LIBRARY_INIT_ERROR)

LUT_CRC_ERROR = (-20) Prüfsummenfehler in der blz.lut Datei

INT2FIX(LUT_CRC_ERROR)

FALSE_GELOESCHT = (-19) falsch (die BLZ wurde außerdem gelöscht)

INT2FIX(FALSE_GELOESCHT)

OK_NO_CHK_GELOESCHT = (-18) ok, ohne Prüfung (die BLZ wurde allerdings gelöscht)

INT2FIX(OK_NO_CHK_GELOESCHT)

OK_GELOESCHT = (-17) ok (die BLZ wurde allerdings gelöscht)

INT2FIX(OK_GELOESCHT)

BLZ_GELOESCHT = (-16) die Bankleitzahl wurde gelöscht

INT2FIX(BLZ_GELOESCHT)

INVALID_BLZ_FILE = (-15) Fehler in der blz.txt Datei (falsche Zeilenlänge)

INT2FIX(INVALID_BLZ_FILE)

LIBRARY_IS_NOT_THREAD_SAFE = (-14) undefinierte Funktion, die library wurde mit THREAD_SAFE=0 kompiliert

INT2FIX(LIBRARY_IS_NOT_THREAD_SAFE)

FATAL_ERROR = (-13) schwerer Fehler im Konto_check-Modul

INT2FIX(FATAL_ERROR)

INVALID_KTO_LENGTH = (-12) ein Konto muß zwischen 1 und 10 Stellen haben

INT2FIX(INVALID_KTO_LENGTH)

FILE_WRITE_ERROR = (-11) kann Datei nicht schreiben

INT2FIX(FILE_WRITE_ERROR)

FILE_READ_ERROR = (-10) kann Datei nicht lesen

INT2FIX(FILE_READ_ERROR)

ERROR_MALLOC = (-9) kann keinen Speicher allokieren

INT2FIX(ERROR_MALLOC)

NO_BLZ_FILE = (-8) die blz.txt Datei wurde nicht gefunden

INT2FIX(NO_BLZ_FILE)

INVALID_LUT_FILE = (-7) die blz.lut Datei ist inkosistent/ungültig

INT2FIX(INVALID_LUT_FILE)

NO_LUT_FILE = (-6) die blz.lut Datei wurde nicht gefunden

INT2FIX(NO_LUT_FILE)

INVALID_BLZ_LENGTH = (-5) die Bankleitzahl ist nicht achtstellig

INT2FIX(INVALID_BLZ_LENGTH)

INVALID_BLZ = (-4) die Bankleitzahl ist ungültig

INT2FIX(INVALID_BLZ)

INVALID_KTO = (-3) das Konto ist ungültig

INT2FIX(INVALID_KTO)

NOT_IMPLEMENTED = (-2) die Methode wurde noch nicht implementiert

INT2FIX(NOT_IMPLEMENTED)

NOT_DEFINED = (-1) die Methode ist nicht definiert

INT2FIX(NOT_DEFINED)

FALSE = (0) falsch

INT2FIX(FALSE)

OK = (1) ok

INT2FIX(OK)

OK_NO_CHK = (2) ok, ohne Prüfung

INT2FIX(OK_NO_CHK)

OK_TEST_BLZ_USED = (3) ok, für den Test wurde eine Test-BLZ verwendet

INT2FIX(OK_TEST_BLZ_USED)

LUT2_VALID = (4) Der Datensatz ist aktuell gültig

INT2FIX(LUT2_VALID)

LUT2_NO_VALID_DATE = (5) Der Datensatz enthält kein Gültigkeitsdatum

INT2FIX(LUT2_NO_VALID_DATE)

LUT1_SET_LOADED = (6) Die Datei ist im alten LUT-Format (1.0/1.1)

INT2FIX(LUT1_SET_LOADED)

LUT1_FILE_GENERATED = (7) ok, es wurde allerdings eine LUT-Datei im alten Format (1.0/1.1) generiert

INT2FIX(LUT1_FILE_GENERATED)

DTA_FILE_WITH_WARNINGS = (8) In der DTAUS-Datei wurden kleinere Fehler gefunden

INT2FIX(DTA_FILE_WITH_WARNINGS)

LUT_V2_FILE_GENERATED = (9) ok, es wurde allerdings eine LUT-Datei im Format 2.0 generiert (Compilerswitch)

INT2FIX(LUT_V2_FILE_GENERATED)

KTO_CHECK_VALUE_REPLACED = (10) ok, der Wert für den Schlüssel wurde überschrieben

INT2FIX(KTO_CHECK_VALUE_REPLACED)

OK_UNTERKONTO_POSSIBLE = (11) wahrscheinlich ok, die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten

INT2FIX(OK_UNTERKONTO_POSSIBLE)

OK_UNTERKONTO_GIVEN = (12) wahrscheinlich ok, die Kontonummer enthält eine Unterkontonummer

INT2FIX(OK_UNTERKONTO_GIVEN)

OK_SLOT_CNT_MIN_USED = (13) ok, die Anzahl Slots wurde auf SLOT_CNT_MIN (60) hochgesetzt

INT2FIX(OK_SLOT_CNT_MIN_USED)

SOME_KEYS_NOT_FOUND = (14) ok, ein(ige) Schlüssel wurden nicht gefunden

INT2FIX(SOME_KEYS_NOT_FOUND)

LUT2_KTO_NOT_CHECKED = (15) Die Bankverbindung wurde nicht getestet

INT2FIX(LUT2_KTO_NOT_CHECKED)

LUT2_OK_WITHOUT_IBAN_RULES = (16) Es wurden fast alle Blocks (außer den IBAN-Regeln) geladen

INT2FIX(LUT2_OK_WITHOUT_IBAN_RULES)

OK_NACHFOLGE_BLZ_USED = (17) ok, für die BLZ wurde allerdings die Nachfolge-BLZ eingesetzt

INT2FIX(OK_NACHFOLGE_BLZ_USED)

OK_KTO_REPLACED = (18) ok, die Kontonummer wurde allerdings ersetzt

INT2FIX(OK_KTO_REPLACED)

OK_BLZ_REPLACED = (19) ok, die Bankleitzahl wurde allerdings ersetzt

INT2FIX(OK_BLZ_REPLACED)

OK_BLZ_KTO_REPLACED = (20) ok, die Bankleitzahl und Kontonummer wurden allerdings ersetzt

INT2FIX(OK_BLZ_KTO_REPLACED)

OK_IBAN_WITHOUT_KC_TEST = (21) ok, die Bankverbindung ist (ohne Test) als richtig anzusehen

INT2FIX(OK_IBAN_WITHOUT_KC_TEST)

OK_INVALID_FOR_IBAN = (22) ok, für die die IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert

INT2FIX(OK_INVALID_FOR_IBAN)

OK_HYPO_REQUIRES_KTO = (23) ok, für die BIC-Bestimmung der ehemaligen Hypo-Bank für IBAN wird i.A. zusätzlich die Kontonummer benötigt

INT2FIX(OK_HYPO_REQUIRES_KTO)

OK_KTO_REPLACED_NO_PZ = (24) ok, die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer

INT2FIX(OK_KTO_REPLACED_NO_PZ)

OK_UNTERKONTO_ATTACHED = (25) ok, es wurde ein (weggelassenes) Unterkonto angefügt

INT2FIX(OK_UNTERKONTO_ATTACHED)

OK_SHORT_BIC_USED = (26) ok, für den BIC wurde die Zweigstellennummer allerdings durch XXX ersetzt

INT2FIX(OK_SHORT_BIC_USED)

Class Method Summary collapse

.bank_aenderung(*args) ⇒ Object

KontoCheckRaw::bank_aenderung( blz [,filiale]) =====KontoCheck::bank_aenderung( blz [,filiale]).
.bank_alles(*args) ⇒ Object

KontoCheckRaw::bank_alles( blz [,filiale]) =====KontoCheck::bank_alles( blz [,filiale]).
.bank_bic(*args) ⇒ Object

KontoCheckRaw::bank_bic( blz [,filiale]) =====KontoCheck::bank_bic( blz [,filiale]).
.bank_filialen(*args) ⇒ Object

KontoCheckRaw::bank_filialen( blz) =====KontoCheck::bank_filialen( blz).
.bank_loeschung(*args) ⇒ Object

KontoCheckRaw::bank_loeschung( blz [,filiale]) =====KontoCheck::bank_loeschung( blz [,filiale]).
.bank_nachfolge_blz(*args) ⇒ Object

KontoCheckRaw::bank_nachfolge_blz( blz [,filiale]) =====KontoCheck::bank_nachfolge_blz( blz [,filiale]).
.bank_name(*args) ⇒ Object

KontoCheckRaw::bank_name( blz [,filiale]) =====KontoCheck::bank_name( blz [,filiale]).
.bank_name_kurz(*args) ⇒ Object

KontoCheckRaw::bank_name_kurz( blz [,filiale]) =====KontoCheck::bank_name_kurz( blz [,filiale]).
.bank_nr(*args) ⇒ Object

KontoCheckRaw::bank_nr( blz [,filiale]) =====KontoCheck::bank_nr( blz [,filiale]).
.bank_ort(*args) ⇒ Object

KontoCheckRaw::bank_ort( blz [,filiale]) =====KontoCheck::bank_ort( blz [,filiale]).
.bank_pan(*args) ⇒ Object

KontoCheckRaw::bank_pan( blz [,filiale]) =====KontoCheck::bank_pan( blz [,filiale]).
.bank_plz(*args) ⇒ Object

KontoCheckRaw::bank_plz( blz [,filiale]) =====KontoCheck::bank_plz( blz [,filiale]).
.bank_pz(*args) ⇒ Object

KontoCheckRaw::bank_pz( blz) =====KontoCheck::bank_pz( blz).
.bank_suche_bic(*args) ⇒ Object

KontoCheckRaw::bank_suche_bic( search_bic [,sort_uniq [,sort]]) =====KontoCheck::suche().
.bank_suche_blz(*args) ⇒ Object

KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,uniq]]) =====KontoCheck::suche().
.bank_suche_multiple(*args) ⇒ Object

KontoCheckRaw::bank_suche_multiple( suchtext [,such_cmd] [,uniq]) =====KontoCheck::suche().
.bank_suche_namen(*args) ⇒ Object

KontoCheckRaw::bank_suche_namen( name [,sort_uniq [,sort]]) =====KontoCheck::suche().
.bank_suche_namen_kurz(*args) ⇒ Object

KontoCheckRaw::bank_suche_namen_kurz( short_name [,sort_uniq [,sort]]) =====KontoCheck::suche().
.bank_suche_ort(*args) ⇒ Object

KontoCheckRaw::bank_suche_ort( suchort [,uniq]) =====KontoCheck::suche().
.bank_suche_plz(*args) ⇒ Object

KontoCheckRaw::bank_suche_plz( plz1 [,plz2 [,sort_uniq [,sort]]]) =====KontoCheck::suche().
.bank_suche_pz(*args) ⇒ Object

KontoCheckRaw::bank_suche_pz( pz1 [,pz2 [,sort_uniq [,sort]]]) ===== KontoCheck::suche().
.bank_suche_regel(*args) ⇒ Object

KontoCheckRaw::bank_suche_regel( regel1 [,regel2 [,sort_uniq [,sort]]]) ===== KontoCheck::suche().
.bank_suche_volltext(*args) ⇒ Object

KontoCheckRaw::bank_suche_volltext( suchwort [,sort_uniq [,sort]]) =====KontoCheck::suche().
.bank_valid(*args) ⇒ Object

KontoCheckRaw::bank_valid( blz [,filiale]) ====== KontoCheck::bank_valid( blz [,filiale]) ====== KontoCheck::bank_valid?( blz [,filiale]) Diese Funktion testet, ob eine gegebene BLZ gültig ist.
.bic_check(bic_v) ⇒ Object

KontoCheckRaw::bic_check( bic) =====KontoCheck::bic_check( bic) Diese Funktion testet die Existenz eines (deutschen) BIC.
.ci_check(ci_v) ⇒ Object

KontoCheckRaw::ci_check( ci) =====KontoCheck::ci_check( ci) Diese Funktion testet eine Gläubiger-Identifikationsnummer (Credit Identifier, ci).
.current_lutfile_name ⇒ Object

KontoCheckRaw::current_lutfile_name() =====KontoCheck::current_lutfile_name() =====KontoCheck::current_lutfile_set() =====KontoCheck::current_init_level().
.dump_lutfile(*args) ⇒ Object

KontoCheckRaw::dump_lutfile( lutfile) =====KontoCheck::dump_lutfile( lutfile).
.encoding(*args) ⇒ Object

KontoCheckRaw::encoding( [mode]) =====KontoCheck::encoding( [mode]) =====KontoCheckRaw::encoding_str( [mode]) =====KontoCheckRaw::keep_raw_data( mode).
.encoding_str(*args) ⇒ Object

KontoCheckRaw::encoding_str( mode) =====KontoCheck::encoding_str( mode) =====KontoCheckRaw::encoding( mode) =====KontoCheckRaw::keep_raw_data( mode).
.free ⇒ Object

KontoCheckRaw::free() =====KontoCheck::free().
.generate_lutfile(*args) ⇒ Object

KontoCheckRaw::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]]) =====KontoCheck::generate_lutfile( inputfile,outputfile [,user_info [,gueltigkeit [,felder [,filialen [,set [,iban_file]]]]]]).
.iban2bic(*args) ⇒ Object

KontoCheckRaw::iban2bic( iban) =====KontoCheck::iban2bic( iban).
.iban_check(*args) ⇒ Object

KontoCheckRaw::iban_check( iban) =====KontoCheck::iban_check( iban) Diese Funktion testet eine IBAN; bei deutschen Bankverbindungen wird zusätzlich noch die Plausibilität der Bankverbindung getestet und im Statuswert zurückgegeben.
.iban_gen(*args) ⇒ Object

KontoCheckRaw::iban_gen( blz,kto) =====KontoCheck::iban_gen( kto,blz) Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN, sowie den zugehörigen BIC.
.init(*args) ⇒ Object

KontoCheckRaw::init( [p1 [,p2 [,set]]]) =====KontoCheck::init( [p1 [,p2 [,set]]]) Diese Funktion initialisiert die Bibliothek und lädt die gewünschten Datenblocks in den Speicher.
.ipi_check(*args) ⇒ Object

KontoCheckRaw::ipi_check( zweck) =====KontoCheck::ipi_check( zweck).
.ipi_gen(*args) ⇒ Object

KontoCheckRaw::ipi_gen( zweck) =====KontoCheck::ipi_gen( zweck).
.keep_raw_data(mode_rb) ⇒ Object

KontoCheckRaw::keep_raw_data( mode) =====KontoCheckRaw::encoding( mode) =====KontoCheck::encoding( mode).
.konto_check(*args) ⇒ Object

KontoCheckRaw::konto_check( blz, kto) =====KontoCheck::konto_check( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
.konto_check_pz(*args) ⇒ Object

KontoCheckRaw::konto_check_pz( pz, kto [,blz]) =====KontoCheck::konto_check_pz( pz, kto [,blz]).
.konto_check_regel(*args) ⇒ Object

KontoCheckRaw::konto_check_regel( blz, kto) =====KontoCheckRaw::konto_check_regel_dbg( blz, kto) =====KontoCheck::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel?( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
.konto_check_regel_dbg(*args) ⇒ Object

KontoCheckRaw::konto_check_regel_dbg( blz, kto) =====KontoCheckRaw::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel?( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.
.load_bank_data(path_rb) ⇒ Object

KontoCheckRaw::load_bank_data( datafile) =====KontoCheck::load_bank_data( datafile).
.lut_blocks(*args) ⇒ Object

KontoCheckRaw::lut_blocks( mode) =====KontoCheck::lut_blocks( mode) Die Funktion gibt Auskunft, ob bei der Initialisierung alle angeforderten Blocks der LUT-Datei geladen wurden und gibt den Dateinamen der LUT-Datei, eine Liste der geladenen Blocks sowie eine Liste der Blocks die nicht geladen werden konnten, zurück.
.lut_blocks1(*args) ⇒ Object

KontoCheckRaw::lut_blocks1( ) =====KontoCheckRaw::lut_blocks( mode) =====KontoCheck::lut_blocks( ) Diese Funktion entspricht weitgehend der Funktion lut_blocks(); sie gibt allerdings nur den Statuscode zurück, keine Strings.
.lut_info(*args) ⇒ Object

KontoCheckRaw::lut_info( [lutfile]) =====KontoCheck::lut_info() =====KontoCheck::lut_info1( lutfile) =====KontoCheck::lut_info2( lutfile).
.retval2dos(retval) ⇒ Object

KontoCheckRaw::retval2dos( retval) =====KontoCheck::retval2dos( retval).
.retval2html(retval) ⇒ Object

KontoCheckRaw::retval2html( retval) =====KontoCheck::retval2html( retval).
.retval2iso(retval) ⇒ Object

KontoCheckRaw::retval2iso( retval) =====KontoCheck::retval2iso( retval).
.retval2txt(retval) ⇒ Object

KontoCheckRaw::retval2txt( retval) =====KontoCheck::retval2txt( retval).
.retval2txt_short(retval) ⇒ Object

KontoCheckRaw::retval2txt_short( retval) =====KontoCheck::retval2txt_short( retval).
.retval2utf8(retval) ⇒ Object

KontoCheckRaw::retval2utf8( retval) =====KontoCheck::retval2utf8( retval).
.version(*args) ⇒ Object

KontoCheckRaw::version( [mode] ) =====KontoCheck::version( [mode] ).

Class Method Details

.bank_aenderung(*args) ⇒ `Object`

KontoCheckRaw::bank_aenderung( blz [,filiale])

KontoCheck::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). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Änderungsflag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

-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”
-43 (LUT2_AENDERUNG_NOT_INITIALIZED) “Das Feld Änderung wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2273

static VALUE bank_aenderung(int argc,VALUE* argv,VALUE self)
{
   char blz[16],aenderung[2],error_msg[512];
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   *aenderung=lut_aenderung(blz,filiale,&retval);
   aenderung[1]=0;
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_AENDERUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(aenderung),INT2FIX(retval));
}

.bank_alles(*args) ⇒ `Object`

KontoCheckRaw::bank_alles( blz [,filiale])

KontoCheck::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.

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2037

static VALUE bank_alles(int argc,VALUE* argv,VALUE self)
{
   char blz[16],**p_name,**p_name_kurz,**p_ort,**p_bic,*p_aenderung,*p_loeschung,aenderung[2],loeschung[2],error_msg[512];
   int retval,filiale,cnt,*p_blz,*p_plz,*p_pan,p_pz,*p_nr,*p_nachfolge_blz;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   retval=lut_multiple(blz,&cnt,&p_blz, &p_name,&p_name_kurz,&p_plz,&p_ort,&p_pan,&p_bic,&p_pz,&p_nr,
         &p_aenderung,&p_loeschung,&p_nachfolge_blz,NULL,NULL,NULL);
   if(retval==LUT2_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   if(filiale<0 || (cnt && filiale>=cnt))return(INT2FIX(LUT2_INDEX_OUT_OF_RANGE));  /* ungültige Filiale */

      /* Fehler; die C-Arrays dürfen in diesem Fall nicht dereferenziert werden */
   if(retval<=0 && retval!=LUT2_PARTIAL_OK)return rb_ary_new3(2,INT2FIX(retval),Qnil);

   if(p_aenderung){
      *aenderung=p_aenderung[filiale];
      *(aenderung+1)=0;
   }
   else
      *aenderung=0;

   if(p_loeschung){
      *loeschung=p_loeschung[filiale];
      *(loeschung+1)=0;
   }
   else
      *loeschung=0;

   /* Makros für StringValue und IntegerValue definieren, damit die Rückgabe
    * einigermaßen übersichtlich bleibt
    */
#define SV(x) *x?rb_str_new2(x):Qnil
#define IV(x) x>=0?INT2FIX(x):Qnil
   return rb_ary_new3(13,INT2FIX(retval),IV(cnt),SV(p_name[filiale]),
         SV(p_name_kurz[filiale]),IV(p_plz[filiale]),SV(p_ort[filiale]),
         IV(p_pan[filiale]),SV(p_bic[filiale]),IV(p_pz),IV(p_nr[filiale]),
         SV(aenderung),SV(loeschung),IV(p_nachfolge_blz[filiale]));
}

.bank_bic(*args) ⇒ `Object`

KontoCheckRaw::bank_bic( blz [,filiale])

KontoCheck::bank_bic( blz [,filiale])

Diese Funktion liefert den BIC (Bank Identifier Code) einer Bank. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem BIC, im zweiten ein Statuscode. Im Fehlerfall wird für den BIC nil zurückgegeben.

Mögliche Statuscodes:

-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”
-46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2242

static VALUE bank_bic(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *ptr;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   ptr=lut_bic(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_BIC_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ptr),INT2FIX(retval));
}

.bank_filialen(*args) ⇒ `Object`

KontoCheckRaw::bank_filialen( blz)

KontoCheck::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. Der Rückgabewert ist ein Array mit der Anzahl Filialen im ersten Parameter, und einem Statuscode im zwweiten.

Mögliche Statuswerte 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”
-52 (LUT2_FILIALEN_NOT_INITIALIZED) “Das Feld Filialen wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1993

static VALUE bank_filialen(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,cnt;

   get_params(argc,argv,blz,NULL,NULL,NULL,0);
   cnt=lut_filialen(blz,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_FILIALEN_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(cnt),INT2FIX(retval));
}

.bank_loeschung(*args) ⇒ `Object`

KontoCheckRaw::bank_loeschung( blz [,filiale])

KontoCheck::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). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht das Flag, im zweiten ein Statuscode. Im Fehlerfall wird für das Flag nil zurückgegeben.

Mögliche Statuscodes:

-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”
-42 (LUT2_LOESCHUNG_NOT_INITIALIZED) “Das Feld Löschung wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2303

static VALUE bank_loeschung(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,loeschung,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   loeschung=lut_loeschung(blz,filiale,&retval)-'0';
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_LOESCHUNG_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(loeschung),INT2FIX(retval));
}

.bank_nachfolge_blz(*args) ⇒ `Object`

KontoCheckRaw::bank_nachfolge_blz( blz [,filiale])

KontoCheck::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). Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nachfolge-BLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die Nachfolge-BLZ nil zurückgegeben.

Mögliche Statuscodes:

-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”
-41 (LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED) “Das Feld Nachfolge-BLZ wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2332

static VALUE bank_nachfolge_blz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,n_blz,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   n_blz=lut_nachfolge_blz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NACHFOLGE_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(n_blz),INT2FIX(retval));
}

.bank_name(*args) ⇒ `Object`

KontoCheckRaw::bank_name( blz [,filiale])

KontoCheck::bank_name( blz [,filiale])

Diese Funktion liefert den Namen einer Bank. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

-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”
-51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2093

static VALUE bank_name(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   name=lut_name(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

.bank_name_kurz(*args) ⇒ `Object`

KontoCheckRaw::bank_name_kurz( blz [,filiale])

KontoCheck::bank_name_kurz( blz [,filiale])

Diese Funktion liefert den Kurznamen einer Bank. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Namen nil zurückgegeben.

Mögliche Statuscodes:

-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”
-48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2122

static VALUE bank_name_kurz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *name;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   name=lut_name_kurz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NAME_KURZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(name),INT2FIX(retval));
}

.bank_nr(*args) ⇒ `Object`

KontoCheckRaw::bank_nr( blz [,filiale])

KontoCheck::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. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Nummer, im zweiten ein Statuscode. Im Fehlerfall wird für die Nummer nil zurückgegeben.

Mögliche Statuscodes:

Possible return values (and short description):

-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”
-44 (LUT2_NR_NOT_INITIALIZED) “Das Feld NR wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2392

static VALUE bank_nr(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,nr,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   nr=lut_nr(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_NR_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(nr),INT2FIX(retval));
}

.bank_ort(*args) ⇒ `Object`

KontoCheckRaw::bank_ort( blz [,filiale])

KontoCheck::bank_ort( blz [,filiale])

Diese Funktion liefert den Ort einer Bank. Falls der Parameter filiale nicht angegeben ist, wird der Sitz der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit dem Namen, im zweiten ein Statuscode. Im Fehlerfall wird für den Ort nil zurückgegeben.

Mögliche Statuscodes:

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

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2153

static VALUE bank_ort(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   const char *ort;
   int retval,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   ort=lut_ort(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_ORT_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:rb_str_new2(ort),INT2FIX(retval));
}

.bank_pan(*args) ⇒ `Object`

KontoCheckRaw::bank_pan( blz [,filiale])

KontoCheck::bank_pan( blz [,filiale])

Diese Funktion liefert den PAN (Primary Account Number) einer Bank. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht der PAN, im zweiten ein Statuscode. Im Fehlerfall wird für den PAN nil zurückgegeben.

Mögliche Statuscodes:

-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”
-47 (LUT2_PAN_NOT_INITIALIZED) “Das Feld PAN wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2360

static VALUE bank_pan(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,pan,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   pan=lut_pan(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PAN_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pan),INT2FIX(retval));
}

.bank_plz(*args) ⇒ `Object`

KontoCheckRaw::bank_plz( blz [,filiale])

KontoCheck::bank_plz( blz [,filiale])

Diese Funktion liefert die Postleitzahl einer Bank. Falls der Parameter filiale nicht angegeben ist, wird die PLZ der Hauptstelle ausgegeben. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die PLZ, im zweiten ein Statuscode. Im Fehlerfall wird für die PLZ nil zurückgegeben.

Mögliche Statuscodes:

-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”
-50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2183

static VALUE bank_plz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,plz,filiale;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   plz=lut_plz(blz,filiale,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(plz),INT2FIX(retval));
}

.bank_pz(*args) ⇒ `Object`

KontoCheckRaw::bank_pz( blz)

KontoCheck::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. Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht die Prüfziffer, im zweiten ein Statuscode. Im Fehlerfall wird für den Prüfziffer nil zurückgegeben.

Mögliche Statuscodes:

-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”
-45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2213

static VALUE bank_pz(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int retval,pz;

   get_params(argc,argv,blz,NULL,NULL,NULL,0);
   pz=lut_pz(blz,0,&retval);
   if(retval==LUT2_BLZ_NOT_INITIALIZED || retval==LUT2_PZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return rb_ary_new3(2,retval<=0?Qnil:INT2FIX(pz),INT2FIX(retval));
}

.bank_suche_bic(*args) ⇒ `Object`

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 fünf Elementen:

Das erste Element ist ein Array mit den gefundenen BIC-Werten
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2567

static VALUE bank_suche_bic(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_bic,NULL);
}

.bank_suche_blz(*args) ⇒ `Object`

KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,uniq]])

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Bankleitzahl gleich <blz1> ist oder (bei Angabe von blz2) die im Bereich zwischen <blz1> und <blz2> liegen. Die Rückgabe ist ein Array mit fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Bankleitzahlen
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen (bei dieser Funktion doppelt gemoppelt :-) )
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-53 (LUT2_BLZ_NOT_INITIALIZED) “Das Feld BLZ wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2705

static VALUE bank_suche_blz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_blz);
}

.bank_suche_multiple(*args) ⇒ `Object`

KontoCheckRaw::bank_suche_multiple( suchtext [,such_cmd] [,uniq])

KontoCheck::suche()

Diese Funktion sucht alle Banken, die mehreren Kriterien entsprechen. Dabei können bis zu 26 Teilsuchen definiert werden, die beliebig miteinander verknüpft werden können (additiv, subtraktiv und multiplikativ).

Aufruf:

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

Parameter:

such_string: Dieser Parameter gibt die Felder an, nach denen gesucht wird. Er besteht aus einem oder mehreren Suchbefehlen, die jeweils folgenden Aufbau haben: [such_index:]suchwert

Der (optionale) Suchindex ist ein Buchstabe von a-z, mit dem das Suchfeld im Suchkommando (zweiter Parameter) referenziert werden kann. Falls er nicht angegeben wird, erhält der erste Suchstring den Index a, der zweite den Index b etc.

Der Suchwert ist der Wert nach dem gesucht werden soll. Für die Textfelder ist es der Beginn des Wortes (aa passt z.B. auf Aach, Aachen, Aalen, Aarbergen), für numerische Felder kann es eine Zahl oder ein Zahlbereich in der Form 22-33 sein.

Das Suchfeld gibt an, nach welchem Feld der BLZ-Datei gesucht werden soll. Falls das Suchfeld nicht angegeben wird, wird eine Volltextsuche (alle Einzelworte in Name, Kurzname und Ort) gemacht. Die folgende Werte sind möglich:
```
bl    BLZ
bi    BIC
k     Kurzname
n     Name
o     Ort
pl    PLZ
pr    Prüfziffer
pz    Prüfziffer
v     Volltext
```
In der obigen Tabelle der Suchfelder sind nur die Kurzversionen angegeben; eine Angabe wie aa@ort oder 57000-58000@plz ist auch problemlos möglich.
such_cmd: Dieser Parameter gibt an, wie die Teilsuchen miteinander verknüpft werden sollen. Der Ausdruck abc bedeutet, daß die BLZs in den Teilsuchen a, b und c enthalten sein müssen; der Ausdruck a+b+c, daß sie in mindestens einer Teilsuche enthalten sein muß; der Ausdruck a-b, daß sie in a, aber nicht in b enthalten sein darf (Beispiel s.u.). Falls das Suchkommando nicht angegeben wird, müssen die Ergebnis-BLZs in allen Teilsuchen enthalten sein.
uniq: Falls dieser Parameter 0 ist, werden alle gefundenen Zweigstellen ausgegeben; falls er 1 ist, wird für jede Bank nur eine Zweigstelle ausgegeben. Die Ausgabe ist (anders als bei den anderen Suchroutinen, bedingt durch die Arbeitsweise der Funktion) immer nach BLZ sortiert. Falls der Parameter weggelassen wird, wird der Standardwert für uniq aus konto_check.h benutzt.

Beispiele:

ret=KontoCheckRaw::bank_suche_multiple( “b:55000000-55100000@blz o:67000-68000@plz sparkasse”,“bo”) Bei diesem Aufruf werden nur die beiden ersten Teilsuchen (nach BLZ und PLZ) benutzt; die Suche findet alle Banken mit einer BLZ zwischen 55000000 und 55100000 im PLZ-Bereich 67000 bis 68000.
ret=KontoCheckRaw::bank_suche_multiple( “b:55000000-55030000@blz o:67000-68000@plz sparkasse”,“co”) Ähnlicher Aufruf wie oben, allerdings werden nur die beiden letzten Teilsuchen berücksichtigt.
ret=KontoCheckRaw::bank_suche_multiple( “67000-68000@plz sparda”,0) Dieser Aufruf gibt alle Filialen der Sparda-Bank im PLZ-Bereich 67000 bis 68000 zurück.
ret=KontoCheckRaw::bank_suche_multiple( “skat”) Dieser Aufruf ist einfach eine Volltextsuche nach der Skat-Bank. Der direkte Aufruf von bank_suche_volltext() ist intern natürlich wesentlich leichtgewichtiger, aber die Suche so auch möglich.

Rückgabe:

Die Rückgabe ist ein Array mit fünf Elementen:

Das erste Element ist immer nil (nur für Kompatibilität mit den anderen Suchfunktionen)
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”
14 (SOME_KEYS_NOT_FOUND) “ok; ein(ige) Schlüssel wurden nicht gefunden”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2932

static VALUE bank_suche_multiple(int argc,VALUE* argv,VALUE self)
{
   char such_text[1280],such_cmd[256],error_msg[512];
   int i,retval,uniq;
   UINT4 *blz,*zweigstelle,anzahl;
   VALUE ret_blz,ret_idx;

   get_params(argc,argv,such_text,such_cmd,NULL,&uniq,6);
   retval=lut_suche_multiple(such_text,uniq>1,such_cmd,&anzahl,&zweigstelle,&blz);
   if(retval==KEY_NOT_FOUND || !anzahl)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
   if(retval<0)RUNTIME_ERROR(retval);
   ret_blz=rb_ary_new2(anzahl);
   ret_idx=rb_ary_new2(anzahl);
   for(i=0;i<(int)anzahl;i++){
      rb_ary_store(ret_blz,i,INT2FIX(blz[i]));
      rb_ary_store(ret_idx,i,INT2FIX(zweigstelle[i]));
   }
   kc_free((char*)blz);
   kc_free((char*)zweigstelle);
   return rb_ary_new3(5,Qnil,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl));
}

.bank_suche_namen(*args) ⇒ `Object`

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 fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Namen
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-51 (LUT2_NAME_NOT_INITIALIZED) “Das Feld Bankname wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2594

static VALUE bank_suche_namen(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_namen,NULL);
}

.bank_suche_namen_kurz(*args) ⇒ `Object`

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

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Kurznamen mit dem angegebenen Wert <search_bic> beginnen. Die Rückgabe ist ein Array mit fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Kurznamen
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-48 (LUT2_NAME_KURZ_NOT_INITIALIZED) “Das Feld Kurzname wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2621

static VALUE bank_suche_namen_kurz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_namen_kurz,NULL);
}

.bank_suche_ort(*args) ⇒ `Object`

KontoCheckRaw::bank_suche_ort( suchort [,uniq])

KontoCheck::suche()

Diese Funktion sucht alle Banken, deren Sitz mit dem angegebenen Wert <suchort> beginnen. Die Rückgabe ist ein Array mit fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Orten
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-49 (LUT2_ORT_NOT_INITIALIZED) “Das Feld Ort wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2732

static VALUE bank_suche_ort(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,lut_suche_ort,NULL);
}

.bank_suche_plz(*args) ⇒ `Object`

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 fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Postleitzahlen
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-50 (LUT2_PLZ_NOT_INITIALIZED) “Das Feld PLZ wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2649

static VALUE bank_suche_plz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_plz);
}

.bank_suche_pz(*args) ⇒ `Object`

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 fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Prüfziffern
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2677

static VALUE bank_suche_pz(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_pz);
}

.bank_suche_regel(*args) ⇒ `Object`

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 fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Regeln
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-45 (LUT2_PZ_NOT_INITIALIZED) “Das Feld Prüfziffer wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2760

static VALUE bank_suche_regel(int argc,VALUE* argv,VALUE self)
{
   return bank_suche_int(argc,argv,self,NULL,lut_suche_regel);
}

.bank_suche_volltext(*args) ⇒ `Object`

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; falls mehrere Worte angegeben werden, wird der Fehlerwert LUT2_VOLLTEXT_SINGLE_WORD_ONLY zurückgegeben. Die Rückgabe ist ein Array mit fünf Elementen:

Das erste Element ist ein Array mit den gefundenen Suchworten
Das zweite Element ist ein Array mit den Bankleitzahlen, die auf das Suchmuster passen
Das dritte Element ist ein Array mit den Zweigstellen-Indizes der gefundenen Bankleitzahlen
das vierte Element ist der Statuscode (s.u.)
das fünfte Element gibt die Anzahl der gefundenen Banken zurück.

Mögliche Statuscodes:

-118 (LUT2_VOLLTEXT_SINGLE_WORD_ONLY) “Die Volltextsuche sucht jeweils nur ein einzelnes Wort; benutzen Sie bank_suche_multiple() zur Suche nach mehreren Worten”
-114 (LUT2_VOLLTEXT_NOT_INITIALIZED) “Das Feld Volltext wurde nicht initialisiert”
-78 (KEY_NOT_FOUND) “Die Suche lieferte kein Ergebnis”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2791

static VALUE bank_suche_volltext(int argc,VALUE* argv,VALUE self)
{
   char such_wort[128],**base_name,error_msg[512];
   int i,j,k,retval,anzahl,anzahl2,last_blz,uniq,*start_idx,*zweigstelle,*blz_base,base_name_idx,zweigstellen_anzahl;
   int *idx_o,*cnt_o;
   VALUE ret_blz,ret_idx,ret_suche;

   get_params(argc,argv,such_wort,NULL,NULL,&uniq,7);
   retval=lut_suche_volltext(such_wort,&anzahl,&base_name_idx,&base_name,&zweigstellen_anzahl,&start_idx,&zweigstelle,&blz_base);
   if(retval==KEY_NOT_FOUND)return rb_ary_new3(5,Qnil,Qnil,Qnil,INT2FIX(retval),INT2FIX(0));
   if(retval<0)RUNTIME_ERROR(retval);
   ret_suche=rb_ary_new2(anzahl);

      /* base_name ist hier komplett unabhängig von den Bankleitzahlen; auch
       * die Größe der beiden Arrays stimmt nicht überein!!! Daher müssen
       * die gefundenen Volltexte in einer eigenen Schleife gespeichert werden.
       */
   for(i=0;i<anzahl;i++){  /* gefundene Volltexte zurückgeben */
      j=base_name_idx+i;
      rb_ary_store(ret_suche,i,rb_str_new2(base_name[j]));
   }
      /* die Anzahl der BLZs steht in der Variablen zweigstellen_anzahl */
   if(uniq) /* bei uniq>0 sortieren, uniq>1 sortieren + uniq */
      lut_suche_sort1(zweigstellen_anzahl,blz_base,zweigstelle,start_idx,&anzahl2,&idx_o,&cnt_o,uniq>1);
   else{
      anzahl2=zweigstellen_anzahl;
      idx_o=start_idx;
      cnt_o=NULL;
   }
   ret_blz=rb_ary_new2(anzahl2);
   ret_idx=rb_ary_new2(anzahl2);
   for(i=k=0,last_blz=-1;i<anzahl2;i++){
      j=idx_o[i];   /* Index innerhalb der BLZ-Datei */
      if(uniq>1 && blz_base[j]==last_blz)
         continue;
      else
         last_blz=blz_base[j];
      rb_ary_store(ret_blz,k,INT2FIX(blz_base[j]));
      rb_ary_store(ret_idx,k++,INT2FIX(zweigstelle[j]));
   }
   if(uniq){
      kc_free((char*)idx_o);
      kc_free((char*)cnt_o);
   }
   return rb_ary_new3(5,ret_suche,ret_blz,ret_idx,INT2FIX(retval),INT2FIX(anzahl2));
}

.bank_valid(*args) ⇒ `Object`

KontoCheckRaw::bank_valid( blz [,filiale])

KontoCheck::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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1962

static VALUE bank_valid(int argc,VALUE* argv,VALUE self)
{
   char blz[16],error_msg[512];
   int filiale,retval;

   get_params(argc,argv,blz,NULL,NULL,&filiale,1);
   retval=lut_blz(blz,filiale);
   if(retval==LUT2_BLZ_NOT_INITIALIZED)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

.bic_check(bic_v) ⇒ `Object`

KontoCheckRaw::bic_check( bic)

KontoCheck::bic_check( bic)

Diese Funktion testet die Existenz eines (deutschen) BIC. Die Rückgabe ist ein Array mit zwei Elementen: im ersten (retval) wird das Testergebnis für die zurückgegeben, im zweiten die Änzahl Banken, die diesen BIC benutzen. 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.

Aufruf:

ret=KontoCheckRaw::bic_check( bic)

Parameter:

bic: der bic, der getestet werden soll

Rückgabe:

Rückgabe ist ein Array mit zwei Elementen:

das erste Element enthält den Statuscode
das zweite Element enthält die Anzahl Banken, die diesen BIC benutzen

Mögliche Rückgabewerte:

-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”
-74 (NO_GERMAN_BIC) “Ein Konto kann kann nur für deutsche Banken geprüft werden”
0 (FALSE) “falsch”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1805

static VALUE bic_check_rb(VALUE self,VALUE bic_v)
{
   char bic[12];
   int retval,cnt;

   if(TYPE(bic_v)!=RUBY_T_STRING)return INT2FIX(INVALID_PARAMETER_TYPE);
   strncpy(bic,RSTRING_PTR(bic_v),11);
   retval=bic_check(bic,&cnt);
   return rb_ary_new3(2,INT2FIX(retval),INT2FIX(cnt));
}

.ci_check(ci_v) ⇒ `Object`

KontoCheckRaw::ci_check( ci)

KontoCheck::ci_check( ci)

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

Aufruf:

ret=KontoCheckRaw::ci_check( ci)

Parameter:

ci: der CI, der getestet werden soll

Mögliche Rückgabewerte für den Test:

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

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1764

static VALUE ci_check_rb(VALUE self,VALUE ci_v)
{
   char ci[36];

   if(TYPE(ci_v)!=RUBY_T_STRING)return INT2FIX(INVALID_PARAMETER_TYPE);
   strncpy(ci,RSTRING_PTR(ci_v),35);
   return INT2FIX(ci_check(ci));
}

.current_lutfile_name ⇒ `Object`

KontoCheckRaw::current_lutfile_name()

KontoCheck::current_lutfile_name()

KontoCheck::current_lutfile_set()

KontoCheck::current_init_level()

Diese Funktion bestimmt den Dateinamen der zur Initialisierung benutzen LUT-Datei, das benutzte Set und den Initialisierungslevel der aktuellen Initialisierung.

Aufruf:

retval=KontoCheckRaw::current_lutfile_name

Rückgabe:

Rückgabewert ist ein Array mit vier Elementen: das erste ist der Dateiname der LUT-Datei, das zweite das benutzte Set (0, falls nicht initialisiert wurde, sonst 1 oder 2), das dritte der Initialisierungslevel und das vierte der Statuscode.

Mögliche Statuscodes:

-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 944

static VALUE current_lutfile_name_rb(VALUE self)
{
   const char *lut_filename;
   int set,level,retval;
   VALUE lut_filename_rb;

   if(!(lut_filename=current_lutfile_name(&set,&level,&retval)))
      lut_filename_rb=Qnil;
   else
      lut_filename_rb=rb_str_new2(lut_filename);
   return rb_ary_new3(4,lut_filename_rb,INT2FIX(set),INT2FIX(level),INT2FIX(retval));
}

.dump_lutfile(*args) ⇒ `Object`

KontoCheckRaw::dump_lutfile( lutfile)

KontoCheck::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.

Aufruf:

retval=KontoCheckRaw::dump_lutfile( lutfile)

Parameter:

lutfile: Name der LUT-Datei.

Rückgabe:

Der Rückgabewert ist ein Array mit zwei Elementen: im ersten steht ein String mit den Infos, im zweiten ein Statuscode. Im Fehlerfall wird für den Infostring nil zurückgegeben.

Mögliche Statuscodes:

-112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde beim Kompilieren nicht eingebunden”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-36 (LUT2_Z_MEM_ERROR) “Memory error in den ZLIB-Routinen”
-35 (LUT2_Z_DATA_ERROR) “Datenfehler im komprimierten LUT-Block”
-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”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1474

static VALUE dump_lutfile_rb(int argc,VALUE* argv,VALUE self)
{
   char lut_name[FILENAME_MAX+1],*ptr;
   int retval;
   VALUE dump;

   get_params_file(argc,argv,lut_name,NULL,NULL,2);
   retval=lut_dir_dump_str(lut_name,&ptr);
   if(retval<=0)
      dump=Qnil;
   else
      dump=rb_str_new2(ptr);
   kc_free(ptr);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
   return rb_ary_new3(2,dump,INT2FIX(retval));
}

.encoding(*args) ⇒ `Object`

KontoCheckRaw::encoding( [mode])

KontoCheck::encoding( [mode])

KontoCheckRaw::encoding_str( [mode])

KontoCheckRaw::keep_raw_data( mode)

Diese Funktion legt den benutzten Zeichensatz für Fehlermeldungen durch die Funktion KontoCheckRaw::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 gelöscht und abgefragt werden.

Aufruf:

KontoCheckRaw::encoding( [mode])

Parameter:

mode: die gewünschte Kodierung. Falls der Parameter nicht angegeben wird, wird die aktuelle Kodierung zurückgegeben. Ansonsten werden für den Parameter mode die folgenden Werte akzeptiert (die Strings sind nicht case sensitiv; Mi oder mI oder MI ist z.B. auch möglich.
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ückgabe:

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

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1222

static VALUE encoding_rb(int argc,VALUE* argv,VALUE self)
{
   return INT2FIX(kto_check_encoding(enc_mode(argc,argv)));
}

.encoding_str(*args) ⇒ `Object`

KontoCheckRaw::encoding_str( mode)

KontoCheck::encoding_str( mode)

KontoCheckRaw::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.

Aufruf:

KontoCheckRaw::encoding_str( [mode])

Parameter:

wie bei KontoCheckRaw::encoding()

Rückgabe:

Rückgabewert ist die aktuelle Kodierung als String:

“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”;

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1268

static VALUE encoding_str_rb(int argc,VALUE* argv,VALUE self)
{
   return rb_str_new2((kto_check_encoding_str(enc_mode(argc,argv))));
}

.free ⇒ `Object`

KontoCheckRaw::free()

KontoCheck::free()

Diese Funktion gibt allen allokierten Speicher wieder frei. Der Rückgabewert ist immer true.

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 963

static VALUE free_rb(VALUE self)
{
   lut_cleanup();
   return Qtrue;
}

.generate_lutfile(*args) ⇒ `Object`

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

KontoCheck::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:

Aufruf:

Parameter:

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

0. BLZ,PZ
1. BLZ,PZ,NAME_KURZ
2. BLZ,PZ,NAME_KURZ,BIC
3. BLZ,PZ,NAME,PLZ,ORT
4. BLZ,PZ,NAME,PLZ,ORT,BIC
5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
   AENDERUNG
8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,
   AENDERUNG,LOESCHUNG
9. 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

Rückgabe:

Mögliche Statuscodes:

-112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde 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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1018

static VALUE generate_lutfile_rb(int argc,VALUE* argv,VALUE self)
{
   char input_name[FILENAME_MAX+1],output_name[FILENAME_MAX+1],iban_blacklist[FILENAME_MAX+1];
   char user_info[256],gueltigkeit[20],buffer[16],error_msg[512];
   int retval,felder,filialen,set,len;
   VALUE input_name_rb,output_name_rb,user_info_rb,
         gueltigkeit_rb,felder_rb,filialen_rb,set_rb,iban_blacklist_rb;

   rb_scan_args(argc,argv,"26",&input_name_rb,&output_name_rb,
         &user_info_rb,&gueltigkeit_rb,&felder_rb,&filialen_rb,&set_rb,&iban_blacklist_rb);

   if(TYPE(input_name_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(input_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
      strncpy(input_name,RSTRING_PTR(input_name_rb),len);
      *(input_name+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given input filename.");

   if(TYPE(output_name_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(output_name_rb))>FILENAME_MAX)len=FILENAME_MAX;
      strncpy(output_name,RSTRING_PTR(output_name_rb),len);
      *(output_name+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given output filename.");

   if(NIL_P(user_info_rb)){
      *user_info=0;
   }
   else if(TYPE(user_info_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(user_info_rb))>255)len=255;
      strncpy(user_info,RSTRING_PTR(user_info_rb),len);
      *(user_info+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given user_info string.");

   if(NIL_P(gueltigkeit_rb)){
      *gueltigkeit=0;
   }
   else if(TYPE(gueltigkeit_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(gueltigkeit_rb))>19)len=19;
      strncpy(gueltigkeit,RSTRING_PTR(gueltigkeit_rb),len);
      *(gueltigkeit+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given gueltigkeit string.");

   if(NIL_P(felder_rb))
      felder=DEFAULT_LUT_FIELDS_NUM;
   else if(TYPE(felder_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(felder_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(felder_rb),len);
      *(buffer+len)=0;
      felder=atoi(buffer);
   }
   else
      felder=NUM2INT(felder_rb);

   if(NIL_P(filialen_rb))
      filialen=0;
   else if(TYPE(filialen_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(felder_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(filialen_rb),len);
      *(buffer+len)=0;
      filialen=atoi(buffer);
   }
   else
      filialen=NUM2INT(filialen_rb);

   if(NIL_P(set_rb))
      set=0;
   else if(TYPE(set_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(set_rb))>15)len=15;
      strncpy(buffer,RSTRING_PTR(set_rb),len);
      *(buffer+len)=0;
      set=atoi(buffer);
   }
   else
      set=NUM2INT(set_rb);

   if(NIL_P(iban_blacklist_rb)){
      *iban_blacklist=0;
   }
   else if(TYPE(iban_blacklist_rb)==RUBY_T_STRING){
      if((len=RSTRING_LEN(iban_blacklist_rb))>FILENAME_MAX)len=FILENAME_MAX;
      strncpy(iban_blacklist,RSTRING_PTR(iban_blacklist_rb),len);
      *(iban_blacklist+len)=0;
   }
   else
      rb_raise(rb_eTypeError,"%s","Unable to convert given iban file name to string.");

   retval=generate_lut2_p(input_name,output_name,user_info,gueltigkeit,felder,filialen,0,0,set);
   if(retval<0)RUNTIME_ERROR(retval);
   if(*iban_blacklist)lut_keine_iban_berechnung(iban_blacklist,output_name,0);
   return INT2FIX(retval);
}

.iban2bic(*args) ⇒ `Object`

KontoCheckRaw::iban2bic( iban)

KontoCheck::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/

Aufruf:

ret=KontoCheckRaw::iban2bic( iban)

Parameter:

iban: die IBAN, zu der der entsprechende BIC bestimmt werden soll.

Rückgabe:

Der Rückgabewert ist ein Array mit vier Elementen: im ersten steht der BIC, im zweiten ein Statuscode, im dritten die BLZ und im vierten die Kontonummer (die beiden letzteren werden aus der IBAN extrahiert). Im Fehlerfall wird für BIC, BLZ und Kontonummer nil zurückgegeben.

Mögliche Statuscodes:

-68 (IBAN2BIC_ONLY_GERMAN) “Die Funktion iban2bic() arbeitet nur mit deutschen Bankleitzahlen”
-46 (LUT2_BIC_NOT_INITIALIZED) “Das Feld BIC wurde nicht initialisiert”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-5 (INVALID_BLZ_LENGTH) “die Bankleitzahl ist nicht achtstellig”
-4 (INVALID_BLZ) “die Bankleitzahl ist ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1635

static VALUE iban2bic_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[128],blz[10],kto[16];
//   char error_msg[512];
   const char *bic;
   int retval;

   get_params(argc,argv,iban,NULL,NULL,NULL,3);
   bic=iban2bic(iban,&retval,blz,kto);
   return rb_ary_new3(4,!*bic?Qnil:rb_str_new2(bic),INT2FIX(retval),
         !*blz?Qnil:rb_str_new2(blz),!*kto?Qnil:rb_str_new2(kto));
}

.iban_check(*args) ⇒ `Object`

KontoCheckRaw::iban_check( iban)

KontoCheck::iban_check( iban)

Diese Funktion testet eine IBAN; bei deutschen Bankverbindungen wird zusätzlich noch die Plausibilität der Bankverbindung getestet und im Statuswert zurückgegeben. Die Rückgabe ist ein Array mit zwei Elementen: im ersten (retval) wird das Testergebnis für die IBAN zurückgegeben, im zweiten (bei deutschen Bankverbindungen) das Testergebnis des Kontotests.

Aufruf:

ret=KontoCheckRaw::iban_check( iban)

Parameter:

iban: die IBAN, die getestet werden soll

Rückgabe:

Rückgabe ist ein Array mit zwei Elementen:

das erste Element enthält den Statuscode für den IBAN-Test
das zweite Element enthält den Statuscode für den Test der Bankverbindung (nur für deutsche Kontoverbindungen)

Mögliche Rückgabewerte für den IBAN-Test:

-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”

Mögliche Rückgabewerte für den Kontotest:

-77 (BAV_FALSE) “BAV denkt, das Konto ist falsch (konto_check hält es für richtig)”
-74 (NO_GERMAN_BIC) “Ein Konto kann kann nur für deutsche Banken geprüft werden”
-69 (MISSING_PARAMETER) “Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-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 (Unter)Methode ist nicht definiert”
-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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1858

static VALUE iban_check_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[128];
   int retval,retval_kc;

   get_params(argc,argv,iban,NULL,NULL,NULL,3);
   retval=iban_check(iban,&retval_kc);
   return rb_ary_new3(2,INT2FIX(retval),INT2FIX(retval_kc));
}

.iban_gen(*args) ⇒ `Object`

KontoCheckRaw::iban_gen( blz,kto)

KontoCheck::iban_gen( kto,blz)

Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN, sowie den zugehörigen BIC.

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.

Aufruf:

ret=KontoCheckRaw::iban_gen( blz,kto)

Parameter:

blz: die BLZ, zu der die IBAN generiert werden soll
kto: Kontonummer

Rückgabe:

Rückgabe ist ein Array mit sieben Elementen:

das erste Element enthält die generierten IBAN in komprimierter Form
das zweite Element enthält die generierte IBAN in Papierform (mit eingestreuten Blanks)
das dritte Element enthält den Statuscode der Funktion
das vierte Element enthält den BIC (dieser unterscheidet sich u.U. von demjenigen der BLZ-Datei!!). Dieses und die folgenden Elemente waren ursprünglich nicht in der Funktion enthalten und wurde erst nach Einführung der IBAN-Regeln (Juni 2013) hinzugefügt.
das fünfte Element enthält die verwendete BLZ
das sechste Element enthält die verwendete Kontonummer
das siebte Element enthält die verwendete IBAN-Regel

Mögliche Statuscodes:

-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”
-123 (OLD_BLZ_OK_NEW_NOT) “Die Bankverbindung ist mit der alten BLZ stimmig, mit der Nachfolge-BLZ nicht”
-122 (LUT2_IBAN_REGEL_NOT_INITIALIZED) “Das Feld IBAN-Regel wurde nicht initialisiert”
-120 (LUT2_NO_ACCOUNT_GIVEN) “Keine Bankverbindung/IBAN angegeben”
-113 (NO_OWN_IBAN_CALCULATION) “das Institut erlaubt keine eigene IBAN-Berechnung”
-77 (BAV_FALSE) “BAV denkt, das Konto ist falsch (konto_check hält es für richtig)”
-74 (NO_GERMAN_BIC) “Ein Konto kann kann nur für deutsche Banken geprüft werden”
-69 (MISSING_PARAMETER) “Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-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 nicht definiert”
-3 (INVALID_KTO) “das Konto ist ungültig”
-2 (NOT_IMPLEMENTED) “die Methode wurde noch nicht implementiert”
-1 (NOT_DEFINED) “die (Unter)Methode ist nicht definiert”
0 (FALSE) “falsch”
1 (OK) “ok”
2 (OK_NO_CHK) “ok, ohne Prüfung”
11 (OK_UNTERKONTO_POSSIBLE) “wahrscheinlich ok; die Kontonummer kann allerdings (nicht angegebene) Unterkonten enthalten”
12 (OK_UNTERKONTO_GIVEN) “wahrscheinlich ok; die Kontonummer enthält eine Unterkontonummer”
18 (OK_KTO_REPLACED) “ok; die Kontonummer wurde allerdings ersetzt”
19 (OK_BLZ_REPLACED) “ok; die Bankleitzahl wurde allerdings ersetzt”
20 (OK_BLZ_KTO_REPLACED) “ok; die Bankleitzahl und Kontonummer wurde allerdings ersetzt”
21 (OK_IBAN_WITHOUT_KC_TEST) “ok; die Bankverbindung ist (ohne Test) als richtig anzusehen”
22 (OK_INVALID_FOR_IBAN) “ok; für IBAN ist (durch eine Regel) allerdings ein anderer BIC definiert”
24 (OK_KTO_REPLACED_NO_PZ) “ok; die Kontonummer wurde ersetzt, die neue Kontonummer hat keine Prüfziffer”
25 (OK_UNTERKONTO_ATTACHED) “ok; es wurde ein (weggelassenes) Unterkonto angefügt”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1721

static VALUE iban_gen_rb(int argc,VALUE* argv,VALUE self)
{
   char iban[128],*papier,*ptr,*dptr,blz[20],kto[20],blz2[20],kto2[20];
   const char *bic;
   int retval,regel;
   VALUE iban_rb,papier_rb,bic_rb,blz2_rb,kto2_rb;

   get_params(argc,argv,blz,kto,NULL,NULL,2);
   papier=iban_bic_gen(blz,kto,&bic,blz2,kto2,&retval);
   regel=-1;
   if(retval>0){
      for(ptr=papier,dptr=iban;*ptr;ptr++)if(*ptr!=' ')*dptr++=*ptr;
      *dptr=0;
      iban_rb=rb_str_new2(iban);
      papier_rb=rb_str_new2(papier);
      bic_rb=rb_str_new2(bic);
      blz2_rb=rb_str_new2(blz2);
      kto2_rb=rb_str_new2(kto2);
      kc_free(papier);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
      regel=lut_iban_regel(blz,0,NULL)/100;
   }
   else
      iban_rb=papier_rb=blz2_rb=kto2_rb=bic_rb=Qnil;
   return rb_ary_new3(7,iban_rb,papier_rb,INT2FIX(retval),bic_rb,blz2_rb,kto2_rb,INT2FIX(regel));
}

.init(*args) ⇒ `Object`

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

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

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.

Aufruf:

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

Beispielsaufrufe:

ret=KontoCheckRaw::init
ret=KontoCheckRaw::init( 5)
ret=KontoCheckRaw::init( “/etc/blz.lut”)
ret=KontoCheckRaw::init( 3,“/etc/blz.lut”)
ret=KontoCheckRaw::init( “/etc/blz.lut”,9,2)

Parameter:

Die Variablen p1 und p2 stehen für den Initialisierungslevel und den Dateinamen der LUT-Datei (in beliebiger Reihenfolge); die Zuordnung der beiden Parameter erfolgt on the fly durch eine Typüberprüfung. Der Dateiname ist immer als String anzugeben, der Initialisierungslevel immer als Zahl, ansonsten gibt es eine TypeError Exception. Auf diese Weise ist es eindeutig möglich festzustellen, wie die Parameter p1 und p2 den Variablen lutfile und level zuzuordnen sind.

Der Initialisierungslevel ist eine Zahl zwischen 0 und 9, die die zu ladenden Blocks angibt. Die folgenden Werte sind definiert:

0. BLZ,PZ
1. BLZ,PZ,NAME_KURZ
2. BLZ,PZ,NAME_KURZ,BIC
3. BLZ,PZ,NAME,PLZ,ORT
4. BLZ,PZ,NAME,PLZ,ORT,BIC
5. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC
6. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ
7. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG
8. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
   LOESCHUNG
9. BLZ,PZ,NAME_NAME_KURZ,PLZ,ORT,BIC,NACHFOLGE_BLZ,AENDERUNG,
   LOESCHUNG,PAN,NR

Der Parameter set bezeichnet den zu ladenden Datensatz (1 oder 2) der LUT-Datei. Falls der Parameter set nicht angegeben oder 0 ist, wird versucht, das aktuell gültige Set aus dem Systemdatum und dem Gültigkeitszeitraum der in der LUT-Datei gespeicherten Sets zu bestimmen.

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.

Rückgabe:

Es wird ein skalarer Statuscode zurückgegeben, der Auskunft über die Initialisierung bzw. aufgetretene Fehler gibt.

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)”
-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; in vielen Situationen ist dies mehr eine Warnung, nicht ein Fehler.

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 902

static VALUE init(int argc,VALUE* argv,VALUE self)
{
   char lut_name[FILENAME_MAX+1],error_msg[512];
   int retval,level,set;

   get_params_file(argc,argv,lut_name,&level,&set,1);
   retval=lut_init(lut_name,level,set);
   switch(retval){
      case OK:
      case LUT1_SET_LOADED:
      case LUT2_PARTIAL_OK:
         break;
      default:
         RUNTIME_ERROR(retval);
   }
   return INT2FIX(retval);
}

.ipi_check(*args) ⇒ `Object`

KontoCheckRaw::ipi_check( zweck)

KontoCheck::ipi_check( zweck)

Die Funktion testet, ob ein Strukturierter Verwendungszweck gültig ist (Anzahl Zeichen, Prüfziffer).

Aufruf:

ret=KontoCheckRaw::ipi_check( zweck)

Parameter:

zweck: der Strukturierte Verwendungszweck, der getestet werden soll

Rückgabe:

Zurückgegeben wird ein skalarer Statuscode.

Mögliche Statuscodes:

-73 (IPI_CHECK_INVALID_LENGTH) “Der zu validierende strukturierete Verwendungszweck muß genau 20 Zeichen enthalten”
0 (FALSE) “falsch”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1937

static VALUE ipi_check_rb(int argc,VALUE* argv,VALUE self)
{
   char zweck[128];

   get_params(argc,argv,zweck,NULL,NULL,NULL,3);
   return INT2FIX(ipi_check(zweck));
}

.ipi_gen(*args) ⇒ `Object`

KontoCheckRaw::ipi_gen( zweck)

KontoCheck::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.

ACHTUNG Die Reihenfolge der Parameter dieser Funktion hat sich in Version 0.2.2 geändert; der Statuscode wird nun als letzter Arraywert zurückgegeben, die Papierform als zweiter Wert (wie bei iban_gen(). Es ist nicht schön,so allerdings insgesamt konsistenter (ich habe auch eine Abneigung gegen Änderungen des Interfaces, aber an dieser Stelle schien es geboten zu sein).

Aufruf:

ret=KontoCheckRaw::ipi_gen( zweck)

Parameter:

zweck: String für den ein Strukturierter Verwendungszweck generiert werden soll. Der String für den Strukturierten Verwendungszweck darf maximal 18 Byte lang sein und nur alphanumerische Zeichen enthalten (also auch keine Umlaute).

Rückgabe:

Der Rückgabewert ist ein Array mit drei Elementen:

im ersten steht der Strukturierte Verwendungszweck,
im zweiten die Papierform (mit eingestreuten Blanks).
im dritten ein Statuscode

Mögliche Statuscodes:

-71 (IPI_INVALID_LENGTH) “Die Länge des IPI-Verwendungszwecks darf maximal 18 Byte sein”
-72 (IPI_INVALID_CHARACTER) “Im strukturierten Verwendungszweck dürfen nur alphanumerische Zeichen vorkommen”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1902

static VALUE ipi_gen_rb(int argc,VALUE* argv,VALUE self)
{
   char zweck[24],dst[24],papier[30];
   int retval;

   get_params(argc,argv,zweck,NULL,NULL,NULL,4);
   retval=ipi_gen(zweck,dst,papier);
   if(retval==OK)
      return rb_ary_new3(3,rb_str_new2(dst),rb_str_new2(papier),INT2FIX(retval));
   else
      return rb_ary_new3(3,Qnil,Qnil,INT2FIX(retval));
}

.keep_raw_data(mode_rb) ⇒ `Object`

KontoCheckRaw::keep_raw_data( mode)

KontoCheckRaw::encoding( mode)

KontoCheck::encoding( mode)

Diese Funktion setzt bzw. liest das Flag keep_raw_data in der C-Bibliothek. Falls es gesetzt ist, werden werden die Rohdaten der Blocks Name, Kurzname und Ort im Speicher gehalten; bei einem Wechsel der Kodierung werden diese Blocks dann auch auf die neue Kodierung umgesetzt. Für die Speicherung der Blocks werden allerdings etwa 900 KB Hauptspeicher benötigt, die andernfalls wieder freigegeben würden.

Da diese Funktion etwas exotisch ist, ist sie nur in der KontoCheckRaw Bibliothek enthalten, nicht in KontoCheck.

Aufruf:

retval=KontoCheck::encoding( mode)

Parameter:

Das Verhalten der Funktion wird durch den Parameter mode gesteuert:

-1: Flag keep_raw_data ausschalten
1: Flag keep_raw_data einschalten
0/nil: Flag lesen

Mögliche Rückgabewerte

Der Rückgabewert ist true oder false.

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1300

static VALUE keep_raw_data_rb(VALUE self, VALUE mode_rb)
{
   int t,mode;

   if(NIL_P(mode_rb))
      mode=0;
   else if((t=TYPE(mode_rb))==RUBY_T_STRING)
      mode=*(RSTRING_PTR(mode_rb))-'0';
   else if(t==RUBY_T_FLOAT || t==RUBY_T_FIXNUM || t==RUBY_T_BIGNUM)
      mode=FIX2INT(mode_rb);
   else  /* nicht unterstützter Typ */
      mode=0;
   return keep_raw_data(mode)?Qtrue:Qfalse;
}

.konto_check(*args) ⇒ `Object`

KontoCheckRaw::konto_check( blz, kto)

KontoCheck::konto_check( blz, kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.

Aufruf:

ret=KontoCheckRaw::konto_check( blz, kto)

Parameter:

blz: Die Bankleitzahl der zu testenden Bankverbindung
kto: Die Kontonummer der zu testenden Bankverbindung

Rückgabe:

Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält.

Mögliche Statuscodes:

-77 BAV_FALSE “BAV denkt, das Konto ist falsch (konto_check hält es für richtig)”
-69 MISSING_PARAMETER “Bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)”
-40 LUT2_NOT_INITIALIZED “die Programmbibliothek wurde noch nicht initialisiert”
-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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 556

static VALUE konto_check(int argc,VALUE* argv,VALUE self)
{
   char kto[16],blz[16],error_msg[512];
   int retval;

   get_params(argc,argv,blz,kto,NULL,NULL,2);
   if((*blz=='0' || strlen(blz)!=8) && lut_blz(kto+2,0)==OK)   /* BLZ/Kto vertauscht, altes Interface */
      rb_raise(rb_eRuntimeError,"%s","It seems that you use the old interface of konto_check?\n"
            "Please check the order of function arguments for konto_test(); should be (blz,kto)");
   if((retval=kto_check_blz(blz,kto))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

.konto_check_pz(*args) ⇒ `Object`

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

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

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

Aufruf:

ret=KontoCheckRaw::konto_check_pz( pz, kto [,blz])

Parameter:

pz: Prüfzifferverfahren das benutzt werden soll
kto: Kontonummer die getestet werden soll
blz: Dieser Parameter ist nur für die Verfahren 52, 53, B6 und C0 notwendig; bei allen anderen Prüfzifferverfahren wird er ignoriert. Bei diesen Verfahren geht die BLZ in die Berechnung der Prüfziffer ein. Wird der Parameter bei einem dieser Verfahren nicht angegeben, wird stattdessen eine Test-BLZ (wie in der Beschreibung der Prüfziffermethoden von der Deutschen Bundesbank angegeben) eingesetzt.

Rückgabe:

Die Funktion gibt einen skalaren Statuscode zurück, der das Ergebnis der Prüfung enthält.

Mögliche Statuscodes:

-77 (BAV_FALSE) “BAV denkt, das Konto ist falsch (konto_check hält es für richtig)”
-69 (MISSING_PARAMETER) “bei der Kontoprüfung fehlt ein notwendiger Parameter (BLZ oder Konto)”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 516

static VALUE konto_check_pz(int argc,VALUE* argv,VALUE self)
{
   char pz[16],blz[16],kto[16],error_msg[512];
   int retval;

   get_params(argc,argv,pz,kto,blz,NULL,5);
   if((retval=kto_check_pz(pz,kto,blz))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

.konto_check_regel(*args) ⇒ `Object`

KontoCheckRaw::konto_check_regel( blz, kto)

KontoCheckRaw::konto_check_regel_dbg( blz, kto)

KontoCheck::konto_check_regel( blz, kto)

KontoCheck::konto_check_regel?( blz, kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U. BLZ und/oder Kontonummer ersetzt.

Aufruf:

ret=KontoCheckRaw::konto_check_regel( blz, kto)

Parameter:

blz: Die Bankleitzahl der zu testenden Bankverbindung
kto: Die Kontonummer der zu testenden Bankverbindung

Rückgabe:

Rückgabe ist ein skalarer Statuswert, der das Ergebnis der Prüfung enthält. Es sind auch die Rückgabewerte der Initialisierung möglich (wegen iban_init()), deshalb gibt es so viele mögliche Rückgabewerte.

Mögliche Statuscodes:

-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 wurde 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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 631

static VALUE konto_check_regel(int argc,VALUE* argv,VALUE self)
{
   char kto[16],blz[16],error_msg[512];
   int retval;

   get_params(argc,argv,blz,kto,NULL,NULL,2);
   if((retval=kto_check_regel(blz,kto))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return INT2FIX(retval);
}

.konto_check_regel_dbg(*args) ⇒ `Object`

KontoCheckRaw::konto_check_regel_dbg( blz, kto)

KontoCheckRaw::konto_check_regel( blz, kto)

KontoCheck::konto_check_regel( blz, kto)

KontoCheck::konto_check_regel?( blz, kto)

Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält. Vor der Prüfung werden die IBAN-Regeln angewendet; dabei wird u.U. BLZ und/oder Kontonummer ersetzt. Die Funktion gibt viele Interna

zurück und ist daher nur in der KontoCheckRaw: Bibliothek enthalten.

Aufruf:

ret=KontoCheckRaw::konto_check_regel_dbg( blz, kto)

Parameter:

blz: Die Bankleitzahl der zu testenden Bankverbindung
kto: Die Kontonummer der zu testenden Bankverbindung

Rückgabe:

Rückgabe ist ein Array mit 10 Elementen, der das Ergebnis der Prüfung sowie eine Reihe interner Werte enthält. Für den Statuscode sind auch die Rückgabewerte der Initialisierung möglich (wegen iban_init()), deshalb gibt es so viele mögliche Werte.

das erste Element enthält den Statuscode
das zweite Element enthält die benutzte BLZ (die BLZ wird durch die IBAN-Regeln u.U. ersetzt)
das dritte Element enthält die benutzte Kontonummer (wird manchmal auch ersetzt)
das vierte Element enthält den BIC der Bank
das fünfte Element enthält die benutzte IBAN-Regel
das sechste Element enthält die Regel-Version
das siebte Element enthält Prüfziffermethode als Text
das achte Element enthält die Prüfziffermethode (numerisch)
das neunte Element enthält die Prüfziffer
das zehnte Element enthält die Position der Prüfziffer

Mögliche Statuscodes:

-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 wurde 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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 714

static VALUE konto_check_regel_dbg(int argc,VALUE* argv,VALUE self)
{
   char kto[16],blz[16],kto2[16],blz2[16],error_msg[512];
   const char *bic2;
   int retval,regel;
   RETVAL rv;

   get_params(argc,argv,blz,kto,NULL,NULL,2);
   if((retval=kto_check_regel_dbg(blz,kto,blz2,kto2,&bic2,&regel,&rv))==LUT2_NOT_INITIALIZED || retval==MISSING_PARAMETER)RUNTIME_ERROR(retval);
   return rb_ary_new3(10,INT2FIX(retval),rb_str_new2(blz2),rb_str_new2(kto2),rb_str_new2(bic2),INT2FIX(regel/100),INT2FIX(regel%100),
         rv.methode?rb_str_new2(rv.methode):Qnil,INT2FIX(rv.pz_methode),INT2FIX(rv.pz),INT2FIX(rv.pz_pos));
}

.load_bank_data(path_rb) ⇒ `Object`

KontoCheckRaw::load_bank_data( datafile)

KontoCheck::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 generierte 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 ohne Generierung der Indexblocks; mit Indexblocks macht es noch wesentlich mehr aus) und hat eine Reihe weiterer Vorteile. So ist es z.B. möglich, zwei 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ß.

Aufruf:

retval=KontoCheckRaw::load_bank_data( datafile)

Parameter:

der alte Parameter datafile ist die BLZ-Datei der Deutschen Bundesbank; er wird ignoriert.

Rückgabe:

es erfolgt keine Rückgabe, sondern es wird nur eine runtime Exception generiert, daß scheinbar das alte Interface benutzt wurde, dieses aber nicht mehr unterstützt wird.

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1598

static VALUE load_bank_data(VALUE self, VALUE path_rb)
{
   rb_raise(rb_eRuntimeError,"%s","Perhaps you used the old interface of konto_check.\n"
         "Use KontoCheck::init() to initialize the library\n"
         "and check the order of function arguments for konto_test(blz,kto)");
}

.lut_blocks(*args) ⇒ `Object`

KontoCheckRaw::lut_blocks( mode)

KontoCheck::lut_blocks( mode)

Die Funktion gibt Auskunft, ob bei der Initialisierung alle angeforderten Blocks der LUT-Datei geladen wurden und gibt den Dateinamen der LUT-Datei, eine Liste der geladenen Blocks sowie eine Liste der Blocks die nicht geladen werden konnten, zurück.

Aufruf:

ret=KontoCheckRaw::lut_blocks( mode)

Parameter:

mode: Ausgabeformat (1..3)

Rückgabe:

Rückgabe ist ein Array mit vier Elementen, das den Statuscode sowie drei Strings mit dem Dateinamen sowie den Blocklisten enthält:

das erste Element enthält den Statuscode
das zweite Element enthält den Dateinamen der verwendeten LUT-Datei
das dritte Element enthält eine Liste der geladenen LUT-Blocks
das vierte Element enthält eine Liste der LUT-Blocks, die nicht geladen werden konnten

Mögliche Statuscodes:

-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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 756

static VALUE lut_blocks_rb(int argc,VALUE* argv,VALUE self)
{
   char *lut_filename,*lut_blocks_ok,*lut_blocks_fehler;
   int mode,retval;
   VALUE mode_rb,filename_rb,blocks_ok_rb,blocks_fehler_rb;

   rb_scan_args(argc,argv,"01",&mode_rb);
   if(NIL_P(mode_rb))
      mode=1;
   else{
      switch(TYPE(mode_rb)){
         case RUBY_T_FLOAT:
         case RUBY_T_FIXNUM:
         case RUBY_T_BIGNUM:
            mode=NUM2INT(mode_rb);
            break;
         default:
            mode=1;
            rb_raise(rb_eTypeError,"%s","lut_blocks() requires an int parameter");
            break;
      }
   }

   if((retval=lut_blocks(mode,&lut_filename,&lut_blocks_ok,&lut_blocks_fehler))==LUT2_NOT_INITIALIZED || retval==ERROR_MALLOC)
      filename_rb=blocks_ok_rb=blocks_fehler_rb=Qnil;
   else{
      filename_rb=rb_str_new2(lut_filename);
      blocks_ok_rb=rb_str_new2(lut_blocks_ok);
      blocks_fehler_rb=rb_str_new2(lut_blocks_fehler);
      kc_free(lut_filename);
      kc_free(lut_blocks_ok);
      kc_free(lut_blocks_fehler);
   }
   return rb_ary_new3(4,INT2FIX(retval),filename_rb,blocks_ok_rb,blocks_fehler_rb);
}

.lut_blocks1(*args) ⇒ `Object`

KontoCheckRaw::lut_blocks1( )

KontoCheckRaw::lut_blocks( mode)

KontoCheck::lut_blocks( )

Diese Funktion entspricht weitgehend der Funktion lut_blocks(); sie gibt allerdings nur den Statuscode zurück, keine Strings. Sie wird für die Funktion KontoCheck::lut_blocks() benutzt.

Parameter:

keine

Rückgabe:

Rückgabe ist ein Integerwert, der Aufschluß über den aktuellen Stand der Initialisierung gibt.

Mögliche Statuscodes:

-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”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 812

static VALUE lut_blocks1_rb(int argc,VALUE* argv,VALUE self)
{
   rb_scan_args(argc,argv,"0");
   return INT2FIX(lut_blocks(0,NULL,NULL,NULL));
}

.lut_info(*args) ⇒ `Object`

KontoCheckRaw::lut_info( [lutfile])

KontoCheck::lut_info()

KontoCheck::lut_info1( lutfile)

KontoCheck::lut_info2( lutfile)

Diese Funktion liefert Informationen über die Datensätze sowie die beiden Infoblocks einer LUT-Date oder die in den Speicher geladenen Blocks.

Aufruf:

ret=KontoCheckRaw::lut_info( [lutfile])

Parameter:

lutfile: Name der LUT-Datei, falls angegeben. Falls der Parameter weggelassen wird, werden Infnos über die geladenen Blocks zurückgegeben.

Rückgabe:

Der Rückgabewert ist ein Array mit 5 Elementen:

das erste Element (retval) enthält den Statuscode für die Funktion insgesamt
das zweite Element (valid1) enthält den Gültigkeitscode für den ersten Block
das dritte Element (valid2) enthält den Gültigkeitscode für den zweiten Block
das vierte Element (info1) enthält den erster Infoblock, oder nil, falls der Block nicht existiert
das fünfte Element (info2) enthält den zweiter Infoblock, oder nil, falls der Block nicht existiert

Mögliche Statuscodes für valid1 and valid2:

-105 (LUT2_NO_LONGER_VALID_BETTER) “Beide Datensätze sind nicht mehr gültig; dieser ist aber jünger als der andere”
-59 (LUT2_NOT_YET_VALID) “Der Datenblock ist noch nicht gültig”
-58 (LUT2_NO_LONGER_VALID) “Der Datenblock ist nicht mehr gültig”
-34 (LUT2_BLOCK_NOT_IN_FILE) “Die LUT-Datei enthält den Infoblock nicht”
4 (LUT2_VALID) “Der Datenblock ist aktuell gültig”
5 (LUT2_NO_VALID_DATE) “Der Datenblock enthält kein Gültigkeitsdatum”

Mögliche Werte für den Statuscode retval:

-112 (KTO_CHECK_UNSUPPORTED_COMPRESSION) “die notwendige Kompressions-Bibliothek wurde beim Kompilieren nicht eingebunden”
-10 (FILE_READ_ERROR) “kann Datei nicht lesen”
-70 (LUT1_FILE_USED) “Es wurde eine LUT-Datei im Format 1.0/1.1 geladen”
-40 (LUT2_NOT_INITIALIZED) “die Programmbibliothek wurde noch nicht initialisiert”
-37 (LUT2_Z_BUF_ERROR) “Buffer error in den ZLIB Routinen”
-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”
-31 (LUT2_FILE_CORRUPTED) “Die LUT-Datei ist korrumpiert”
-20 (LUT_CRC_ERROR) “Prüfsummenfehler in der blz.lut Datei”
-9 (ERROR_MALLOC) “kann keinen Speicher allokieren”
-7 (INVALID_LUT_FILE) “die blz.lut Datei ist inkosistent/ungültig”
1 (OK) “ok”

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1538

static VALUE lut_info_rb(int argc,VALUE* argv,VALUE self)
{
   char lut_name[FILENAME_MAX+1],*info1,*info2,error_msg[512];
   int retval,valid1,valid2;
   VALUE info1_rb,info2_rb;

   get_params_file(argc,argv,lut_name,NULL,NULL,3);
   retval=lut_info(lut_name,&info1,&info2,&valid1,&valid2);
   if(!info1)
      info1_rb=Qnil;
   else
      info1_rb=rb_str_new2(info1);
   if(!info2)
      info2_rb=Qnil;
   else
      info2_rb=rb_str_new2(info2);
   kc_free(info1);  /* die C-Funktion allokiert Speicher, der muß wieder freigegeben werden */
   kc_free(info2);
   if(retval<0)RUNTIME_ERROR(retval);
   return rb_ary_new3(5,INT2FIX(retval),INT2FIX(valid1),INT2FIX(valid2),info1_rb,info2_rb);
}

.retval2dos(retval) ⇒ `Object`

KontoCheckRaw::retval2dos( retval)

KontoCheck::retval2dos( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2dos( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1396

static VALUE retval2dos_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2dos(FIX2INT(retval)));
}

.retval2html(retval) ⇒ `Object`

KontoCheckRaw::retval2html( retval)

KontoCheck::retval2html( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2html( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1417

static VALUE retval2html_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2html(FIX2INT(retval)));
}

.retval2iso(retval) ⇒ `Object`

KontoCheckRaw::retval2iso( retval)

KontoCheck::retval2iso( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2iso( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1354

static VALUE retval2iso_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2iso(FIX2INT(retval)));
}

.retval2txt(retval) ⇒ `Object`

KontoCheckRaw::retval2txt( retval)

KontoCheck::retval2txt( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2txt( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1333

static VALUE retval2txt_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2txt(FIX2INT(retval)));
}

.retval2txt_short(retval) ⇒ `Object`

KontoCheckRaw::retval2txt_short( retval)

KontoCheck::retval2txt_short( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2txt_short( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1375

static VALUE retval2txt_short_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2txt_short(FIX2INT(retval)));
}

.retval2utf8(retval) ⇒ `Object`

KontoCheckRaw::retval2utf8( retval)

KontoCheck::retval2utf8( retval)

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

Aufruf:

retval_str=KontoCheckRaw::retval2utf8( retval)

Parameter:

retval: der zu konvertierende numerische Rückgabewert

Rückgabe:

String, der dem Rückgabewert entspricht

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 1438

static VALUE retval2utf8_rb(VALUE self, VALUE retval)
{
   return rb_str_new2(kto_check_retval2utf8(FIX2INT(retval)));
}

.version(*args) ⇒ `Object`

KontoCheckRaw::version( [mode] )

KontoCheck::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)

# File 'ext/konto_check_raw/konto_check_raw_ruby.c', line 2971

static VALUE version_rb(int argc,VALUE* argv,VALUE self)
{
   int level;
   VALUE level_rb;

   rb_scan_args(argc,argv,"01",&level_rb);
   if(NIL_P(level_rb))
      level=0;
   else
      level=NUM2INT(level_rb);
   return rb_str_new2(get_kto_check_version_x(level));
}

Module: KontoCheckRaw

Constant Summary collapse

Class Method Summary collapse

KontoCheckRaw::bank_aenderung( blz [,filiale]) =====KontoCheck::bank_aenderung( blz [,filiale]).

KontoCheckRaw::bank_alles( blz [,filiale]) =====KontoCheck::bank_alles( blz [,filiale]).

KontoCheckRaw::bank_bic( blz [,filiale]) =====KontoCheck::bank_bic( blz [,filiale]).

KontoCheckRaw::bank_filialen( blz) =====KontoCheck::bank_filialen( blz).

KontoCheckRaw::bank_loeschung( blz [,filiale]) =====KontoCheck::bank_loeschung( blz [,filiale]).

KontoCheckRaw::bank_nachfolge_blz( blz [,filiale]) =====KontoCheck::bank_nachfolge_blz( blz [,filiale]).

KontoCheckRaw::bank_name( blz [,filiale]) =====KontoCheck::bank_name( blz [,filiale]).

KontoCheckRaw::bank_name_kurz( blz [,filiale]) =====KontoCheck::bank_name_kurz( blz [,filiale]).

KontoCheckRaw::bank_nr( blz [,filiale]) =====KontoCheck::bank_nr( blz [,filiale]).

KontoCheckRaw::bank_ort( blz [,filiale]) =====KontoCheck::bank_ort( blz [,filiale]).

KontoCheckRaw::bank_pan( blz [,filiale]) =====KontoCheck::bank_pan( blz [,filiale]).

KontoCheckRaw::bank_plz( blz [,filiale]) =====KontoCheck::bank_plz( blz [,filiale]).

KontoCheckRaw::bank_pz( blz) =====KontoCheck::bank_pz( blz).

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

KontoCheckRaw::bank_suche_blz( blz1 [,blz2 [,uniq]]) =====KontoCheck::suche().

KontoCheckRaw::bank_suche_multiple( suchtext [,such_cmd] [,uniq]) =====KontoCheck::suche().

KontoCheckRaw::bank_suche_namen( name [,sort_uniq [,sort]]) =====KontoCheck::suche().

KontoCheckRaw::bank_suche_namen_kurz( short_name [,sort_uniq [,sort]]) =====KontoCheck::suche().

KontoCheckRaw::bank_suche_ort( suchort [,uniq]) =====KontoCheck::suche().

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

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

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

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

KontoCheckRaw::bank_valid( blz [,filiale]) ====== KontoCheck::bank_valid( blz [,filiale]) ====== KontoCheck::bank_valid?( blz [,filiale]) Diese Funktion testet, ob eine gegebene BLZ gültig ist.

KontoCheckRaw::bic_check( bic) =====KontoCheck::bic_check( bic) Diese Funktion testet die Existenz eines (deutschen) BIC.

KontoCheckRaw::ci_check( ci) =====KontoCheck::ci_check( ci) Diese Funktion testet eine Gläubiger-Identifikationsnummer (Credit Identifier, ci).

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

KontoCheckRaw::dump_lutfile( lutfile) =====KontoCheck::dump_lutfile( lutfile).

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

KontoCheckRaw::encoding_str( mode) =====KontoCheck::encoding_str( mode) =====KontoCheckRaw::encoding( mode) =====KontoCheckRaw::keep_raw_data( mode).

KontoCheckRaw::free() =====KontoCheck::free().

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

KontoCheckRaw::iban2bic( iban) =====KontoCheck::iban2bic( iban).

KontoCheckRaw::iban_check( iban) =====KontoCheck::iban_check( iban) Diese Funktion testet eine IBAN; bei deutschen Bankverbindungen wird zusätzlich noch die Plausibilität der Bankverbindung getestet und im Statuswert zurückgegeben.

KontoCheckRaw::iban_gen( blz,kto) =====KontoCheck::iban_gen( kto,blz) Diese Funktion generiert aus (deutscher) BLZ und Konto einen IBAN, sowie den zugehörigen BIC.

KontoCheckRaw::init( [p1 [,p2 [,set]]]) =====KontoCheck::init( [p1 [,p2 [,set]]]) Diese Funktion initialisiert die Bibliothek und lädt die gewünschten Datenblocks in den Speicher.

KontoCheckRaw::ipi_check( zweck) =====KontoCheck::ipi_check( zweck).

KontoCheckRaw::ipi_gen( zweck) =====KontoCheck::ipi_gen( zweck).

KontoCheckRaw::keep_raw_data( mode) =====KontoCheckRaw::encoding( mode) =====KontoCheck::encoding( mode).

KontoCheckRaw::konto_check( blz, kto) =====KontoCheck::konto_check( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.

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

KontoCheckRaw::konto_check_regel( blz, kto) =====KontoCheckRaw::konto_check_regel_dbg( blz, kto) =====KontoCheck::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel?( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.

KontoCheckRaw::konto_check_regel_dbg( blz, kto) =====KontoCheckRaw::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel( blz, kto) =====KontoCheck::konto_check_regel?( blz, kto) Test, ob eine BLZ/Konto-Kombination eine gültige Prüfziffer enthält.

KontoCheckRaw::load_bank_data( datafile) =====KontoCheck::load_bank_data( datafile).

KontoCheckRaw::lut_blocks1( ) =====KontoCheckRaw::lut_blocks( mode) =====KontoCheck::lut_blocks( ) Diese Funktion entspricht weitgehend der Funktion lut_blocks(); sie gibt allerdings nur den Statuscode zurück, keine Strings.

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

KontoCheckRaw::retval2dos( retval) =====KontoCheck::retval2dos( retval).

KontoCheckRaw::retval2html( retval) =====KontoCheck::retval2html( retval).

KontoCheckRaw::retval2iso( retval) =====KontoCheck::retval2iso( retval).

KontoCheckRaw::retval2txt( retval) =====KontoCheck::retval2txt( retval).

KontoCheckRaw::retval2txt_short( retval) =====KontoCheck::retval2txt_short( retval).

KontoCheckRaw::retval2utf8( retval) =====KontoCheck::retval2utf8( retval).

KontoCheckRaw::version( [mode] ) =====KontoCheck::version( [mode] ).

Class Method Details

.bank_aenderung(*args) ⇒ Object

KontoCheckRaw::bank_aenderung( blz [,filiale])

KontoCheck::bank_aenderung( blz [,filiale])

.bank_alles(*args) ⇒ Object

KontoCheckRaw::bank_alles( blz [,filiale])

KontoCheck::bank_alles( blz [,filiale])

.bank_bic(*args) ⇒ Object

KontoCheckRaw::bank_bic( blz [,filiale])

KontoCheck::bank_bic( blz [,filiale])

.bank_filialen(*args) ⇒ Object

KontoCheckRaw::bank_filialen( blz)

KontoCheck::bank_filialen( blz)

.bank_loeschung(*args) ⇒ Object

KontoCheckRaw::bank_loeschung( blz [,filiale])

KontoCheck::bank_loeschung( blz [,filiale])

.bank_nachfolge_blz(*args) ⇒ Object

KontoCheckRaw::bank_nachfolge_blz( blz [,filiale])

KontoCheck::bank_nachfolge_blz( blz [,filiale])

.bank_name(*args) ⇒ Object

KontoCheckRaw::bank_name( blz [,filiale])

KontoCheck::bank_name( blz [,filiale])

.bank_name_kurz(*args) ⇒ Object

KontoCheckRaw::bank_name_kurz( blz [,filiale])

.bank_aenderung(*args) ⇒ `Object`

.bank_alles(*args) ⇒ `Object`

.bank_bic(*args) ⇒ `Object`

.bank_filialen(*args) ⇒ `Object`

.bank_loeschung(*args) ⇒ `Object`

.bank_nachfolge_blz(*args) ⇒ `Object`

.bank_name(*args) ⇒ `Object`

.bank_name_kurz(*args) ⇒ `Object`

.bank_nr(*args) ⇒ `Object`

.bank_ort(*args) ⇒ `Object`

.bank_pan(*args) ⇒ `Object`

.bank_plz(*args) ⇒ `Object`

.bank_pz(*args) ⇒ `Object`

.bank_suche_bic(*args) ⇒ `Object`

.bank_suche_blz(*args) ⇒ `Object`

.bank_suche_multiple(*args) ⇒ `Object`

.bank_suche_namen(*args) ⇒ `Object`

.bank_suche_namen_kurz(*args) ⇒ `Object`

.bank_suche_ort(*args) ⇒ `Object`

.bank_suche_plz(*args) ⇒ `Object`

.bank_suche_pz(*args) ⇒ `Object`

.bank_suche_regel(*args) ⇒ `Object`

.bank_suche_volltext(*args) ⇒ `Object`

.bank_valid(*args) ⇒ `Object`

.bic_check(bic_v) ⇒ `Object`

.ci_check(ci_v) ⇒ `Object`

.current_lutfile_name ⇒ `Object`