da_funk 0.4.4

data/lib/device/transaction/iso.rb

@@ -0,0 +1,75 @@
+
+class Device
+  class Transaction
+    # Object responsible to create ISO8583 message
+    #
+    # == Sample:
+    #
+    #   message = Device::Iso.new
+    #   message.mti = 1110
+    #   message[2] = 474747474747
+    #   message["Processing Code"] = "123456"
+    #
+    #   pan = message["Primary Account Number (PAN)"]
+    #   message.pan = 47474747474747
+    #
+    #   puts message.pan
+    #   puts message.to_b
+    #   puts message.to_s
+    #   mes2 = Device::Iso.parse input
+    #
+    class Iso < ISO8583::Message
+      include ISO8583
+      mti_format N, :length => 4
+      mti 1100, "Authorization Request Acquirer Gateway"
+
+      mti 1110, "Authorization Request Response Issuer Gateway"
+      mti 1420, "Reversal Advice Acquirer Gateway"
+      mti 1421, "Reversal Advice Repeat Acquirer Gateway"
+      mti 1430, "Reversal Advice Response Issuer Gateway"
+      mti 1804, "Network Management Request Acquirer Gateway or Issuer Gateway"
+      mti 1814, "Network Management Request Response Issuer Gateway or Acquirer Gateway"
+
+      bmp  2, "Primary Account Number (PAN)",               LLVAR_N,   :max    => 19
+      bmp  3,  "Processing Code",                           N,         :length =>  6
+      bmp  4,  "Amount (Transaction)",                      N,         :length => 12
+      bmp  6,  "Amount, Cardholder Billing" ,               N,         :length => 12
+      bmp  7,  "Date and Time, Transmission"  ,             MMDDhhmmss
+      bmp 10, "Conversion Rate, Cardholder Billing",        N,         :length =>  8
+      bmp 11, "System Trace Audit Number (STAN)",           N,         :length =>  6
+      bmp 12, "Date and Time, Local Transaction",           YYMMDDhhmmss
+      bmp 14, "Date, Expiration",                           YYMM
+      bmp 22, "POS Data Code",                              AN,        :length => 12
+      bmp 23, "Card Sequence Number",                       N,         :length =>  3
+      bmp 24, "Function Code",                              N,         :length =>  3
+      bmp 25, "Message Reason Code",                        N,         :length =>  4
+      bmp 26, "Card Acceptor Business Code",                N,         :length =>  4
+      bmp 30, "Amounts, Original",                          N,         :length => 24
+      bmp 32, "Acquiring Institution Identification Code",  LLVAR_N,   :max    => 11
+      bmp 35, "Track 2 Data",                               LLVAR_Z,   :max    => 37
+      bmp 37, "Retrieval Reference Number",                 ANP,       :length => 12
+      bmp 38, "Approval Code",                              ANP,       :length =>  6
+      bmp 39, "Action Code",                                N,         :length =>  3
+      bmp 41, "Card Acceptor Terminal Identification",      ANS,       :length =>  8
+      bmp 42, "Card Acceptor Identification Code",          ANS,       :length => 15
+      bmp 43, "Card Acceptor Name/Location",                LLVAR_ANS, :max    => 56
+      bmp 49, "Currency Code, Transaction",                 N,         :length =>  3
+      bmp 51, "Currency Code, Cardholder Billing",          N,         :length =>  3
+      bmp 52, "Personal Identification Number (PIN) Data",  B,         :length =>  8
+      bmp 53, "Security Related Control Information",       LLVAR_B,   :max    => 48
+      bmp 54, "Amounts, Additional",                        LLLVAR_ANS,:max    => 40
+
+      bmp 55, "Integrated Circuit Card (ICC) System Related Data", LLLVAR_B,   :max    => 255
+      bmp 56, "Original Data Elements",                            LLVAR_N,    :max    => 35
+      bmp 58, "Authorizing Agent Institution Identification Code", LLVAR_N,    :max    => 11
+      bmp 59, "Additional Data - Private",                         LLLVAR_ANS, :max    => 67
+      bmp 64, "Message Authentication Code (MAC) Field",           B,          :length => 8
+
+      bmp_alias  2, :pan
+      bmp_alias  3, :proc_code
+      bmp_alias  4, :amount
+      bmp_alias 12, :exp_date
+    end
+  end
+end
+

