da_funk 0.28.0 → 1.0.0

data/lib/device/setting.rb

@@ -112,11 +112,11 @@ class Device
 
     # Custom Attributes
     def self.tcp_recv_timeout
-      Device::ParamsDat.file["tcp_recv_timeout"] || method_missing(:tcp_recv_timeout)
+      DaFunk::ParamsDat.file["tcp_recv_timeout"] || method_missing(:tcp_recv_timeout)
     end
 
     def self.attach_gprs_timeout
-      value = (Device::ParamsDat.file["attach_gprs_timeout"] || method_missing(:attach_gprs_timeout))
+      value = (DaFunk::ParamsDat.file["attach_gprs_timeout"] || method_missing(:attach_gprs_timeout))
       value.to_s.empty? ? nil : value.to_s.to_i
     end
   end

data/test/integration/mrb_eval_test.rb

@@ -6,8 +6,8 @@ class MrbEvalTest < DaFunk::Test.case
     Device::Setting.company_name = "pc1"
     Device::Setting.logical_number = "1234"
 
-    Device::Notification.start
-    Device::Notification.check
+    DaFunk::Notification.start
+    DaFunk::Notification.check
 
     http = SimpleHttp.new('http', 'http://google.com', 443)
     http.socket = Device::Network.socket.call
@@ -33,4 +33,4 @@ EOF
 
     assert_equal 302, mrb_eval(command)
   end
-end
+end

data/test/integration/notification_test.rb

@@ -2,15 +2,15 @@
 class NotificationTest < DaFunk::Test.case
   def test_notification
     Device::Setting.company_name = "pc1"
-    Device::Notification.setup
-    notification = Device::Notification.new
+    DaFunk::Notification.setup
+    notification = DaFunk::Notification.new
 
     assert_equal nil, notification.check
     notification.check
     notification.check
     assert notification.close
     assert notification.closed?
-    notification = Device::Notification.new
+    notification = DaFunk::Notification.new
     assert_equal nil, notification.check
     notification.check
     notification.check
@@ -21,12 +21,12 @@ class NotificationTest < DaFunk::Test.case
   def test_notification_SHOW_MESSAGE
     $status = nil
     Device::Setting.company_name = "pc1"
-    Device::Notification.setup
-    Device::NotificationCallback.new "SHOW_MESSAGE", :on => Proc.new { |message,datetime|
+    DaFunk::Notification.setup
+    DaFunk::NotificationCallback.new "SHOW_MESSAGE", :on => Proc.new { |message,datetime|
       $status = message
     }
 
-    notification = Device::Notification.new
+    notification = DaFunk::Notification.new
 
     p "Must create message AAAA"
     p "Remember to Press Enter after message appears"

data/test/integration/params_dat_test.rb

@@ -5,7 +5,7 @@ class ParamsDatTest < DaFunk::Test.case
     Device::Setting.host = Device::Setting::HOST_STAGING
     Device::Setting.company_name = "pc1"
     Device::Setting.logical_number = "1410"
-    Device::ParamsDat.update_apps
-    Device::ParamsDat.application_menu
+    DaFunk::ParamsDat.update_apps
+    DaFunk::ParamsDat.application_menu
   end
 end

data/test/unit/device/application_test.rb

@@ -11,17 +11,17 @@ class ApplicationTest < DaFunk::Test.case
   end
 
   def test_check_crc_true
-    application = Device::Application.new("TTT", @file_path, "ruby", nil)
+    application = DaFunk::Application.new("TTT", @file_path, "ruby", nil)
     assert_equal true, application.outdated?
   end
 
   def test_check_crc_false
-    application = Device::Application.new("TTT", @file_path, "ruby", @crc)
+    application = DaFunk::Application.new("TTT", @file_path, "ruby", @crc)
     assert_equal false, application.outdated?
   end
 
   def test_check_crc_non_file
-    application = Device::Application.new("TTT", "./non_exists", "ruby", "1111")
+    application = DaFunk::Application.new("TTT", "./non_exists", "ruby", "1111")
     assert_equal true, application.outdated?
   end
 

data/test/unit/device/notification_event_test.rb

@@ -8,7 +8,7 @@ class NotificationEventTest < DaFunk::Test.case
       "Name" => "pc1;0101",
       "Event" => "user"
     }
