liberic 0.1.0

data/lib/liberic/helpers.rb

@@ -0,0 +1 @@
+require 'liberic/helpers/invocation'

data/lib/liberic/helpers/invocation.rb

@@ -0,0 +1,27 @@
+module Liberic
+  module Helpers
+    module Invocation
+      class Error < StandardError
+      end
+
+      extend self
+
+      def raise_on_error(value)
+        return value if value == SDK::Fehlercodes::OK
+        raise Error.new(SDK::Fehlercodes::CODES[value])
+      end
+
+      def with_result_buffer(raise_on_error = true, &block)
+        handle = SDK::API.rueckgabepuffer_erzeugen
+        if raise_on_error
+          raise_on_error(yield(handle))
+        else
+          yield(handle)
+        end
+        result = Liberic::SDK::API.rueckgabepuffer_inhalt(handle)
+        SDK::API.rueckgabepuffer_freigeben(handle)
+        result
+      end
+    end
+  end
+end

data/lib/liberic/process.rb

@@ -0,0 +1,105 @@
+module Liberic
+  # +Process+ encapsulates the main functionality of ERiC. (+eric_bearbeite_vorgang+).
+  #
+  # +Process+ must be initialized with an XML string containing the tax filing (or other data to be submitted) as well
+  # as the type of case.
+  #
+  # +Process+ exposes the +check+ method to let ERiC check the validity of the supplied XML schema. An Exception is thrown if
+  # validation fails.
+  #
+  # Calling +check+ is optional. See +execute+ to start the actual execution of the tax case. +execute+ will +check+ as well (not in this library,
+  # but ERiC will do this
+  class Process
+    class ExecutionError < StandardError
+    end
+
+    def initialize(xml, type)
+      @xml = xml
+      @type = type
+    end
+
+    def check
+      Helpers::Invocation.with_result_buffer do |handle|
+        SDK::API.check_xml(@xml, @type, handle)
+      end
+    end
+
+    # Executes the actual call to +EricBearbeiteVorgang()+
+    #
+    # Taken an optional hash with an +:action+ parameter, which can be one of the following:
+    #
+    #   * +:validate+ validate the tax filing and return errors (local processing only)
+    #   * +:print+ validate the tax filing and create summary PDF
+    #   * +:print_and_submit+ validate the tax filing, create summary PDF and submit filing to ELSTER (server).
+    #
+    # Options for controlling the PDF output (printing)
+    #
+    #   * +:filename+     (set a filename including path where to store the PDF file)
+    #   * +:draft+        (set to +false+ to remove the the text "*** ENTWURF ***" on every page)
+    #   * +:footer+       (set a string that will be printed on ever page footer)
+    #   * +:cover_page+   (set to +true+ to include a cover page)
+    #   * +:duplex+       (set to +true+ to generate pages for duplex printing (alternating margin left and right)
+    #
+    # Other options
+    #   * +:encryption+  An instance of +SDK::Types::VerschluesselungsParameter+ (Leave this empty when requesting BescheidRueckuebermittlung with CEZ (locally generated certificate))
+    #                    No use case tested yet.
+    #
+    # TODO: Please note that some parameter combinations might result in errors and will return empty strings for the XML
+    # (these errors are currently not checked). One example is using +draft: false+ with test data
+    #
+    # Set +Liberic.config.data_path+ to the location where the PDF should be stored, if +:filename+ is not provided.
+    #
+    # Example:
+    #
+    #   filing = Liberic::Process.new(xml_tax_filing, 'ESt_2011')
+    #   filing.execute(action: :print)
+    #
+    # Will generate a PDF in the current directory if not specified otherwise.
+    # *WARNING* method signature and parameters are WIP and subject to change
+    def execute(options = {})
+      action = options[:action] ||= :validate
+      eric_action = ACTIONS[action] || (raise ExecutionError.new("Invalid action: #{action}. Valid actions are #{ACTIONS.keys.join(', ')}"))
+      print_params = create_print_params(options)
+      server_buffer = SDK::API.rueckgabepuffer_erzeugen
+      result = Helpers::Invocation.with_result_buffer(true) do |local_buffer|
+        SDK::API.bearbeite_vorgang(@xml, @type,
+          eric_action,
+          print_params,
+          options[:encryption],
+          nil, # transferHandle
+          local_buffer,
+          server_buffer)
+      end
+      server_result = SDK::API.rueckgabepuffer_inhalt(server_buffer)
+      SDK::API.rueckgabepuffer_freigeben(server_buffer)
+      print_params.pointer.free
+      {
+        result: result,
+        server_result: server_result
+      }
+    end
+
+    private
+
+    ACTIONS = {
+      validate: :validiere,
+      print: :drucke,
+      print_and_submit: :sende
+    }
+
+    def create_print_params(options)
+      params = SDK::Types::DruckParameter.new
+      params[:version]     = 2
+      params[:ersteSeite]  = options[:cover_page] ? 1 : 0
+      params[:duplexDruck] = options[:duplex] ? 1 : 0
+      params[:vorschau]    = options.has_key?(:draft) ? (options[:draft] ? 1 : 0) : 1
+      {pdfName: :filename,
+       fussText: :footer}.each do |eric_param, ruby_param|
+        if options[ruby_param]
+          params[eric_param] = FFI::MemoryPointer.from_string(options[ruby_param]).address
+        end
+      end
+      params
+    end
+  end
+end

