da_funk 0.4.4

data/lib/device/params_dat.rb

@@ -0,0 +1,119 @@
+class Device
+  class ParamsDat
+    FILE_NAME = "./main/params.dat"
+
+    include Device::Helper
+
+    class << self
+      attr_accessor :file, :apps, :status
+    end
+
+    self.apps = Array.new
+
+    # To control if there is any app and parse worked
+    self.status = false
+
+    def self.setup
+      if File.exists?(FILE_NAME)
+        @file = FileDb.new(FILE_NAME)
+      else
+        false
+      end
+    end
+
+    # TODO Scalone: Change after @bmsatierf change the format
+    # For each apps on apps_list We'll have:
+    # Today: <label>,<arquivo>,<pages>,<crc>;
+    # After: <label>,<arquivo>,<type>,<crc>;
+    # Today: "1 - App,pc2_app.posxml,1,E0A0;"
+    # After: "1 - App,pc2_app.posxml,posxml,E0A0;"
+    # After: "1 - App,pc2_app.zip,ruby,E0A0;"
+    def self.parse_apps
+      @apps = []
+      return unless self.setup
+
+      self.file["apps_list"].to_s.gsub("\"", "").split(";").each do |app|
+        @apps << Device::Application.new(*app.split(","))
+      end
+
+      if (@apps.size >= 1)
+        self.status = true
+      else
+        self.status = false
+      end
+    end
+
+    def self.download
+      if attach
+        Device::Display.clear
+        puts "Downloading Params"
+        ret = Device::Transaction::Download.request_param_file(FILE_NAME)
+        if value = check_download_error(ret)
+          puts "Downloaded Successfully"
+          Device::Network.close_socket
+          # TODO
+          #Device::Network.walk_socket.close unless Device::Network.walk_socket.closed?
+          parse_apps
+        end
+        value
+      end
+    end
+
+    def self.update_apps(force = false)
+      if force || ! self.status
+        self.download
+      end
+      if self.status
+        @apps.each do |app|
+          self.update_app(app)
+        end
+      end
+    end
+
+    def self.format!
+      self.apps.each do |app|
+        File.delete(app.zip) if File.exists?(app.zip)
+        Dir.delete(app.file_no_ext) if File.exists?(app.file_no_ext) && File.exists?(app.file_no_ext)
+      end
+      File.delete(FILE_NAME) if File.exists?(FILE_NAME)
+      Device::System.restart
+    end
+
+    def self.update_app(application)
+      if attach && application
+        Device::Display.clear
+        puts "Downloading #{application.file}..."
+        ret = Device::Transaction::Download.request_file(application.file, application.zip)
+        Device::Network.close_socket
+        # TODO
+        #Device::Network.walk_socket.close unless Device::Network.walk_socket.closed?
+
+        unless check_download_error ret
+          sleep 2
+        end
+      end
+    end
+
+    def self.apps
+      self.parse_apps unless self.status
+      @apps
+    end
+
+    def self.executable_app
+      selected = self.executable_apps
+      if selected.size == 1
+        selected[selected.keys.first]
+      end
+    end
+
+    def self.executable_apps
+      self.apps.select{|app| app.label != "X"}
+    end
+
+    def self.application_menu
+      options = Hash.new
+      executable_apps.each { |app| options[app.label] = app }
+      menu("Application Menu", options, {:number => true})
+    end
+  end
+end

data/lib/device/printer.rb

@@ -0,0 +1,35 @@
+
+class Device
+  class Printer
+    def self.adapter
+      Device.adapter::Printer
+    end
+
+    # Same as print, but add "\n" at end of print
+    #
+    # @param buf [String] Text to be printed.
+    # @param option [Symbol] :big, :bar_code, :bitmap
+    # @return [String] buffer read from keyboard
+    def self.puts(buf, option=nil)
+      adapter.puts(buf, option)
+    end
+
+    # Print buffer
+    #
+    # @param buf [String] Text to be printed.
+    # @param option [Symbol] :big, :bar_code, :bitmap
+    # @return [String] buffer read from keyboard
+    def self.print(buf, option=nil)
+      adapter.print(buf, option)
+    end
+
+    def self.paper?
+      adapter.paper?
+    end
+
+    def self.paperfeed
+      adapter.paperfeed
+    end
+  end
+end
+