-    @event = Device::NotificationEvent.new(@stream_event)
+    @event = DaFunk::NotificationEvent.new(@stream_event)
   end
 
   def test_attr_coalesce
@@ -59,14 +59,14 @@ class NotificationEventTest < DaFunk::Test.case
   def test_attr_one_parameter
     stream_event = @stream_event.dup
     stream_event["Payload"].gsub!("a", "|")
-    event = Device::NotificationEvent.new(stream_event)
+    event = DaFunk::NotificationEvent.new(stream_event)
     assert_equal ["ge 62"], event.parameters
   end
 
   def test_attr_multiple_parameters
     stream_event = @stream_event.dup
     stream_event["Payload"].gsub!("e", "|")
-    event = Device::NotificationEvent.new(stream_event)
+    event = DaFunk::NotificationEvent.new(stream_event)
     assert_equal ["ssag", " 62"], event.parameters
   end
 end

data/test/unit/device/notification_test.rb

@@ -1,7 +1,7 @@
 
 class NotificationTest < DaFunk::Test.case
   def setup
-    @notification = Device::Notification.new(15, 10)
+    @notification = DaFunk::Notification.new(15, 10)
   end
 
   def test_interval_last_check_blank

data/test/unit/params_dat_test.rb

@@ -1,11 +1,11 @@
 
 class ParamsDatTest < DaFunk::Test.case
   def test_params_dat_not_nil_file
-    assert_equal false, Device::ParamsDat.file.nil?
+    assert_equal false, DaFunk::ParamsDat.file.nil?
   end
 
   def test_params_dat_initialize_calling_file
-    assert Device::ParamsDat.file.hash.is_a? Hash
+    assert DaFunk::ParamsDat.file.hash.is_a? Hash
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: da_funk
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Thiago Scalone
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-07 00:00:00.000000000 Z
+date: 2018-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -152,6 +152,7 @@ files:
 - guides/sample_transaction_iso8583.rb
 - imgs/daft-punk-da-funk.jpg
 - lib/da_funk.rb
+- lib/da_funk/application.rb
 - lib/da_funk/callback_flow.rb
 - lib/da_funk/engine.rb
 - lib/da_funk/event_handler.rb
@@ -162,33 +163,30 @@ files:
 - lib/da_funk/i18n.rb
 - lib/da_funk/i18n_error.rb
 - lib/da_funk/iso8583.rb
+- lib/da_funk/notification.rb
+- lib/da_funk/notification_callback.rb
+- lib/da_funk/notification_event.rb
+- lib/da_funk/params_dat.rb
 - lib/da_funk/rake_task.rb
 - lib/da_funk/screen.rb
 - lib/da_funk/screen_flow.rb
 - lib/da_funk/struct.rb
 - lib/da_funk/test.rb
+- lib/da_funk/transaction/download.rb
+- lib/da_funk/transaction/iso.rb
 - lib/da_funk/version.rb
 - lib/device.rb
-- lib/device/application.rb
 - lib/device/audio.rb
 - lib/device/crypto.rb
 - lib/device/display.rb
-- lib/device/helper.rb
 - lib/device/io.rb
 - lib/device/magnetic.rb
 - lib/device/network.rb
-- lib/device/notification.rb
-- lib/device/notification_callback.rb
-- lib/device/notification_event.rb
-- lib/device/params_dat.rb
 - lib/device/printer.rb
 - lib/device/runtime.rb
 - lib/device/setting.rb
 - lib/device/support.rb
 - lib/device/system.rb
-- lib/device/transaction/download.rb
-- lib/device/transaction/emv.rb
-- lib/device/transaction/iso.rb
 - lib/device/version.rb
 - lib/ext/array.rb
 - lib/ext/float.rb
@@ -206,11 +204,6 @@ files:
 - lib/iso8583/message.rb
 - lib/iso8583/util.rb
 - lib/iso8583/version.rb
-- lib/serfx.rb
-- lib/serfx/commands.rb
-- lib/serfx/connection.rb
-- lib/serfx/exceptions.rb
-- lib/serfx/response.rb
 - lib/zip.rb
 - out/da_funk.mrb
 - test/integration/getc_test.rb

data/lib/device/helper.rb

