king_dtaus 1.0.2 → 2.0.0.pre

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create ree@dtazv

data/DTAUS0.TXT

@@ -0,0 +1 @@
+0256Q370502991326049634JAN                                KUS                                MEINE EINE STRASSE 2               51063 MEINE KOELN                  11060801110608N0000000000                                                                    0768T37050299EUR132604963411060800000000   0000000000MARKF1100                                                                                                                                                 DE FIDEL                              CASTRO                             BUSH-AVENUE 55                     445555 KUBA                                                                                              /GR1601101250000000012300695       EUR00000000000220250                                                                                                                                            00000000                         0013                                                              0                                                   000256Z000000000000220000000000000001                                                                                                                                                                                                                             

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    king_dtaus (1.0.2)
+      king_dtaus
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mocha (0.9.12)
+    rake (0.9.1)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.3)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  king_dtaus!
+  mocha
+  rspec
+  simplecov

data/README.rdoc

@@ -1,32 +1,52 @@
-= Dtaus
+= DTAUS & DTAZV always comes together
 
-DTAUS is a format for German bank transfers and is short for 
-"Datenträgeraustausch". The format itself totally sucks because it was 
-established in the last century, to be used on floppy disks. Still almost 
-all German banks use it(they only seem innovative at robbing), and it is 
+DTAUS & DTAZV are formats for German bank transfers and is short for
+"Datenträgeraustausch". The format itself totally sucks because it was
+established in the last century, to be used on floppy disks. Still almost
+all German banks use it (they only seem innovative at robbing), and it is
 therefore supported in common banking programs too.
 
-This gem saves you all the trouble when generating dtaus-text. 
+This gem saves you all the trouble when generating DTAUS- or DTAZV-text.
+
+We love building payment applications
 
 == Install
 
   gem install king_dtaus
 
 == Features
- 
-* create lastschrift
-* create gutschrift
 
+* create DTAUS debit advice (Lastschrift)
+* create DTAUS credit advice (Gutschrift)
+* create DTAZV debit advice
+
+== TODOs
+
+* first gem with no todo's - never seen it, huh?
+
+== Resources
+
+* DTAZV-Viewer: http://www.meta-evolutions.de/pages/artikel-20070630-dtazv-datei-betrachter.html
+* DTA/DTAZV PHP Pear: http://pear.php.net/package/Payment_DTA
+* Ruby Kernel Module: http://www.ruby-doc.org/core/classes/Kernel.html
+* Windata ZV-Tools: http://www.windata.de/Site/2Produkte2/ZVTools.aspx
+* The Swift Codes: http://www.theswiftcodes.com/
+* StarMoney: http://www.starmoney.de/index.php?id=starmoneybusiness_testen
+* SalesKing: http://salesking.eu
+
+== Examples
+
+Here are some examples how to create a DTA- or DTAZV-File. Also check out the spec/dtazv_test.rb to have a running Example of an Export.
+
+=== DTA
 
-== Example
-  
-  #create a new dtaus object
+  # create a new dtaus object
   dta = KingDta::Dtaus.new('LK')
   # set sender account
-  dta.account = KingDta::Account.new( "bank_account_number", "bank_number", "bank_owner")
+  dta.account = KingDta::Account.new(:account_number => @kto1.account_number, :bank_number => @kto1.bank_number, :client_name => @kto1.client_name, :bank_name => @kto1.bank_name)
   # the following should be done in a loop to add multiple bookings
   # create receiving account
-  rec_acnt = KingDta::Account.new( "bank_account_number", "bank_number", "bank_owner" )
+  rec_acnt = KingDta::Account.new(:account_number => @kto1.account_number, :bank_number => @kto1.bank_number, :client_name => @kto1.client_name, :bank_name => @kto1.bank_name)
   # create booking
   booking = KingDta::Booking.new(rec_acnt, 100.00 )
   # set booking text if you want to
@@ -38,15 +58,62 @@ This gem saves you all the trouble when generating dtaus-text.
   # create datausstring and do with it whatever fits your workflow
   my_str = dta.create
 