data/lib/device/runtime.rb

@@ -0,0 +1,22 @@
+class Device
+  class Runtime
+    def self.adapter
+      Device.adapter::Runtime
+    end
+
+    # Execute app in new context.
+    #   To execute the should exists a zip file cotain the app,
+    #   previously downloaded from CloudWalk.
+    #
+    # @param app [String] App name, example "app", should exists file app.zip
+    # @param json [String] Parameters to confifure new aplication.
+    # @return [Object] From the new runtime instance.
+    def self.execute(app, json = nil)
+      zip = "./#{app}.zip"
+      Device::Display.clear
+      raise File::FileError, zip unless File.exists?(zip)
+      raise "Problem to unzip #{zip}" unless Zip.uncompress(zip, app)
+      return mrb_eval "Context.start('#{app}', '#{Device.adapter}', '#{json}')"
+    end
+  end
+end

data/lib/device/setting.rb

@@ -0,0 +1,63 @@
+
+class Device
+  class Setting
+    FILE_PATH       = "./main/config.dat"
+    HOST_PRODUCTION = "switch.cloudwalk.io"
+    HOST_STAGING    = "switch-staging.cloudwalk.io"
+
+    DEFAULT     = {
+      "host"                        => "switch-staging.cloudwalk.io",
+      "host_port"                   => "31416",
+      "ssl"                         => "1",
+      "user"                        => "",
+      "password"                    => "", #WIFI
+      "apn"                         => "",
+      "authentication"              => "", #WIFI
+      "essid"                       => "", #WIFI
+      "bssid"                       => "", #WIFI
+      "cipher"                      => "", #WIFI
+      "mode"                        => "", #WIFI
+      "channel"                     => "", #WIFI
+      "media"                       => "",
+      "ip"                          => "",
+      "gateway"                     => "",
+      "dns1"                        => "",
+      "dns2"                        => "",
+      "subnet"                      => "",
+      "logical_number"              => "",
+      "network_configured"          => "",
+      "environment"                 => "",
+      "notification_timeout"        => "",
+      "notification_interval"       => "",
+      "notification_stream_timeout" => "",
+      "company_name"                => ""
+    }
+
+    def self.setup
+      @file = FileDb.new(FILE_PATH, DEFAULT)
+      self.host = HOST_STAGING if self.staging?
+      @file
+    end
+
+    def self.production?
+      self.environment == "production"
+    end
+
+    def self.staging?
+      self.environment == "staging"
+    end
+
+    def self.method_missing(method, *args, &block)
+      setup unless @file
+      param = method.to_s
+      if @file[param]
+        @file[param]
+      elsif (param[-1..-1] == "=" && @file[param[0..-2]])
+        @file[param[0..-2]] = args.first
+      else
+        super
+      end
+    end
+  end
+end
+

data/lib/device/support.rb

@@ -0,0 +1,28 @@
+class Device
+  class Support
+    def self.class_to_path(klass)
+      klass.to_s.downcase
+    end
+
+    def self.path_to_class(path)
+      constantize(camelize(remove_extension(path)))
+    end
+
+    def self.camelize(str)
+      str.split('_').map {|w| w.capitalize}.join
+    end
+
+    def self.remove_extension(path)
+      path.to_s.split(".")[-2].split("/").last
+    end
+
+    def self.constantize(name)
+      if ! name.empty? && Object.const_defined?(name)
+        Object.const_get name
+      else
+        nil
+      end
+    end
+  end
+end
+

data/lib/device/system.rb