@@ -1,5 +0,0 @@
-class Device
-  # Backward compatibility
-  Helper = DaFunk::Helper
-end
-

data/lib/device/notification.rb

@@ -1,173 +0,0 @@
-
-class Device
-  class Notification
-    DEFAULT_TIMEOUT           = 20
-    DEFAULT_INTERVAL          = 10
-    DEFAULT_STREAM_TIMEOUT    = 0
-    DEFAULT_CREATION_INTERVAL = 180
-
-    class << self
-      attr_accessor :callbacks, :current, :last_creation, :creation_interval, :last_event
-    end
-
-    self.callbacks = Hash.new
-    self.creation_interval = DEFAULT_CREATION_INTERVAL
-
-    attr_reader :fiber, :timeout, :interval, :last_check, :stream_timeout
-
-    def self.check
-      self.current.check if self.current
-    end
-
-    def self.execute(event)
-      calls = self.callbacks[event.callback]
-      return unless calls
-      [:before, :on, :after].each do |moment|
-        calls.each{|callback| callback.call(event, moment)}
-      end
-    end
-
-    def self.schedule(callback)
-      self.callbacks[callback.description] ||= []
-      self.callbacks[callback.description] << callback
-    end
-
-    def self.config
-      self.creation_interval      = Device::Setting.notification_socket_timeout.empty? ? DEFAULT_CREATION_INTERVAL : Device::Setting.notification_socket_timeout.to_i
-      notification_timeout        = Device::Setting.notification_timeout.empty? ? DEFAULT_TIMEOUT : Device::Setting.notification_timeout.to_i
-      notification_interval       = Device::Setting.notification_interval.empty? ? DEFAULT_INTERVAL : Device::Setting.notification_interval.to_i
-      notification_stream_timeout = Device::Setting.notification_stream_timeout.empty? ? DEFAULT_STREAM_TIMEOUT : Device::Setting.notification_stream_timeout.to_i
-      [notification_timeout, notification_interval, notification_stream_timeout]
-    end
-
-    def self.start
-      if create_fiber? && Device::Network.connected?
-        unless Device::Notification.current && Device::Notification.current.closed?
-          self.new(*self.config)
-        end
-      end
-    end
-
-    def self.create_fiber?(force = false)
-      (! Device::Setting.company_name.empty?) &&
-        (! Device::Setting.logical_number.empty?) &&
-        (force || self.valid_creation_interval?) &&
-        Device::ParamsDat.file["notification_enabled"] == "1"
-    end
-
-    def self.valid_creation_interval?
-      if @last_creation
-        (@last_creation + self.creation_interval) < Time.now
-      else
-        true
-      end
-    end
-
-    def initialize(timeout = DEFAULT_TIMEOUT, interval = DEFAULT_INTERVAL, stream_timeout = DEFAULT_STREAM_TIMEOUT)
-      @timeout        = timeout
-      @stream_timeout = stream_timeout
-      @interval       = interval
-      Device::Notification.current = self
-      @fiber = create_fiber
-    end
-
-    # Check if there is any notification
-    def check
-      # TODO check if should execute this(because of connection exception)
-      if valid_check_interval? && Device::Network.connected?
-        if @fiber.alive?
-          if (notification = @fiber.resume)
-            Notification.execute(NotificationEvent.new(notification))
-          end
-        else
-          if Device::Notification.create_fiber?(true)
-            self.close
-            @fiber = create_fiber
-          end
-        end
-        @last_check = Time.now
-      end
-    end
-
-    # Close socket and finish Fiber execution
-    def close
-      if closed?
-        true
-      else
-        ! @fiber.resume "close"
-      end
-    end
-
-    def closed?
-      ! @fiber.alive?
-    end
-
-    def valid_check_interval?
-      if @last_check
-        (@last_check + self.interval) < Time.now
-      else
-        true
-      end
-    end
-
-    def valid_event_interval?
-      if @last_event
-        (@last_event + Notification.creation_interval) < Time.now
-      else
-        true
-      end
-    end
-
-    private
-    def reply(conn, ev)
-      if ev.is_a?(Hash)
-        if ev["Event"] == "user" && ev["Payload"] && ev["Payload"].include?("Id")
-          index = ev["Payload"].index("\"Id")
-          id = ev["Payload"][(index+7)..(index+38)]
-          @last_event = Time.now
-          conn.event(event_name, "{\"Id\"=>\"#{id}\"}", false)
-        end
-      elsif ev.nil?
-        if self.valid_event_interval?
-          @last_event = Time.now
-          conn.event(event_name, "", false)
-        end
-      end
-    end
-
-    def check_errors(exception)
-      case exception.message
-      when "Invalid authentication token"
-        Device::Setting.cw_pos_timezone = "" # Clear timezone if authentication error
-      when "Socket closed"
-      else
-      end
-      false
-    end
-
-    def create_fiber
-      Fiber.new do
-        begin
-          Serfx.connect(socket_block: Device::Network.socket, timeout: timeout, stream_timeout: stream_timeout) do |conn|
-            @last_event = Time.now
-            conn.auth(CloudwalkTOTP.at)
-            Device::Notification.last_creation = Time.now
-            conn.stream(subscription) { |ev| reply(conn, ev) }
-          end
-          true
-        rescue => exception
-          check_errors(exception)
-        end
-      end
-    end
-
-    def subscription
-      "user:#{event_name}"
-    end
-
-    def event_name
-      "#{Device::Setting.company_name};#{Device::Setting.logical_number}"
-    end
-  end
-end
-