data/lib/device/version.rb

@@ -0,0 +1,11 @@
+
+class Device
+  def self.api_version
+    Device::API_VERSION
+  end
+
+  def self.version
+    adapter.version
+  end
+end
+

data/lib/device/walk.rb

@@ -0,0 +1,8 @@
+
+class Device
+  class Walk
+    def self.execute(file)
+      load file
+    end
+  end
+end

data/lib/device.rb

@@ -0,0 +1,28 @@
+class Device
+  class << self
+    attr_accessor :adapter
+  end
+
+  # Flat syntax/behaviour API between versions, to any application be able to execute on whole versions.
+  #
+  # @return [Class] the class object flatted
+  def self.flat_api
+    klass_version = Device.version.gsub(".", "")
+    # Sample
+    #if Device.version == "0.4.3"
+      #const_get("VersionFlat#{klass_version}").flat Device
+    #end
+  end
+
+  def self.call(*args)
+  end
+
+  def self.app_loop(&block)
+    Notification.setup
+    loop do
+      Notification.check
+      block.call(self)
+    end
+  end
+end
+

data/lib/ext/kernel.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def get_format(*args)
+    Device::IO.get_format(*args)
+  end
+
+  def print_line(buf, row = 0, column = 0)
+    Device::Display.print_line(buf, row, column)
+  end
+end

data/lib/file_db.rb

@@ -0,0 +1,47 @@
+
+class FileDb
+  attr_accessor :path, :hash
+
+  def initialize(path, default_value = {})
+    @hash = default_value.dup
+    @path = path
+    self.open
+  end
+
+  def open
+    if File.exist?(@path)
+      file = File.open(@path)
+      self.parse(file.read)
+    end
+  ensure
+    file.close if file
+  end
+
+  def parse(text)
+    text.split("\n").compact.each do |line|
+      key_value = line.split("=")
+      if key_value[1] && (@hash[key_value[0]].nil? || @hash[key_value[0]].empty?)
+        @hash[key_value[0]] = key_value[1]
+      end
+    end
+  end
+
+  def save
+    file_new = File.open(@path, "w+")
+    @hash.each do |line_key, line_value|
+      file_new.puts("#{line_key}=#{line_value}")
+    end
+    file_new.close
+  end
+
+  def []=(key, value)
+    ret = @hash[key] = value
+    save
+    ret
+  end
+
+  def [](key)
+    @hash[key]
+  end
+end
+

data/lib/iso8583/bitmap.rb

@@ -0,0 +1,114 @@
+
+module ISO8583
+
+  # This class constructs an object for handling bitmaps
+  # with which ISO8583 messages typically begin.
+  # Bitmaps are either 8 or 16 bytes long, an extended length
+  # bitmap is indicated by the first bit being set.
+  # In all likelyhood, you won't be using this class much, it's used
+  # transparently by the Message class.
+  class Bitmap
+
+    # create a new Bitmap object. In case an iso message
+    # is passed in, that messages bitmap will be parsed. If
+    # not, this initializes and empty bitmap.
+    def initialize(message = nil)
+      @bmp = Array.new(128, false)
+      if !message
+
+      else
+        initialize_from_message message
+      end
+    end
+    
+    # yield once with the number of each set field.
+    def each #:yields: each bit set in the bitmap.
+      @bmp.each_with_index {|set, i| yield i+1 if set}
+    end
+    
+    # Returns whether the bit is set or not.
+    def [](i)
+      @bmp[i-1]
+    end
+
+    # Set the bit to the indicated value. Only `true` sets the
+    # bit, any other value unsets it.
+    def []=(i, value)
+      if i > 128 
+        raise ISO8583Exception.new("Bits > 128 are not permitted.")
+      elsif i < 2
+        raise ISO8583Exception.new("Bits < 2 are not permitted (continutation bit is set automatically)")
+      end
+      @bmp[i-1] = (value == true)
+    end
+
+    # Sets bit #i
+    def set(i)
+      self[i] = true
+    end
+    
+    # Unsets bit #i
+    def unset(i)
+      self[i] = false
+    end
+
+    # Generate the bytes representing this bitmap.
+    def to_bytes
+      arr = [self.to_s]
+      # tricky and ugly, setting bit[1] only when generating to_s...
+      count = self[1] ? 128 : 64
+      arr.pack("B#{count}")
+    end
+    alias_method :to_b, :to_bytes
+
+    # Generate a String representation of this bitmap in the form:
+    # 01001100110000011010110110010100100110011000001101011011001010
+    def to_s
+      #check whether any `high` bits are set
+      @bmp[0] = false
+      65.upto(128) {|i|
+        if self[i]
+          # if so, set continuation bit
+          @bmp[0] = true
+          break
+        end
+      }
+      str = ""
+      1.upto(self[1] ? 128 : 64) {|i|
+        str << (self[i] ? "1" : "0")
+      }
+      str
+    end
+
+
+    private
+
+    def initialize_from_message(message)
+      bmp = message.to_i(16).to_s(2)
+      if bmp[0,1] == "1"
+        bmp = message.to_i(16).to_s(2)
+      end
+
+      0.upto(bmp.length-1) do |i|
+        @bmp[i] = (bmp[i,1] == "1")
+      end
+    end
+
+    class << self
+      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
+      # after the bitmap is taken away.
+      def parse(str)
+        bmp  = Bitmap.new(str)
+        rest = bmp[1] ? str[32, str.length] : str[16, str.length]
+        [ bmp, rest ]
+      end
+    end
+    
+  end
+end
+
+if __FILE__==$0
+  mp = ISO8583::Bitmap.new
+  20.step(128,7) {|i| mp.set(i)}
+  print mp.to_bytes
+end