-also make sure to read the specs
+=== DTAZV
+
+  @date = Date.today
+  @dudes_dtazv_export = KingDta::Dtazv.new(@date)
+  @dudes_konto = self.dudes_konto
+  @dalai_lamas_account = self.dalai_lamas_account
+  @dudes_dtazv_export.account = KingDta::Account.new(
+    :account_number =>      @dudes_konto.account_number,
+    :bank_number =>         @dudes_konto.bank_number,
+    :client_name =>         @dudes_konto.client_name,
+    :client_number =>       @dudes_konto.client_number,
+    :bank_street =>         @dudes_konto.account_street,
+    :bank_city =>           @dudes_konto.account_city,
+    :bank_zip_code =>       @dudes_konto.account_zip_code,
+    :bank_name =>           @dudes_konto.bank_name,
+    :client_street =>       @dudes_konto.client_street,
+    :client_city =>         @dudes_konto.client_city,
+    :client_zip_code =>     @dudes_konto.client_zip_code,
+    :bank_country_code =>   @dudes_konto.bank_country_code,
+    :client_country_code => @dudes_konto.client_country_code
+  )
+
+  @fidel_castros_booking = KingDta::Booking.new(KingDta::Account.new(
+    :account_number =>      @dalai_lamas_account.account_number,
+    :bank_number =>         @dalai_lamas_account.bank_number,
+    :client_name =>         @dalai_lamas_account.client_name,
+    :client_number =>       @dalai_lamas_account.bank_name,
+    :bank_street =>         @dalai_lamas_account.account_street,
+    :bank_city =>           @dalai_lamas_account.account_city,
+    :bank_zip_code =>       @dalai_lamas_account.account_zip_code,
+    :bank_name =>           @dalai_lamas_account.bank_name,
+    :client_street =>       @dalai_lamas_account.client_street,
+    :client_city =>         @dalai_lamas_account.client_city,
+    :client_zip_code =>     @dalai_lamas_account.client_zip_code,
+    :bank_country_code =>   @dalai_lamas_account.bank_country_code,
+    :client_country_code => @dalai_lamas_account.client_country_code
+  ), 220.25)
+
+  @dudes_dtazv_export.add(@fidel_castros_booking)
+  @dudes_dtazv_export.create_file
 
+  # Output is DTAZV0.TXT
+
+also make sure to read the specs
 
 == Credits
 
-This gem used https://rubygems.org/gems/DTAUS as a starting point. 
-It was disected, turned into a real class structure, bugs where fixed and 
+Bugfixes and enhancements by
+
+* Georg Ledermann - https://github.com/ledermann
+* Kim Rudolph - https://github.com/krudolph
+* Thorsten Böttger - https://github.com/alto
+* Jan Kus - https://github.com/koos
+
+This gem used https://rubygems.org/gems/DTAUS as a starting point.
+It was disected, turned into a real class structure, bugs where fixed and
 of course a full test suite ensures its functionality.
 
-Copyright (c) 2009-2010 Georg Leciejewski, 
-Bugfixes and enhancements by Georg Ledermann 
-released under the MIT license
+Copyright (c) 2009-2011 Georg Leciejewski (SalesKing), Jan Kus (Railslove), released under the MIT license

data/Rakefile

@@ -1,33 +1,13 @@
 require 'rake'
-require 'rake/rdoctask'
-require 'spec/rake/spectask'
-
-desc 'Default: run specs.'
-task :default => :spec
-
-spec_files = Rake::FileList["spec/**/*_spec.rb"]
+require 'rdoc/task'
+require 'rspec/core/rake_task'
 
 desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = spec_files
-  t.spec_opts = ["-c"]
-end
+RSpec::Core::RakeTask.new
 
-desc "Generate code coverage"
-Spec::Rake::SpecTask.new(:coverage) do |t|
-  t.spec_files = spec_files
-  t.rcov = true
-  t.rcov_opts = ['--exclude', 'spec,/var/lib/gems']
-end
+task :default => :spec
 
-desc 'Generate documentation'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'dtaus'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }
 
 begin
   require 'jeweler'

data/VERSION

@@ -1 +1 @@
-1.0.2
+2.0.0.pre

data/example.output

@@ -0,0 +1,7 @@
+0256P37040044                                                     Commerzbank Köln                   5th avenue 55323                        los angeles1106080100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+0256Q370400447828970037                                                   GIMME YOUR MONEY AG                  6th avenue 445555                        los angeles11060801110608N000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+0572T37040044EUR782897003711060837040044EUR0037040044  MARKF1100                                                                                                                                                                                                            FIDEL CASTRO                                                                                                                                           0        GR1601101250000000012300695EUR00000000000220025                                                                                                                                             0 0 0 0                        00013                          0                                  00000000000000000000000000000000000000000000000000000 00
+
+256Y000000000000000000000000000000000000000000000000000000000000000000000001                                                                                                                                                                                  0