data/lib/device/notification_event.rb

@@ -1,39 +0,0 @@
-class Device
-  class NotificationEvent
-    attr_reader :values, :coalesce, :ltime, :payload, :name, :event, :message, :value, :body, :callback, :parameters
-
-    def initialize(values)
-      @values = values
-      parse(values)
-    end
-
-    def type
-      @event
-    end
-
-    private
-    def parse(values)
-      @coalesce = values["Coalesce"]
-      @ltime    = values["LTime"]
-      @payload  = values["Payload"]
-      @name     = values["Name"]
-      @event    = values["Event"]
-
-      @message  = payload.to_s.gsub("=>", " : ")
-      @value    = JSON.parse(@message) unless @message.empty?
-      @body     = extract_body(value)
-
-      @callback, *@parameters = @body.to_s.split("|")
-    end
-
-    def extract_body(value)
-      unless value.nil?
-        return value["Body"] if value["Body"]
-        # TODO: For some reason the JSON parse has a problem
-        # and extract "B" from "Body"
-        return value["ody"] if value["ody"]
-      end
-    end
-  end
-end
-

data/lib/device/transaction/emv.rb

@@ -1,45 +0,0 @@
-
-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
-

data/lib/serfx/commands.rb

@@ -1,193 +0,0 @@
-module Serfx
-  # Implements all of Serf's rpc commands using
-  # Serfx::Connection#request method
-  module Commands
-    # performs initial hanshake of an RPC session. Handshake has to be the
-    # first command to be invoked during an RPC session.
-    #
-    # @return  [Response]
-    def handshake
-      tcp_send(:handshake, 'Version' => 1, 'SerialNumber' => Device::System.serial)
-      read_response(:handshake)
-    end
-
-    # authenticate against the serf agent. if RPC credentials are setup, then
-    # `auth` has to be second command, immediately after `handshake`.
-    #
-    # @return  [Response]
-    def auth(key = @authkey)
-      tcp_send(:auth, 'AuthKey' => key)
-      read_response(:auth)
-    end
-    # fires an user event
-    #
-    # @param name [String] a string representing name of the event
-    # @param payload [String] payload, default is nil
-    # @param coalesce [Boolena] whether serf should coalesce events within
-    # same name during  similar time frame
-    # @return  [Response]
-    def event(name, payload = nil, coalesce = true)
-      event = {
-        'Name' => name,
-        'Coalesce' => coalesce
-      }
-      event['Payload'] = payload unless payload.nil?
-      request(:event, event)
-    end
-
-    # force a failed node to leave the cluster
-    #
-    # @param node [String] name of the failed node
-    # @return  [Response]
-    def force_leave(node)
-      request(:force_leave, 'Node' => node)
-    end
-
-    # join an existing cluster.
-    #
-    # @param existing [Array] an array of existing serf agents
-    # @param replay [Boolean] Whether events should be replayed upon joining
-    # @return  [Response]
-    def join(existing, replay = false)
-      request(:join, 'Existing' => existing, 'Replay' => replay)
-    end
-
-    # obtain the list of existing members
-    #
-    # @return  [Response]
-    def members
-      request(:members)
-    end
-
-    # obatin the list of cluster members, filtered by tags.
-    #
-    # @param tags [Array] an array of tags for filter
-    # @param status [Boolean] filter members based on their satatus
-    # @param name [String] filter based on exact name or pattern.
-    #
-    # @return  [Response]
-    def members_filtered(tags, status = 'alive', name = nil)
-      filter = {
-        'Tags' => tags,
-        'Status' => status
-      }
-      filter['Name'] = name unless name.nil?
-      request(:members_filtered, filter)
-    end
-
-    # alter the tags on a Serf agent while it is running. A member-update
-    # event will be triggered immediately to notify the other agents in the
-    # cluster of the change. The tags command can add new tags, modify
-    # existing tags, or delete tags
-    #
-    # @param tags [Hash] a hash representing tags as key-value pairs
-    # @param delete_tags [Array] an array of tags to be deleted
-    # @return  [Response]
-    def tags(tags, delete_tags = [])
-      request(:tags, 'Tags' => tags, 'DeleteTags' => delete_tags)
-    end
-
-    # subscribe to a stream of all events matching a given type filter.
-    # Events will continue to be sent until the stream is stopped
-    #
-    # @param types [String] comma separated list of events
-    # @return  [Thread, Response]
-    def stream(types, &block)
-      res = request(:stream, {'Type' => types})
-      loop do
-        header, ev = read_data(self.stream_timeout)
-        check_rpc_error!(header)
-        block.call(ev) if block_given?
-        break unless fiber_yield!(ev)
-      end
-      res
-    end
-
-    # monitor is similar to the stream command, but instead of events it
-    # subscribes the channel to log messages from the agent
-    #
-    # @param loglevel [String]
-    # @return  [Response]
-    def monitor(loglevel = 'debug')
-      request(:monitor, 'LogLevel' => loglevel.upcase)
-    end
-
-    # stop is used to stop either a stream or monitor
-    def stop(sequence_number)
-      tcp_send(:stop, 'Stop' => sequence_number)
-    end
-
-    # leave is used trigger a graceful leave and shutdown of the current agent
-    #
-    # @return  [Response]
-    def leave
-      request(:leave)
-    end
-
-    # query is used to issue a new query
-    #
-    # @param name [String] name of the query
-    # @param payload [String] payload for this query event
-    # @param opts [Hash] additional query options
-    # @return  [Response]
-    def query(name, payload, opts = {}, &block)
-      params = { 'Name' => name, 'Payload' => payload }
-      params.merge!(opts)
-      res = request(:query, params)
-      loop do
-        header, ev = read_data
-        check_rpc_error!(header)
-        block.call(ev) if block_given?
-        break unless fiber_yield!(ev)
-      end
-      res
-    end
-
-    # respond is used with `stream` to subscribe to queries and then respond.
-    #
-    # @param id [Integer] an opaque value that is assigned by the IPC layer
-    # @param payload [String] payload for the response event
-    # @return  [Response]
-    def respond(id, payload)
-      request(:respond, 'ID' => id, 'Payload' => payload)
-    end
-
-    # install a new encryption key onto the cluster's keyring
-    #
-    # @param key [String] 16 bytes of base64-encoded data.
-    # @return  [Response]
-    def install_key(key)
-      request(:install_key, 'Key' => key)
-    end
-
-    # change the primary key, which is used to encrypt messages
-    #
-    # @param key [String] 16 bytes of base64-encoded data.
-    # @return  [Response]
-    def use_key(key)
-      request(:use_key, 'Key' => key)
-    end
-
-    # remove a key from the cluster's keyring
-    #
-    # @param key [String] 16 bytes of base64-encoded data.
-    # @return  [Response]
-    def remove_key(key)
-      request(:remove_key, 'Key' => key)
-    end
-
-    # return a list of all encryption keys currently in use on the cluster
-    #
-    # @return  [Response]
-    def list_keys
-      request(:list_keys)
-    end
-
-    # obtain stats about the agent(same as info command)
-    #
-    # @return  [Response]
-    def stats
-      request(:stats)
-    end
-  end
-end