data/lib/liberic/response.rb

@@ -0,0 +1,2 @@
+require 'liberic/response/errors'
+require 'liberic/response/version'

data/lib/liberic/response/errors.rb

@@ -0,0 +1,9 @@
+module Liberic
+  module Response
+    class ResponseError < StandardError
+    end
+
+    class LibraryNotFound < ResponseError
+    end
+  end
+end

data/lib/liberic/response/version.rb

@@ -0,0 +1,38 @@
+module Liberic
+  module Response
+    class Version
+      VERSION_NS = 'http://www.elster.de/EricXML/1.0/EricVersion'
+
+      attr_reader :response_xml, :response_dom
+      attr_reader :libs
+
+      def initialize(response_xml)
+        @response_xml = response_xml
+        @response_dom = Nokogiri::XML(@response_xml)
+        @libs = @response_dom.xpath('//version:Bibliothek', version: VERSION_NS).map do |lib|
+          fields = Hash[
+            {file: 'Name',
+             product_version: 'Produktversion',
+             file_version: 'Dateiversion'}.map do |key, german_field|
+              [key, lib.xpath("version:#{german_field}", version: VERSION_NS).text]
+            end
+          ]
+
+          fields[:name] = fields[:file].split('.').first
+
+          [:product_version, :file_version].each do |version_type|
+            fields[version_type] = fields[version_type].split(',').map(&:strip).join('.')
+          end
+          fields
+        end
+      end
+
+      def for_library(name)
+        (
+          @libs.find { |lib| lib[:name] == name } ||
+          (raise LibraryNotFound.new("Library #{name} could not be found in this ERiC installation"))
+        )[:product_version]
+      end
+    end
+  end
+end

data/lib/liberic/sdk.rb

@@ -0,0 +1,5 @@
+require 'liberic/sdk/configuration'
+require 'liberic/sdk/fehlercodes'
+require 'liberic/sdk/types'
+require 'liberic/sdk/api'
+require 'liberic/sdk/def'

data/lib/liberic/sdk/api.rb