data/lib/iso8583/codec.rb

@@ -0,0 +1,197 @@
+#require 'date'
+
+module ISO8583
+
+  # Codec provides functionality to encode and decode values, codecs are
+  # used internally by Field instances in order to do character conversions
+  # and checking for proper values.
+  # Although they are used internally, you will probably need to write
+  # your own Codec sooner or later. The codecs used by Field instances are
+  # typically instances of Codec, it may or may not be usefull to subclass
+  # Codec.
+  # 
+  # Say, for example, a text field needs to be encoded in EBCDIC in the
+  # message, this is how a corresponding codec would be constructed:
+  #
+  #    EBCDIC_Codec = Codec.new
+  #    EBCDIC_Codec.encoder = lambda {|ascii_str|
+  #       raise ISO8583Exception.new("String (#{ascii_str})not valid!") unless =~ /someregexp/
+  #       ascii2ebcdic ascii_str  # implementing ascii_str is left as an excercise
+  #    }
+  #    EBCDIC_Codec.decode = lambda {|ebcdic_str|
+  #       # you may or may not want to raise exceptions at this point ....
+  #       # strip removes any padding...
+  #       ebcdic2ascii(ebcdic_str).strip
+  #    }
+  #
+  # This instance of Codec would then be used be the corresponding Field
+  # encoder/decoder, which may look similar to this:
+  #
+  #    EBCDIC         = Field.new
+  #    EBCDIC.codec   = EBCDIC_Codec
+  #    EBCDIC.padding = PADDING_LEFT_JUSTIFIED_SPACES
+  #
+  # Notice there is a bit of inconsistancy: the padding is added by the
+  # field, but removed by the codec. I would like to find a better
+  # solution to this...
+  #
+  # See also: Field, link:files/lib/fields_rb.html
+  #
+  # The following codecs are already implemented:
+  # [+ASCII_Number+]      encodes either a Number or String representation of 
+  #                       a number to the ASCII represenation of the number, 
+  #                       decodes ASCII  numerals to a number
+  # [+A_Codec+]           passes through ASCII string checking they conform to [A-Za-z]
+  #                       during encoding, no validity check during decoding. 
+  # [+AN_Codec+]          passes through ASCII string checking they conform to [A-Za-z0-9]
+  #                       during encoding, no validity check during decoding. 
+  # [+ANP_Codec+]         passes through ASCII string checking they conform to [A-Za-z0-9 ] 
+  #                       during encoding, no validity check during decoding. 
+  # [+ANS_Codec+]         passes through ASCII string checking they conform to [\x20-\x7E]
+  #                       during encoding, no validity check during decoding.
+  # [+Null_Codec+]        passes anything along untouched.
+  # [<tt>Track2</tt>]     rudimentary check that string conforms to Track2
+  # [+MMDDhhmmssCodec+]   encodes Time, Datetime or String to the described date format, checking 
+  #                       that it is a valid date. Decodes to a DateTime instance, decoding and 
+  #                       encoding perform validity checks!
+  # [+YYMMDDhhmmssCodec+] encodes Time, Datetime or String to the described date format, checking 
+  #                       that it is a valid date. Decodes to a DateTime instance, decoding and 
+  #                       encoding perform validity checks!
+  # [+YYMMCodec+]         encodes Time, Datetime or String to the described date format (exp date), 
+  #                       checking that it is a valid date. Decodes to a DateTime instance, decoding
+  #                       and encoding perform validity checks!
+  #
+  class Codec
+    attr_accessor :encoder
+    attr_accessor :decoder
+
+    def decode(raw)
+      decoder.call(raw)
+    end
+
+    # length is either a fixnum or a lenth encoder.
+    def encode(value)
+      encoder.call(value)
+    end
+  end
+
+  # ASCII_Number
+  ASCII_Number = Codec.new
+  ASCII_Number.encoder= lambda{|num|
+    enc = num.to_s
+    raise ISO8583Exception.new("Invalid value: #{enc} must be numeric!") unless enc =~ /^[0-9]*$/
+    enc
+  }
+
+  ASCII_Number.decoder = lambda{|raw|
+    raw.to_i
+  }
+
+  PASS_THROUGH_DECODER = lambda{|str|
+    str.strip # remove padding
+  }
+
+  # Takes a number or str representation of a number and BCD encodes it, e.g.
+  # "1234" => "\x12\x34"
+  # 3456   => "\x34\x56"
+  #
+  # right justified with null ... (correct to do this? almost certainly not...)
+  Packed_Number = Codec.new
+  Packed_Number.encoder = lambda { |val|
+    val = val.to_s
+    val = val.length % 2 == 0 ? val : "0"+val
+    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9]*$/
+    [val].pack("H*")
+  }
+  Packed_Number.decoder = lambda{|encoded|
+    d = encoded.unpack("H*")[0].to_i
+  }
+
+  A_Codec = Codec.new
+  A_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-z]") unless str =~ /^[A-Za-z]*$/
+    str
+  }
+  A_Codec.decoder = PASS_THROUGH_DECODER
+
+  AN_Codec = Codec.new
+  AN_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-y0-9]") unless str =~ /^[A-Za-z0-9]*$/
+    str
+  }
+  AN_Codec.decoder = PASS_THROUGH_DECODER
+
+  ANP_Codec = Codec.new
+  ANP_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-y0-9 ]") unless str =~ /^[A-Za-z0-9 ]*$/
+    str
+  }
+  ANP_Codec.decoder = PASS_THROUGH_DECODER
+
+  ANS_Codec = Codec.new
+  ANS_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [\x20-\x7E]") unless str =~ /^[\x20-\x7E]*$/
+    str
+  }
+  ANS_Codec.decoder = PASS_THROUGH_DECODER
+
+  Null_Codec = Codec.new
+  Null_Codec.encoder = lambda {|str|
+    str
+  }
+  Null_Codec.decoder = lambda {|str|
+    str.gsub(/\000*$/, '')
+  } 
+
+  Track2 = Codec.new
+  Track2.encoder = lambda{|track2|
+    #SS | PAN | FS | Expiration Date | Service Code | Discretionary Data | ES | LRC
+    # SS = ;
+    # PAN = up to 19 digits (at least 9?)
+    # FS = '='
+    # Exp Date = YYMM
+    # SC: 3 digits or =
+    # ES = ?
+    # lrc : 1byte
+    raise ISO8583Exception.new("Invalid Track2 data: #{track2}") unless track2 =~ /^;*(\d{9,19})=(.*)\?.$/
+    track2
+  }
+  Track2.decoder = PASS_THROUGH_DECODER
+
+  def self._date_codec(fmt) 
+    c = Codec.new
+    c.encoder = lambda {|date|
+      enc = case date
+            when DateTime, Date, Time
+              date.strftime(fmt)
+            when String
+              begin
+                dt = DateTime.strptime(date, fmt)
+                dt.strftime(fmt)
+              rescue
+                raise ISO8583Exception.new("Invalid format encoding: #{date}, must be #{fmt}.")
+              end
+            else  
+              raise ISO8583Exception.new("Don't know how to encode: #{date.class} to a time.")
+            end
+      return enc
+    }
+    c.decoder = lambda {|str|
+      begin
+        DateTime.strptime(str, fmt)
+      rescue
+        raise ISO8583Exception.new("Invalid format decoding: #{str}, must be #{fmt}.")
+      end
+    }
+
+    c
+  end
+
+  MMDDhhmmssCodec   = _date_codec("%m%d%H%M%S")
+  HhmmssCodec       = _date_codec("%H%M%S")
+  YYMMDDhhmmssCodec = _date_codec("%y%m%d%H%M%S")
+  YYMMCodec         = _date_codec("%y%m")
+  MMDDCodec         = _date_codec("%m%d")      
+  YYMMDDCodec       = _date_codec("%y%m%d")  
+
+end