@@ -0,0 +1,61 @@
+
+class Device
+  class System
+    class << self
+      attr_reader :serial, :backlight
+      attr_accessor :klass
+    end
+
+    def self.adapter
+      Device.adapter::System
+    end
+
+    def self.serial
+      @serial ||= adapter.serial
+    end
+
+    # Set screen backlight (turn on automatically if there has actions like key-pressing, card-swiping or card-inserting).
+    #  0 = Turn off backlight.
+    #  1 = (D200): Keep backlight on for 30 seconds ( auto-shut-down after 30 seconds).
+    #  1 = (Vx510): On.
+    #  2 = (D200): Always on.
+    #  n = (Evo/Telium 2): Percentage until 100.
+    def self.backlight=(level)
+      adapter.backlight = level
+      @backlight = level
+    end
+
+    def self.backlight
+      @backlight ||= adapter.backlight
+    end
+
+    # Read the battery level.
+    #  0 Battery voltage low and battery icon blinks. Suggested that do not process transaction, print and wireless communication etc. at this moment. You should recharge the battery immediately to avoid shut down and lost data.
+    #  1 Battery icon displays 1 grid
+    #  2 Battery icon displays 2 grids
+    #  3 Battery icon displays 3 grids
+    #  4 Battery icon displays 4 grids
+    #  5 Powered by external power supply and the battery in charging. Battery icon displays form empty to full cycle. The battery status indicator on the bottom of terminal is displaying red
+    # 6 Powered by external power supply and the battery charging 6 finished. Battery icon displays full grids. The battery status indicator on the bottom of terminal is displaying green.
+    def self.battery
+      adapter.battery
+    end
+
+    def self.beep
+      adapter.beep
+    end
+
+    def self.restart
+      adapter.restart
+    end
+
+    def self.app
+      self.klass.to_s.downcase
+    end
+
+    def self.model
+      adapter.model
+    end
+  end
+end
+

data/lib/device/transaction/download.rb