data/king_dtaus.gemspec

@@ -5,53 +5,73 @@
 
 Gem::Specification.new do |s|
   s.name = %q{king_dtaus}
-  s.version = "1.0.2"
+  s.version = "2.0.0.pre"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Georg Leciejewski", "Georg Ledermann"]
-  s.date = %q{2011-02-10}
+  s.date = %q{2011-06-15}
   s.description = %q{DTAUS is a text-based format, to create bank transfers for german banks. This gem helps with the creation of those transfer files.}
   s.email = %q{gl@salesking.eu}
   s.extra_rdoc_files = [
     "README.rdoc"
   ]
   s.files = [
+    ".rvmrc",
+    "DTAUS0.TXT",
+    "Gemfile",
+    "Gemfile.lock",
     "MIT-LICENSE",
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "docs/dtazv.pdf",
+    "docs/dtazv_bank_bbk.pdf",
+    "example.output",
     "king_dtaus.gemspec",
     "lib/king_dta/account.rb",
     "lib/king_dta/booking.rb",
+    "lib/king_dta/dta.rb",
     "lib/king_dta/dtaus.rb",
+    "lib/king_dta/dtazv.rb",
     "lib/king_dta/exception.rb",
     "lib/king_dta/helper.rb",
     "lib/king_dtaus.rb",
     "spec/account_spec.rb",
     "spec/booking_spec.rb",
     "spec/dtaus_spec.rb",
+    "spec/dtazv_spec.rb",
+    "spec/dtazv_test.rb",
     "spec/helper_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/salesking/king_dtaus}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.1}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Generate DTAUS strings and files}
-  s.test_files = [
-    "spec/account_spec.rb",
-    "spec/booking_spec.rb",
-    "spec/dtaus_spec.rb",
-    "spec/helper_spec.rb",
-    "spec/spec_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<king_dtaus>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
+      s.add_dependency(%q<king_dtaus>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
+    s.add_dependency(%q<king_dtaus>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end
 

data/lib/king_dta/account.rb

@@ -4,21 +4,54 @@ module KingDta
   class Account
     include KingDta::Helper
     # dta~ jeweilige Feld in DTAUS-Norm
-    attr_reader  :bank_account_number, :bank_number, :owner, :client_number
-    
-    def initialize( ban, bank_number, owner, client_number="" )
-
-      @bank_account_number = ban.kind_of?( Integer ) ? ban : ban.gsub(/\s/, '').to_i      
-      @bank_number  = bank_number.kind_of?( Integer ) ? bank_number :  bank_number.gsub(/\s/, '').to_i      
-      @client_number = client_number.kind_of?( Integer ) ? client_number : client_number.gsub(/\s/, '').to_i
-      @owner= convert_text( owner )
-
-      raise ArgumentError.new('Bank account number too long, max 10 allowed') if "#{@bank_account_number}".length > 10
-      raise ArgumentError.new('Bank number too long, max 8 allowed') if "#{@bank_number}".length > 8
-      raise ArgumentError.new('Client number too long, max 10 allowed') if "#{@client_number}".length > 10
-      raise ArgumentError.new("Bank account number cannot be 0")  if @bank_account_number == 0
-      raise ArgumentError.new("Bank number cannot be 0")   if @bank_number == 0
+    attr_accessor :account_number, :bank_number, :client_number, :bank_street, :bank_city, :bank_zip_code, :bank_name,
+:client_name, :client_street, :client_city, :client_zip_code, :bank_country_code, :client_country_code
+
+    # TODO test
+    def initialize(args={})
+
+      @bank_street = convert_text(args.delete(:bank_street))
+      @bank_city = convert_text(args.delete(:bank_city))
+      @bank_name = convert_text(args.delete(:bank_name))
+      @client_name = convert_text(args.delete(:client_name))
+      @client_street = convert_text(args.delete(:client_street))
+      @client_city = convert_text(args.delete(:client_city))
+
+      args.each do |key,value|
+        self.send("#{key}=",value)
+      end
+
+      raise ArgumentError.new('Account number too long, max 35 allowed') if @account_number && "#{@account_number}".length > 35
+      raise ArgumentError.new('Bank number too long, max 11 allowed') if @bank_number && "#{@bank_number}".length > 11
+      raise ArgumentError.new('Client number too long, max 10 allowed') if @client_number && "#{@client_number}".length > 10
+      raise ArgumentError.new("Bank account number cannot be 0")  if @account_number && @account_number == 0
+      raise ArgumentError.new("Bank number cannot be 0")   if @bank_number && @bank_number == 0
+      raise ArgumentError.new("Street and/or Zip Code too long, max 35 allowed") if @bank_street && @bank_zip_code && "#{@bank_street} #{@bank_zip_code}".length > 35
+      raise ArgumentError.new("City too long, max 35 allowed") if @bank_city && @bank_city.length > 35
+      raise ArgumentError.new("Bank Name too long, max 35 allowed") if @bank_name && @bank_name.length > 35
+      raise ArgumentError.new("Client Street and/or Zip Code too long, max 35 allowed") if @client_street && @client_zip_code && "#{@client_street} #{@client_zip_code}".length > 35
+      raise ArgumentError.new("Client City too long, max 35 allowed") if @client_city && @client_city.length > 35
+      raise ArgumentError.new("Bank Country code too long, max 2 allowed") if @bank_country_code && @bank_country_code.length > 2
+      raise ArgumentError.new("Client Country code too long, max 2 allowed") if @client_country_code && @client_country_code.length > 2
+
+    end
+
+    # TODO test
+    def client_firstname
+      @client_name.split(' ')[0]
     end
-    
+
+    def client_surname
+      @client_name.split(' ')[1]
+    end
+
+    def zip_city
+      "#{@bank_zip_code} #{@bank_city}"
+    end
+
+    def client_zip_city
+      "#{@client_zip_code} #{@client_city}"
+    end
+
   end
 end

data/lib/king_dta/booking.rb

@@ -8,17 +8,17 @@ module KingDta
     LASTSCHRIFT_EINZUGSERMAECHTIGUNG = '05000'
     UEBERWEISUNG_GUTSCHRIFT          = '51000'
 
-    attr_reader :value, :account, :text, :schluessel
+    attr_accessor :value, :account, :text, :account_key
     #Eine Buchung ist definiert durch:
     #- Konto (siehe Klasse Konto
     #- Betrag
     #  Der Betrag kann , oder . als Dezimaltrenner enthalten.
     #- optional Buchungstext
-    def initialize( account, value, text=nil, schluessel=nil )
+    def initialize( account, value, text=nil, account_key=nil )
       raise Exception.new("Hey, a booking should have an Account") unless account.kind_of?( Account )
       @account = account
       @text = text ? convert_text( text ) : text
-      @schluessel = schluessel
+      @account_key = account_key
       if value.is_a?(String)
         value = BigDecimal.new value.sub(',', '.')
       elsif value.is_a?(Numeric)
@@ -37,7 +37,7 @@ module KingDta
         @pos   = false
       end
     end
-    
+
     def text=(text)
        @text = convert_text( text )
     end

data/lib/king_dta/dta.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module KingDta
+  class Dta
+    include KingDta::Helper
+    attr_reader :default_text
+
+    #  Set the sending account(you own)
+    # === Parameter
+    # account<Account>:: the sending account, must be an instance of class
+    # KingDta::Account
+    def account=( account )
+      raise Exception.new("Come on, i need an Account object") unless account.kind_of?( Account )
+      @account = account
+    end
+
+    # The dtaus format as string. All data is appended to it during creation
+    def dta_string
+      @dta_string ||= ''
+    end
+    # Array of bookings
+    def bookings
+      @bookings ||= []
+    end
+    # default text used on all bookings with emtpy text
+    def default_text=(text='')
+      @default_text = convert_text( text )
+    end
+
+    # Add a booking. The prefix (pos/neg) is beeing checked if it is identical
+    # with the last one
+    # === Parameter
+    # booking<Booking>:: KingDta::Booking object
+    # === Raises
+    # error if the prefix within the bookings has changed
+    def add ( booking )
+      raise Exception.new("The file has alreay been closed, cannot add new booking") if @closed
+      #the first booking decides wether all values are po or negative
+      @value_pos = booking.pos?  if bookings.empty?
+      raise Exception.new("The prefix within bookings changed from #{@value_pos} to #{booking.pos?}") if @value_pos != booking.pos?
+      bookings << booking
+    end
+
+    # Create a DTA-File, from current dta information
+    # === Parameter
+    # filename<String>:: defaults to dta.txt
+    def create_file(filename ='dta.txt')
+      file = open( filename, 'w')
+      file  << create
+      file.close()
+    end
+
+  end
+end

data/lib/king_dta/dtaus.rb

@@ -5,9 +5,8 @@
 #Infos zu DTAUS: http://www.infodrom.org/projects/dtaus/dtaus.php3
 
 module KingDta
-  class Dtaus
-    include KingDta::Helper
-    attr_reader :sum_bank_account_numbers, :sum_bank_numbers, :sum_values, :default_text
+  class Dtaus < KingDta::Dta
+    attr_reader :sum_bank_account_numbers, :sum_bank_numbers, :sum_values
 
     # Create a new dtaus file/string.
     # === Parameter
@@ -23,42 +22,6 @@ module KingDta
       @default_text = '' # default verwendungzweck
     end
 
-    #  Set the sending account(you own)
-    # === Parameter
-    # account<Account>:: the sending account, must be an instance of class
-    # KingDta::Account
-    def account=( account )
-      raise Exception.new("Come on, i need an Account object") unless account.kind_of?( Account )
-      @account = account
-    end
-
-    # The dtaus format as string. All data is appended to it during creation
-    def dta_string
-      @dta_string ||= ''
-    end
-    # Array of bookings
-    def bookings
-      @bookings ||= []
-    end
-    # default text used on all bookings with emtpy text
-    def default_text=(text='')
-      @default_text = convert_text( text )
-    end
-
-    # Add a booking. The prefix (pos/neg) is beeing checked if it is identical
-    # with the last one
-    # === Parameter
-    # booking<Booking>:: KingDta::Booking object
-    # === Raises
-    # error if the prefix within the bookings has changed
-    def add ( booking )
-      raise Exception.new("The file has alreay been closed, cannot add new booking") if @closed
-      #the first booking decides wether all values are po or negative
-      @value_pos = booking.pos?  if bookings.empty?
-      raise Exception.new("The prefix within bookings changed from #{@value_pos} to #{booking.pos?}") if @value_pos != booking.pos?
-      bookings << booking
-    end
-
     # Creates the whole dta string(in the right order) and returns it
     # === Raises
     # error if there are no bookings
@@ -74,26 +37,16 @@ module KingDta
       dta_string
     end
 
+    # TODO do it works? the .to_i stuff
     def set_checksums
       @sum_bank_account_numbers, @sum_bank_numbers, @sum_values  = 0,0,0
       bookings.each do |b|
-        @sum_bank_account_numbers  += b.account.bank_account_number
-        @sum_bank_numbers += b.account.bank_number
+        @sum_bank_account_numbers  += b.account.account_number.to_i
+        @sum_bank_numbers += b.account.bank_number.to_i
         @sum_values += b.value
       end
     end
 
-    # Create a DTA-File, from current dta information
-    # === Parameter
-    # filename<String>:: defaults to DTAUS0.TXT
-    def create_file(filename ='DTAUS0.TXT')
-      file = open( filename, 'w')
-      file  << create
-      file.close()
-      print "#{filename} created containing #{@bookings.size} bookings\n"
-    end
-
-
     #Erstellen A-Segment der DTAUS-Datei
     #Aufbau des Segments:
     # Nr.  Start  Länge     Beschreibung
@@ -124,10 +77,10 @@ module KingDta
       data += @typ        #Lastschriften Kunde
       data += '%8i' % @account.bank_number #.rjust(8)  #bank_number
       data += '%08i' % 0                 #belegt, wenn Bank
-      data += '%-27.27s' % @account.owner
+      data += '%-27.27s' % @account.client_name
       data += @date.strftime("%d%m%y")  #aktuelles Datum im Format DDMMJJ
       data += ' ' * 4  #bankinternes Feld
-      data += '%010i' % @account.bank_account_number
+      data += '%010i' % @account.account_number
       data += '%010i' % 0 #Referenznummer
       data += ' '  * 15  #Reserve
       data += '%8s' % @date.strftime("%d%m%Y")     #Ausführungsdatum (ja hier 8 Stellen, Erzeugungsdat. hat 6 Stellen)
@@ -195,11 +148,9 @@ module KingDta
     # <String>:: The current dta_string
     def add_c( booking )
       zahlungsart = if @typ == 'LK'
-                      booking.schluessel || Booking::LASTSCHRIFT_EINZUGSERMAECHTIGUNG
+                      booking.account_key || Booking::LASTSCHRIFT_EINZUGSERMAECHTIGUNG
                     elsif @typ == 'GK'
-                      booking.schluessel || Booking::UEBERWEISUNG_GUTSCHRIFT
-                    else
-                      raise 'Wrong booking type'
+                      booking.account_key || Booking::UEBERWEISUNG_GUTSCHRIFT
                     end
       #Extended segments Long name & booking texts
       exts = []  #('xx', 'inhalt') xx: 01=Name 02=Verwendung 03=Name
@@ -208,22 +159,25 @@ module KingDta
       data1 = 'C'
       data1 +=  '%08i' % 0  #freigestellt
       data1 +=  '%08i' % booking.account.bank_number
-      data1 +=  '%010i' % booking.account.bank_account_number
-      data1 +=  '0%011i0' % booking.account.client_number   #interne Kundennummer
+      data1 +=  '%010i' % booking.account.account_number
+      # RUBY 1.9 workaround => || 0
+      # Ruby 1.9 '0%011i0' % nil => Exception
+      # Ruby 1.8 '0%011i0' % nil => "00000000000"
+      data1 +=  '0%011i0' % (booking.account.client_number || 0)   #interne Kundennummer
       data1 +=  zahlungsart
       data1 +=  ' ' #bankintern
       data1 +=  '0' * 11   #Reserve
       data1 +=  '%08i' % @account.bank_number
-      data1 +=  '%010i' % @account.bank_account_number
+      data1 +=  '%010i' % @account.account_number
       data1 +=  '%011i' % booking.value #Betrag in Euro einschl. Nachkomma
       data1 +=  ' ' * 3
-      data1 +=  '%-27.27s' % booking.account.owner #Name Begünstigter/Zahlungspflichtiger
-      exts << ['01', booking.account.owner[27..999] ] if booking.account.owner.size > 27
+      data1 +=  '%-27.27s' % booking.account.client_name #Name Begünstigter/Zahlungspflichtiger
+      exts << ['01', booking.account.client_name[27..999] ] if booking.account.client_name.size > 27
       data1 +=  ' ' * 8
       #Einfügen erst möglich, wenn Satzlänge bekannt
 
       # 2. Satzabschnitt
-      data2 = "%27.27s" % @account.owner
+      data2 = "%27.27s" % @account.client_name
       zweck = booking.text || default_text
       #Erste 27 Zeichen
       #Wenn text < 26 Zeichen, dann mit spaces auffüllen.
@@ -234,13 +188,13 @@ module KingDta
         exts << ['02', zweck.ljust(27) ]
         zweck = zweck[27..999]
       end
-      exts << ['03', @account.owner[27..999] ] if @account.owner.size > 27
+      exts << ['03', @account.client_name[27..999] ] if @account.client_name.size > 27
 
       data2 +=  '1'     #Währungskennzeichen
       data2 +=  ' ' * 2
       # Gesamte Satzlänge ermitteln ( data1(+4) + data2 + Erweiterungen )
       data1 = "%04i#{data1}" % ( data1.size + 4 + data2.size+ 2 + exts.size * 29 )
-      raise "DTAUS: Längenfehler C/1 #{data1.size} nicht 128, #{booking.account.owner}" unless data1.size == 128
+      raise "DTAUS: Längenfehler C/1 #{data1.size} nicht 128, #{booking.account.client_name}" unless data1.size == 128
       dta_string << data1
       #Anzahl Erweiterungen anfügen
       data2 +=  '%02i' % exts.size  #Anzahl Erweiterungsteile
@@ -251,7 +205,7 @@ module KingDta
       exts[0..1].each{|e| data2 +=  "%2.2s%-27.27s" % format_ext(e[0], e[1]) }
       data2 +=  ' ' * 11
       # add the final piece of the second C section
-      raise "DTAUS: Längenfehler C/2 #{data2.size} nicht 128, #{booking.account.owner}" unless data2.size == 128
+      raise "DTAUS: Längenfehler C/2 #{data2.size} nicht 128, #{booking.account.client_name}" unless data2.size == 128
       dta_string << data2
       #Erstellen der Texterweiterungen à vier Stück
       add_ext( exts[2..5] )
@@ -313,6 +267,6 @@ module KingDta
       raise "DTAUS: Längenfehler E #{str.size} <> 128" if str.size != 128
       dta_string << str
     end
-    
+
   end  #class dtaus
 end