@@ -0,0 +1,205 @@
+module Liberic
+  module SDK
+    module API
+      extend FFI::Library
+      ffi_lib Liberic.library_path
+
+      def self.attach_eric_function(name, params, return_type, original_name = nil)
+        original_name ||= 'Eric' + name.to_s.capitalize.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+        attach_function(name, original_name, params, return_type)
+      end
+
+      # ERICAPI_DECL int STDCALL EricBearbeiteVorgang(
+      #     const char* datenpuffer,
+      #     const char* datenartVersion,
+      #     uint32_t bearbeitungsFlags,
+      #     const eric_druck_parameter_t* druckParameter,
+      #     const eric_verschluesselungs_parameter_t* cryptoParameter,
+      #     EricTransferHandle* transferHandle,
+      #     EricRueckgabepufferHandle rueckgabeXmlPuffer,
+      #     EricRueckgabepufferHandle serverantwortXmlPuffer);
+      attach_eric_function :bearbeite_vorgang, [:string, :string,
+          Types::BearbeitungFlag,
+          :pointer,
+          :pointer,
+          :pointer,
+
+          :pointer,
+          :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricChangePassword(const char* psePath, const char* oldPin,
+      #     const char* newPin);
+      attach_eric_function :change_password, [:string, :string, :string], :int
+
+      # ERICAPI_DECL int STDCALL EricCheckBuFaNummer(const char* steuernummer);
+      attach_eric_function :check_bu_fa_nummer, [:string], :int
+
+      # ERICAPI_DECL int STDCALL EricCheckXML(const char* xml, const char* datenartVersion,
+      #     EricRueckgabepufferHandle fehlertextPuffer);
+      attach_eric_function :check_xml, [:string, :string, :pointer], :int, :EricCheckXML
+
+      # ERICAPI_DECL int STDCALL EricCloseHandleToCertificate(EricZertifikatHandle hToken);
+      attach_eric_function :close_handle_to_certificate, [:uint], :int
+
+      # TODO
+      # ERICAPI_DECL int STDCALL EricCreateKey(const char* pin, const char* pfad,
+      #    const eric_zertifikat_parameter_t* zertifikatInfo);
+      attach_eric_function :create_key, [:string, :string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricCreateTH(const char* xml, const char* verfahren,
+      #     const char* datenart, const char* vorgang,
+      #     const char* testmerker, const char* herstellerId,
+      #     const char* datenLieferant, const char* versionClient,
+      #     const char* publicKey,
+      #     EricRueckgabepufferHandle xmlRueckgabePuffer);
+      attach_eric_function :create_th, [:string, :string, :string, :string,
+          :string, :string, :string, :string, :string, :pointer], :int, :EricCreateTH
+
+      # ERICAPI_DECL int STDCALL EricDekodiereDaten(
+      #     EricZertifikatHandle zertifikatHandle,
+      #     const char* pin,
+      #     const char* base64Eingabe,
+      #     EricRueckgabepufferHandle rueckgabePuffer);
+      attach_eric_function :dekodiere_daten, [:uint, :string, :string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricEinstellungAlleZuruecksetzen(void);
+      attach_eric_function :einstellung_alle_zuruecksetzen, [:void], :int
+
+      # ERICAPI_DECL int STDCALL EricEinstellungLesen(const char* name,
+      #     EricRueckgabepufferHandle rueckgabePuffer);
+      attach_eric_function :einstellung_lesen, [:string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricEinstellungSetzen(const char* name, const char* wert);
+      attach_eric_function :einstellung_setzen, [:string, :string], :int
+
+      # ERICAPI_DECL int STDCALL EricEinstellungZuruecksetzen(const char* name);
+      attach_eric_function :einstellung_zuruecksetzen, [:string], :int
+
+      # ERICAPI_DECL int STDCALL EricEntladePlugins();
+      attach_eric_function :entlade_plugins, [], :int
+
+      # ERICAPI_DECL int STDCALL EricFormatStNr(const char* eingabeSteuernummer,
+      #     EricRueckgabepufferHandle rueckgabePuffer);
+      attach_eric_function :format_st_nr, [:string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricGetAuswahlListen (const char* datenartVersion, const char* feldkennung,
+      #     EricRueckgabepufferHandle rueckgabeXmlPuffer);
+      attach_eric_function :get_auswahl_listen, [:string, :string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricGetErrormessagesFromXMLAnswer(
+      #     const char* xml,
+      #     EricRueckgabepufferHandle transferticketPuffer,
+      #     EricRueckgabepufferHandle returncodeTHPuffer,
+      #     EricRueckgabepufferHandle fehlertextTHPuffer,
+      #     EricRueckgabepufferHandle returncodesUndFehlertexteNDHXmlPuffer);
+      attach_eric_function :get_errormessages_from_xml_answer, [:string, :pointer, :pointer, :pointer, :pointer], :int, :EricGetErrormessagesFromXMLAnswer
+
+      # ERICAPI_DECL int STDCALL EricGetHandleToCertificate(EricZertifikatHandle* hToken,
+      #     uint32_t* iInfoPinSupport,
+      #     const char* pathToKeystore);
+      attach_eric_function :get_handle_to_certificate, [:pointer, :pointer, :string], :int
+
+      # ERICAPI_DECL int STDCALL EricGetPinStatus(EricZertifikatHandle hToken, uint32_t* pinStatus,
+      #     uint32_t keyType);
+      attach_eric_function :get_pin_status, [:uint, :pointer, :uint], :int
+
+      # TODO
+      # ERICAPI_DECL int STDCALL EricGetPublicKey(const eric_verschluesselungs_parameter_t* cryptoParameter,
+      #     EricRueckgabepufferHandle rueckgabePuffer);
+      # attach_eric_function :get_public_key, [:string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricHoleFehlerText(int fehlerkode,
+      #     EricRueckgabepufferHandle rueckgabePuffer);
+      attach_eric_function :hole_fehler_text, [:int, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricHoleFinanzaemter(const char* finanzamtLandNummer,
+      #     EricRueckgabepufferHandle rueckgabeXmlPuffer);
+      attach_eric_function :hole_finanzaemter, [:string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricHoleFinanzamtLandNummern(EricRueckgabepufferHandle rueckgabeXmlPuffer);
+      attach_eric_function :hole_finanzamt_land_nummern, [:pointer], :int
+
+      # TODO
+      # ERICAPI_DECL int STDCALL EricHoleFinanzamtsdaten(const char bufaNr[5],
+      #     struct  Finanzamtsdaten *finanzamtsdaten);
+
+      # ERICAPI_DECL int STDCALL EricHoleTestfinanzaemter(EricRueckgabepufferHandle rueckgabeXmlPuffer);
+      attach_eric_function :hole_testfinanzaemter, [:pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricHoleZertifikatFingerabdruck(
+      #     const eric_verschluesselungs_parameter_t* cryptoParameter,
+      #     EricRueckgabepufferHandle fingerabdruckPuffer,
+      #     EricRueckgabepufferHandle signaturPuffer);
+      attach_eric_function :hole_zertifikat_fingerabdruck, [:pointer, :pointer, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricKonvertiereZertifikat(const char* pin, const char* pse);
+      attach_eric_function :konvertiere_zertifikat, [:string, :string], :int
+
+      # ERICAPI_DECL int STDCALL EricMakeElsterStnr(const char* steuernrBescheid,
+      #     const char landesnr[2+1],
+      #     const char bundesfinanzamtsnr[4+1],
+      #     EricRueckgabepufferHandle steuernrPuffer);
+      # FIXME: non-pointer string
+      attach_eric_function :make_elster_stnr, [:string, :string, :string, :pointer], :int
+
+      # ERICAPI_DECL int STDCALL EricPruefeBIC(const char* bic);
+      attach_eric_function :pruefe_bic, [:string], :int, :EricPruefeBIC
+
+      # ERICAPI_DECL int STDCALL EricPruefeIBAN(const char* iban);
+      attach_eric_function :pruefe_iban, [:string], :int, :EricPruefeIBAN
+
+      # ERICAPI_DECL int STDCALL EricPruefeIdentifikationsMerkmal(const char* steuerId);
+      attach_eric_function :pruefe_identifikations_merkmal, [:string], :int
+
+      # ERICAPI_DECL int STDCALL EricPruefeSteuernummer(const char* steuernummer);
+      attach_eric_function :pruefe_steuernummer, [:string], :int
+
+      # TODO
+      # ERICAPI_DECL int STDCALL EricRegistriereFortschrittCallback(
+      #     EricFortschrittCallback funktion,
+      #     void* benutzerdaten);
+
+      # TODO
+      # ERICAPI_DECL int STDCALL EricRegistriereGlobalenFortschrittCallback(
+      #     EricFortschrittCallback funktion,
+      #     void* benutzerdaten);
+
+      # typedef void(STDCALL *EricLogCallback)(
+      #         const char* kategorie,
+      #         eric_log_level_t loglevel,
+      #         const char* nachricht,
+      #         void* benutzerdaten);
+      callback :log_callback, [:string, :int, :string, :pointer], :void
+
+      # ERICAPI_DECL int STDCALL EricRegistriereLogCallback(
+      #     EricLogCallback funktion,
+      #     uint32_t schreibeEricLogDatei,
+      #     void* benutzerdaten);
+      attach_eric_function :registriere_log_callback, [:log_callback, :uint, :pointer], :int
+
+      def self.generate_log_callback(&block)
+        FFI::Function.new(:void, [:string, :int, :string, :pointer]) do |category, level, message|
+          block.call(category, level, message)
+        end
+      end
+
+      # ERICAPI_DECL EricRueckgabepufferHandle STDCALL EricRueckgabepufferErzeugen();
+      attach_eric_function :rueckgabepuffer_erzeugen, [], :pointer
+
+      # ERICAPI_DECL int STDCALL EricRueckgabepufferFreigeben(EricRueckgabepufferHandle handle);
+      attach_eric_function :rueckgabepuffer_freigeben, [:pointer], :int
+
+      # ERICAPI_DECL const char* STDCALL EricRueckgabepufferInhalt(EricRueckgabepufferHandle handle);
+      attach_eric_function :rueckgabepuffer_inhalt, [:pointer], :string
+
+      # ERICAPI_DECL uint32_t STDCALL EricRueckgabepufferLaenge(EricRueckgabepufferHandle handle);
+      attach_eric_function :rueckgabepuffer_laenge, [:pointer], :uint
+
+      # ERICAPI_DECL int STDCALL EricSystemCheck();
+      attach_eric_function :system_check, [], :int
+
+      # ERICAPI_DECL int STDCALL EricVersion(EricRueckgabepufferHandle rueckgabeXmlPuffer);
+      attach_eric_function :version, [:pointer], :int
+    end
+  end
+end

data/lib/liberic/sdk/configuration.rb

@@ -0,0 +1,8 @@
+module Liberic
+  module SDK
+    module Configuration
+      LIBERICAPI_VERSION = %w(23.2.12.0 23.3.6.0 23.3.8.0 23.4.10.0)
+      ENCODING = 'iso-8859-15'
+    end
+  end
+end

data/lib/liberic/sdk/def.rb

@@ -0,0 +1,6 @@
+module Liberic
+  module SDK
+    module Def
+    end
+  end
+end

data/lib/liberic/sdk/fehlercodes.rb

@@ -0,0 +1,192 @@
+module Liberic
+  module SDK
+    module Fehlercodes
+      CODES = {
+        0         => 'OK',
+        610001001 => 'GLOBAL_UNKNOWN',
+        610001002 => 'GLOBAL_PRUEF_FEHLER',
+        610001007 => 'GLOBAL_FEHLERMELDUNG_NICHT_VORHANDEN',
+        610001008 => 'GLOBAL_KEINE_DATEN_VORHANDEN',
+        610001013 => 'GLOBAL_NICHT_GENUEGEND_ARBEITSSPEICHER',
+        610001014 => 'GLOBAL_DATEI_NICHT_GEFUNDEN',
+        610001016 => 'GLOBAL_HERSTELLER_ID_NICHT_ERLAUBT',
+        610001017 => 'GLOBAL_ILLEGAL_STATE',
+        610001018 => 'GLOBAL_FUNKTION_NICHT_ERLAUBT',
+        610001019 => 'GLOBAL_ECHTFALL_NICHT_ERLAUBT',
+        610001020 => 'GLOBAL_NO_VERSAND_IN_BETA_VERSION',
+        610001025 => 'GLOBAL_TESTMERKER_UNGUELTIG',
+        610001026 => 'GLOBAL_DATENSATZ_ZU_GROSS',
+        610001027 => 'GLOBAL_VERSCHLUESSELUNGS_PARAMETER_NICHT_ERLAUBT',
+        610001028 => 'GLOBAL_NUR_PORTALZERTIFIKAT_ERLAUBT',
+        610001029 => 'GLOBAL_ABRUFCODE_NICHT_ERLAUBT',
+        610001030 => 'GLOBAL_ERROR_XML_CREATE',
+        610001031 => 'GLOBAL_TEXTPUFFERGROESSE_FIX',
+        610001032 => 'GLOBAL_INTERNER_FEHLER',
+        610001033 => 'GLOBAL_ARITHMETIKFEHLER',
+        610001034 => 'GLOBAL_STEUERNUMMER_UNGUELTIG',
+        610001035 => 'GLOBAL_STEUERNUMMER_FALSCHE_LAENGE',
+        610001036 => 'GLOBAL_STEUERNUMMER_NICHT_NUMERISCH',
+        610001037 => 'GLOBAL_LANDESNUMMER_UNBEKANNT',
+        610001038 => 'GLOBAL_BUFANR_UNBEKANNT',
+        610001039 => 'GLOBAL_LANDESNUMMER_BUFANR',
+        610001040 => 'GLOBAL_PUFFER_ZUGRIFFSKONFLIKT',
+        610001041 => 'GLOBAL_PUFFER_UEBERLAUF',
+        610001042 => 'GLOBAL_DATENARTVERSION_UNBEKANNT',
+        610001044 => 'GLOBAL_DATENARTVERSION_XML_INKONSISTENT',
+        610001045 => 'GLOBAL_COMMONDATA_NICHT_VERFUEGBAR',
+        610001046 => 'GLOBAL_LOG_EXCEPTION',
+        610001047 => 'GLOBAL_TRANSPORTSCHLUESSEL_NICHT_ERLAUBT',
+        610001051 => 'GLOBAL_VORSATZ_UNGUELTIG',
+        610001102 => 'GLOBAL_UNKNOWN_PARAMETER_ERROR',
+        610001108 => 'GLOBAL_CHECK_CORRUPTED_NDS',
+        610001206 => 'GLOBAL_VERSCHLUESSELUNGS_PARAMETER_NICHT_ANGEGEBEN',
+        610001208 => 'GLOBAL_SEND_AUTH_PIN_NICHT_ANGEGEBEN_RESERVIERT',
+        610001209 => 'GLOBAL_SEND_FLAG_MEHR_ALS_EINES',
+        610001218 => 'GLOBAL_UNGUELTIGE_FLAG_KOMBINATION',
+        610001220 => 'GLOBAL_ERSTE_SEITE_DRUCK_NICHT_UNTERSTUETZT',
+        610001222 => 'GLOBAL_UNGUELTIGER_PARAMETER',
+        610001223 => 'GLOBAL_EINGANGSDATENSATZ_ZU_GROSS',
+        610001224 => 'GLOBAL_DRUCK_FUER_VERFAHREN_NICHT_ERLAUBT',
+        610001225 => 'GLOBAL_VERSAND_ART_NICHT_UNTERSTUETZT',
+        610001226 => 'GLOBAL_UNGUELTIGE_PARAMETER_VERSION',
+        610001227 => 'GLOBAL_TRANSFERHANDLE',
+        610001228 => 'GLOBAL_PLUGININITIALISIERUNG',
+        610001229 => 'GLOBAL_INKOMPATIBLE_VERSIONEN',
+        610001230 => 'GLOBAL_VERSCHLUESSELUNGSVERFAHREN_NICHT_UNTERSTUETZT',
+        610001400 => 'GLOBAL_UTI_ERROR',
+        610001404 => 'GLOBAL_UTI_COUNTRY_NOT_SUPPORTED',
+        610001501 => 'GLOBAL_IBAN_FORMALER_FEHLER',
+        610001502 => 'GLOBAL_IBAN_LAENDERCODE_FEHLER',
+        610001503 => 'GLOBAL_IBAN_LANDESFORMAT_FEHLER',
+        610001504 => 'GLOBAL_IBAN_PRUEFZIFFER_FEHLER',
+        610001510 => 'GLOBAL_BIC_FORMALER_FEHLER',
+        610001511 => 'GLOBAL_BIC_LAENDERCODE_FEHLER',
+        610001519 => 'GLOBAL_ZULASSUNGSNUMMER_ZU_LANG',
+        610001520 => 'GLOBAL_IDNUMMER_LAENGE_UNGUELTIG',
+        610001521 => 'GLOBAL_IDNUMMER_NICHT_NUMERISCH',
+        610001522 => 'GLOBAL_IDNUMMER_NICHT_GENAU_EINE_ZIFFER_DOPPELT',
+        610001523 => 'GLOBAL_IDNUMMER_ERSTE_ZIFFER_UNGUELTIG',
+        610001524 => 'GLOBAL_IDNUMMER_PRUEFZIFFER_UNGUELTIG',
+        610001851 => 'GLOBAL_UPDATE_NECESSARY',
+        610001860 => 'GLOBAL_EINSTELLUNG_NAME_UNGUELTIG',
+        610001861 => 'GLOBAL_EINSTELLUNG_WERT_UNGUELTIG',
+        610001862 => 'GLOBAL_ERR_DEKODIEREN',
+        610001863 => 'GLOBAL_FUNKTION_NICHT_UNTERSTUETZT',
+        610001865 => 'GLOBAL_NUTZDATENTICKETS_NICHT_EINDEUTIG',
+        610001866 => 'GLOBAL_NUTZDATENHEADERVERSIONEN_UNEINHEITLICH',
+        610001867 => 'GLOBAL_BUNDESLAENDER_UNEINHEITLICH',
+        610001868 => 'GLOBAL_ZEITRAEUME_UNEINHEITLICH',
+        610001869 => 'GLOBAL_NUTZDATENHEADER_EMPFAENGER_NICHT_KORREKT',
+
+        610101200 => 'TRANSFER_COM_ERROR',
+        610101201 => 'TRANSFER_VORGANG_NICHT_UNTERSTUETZT',
+        610101210 => 'TRANSFER_ERR_XML_THEADER',
+        610101251 => 'TRANSFER_ERR_PARAM',
+        610101253 => 'TRANSFER_ERR_DATENTEILENDNOTFOUND',
+        610101255 => 'TRANSFER_ERR_BEGINDATENLIEFERANT',
+        610101256 => 'TRANSFER_ERR_ENDDATENLIEFERANT',
+        610101257 => 'TRANSFER_ERR_BEGINTRANSPORTSCHLUESSEL',
+        610101258 => 'TRANSFER_ERR_ENDTRANSPORTSCHLUESSEL',
+        610101259 => 'TRANSFER_ERR_BEGINDATENGROESSE',
+        610101260 => 'TRANSFER_ERR_ENDDATENGROESSE',
+        610101271 => 'TRANSFER_ERR_SEND',
+        610101274 => 'TRANSFER_ERR_NOTENCRYPTED',
+        610101276 => 'TRANSFER_ERR_PROXYCONNECT',
+        610101278 => 'TRANSFER_ERR_CONNECTSERVER',
+        610101279 => 'TRANSFER_ERR_NORESPONSE',
+        610101280 => 'TRANSFER_ERR_PROXYAUTH',
+        610101282 => 'TRANSFER_ERR_SEND_INIT',
+        610101283 => 'TRANSFER_ERR_TIMEOUT',
+        610101291 => 'TRANSFER_ERR_OTHER',
+        610101292 => 'TRANSFER_ERR_XML_NHEADER',
+        610101293 => 'TRANSFER_ERR_XML_ENCODING',
+        610101294 => 'TRANSFER_ERR_ENDSIGUSER',
+        610101295 => 'TRANSFER_ERR_XMLTAG_NICHT_GEFUNDEN',
+        610101297 => 'TRANSFER_ERR_DATENTEILFEHLER',
+
+        610201016 => 'CRYPT_ERROR_CREATE_KEY',
+        610201101 => 'CRYPT_E_INVALID_HANDLE',
+        610201102 => 'CRYPT_E_MAX_SESSION',
+        610201103 => 'CRYPT_E_BUSY',
+        610201104 => 'CRYPT_E_OUT_OF_MEM',
+        610201105 => 'CRYPT_E_PSE_PATH',
+        610201106 => 'CRYPT_E_PIN_WRONG',
+        610201107 => 'CRYPT_E_PIN_LOCKED',
+        610201108 => 'CRYPT_E_P7_READ',
+        610201109 => 'CRYPT_E_P7_DECODE',
+        610201110 => 'CRYPT_E_P7_RECIPIENT',
+        610201111 => 'CRYPT_E_P12_READ',
+        610201112 => 'CRYPT_E_P12_DECODE',
+        610201113 => 'CRYPT_E_P12_SIG_KEY',
+        610201114 => 'CRYPT_E_P12_ENC_KEY',
+        610201115 => 'CRYPT_E_P11_SIG_KEY',
+        610201116 => 'CRYPT_E_P11_ENC_KEY',
+        610201117 => 'CRYPT_E_XML_PARSE',
+        610201118 => 'CRYPT_E_XML_SIG_ADD',
+        610201119 => 'CRYPT_E_XML_SIG_TAG',
+        610201120 => 'CRYPT_E_XML_SIG_SIGN',
+        610201121 => 'CRYPT_E_ENCODE_UNKNOWN',
+        610201122 => 'CRYPT_E_ENCODE_ERROR',
+        610201123 => 'CRYPT_E_XML_INIT',
+        610201124 => 'CRYPT_E_ENCRYPT',
+        610201125 => 'CRYPT_E_DECRYPT',
+        610201126 => 'CRYPT_E_P11_SLOT_EMPTY',
+        610201127 => 'CRYPT_E_NO_SIG_ENC_KEY',
+        610201144 => 'CRYPT_E_TOKEN_TYPE_MISMATCH',
+        610201145 => 'CRYPT_E_TOKEN_UNKNOWN',
+        610201200 => 'CRYPT_ZERTIFIKAT',
+        610201201 => 'CRYPT_SIGNATUR',
+        610201202 => 'CRYPT_PSE_PFAD',
+        610201203 => 'CRYPT_NICHT_UNTERSTUETZTES_PSE_FORMAT',
+        610201205 => 'CRYPT_PIN_BENOETIGT',
+        610201206 => 'CRYPT_PIN_STAERKE_NICHT_AUSREICHEND',
+        610201208 => 'CRYPT_E_INTERN',
+        610201209 => 'CRYPT_ZERTIFIKATSPFAD_KEIN_VERZEICHNIS',
+        610201210 => 'CRYPT_ZERTIFIKATSDATEI_EXISTIERT_BEREITS',
+        610201211 => 'CRYPT_PIN_ENTHAELT_UNGUELTIGE_ZEICHEN',
+        610201212 => 'CRYPT_E_INVALID_PARAM_ABC',
+        610201213 => 'CRYPT_CORRUPTED',
+
+        610301001 => 'IO_FEHLER',
+        610301005 => 'IO_DATEI_INKORREKT',
+        610301006 => 'IO_PARSE_FEHLER',
+        610301007 => 'IO_NDS_GENERIERUNG_FEHLGESCHLAGEN',
+        610301010 => 'IO_MASTERDATENSERVICE_NICHT_VERFUEGBAR',
+        610301014 => 'IO_STEUERZEICHEN_IM_NDS',
+        610301031 => 'IO_VERSIONSINFORMATIONEN_NICHT_GEFUNDEN',
+        610301104 => 'IO_FALSCHES_VERFAHREN',
+        610301105 => 'IO_READER_MEHRFACHE_STEUERFAELLE',
+        610301106 => 'IO_READER_UNERWARTETE_ELEMENTE',
+        610301107 => 'IO_READER_FORMALE_FEHLER',
+        610301108 => 'IO_READER_FALSCHES_ENCODING',
+        610301109 => 'IO_READER_MEHRFACHE_NUTZDATEN_ELEMENTE',
+        610301110 => 'IO_READER_MEHRFACHE_NUTZDATENBLOCK_ELEMENTE',
+        610301111 => 'IO_UNBEKANNTE_DATENART',
+        610301114 => 'IO_READER_UNTERSACHBEREICH_UNGUELTIG',
+        610301115 => 'IO_READER_ZU_VIELE_NUTZDATENBLOCK_ELEMENTE',
+        610301150 => 'IO_READER_STEUERZEICHEN_IM_TRANSFERHEADER',
+        610301151 => 'IO_READER_STEUERZEICHEN_IM_NUTZDATENHEADER',
+        610301152 => 'IO_READER_STEUERZEICHEN_IN_DEN_NUTZDATEN',
+        610301200 => 'IO_READER_SCHEMA_VALIDIERUNGSFEHLER',
+        610301201 => 'IO_READER_UNBEKANNTE_XML_ENTITY',
+        610301252 => 'IO_DATENTEILNOTFOUND',
+        610301253 => 'IO_DATENTEILENDNOTFOUND',
+        610301300 => 'IO_UEBERGABEPARAMETER_FEHLERHAFT',
+
+        610501001 => 'PRINT_INTERNER_FEHLER',
+        610501002 => 'PRINT_DRUCKVORLAGE_NICHT_GEFUNDEN',
+        610501004 => 'PRINT_UNGUELTIGER_DATEI_PFAD',
+        610501007 => 'PRINT_INITIALISIERUNG_FEHLERHAFT',
+        610501008 => 'PRINT_AUSGABEZIEL_UNBEKANNT',
+        610501009 => 'PRINT_ABBRUCH_DRUCKVORBEREITUNG',
+        610501010 => 'PRINT_ABBRUCH_GENERIERUNG',
+        610501011 => 'PRINT_STEUERFALL_NICHT_UNTERSTUETZT',
+        610501012 => 'PRINT_FUSSTEXT_ZU_LANG'
+      }
+
+      CODES.each do |value, name|
+        const_set(name, value)
+      end
+    end
+  end
+end