@@ -0,0 +1,268 @@
+
+class Device
+  class Transaction
+    class Download
+      ERL_VERSION_MAGIC        = 131
+      ERL_NIL_EXT              = 'j'
+      ERL_SMALL_TUPLE_EXT      = 'h'
+      ERL_ATOM_EXT             = 'd'
+      ERL_BINARY_EXT           = 'm'
+      ERL_INTEGER_EXT          = 'b'
+      ERL_CONTENT_TYPE         = "application/x-erlang-binary"
+      MAXATOMLEN               = 255
+      PARAMS_FILE              = "params.dat"
+
+      SUCCESS                  = 0
+      FILE_NOT_CHANGE          = 1
+      FILE_NOT_FOUND           = 2
+      SERIAL_NUMBER_NOT_FOUND  = 3
+      COMMUNICATION_ERROR      = -1
+      MAPREDUCE_RESPONSE_ERROR = -2
+      IO_ERROR                 = -3
+
+      def self.request_file(remote_path, local_path)
+        download = Device::Transaction::Download.new(Device::System.serial, "", Device.version)
+        download.perform(Device::Network.walk_socket,
+                         Device::Setting.company_name,
+                         remote_path, local_path, Device::System.app,
+                         Device::Setting.logical_number)
+      end
+
+      def self.request_param_file(file = PARAMS_FILE)
+        request_file("#{Device::Setting.logical_number}_#{PARAMS_FILE}", file)
+      end
+
+      attr_accessor :buffer, :request, :first_packet, :socket, :path, :crc
+
+      def initialize(serial, path, version)
+        @serial  = serial
+        @path    = path
+        @version = version
+      end
+
+      #  0: Success
+      # -1: Commnucation error
+      # -2: Mapreduce response error
+      # -3: IO Error
+      def perform(socket, company_name, remote_path, filepath, current_app, logical_number, file_crc = nil)
+        @socket, @buffer, @request, @first_packet = socket, "", "", ""
+        @crc = file_crc ? file_crc : generate_crc(filepath)
+        key = "#{company_name}_#{remote_path}"
+
+        ei_encode_version                # version
+        ei_encode_list_header(3)         # mapreduce with 3 tuples
+        ei_encode_tuple_header(2)        # tuple 1 inputs
+        ei_encode_atom("inputs")         # atom inputs
+        ei_encode_list_header(1)         # list inputs
+        ei_encode_tuple_header(2)        # tuple contendo 2 elementos binarios, bucket and key
+        ei_encode_binary("assets")       # elemento binario bucket
+        ei_encode_binary(key)            # elemento binario key
+        ei_encode_list_header(0)         # fim da list do inputs
+
+        ei_encode_tuple_header(2)        # tuple 2: query
+        ei_encode_atom("query")          # atom query
+        ei_encode_list_header(1)         # list da query
+        ei_encode_tuple_header(4)        # tuple contendo 4 elementos, { map, {modfun,Module,Function}, args, true }
+        ei_encode_atom("map")            # primeiro elemento, atom type
+        ei_encode_tuple_header(3)        # segundo elemento, nova tuple contendo 3 atoms
+        ei_encode_atom("modfun")         # primeiro atom do segundo elemento, modfun
+        ei_encode_atom("walk")           # segundo atom do segundo elemento, Module
+        ei_encode_atom("get_asset")      # terceiro atom do segundo elemento, Function
+
+        ei_encode_list_header(7)         # terceiro elemento, uma list com parametros do walk
+        ei_encode_binary(@serial)        # elemento binario serialterminal
+        ei_encode_binary(@version)       # elemento binario versao walk
+        ei_encode_binary(remote_path)      # elemento binario nomeaplicativo
+        ei_encode_binary(crc)            # elemento binario crc aplicativo
+        ei_encode_binary("")             # elemento binario buffer do posxml
+        ei_encode_binary(logical_number) # elemento binario numero do terminal
+        ei_encode_binary(current_app)    # elemento binario nome do aplicativo que esta sendo executado
+        ei_encode_list_header(0)         # fim da list com parametros do walk
+
+        ei_encode_atom("true")           # quarto elemento, atom true
+        ei_encode_list_header(0)         # fim da list da query
+
+        ei_encode_tuple_header(2)        # tuple 3: timeout
+        ei_encode_atom("timeout")        # atom timeout
+        ei_encode_long(5000)             # integer timeout
+        ei_encode_list_header(0)         # fim da list do mapreduce contendo 3 tuples
+
+        mount_request                    # add request to protocol buffers message
+
+        return COMMUNICATION_ERROR unless @socket
+
+        # Send Request
+        socket.write(@request)
+
+        return COMMUNICATION_ERROR if (response_size = get_response_size(socket.read(4))) <= 0
+
+        return MAPREDUCE_RESPONSE_ERROR unless @first_packet = get_binary_term_beginning(response_size)
+
+        return_code = @first_packet[7].to_s.unpack("C*").first
+        file_size   = @first_packet[9..12].to_s.unpack("N*").first
+
+        if return_code != FILE_NOT_CHANGE
+          return IO_ERROR if (partial_download_to_store(filepath, response_size, file_size) < 0)
+        end
+
+        # receive 6A
+        @socket.read(1) if response_size > 1024
+
+        return_code
+      end
+
+      def generate_crc(local_path)
+        if File.exists?(local_path)
+          file = File.open(local_path)
+          Device::Crypto.crc16_hex(file.read)
+        else
+          ""
+        end
+      ensure
+        file.close if file
+      end
+
+      private
+
+      def get_response_size(bytes)
+        return -1 if bytes.to_s.size <= 0
+        bytes.to_s.unpack("N*").first
+      end
+
+      def get_binary_term_beginning(response_size)
+        if response_size > 1024
+          packet = socket.read(1024)
+        else
+          packet = socket.read(response_size)
+        end
+
+        if packet.include?("\x83\x6c\x00")
+          "\x83\x6c\x00#{packet.split("\x83\x6C\x00")[1]}"
+        else
+          return false
+        end
+      end
+
+      def makelong(a, b)
+        (a & 0xffff) | ((b & 0xffff) << 16)
+      end
+
+      def makeword(a, b)
+        (a & 0xff) | ((b & 0xff) << 8)
+      end
+
+      def partial_download_to_store(filepath, response_size, file_size)
+        tmp  = tmp_file(filepath)
+        file = File.open(tmp, "w+")
+
+        if (response_size > 1024)
+          file.write(@first_packet[13..-1])
+          downloaded = 1024
+          while(downloaded < (response_size - 1))
+
+            if (to_download = response_size - downloaded) > 1024
+              to_download = 1024
+            else
+              to_download -= 1 # because of 6A
+            end
+
+            downloaded += file.write(socket.read(to_download))
+          end
+        else
+          # -2 because of 6A
+          downloaded = file.write(@first_packet[13..-2])
+        end
+
+        file.close
+        File.rename(tmp, filepath)
+        downloaded
+      end
+
+      def put(value)
+        @buffer << value
+      end
+
+      def put8(value)
+        @buffer << value
+      end
+
+      def put32be(value)
+        @buffer << [value].pack("N")
+      end
+
+      def put16be(value)
+        @buffer << [value].pack("n")
+      end
+
+      def ei_encode_version
+        put8(ERL_VERSION_MAGIC.chr)
+      end
+
+      def ei_encode_list_header(arity)
+        put8(ERL_NIL_EXT)
+        put32be(arity) if arity > 0
+      end
+
+      def ei_encode_tuple_header(arity)
+        # if (arity <= 0xff) ERL_SMALL_TUPLE_EXT else ERL_LARGE_TUPLE_EXT
+        put8(ERL_SMALL_TUPLE_EXT)
+        put8(arity.chr);
+      end
+
+      # TODO: Check why MAXATOMLEN
+      def ei_encode_atom(value)
+        value.size > MAXATOMLEN ? len = MAXATOMLEN : len = value.size
+        put8(ERL_ATOM_EXT)
+        put16be(len)
+        put(value)
+      end
+
+      def ei_encode_binary(value)
+        put8(ERL_BINARY_EXT)
+
+        # TODO: Check it after to implement on put.
+        if value.is_a? Fixnum
+          put32be(2)
+          @buffer << [value].pack("s")
+        else
+          put32be(value.size)
+          put(value)
+        end
+      end
+
+      def ei_encode_long(value)
+        put8(ERL_INTEGER_EXT)
+        put32be(value)
+      end
+
+      def mount_request
+        request_size   = [@buffer.size].pack("s") + "\x01"
+
+        put8("\x12")
+        put8("\x1b")
+        new_request = [@request.size].pack("N")
+        new_request << "\x17"
+        new_request << "\x0A"
+        new_request << "#{request_size}#{@buffer}#{ERL_CONTENT_TYPE}"
+        new_request << @request
+        @request = new_request
+      end
+
+      # MRuby do not support String#ljust
+      # TODO: duplicated from lib/variable.rb
+      def ljust(size, string)
+        if size > string.size
+          string = string + ("\x00" * (size - string.size))
+        end
+        string
+      end
+
+      def tmp_file(path)
+        paths = path.split("/")
+        paths[-1] = "tmp_#{paths.last}"
+        paths.join("/")
+      end
+    end
+  end
+end
+

data/lib/device/transaction/emv.rb

@@ -0,0 +1,45 @@
+
+class Device
+  class Transaction
+    class EMV
+      class << self
+        attr_accessor :status, :mk_slot, :pinpad_type, :pinpad_wk, :show_amout
+      end
+
+      attr_accessor :data, :info
+
+      def self.open(mk_slot, pinpad_type, pinpad_wk, show_amout)
+      end
+
+      def self.close
+      end
+
+      def self.load_tables(acquirer)
+      end
+
+      def clean
+        @data = {:init => {}, :process => {}, :finish => {}}
+        @info = {:init => {}, :process => {}, :finish => {}}
+      end
+
+      def init
+      end
+
+      def response
+      end
+
+      def parameters
+      end
+
+      def timeout=(seconds)
+      end
+
+      def timeout
+      end
+
+      def remove_card
+      end
+    end
+  end
+end
+