data/lib/iso8583/exception.rb

@@ -0,0 +1,4 @@
+module ISO8583
+  class ISO8583Exception < Exception; end
+  class ISO8583ParseException < ISO8583Exception; end
+end

data/lib/iso8583/field.rb

@@ -0,0 +1,90 @@
+module ISO8583
+
+  class Field
+    # may either be some other Field in which the length is encoded or a Fixnum for
+    # fixed length fields. Length should always be the length of the *encoded* value.
+    # A 6 digit BCD field will require a length 3, as will a 5 digit BCD field.
+    # The subclass BCDField handles this to keep things consistant.
+    attr_accessor :length
+    attr_accessor :codec
+    attr_accessor :padding
+    attr_accessor :max
+
+    attr_writer   :name
+    attr_accessor :bmp
+
+    def name
+      "BMP #{bmp}: #{@name}"
+    end
+
+    def parse(raw)
+      len, raw = case length
+                 when Fixnum
+                   [length, raw]
+                 when Field
+                   length.parse(raw)
+                 else
+                   raise ISO8583Exception.new("Cannot determine the length of '#{name}' field")
+                 end
+
+      raw_value = raw[0,len]
+
+      # make sure we have enough data ...
+      if raw_value.length != len
+        mes = "Field has incorrect length! field: #{raw_value} len/expected: #{raw_value.length}/#{len}"
+        raise ISO8583ParseException.new(mes)
+      end
+
+      rest = raw[len, raw.length]
+      begin
+        real_value = codec.decode(raw_value)
+      rescue
+        raise ISO8583ParseException.new($!.message+" (#{name})")
+      end
+
+      [ real_value, rest ]
+    end
+
+
+    # Encoding needs to consider length representation, the actual encoding (such as charset or BCD) 
+    # and padding. 
+    # The order may be important! This impl calls codec.encode and then pads, in case you need the other 
+    # special treatment, you may need to override this method alltogether.
+    # In other cases, the padding has to be implemented by the codec, such as BCD with an odd number of nibbles.
+    def encode(value)
+      encoded_value = codec.encode(value) 
+
+      if padding
+        if padding.arity == 1
+          encoded_value = padding.call(encoded_value)
+        elsif padding.arity == 2
+          encoded_value = padding.call(encoded_value, length)
+        end
+      end
+
+      len_str = case length
+                when Fixnum
+                  raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
+                  raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
+                  "" 
+                when Field
+                  raise ISO8583Exception.new("Max lenth exceeded: #{value}, max: #{max}") if max && encoded_value.length > max
+                  length.encode(encoded_value.length)
+                else
+                  raise ISO8583Exception.new("Invalid length (#{length}) for '#{name}' field")
+                end
+
+      len_str + encoded_value
+    end
+  end
+
+  class BCDField < Field
+    # This corrects the length for BCD fields, as their encoded length is half (+ parity) of the
+    # content length. E.g. 123 (length = 3) encodes to "\x01\x23" (length 2)
+    def length
+      _length = super
+      (_length % 2) != 0 ? (_length / 2) + 1 : _length / 2
+    end
+  end
+
+end