blockchyp 1.24.14 → 2.0.0.pre.alpha7

data/lib/blockchyp_client.rb

@@ -21,7 +21,6 @@ module BlockChyp
       @signing_key = signing_key
       @gateway_host = 'https://api.blockchyp.com'
       @test_gateway_host = 'https://test.blockchyp.com'
-      @dashboard_host = 'https://dashboard.blockchyp.com'
       @https = false
       @route_cache_location = File.join(Dir.tmpdir, '.blockchyp_route')
       @route_cache_ttl = 60
@@ -39,7 +38,6 @@ module BlockChyp
     attr_reader :offline_fixed_key
     attr_accessor :gateway_host
     attr_accessor :test_gateway_host
-    attr_accessor :dashboard_host
     attr_accessor :https
     attr_accessor :route_cache_ttl
     attr_accessor :gateway_timeout
@@ -47,7 +45,25 @@ module BlockChyp
     attr_accessor :offline_cache_enabled
     attr_accessor :terminal_connect_timeout
     attr_accessor :route_cache_location
-    attr_accessor :route_cache
+
+    def gateway_get(path, test)
+      path = resolve_gateway_url(path, test)
+      puts 'GET: ' + path
+      uri = URI(path)
+      req = Net::HTTP::Get.new(uri)
+      headers = generate_gateway_headers
+      headers.each do |key, value|
+        req[key] = value
+      end
+      res = Net::HTTP.new(uri.host, uri.port).start do |inner_http|
+        inner_http.request(req)
+      end
+      if res.is_a?(Net::HTTPSuccess)
+        JSON.parse(res.body)
+      else
+        raise res.message
+      end
+    end
 
     def generate_gateway_headers
       nonce = CryptoUtils.generate_nonce
@@ -68,213 +84,134 @@ module BlockChyp
       OpenSSL::HMAC.hexdigest('SHA256', CryptoUtils.hex2bin(signing_key), canonical_string)
     end
 
-    def resolve_gateway_uri(path, request)
-      url = request.nil? || !request[:test] ? gateway_host : test_gateway_host
-
-      URI.parse(path.nil? ? url : url + path)
-    end
+    def resolve_gateway_url(path, test)
+      url = if test
+              test_gateway_host
+            else
+              gateway_host
+            end
 
-    def resolve_dashboard_uri(path, request)
-      URI.parse(dashboard_host + path)
+      url + path
     end
 
     def generate_error_response(msg)
-      {
-        success: false,
-        error: msg,
-        responseDescription: msg
-      }
+      [
+        'success' => false,
+        'error' => msg,
+        'responseDescription' => msg
+      ]
     end
 
-    def route_terminal_request(method, terminal_path, gateway_path, request)
-      unless request.key?(:terminalName)
-        return gateway_request(method, gateway_path, request)
+    def route_terminal_request(request, terminal_path, gateway_path, method)
+      if request['terminalName'].nil?
+        return gateway_request(gateway_path, request, method)
       end
 
-      route = resolve_terminal_route(request[:terminalName])
+      route = resolve_terminal_route(request['terminalName'])
       if !route
         return generate_error_response('Unkown Terminal')
-      elsif route[:cloudRelayEnabled]
-        return gateway_request(method, gateway_path, request, relay: true)
+      elsif route['cloudRelayEnabled']
+        return gateway_request(gateway_path, request, method)
       end
 
-      terminal_request(method, route, terminal_path, request, true)
+      terminal_request(route, terminal_path, request, method, true)
     end
 
-    def terminal_request(method, route, path, request, open_retry)
-      uri = resolve_terminal_uri(route, path)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.instance_of?(URI::HTTPS)
-      timeout = get_timeout(request, terminal_timeout)
-      http.open_timeout = timeout
-      http.read_timeout = timeout
-
-      tx_creds = route[:transientCredentials]
-
-      wrapped_request = {
-        apiKey: tx_creds[:apiKey],
-        bearerToken: tx_creds[:bearerToken],
-        signingKey: tx_creds[:signingKey],
-        request: request
+    def terminal_request(route, path, request, method, open_retry)
+      url = resolve_terminal_url(route, path)
+
+      tx_creds = route['transientCredentials']
+
+      terminal_request = {
+        'apiKey' => tx_creds['apiKey'],
+        'bearerToken' => tx_creds['bearerToken'],
+        'signingKey' => tx_creds['signingKey'],
+        'request' => request
       }
 
-      req = get_http_request(method, uri)
+      puts method + ': ' + url
+      puts terminal_request.to_json
 
-      req['User-Agent'] = user_agent
-      json = wrapped_request.to_json
+      uri = URI(url)
+      req = if method == 'PUT'
+              Net::HTTP::Put.new(uri)
+            else
+              Net::HTTP::Post.new(uri)
+            end
+      json = terminal_request.to_json
       req['Content-Type'] = 'application/json'
       req['Content-Length'] = json.length
       req.body = json
-
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = terminal_connect_timeout
+      http.read_timeout = terminal_timeout
       begin
-        response = http.request(req)
+        res = http.start do |inner_http|
+          inner_http.request(req)
+        end
       rescue Net::OpenTimeout, Errno::EHOSTDOWN, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH
         if open_retry
-          evict(route[:terminalName])
-          route = resolve_terminal_route(route[:terminalName])
-          return terminal_request(method, route, path, request, false)
+          evict(route['terminalName'])
+          route = resolve_terminal_route(route['terminalName'])
+          return terminal_request(route, path, request, method, false)
         end
-        raise
       end
-      if response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body, symbolize_names: true)
+      if res.is_a?(Net::HTTPSuccess)
+        puts 'Response: ' + res.body
+        JSON.parse(res.body)
       else
-        raise response.message
-      end
-    end
-
-    def get_http_request(method, uri)
-      case method
-      when 'GET'
-        Net::HTTP::Get.new(uri.request_uri)
-      when 'PUT'
-        Net::HTTP::Put.new(uri.request_uri)
-      when 'POST'
-        Net::HTTP::Post.new(uri.request_uri)
-      when 'DELETE'
-        Net::HTTP::Delete.new(uri.request_uri)
+        raise res.message
       end
     end
 
-    def resolve_terminal_uri(route, path)
+    def resolve_terminal_url(route, path)
       url = if https
               'https://'
             else
               'http://'
             end
-      url += route[:ipAddress]
+      url += route['ipAddress']
       port = if https
                ':8443'
              else
                ':8080'
              end
-      URI.parse(url + port + path)
-    end
-
-    def dashboard_request(method, path, request = nil)
-      uri = resolve_dashboard_uri(path, request)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.instance_of?(URI::HTTPS)
-      timeout = get_timeout(request, gateway_timeout)
-      http.open_timeout = timeout
-      http.read_timeout = timeout
-
-      req = get_http_request(method, uri)
-
-      req['User-Agent'] = user_agent
-      unless request.nil?
-        json = request.to_json
-        req['Content-Type'] = 'application/json'
-        req['Content-Length'] = json.length
-        req.body = json
-      end
-
-      headers = generate_gateway_headers
-      headers.each do |key, value|
-        req[key] = value
-      end
-
-      response = http.request(req)
-
-      if response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body, symbolize_names: true)
-      else
-        raise response.message
-      end
+      url + port + path
     end
 
-    def upload_request(path, request, content)
-      uri = resolve_dashboard_uri(path, request)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.instance_of?(URI::HTTPS)
-      timeout = get_timeout(request, gateway_timeout)
-      http.open_timeout = timeout
-      http.read_timeout = timeout
-
-      req = get_http_request("POST", uri)
-      req.body = content
-      req['User-Agent'] = user_agent
-      req['Content-Type'] = 'application/octet-stream'
-
-      if request[:fileName]
-        req['X-Upload-File-Name'] = request[:fileName]
-      end
-
-      if request[:uploadId]
-        req['X-Upload-ID'] = request[:uploadId]
-      end
+    def gateway_request(path, request, method)
+      url = resolve_gateway_url(path, request['test'])
 
-      if request[:fileSize]
-        req['X-File-Size'] = request[:fileSize]
-        req['Content-Length'] = request[:fileSize]
-      end
+      puts method + ': ' + url
+      puts request.to_json
 
+      uri = URI(url)
+      req = if method == 'PUT'
+              Net::HTTP::Put.new(uri)
+            else
+              Net::HTTP::Post.new(uri)
+            end
+      json = request.to_json
+      req['Content-Type'] = 'application/json'
+      req['Content-Length'] = json.length
       headers = generate_gateway_headers
       headers.each do |key, value|
         req[key] = value
       end
-
-      response = http.request(req)
-
-      if response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body, symbolize_names: true)
-      else
-        raise response.message
-      end
-    end
-
-    def gateway_request(method, path, request = nil, relay = false)
-      uri = resolve_gateway_uri(path, request)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.instance_of?(URI::HTTPS)
-      timeout = get_timeout(request, relay ? terminal_timeout : gateway_timeout)
-      http.open_timeout = timeout
-      http.read_timeout = timeout
-
-      req = get_http_request(method, uri)
-
-      req['User-Agent'] = user_agent
-      unless request.nil?
-        json = request.to_json
-        req['Content-Type'] = 'application/json'
-        req['Content-Length'] = json.length
-        req.body = json
-      end
-
-      headers = generate_gateway_headers
-      headers.each do |key, value|
-        req[key] = value
+      req.body = json
+      res = Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.request(req)
       end
-
-      response = http.request(req)
-
-      if response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body, symbolize_names: true)
+      if res.is_a?(Net::HTTPSuccess)
+        puts 'Response: ' + res.body
+        JSON.parse(res.body)
       else
-        raise response.message
+        raise res.message
       end
     end
 
+    attr_accessor :routeCache
+
     def resolve_terminal_route(terminal_name)
       route = route_cache_get(terminal_name, false)
 
@@ -286,8 +223,8 @@ module BlockChyp
 
         ttl = Time.now.utc + (route_cache_ttl * 60)
         route_cache_entry = {}
-        route_cache_entry[:route] = route
-        route_cache_entry[:ttl] = ttl
+        route_cache_entry['route'] = route
+        route_cache_entry['ttl'] = ttl
         @route_cache[api_key + terminal_name] = route_cache_entry
         update_offline_cache(route_cache_entry)
       end
@@ -298,21 +235,19 @@ module BlockChyp
       if offline_cache_enabled
         offline_cache = read_offline_cache
         offline_entry = route_cache_entry.clone
-        route = route_cache_entry[:route].clone
-        tx_creds = route[:transientCredentials].clone
-        tx_creds[:apiKey] = encrypt(tx_creds[:apiKey])
-        tx_creds[:bearerToken] = encrypt(tx_creds[:bearerToken])
-        tx_creds[:signingKey] = encrypt(tx_creds[:signingKey])
-        route[:transientCredentials] = tx_creds
-        offline_entry[:route] = route
-        offline_cache[api_key + route[:terminalName]] = offline_entry
+        route = route_cache_entry['route'].clone
+        tx_creds = route['transientCredentials'].clone
+        tx_creds['apiKey'] = encrypt(tx_creds['api_key'])
+        tx_creds['bearerToken'] = encrypt(tx_creds['bearerToken'])
+        tx_creds['signingKey'] = encrypt(tx_creds['signingKey'])
+        route['transientCredentials'] = tx_creds
+        offline_entry['route'] = route
+        offline_cache[apiKey + route['terminalName']] = offline_entry
         File.write(route_cache_location, offline_cache.to_json)
       end
     end
 
     def encrypt(plain_text)
-      return plain_text if plain_text.nil? || plain_text.empty?
-
       cipher = OpenSSL::Cipher::AES256.new(:CBC)
       cipher.encrypt
       cipher.key = derive_offline_key
@@ -322,12 +257,8 @@ module BlockChyp
     end
 
     def decrypt(cipher_text)
-      return cipher_text if cipher_text.nil? || cipher_text.empty?
-
       tokens = cipher_text.split(':')
 
-      return cipher_text if tokens[0].nil? || tokens[1].nil?
-
       iv = Base64.decode64(tokens[0])
       cp = Base64.decode64(tokens[1])
 
@@ -344,9 +275,9 @@ module BlockChyp
     end
 
     def request_route_from_gateway(terminal_name)
-      route = gateway_request('GET', '/api/terminal-route?terminal=' + CGI.escape(terminal_name))
-      if !route.nil? && !route[:ipAddress].empty?
-        route[:exists] = true
+      route = gateway_get('/api/terminal-route?terminal=' + CGI.escape(terminal_name), false)
+      if !route.nil? && !route['ipAddress'].empty?
+        route['exists'] = true
       end
       route
     end
@@ -368,49 +299,36 @@ module BlockChyp
       end
 
       if route_cache_entry
-        route = route_cache_entry[:route]
-        tx_creds = route[:transientCredentials]
-        tx_creds[:apiKey] = decrypt(tx_creds[:apiKey])
-        tx_creds[:bearerToken] = decrypt(tx_creds[:bearerToken])
-        tx_creds[:signingKey] = decrypt(tx_creds[:signingKey])
-        route[:transientCredentials] = tx_creds
-        route_cache_entry[:route] = route
-
-        raw_ttl = route_cache_entry[:ttl]
-
-        ttl = raw_ttl.instance_of?(Time) ? raw_ttl : Time.parse(route_cache_entry[:ttl])
+        route = route_cache_entry['route']
+        tx_creds = route['transientCredentials']
+        tx_creds['apiKey'] = decrypt(tx_creds['apiKey'])
+        tx_creds['bearerToken'] = decrypt(tx_creds['bearerToken'])
+        tx_creds['signingKey'] = decrypt(tx_creds['signingKey'])
+        route['transientCredentials'] = tx_creds
+        routeCacheEntry['route'] = route
+      end
 
-        if stale || Time.new < ttl
-          route_cache_entry[:route]
+      if route_cache_entry
+        now = Time.new
+        ttl = Time.parse(route_cache_entry['ttl'])
+        if stale || now < ttl
+          puts 'Cache Hit ' + route_cache_entry.to_json
+          route_cache_entry['route']
         end
       end
     end
 
     def read_offline_cache
+      puts route_cache_location
+
       if File.file?(route_cache_location)
 
         config_file = File.open(route_cache_location)
         content = config_file.read
 
-        return JSON.parse(content, symbolize_names: true)
+        return JSON.parse(content)
       end
       {}
     end
-
-    def user_agent
-      if defined? VERSION
-        "BlockChyp-Ruby/#{VERSION}"
-      else
-        'BlockChyp-Ruby'
-      end
-    end
-
-    def get_timeout(request, default)
-      if request.nil? || !request.key?(:timeout) || request[:timeout].zero?
-        return default
-      end
-
-      request[:timeout]
-    end
   end
 end

data/test/boolean_prompt_test.rb

@@ -1,49 +1,35 @@
 # frozen_string_literal: true
 
-# Copyright 2019-2022 BlockChyp, Inc. All rights reserved. Use of this code is
-# governed by a license that can be found in the LICENSE file.
-#
-# This file was generated automatically by the BlockChyp SDK Generator.
-# Changes to this file will be lost every time the code is regenerated.
-
 require ::File.expand_path('test_helper', __dir__)
 
 module BlockChyp
   class BooleanPromptTest < TestCase
     def test_boolean_prompt
-
-      puts "Running test_boolean_prompt..."
-
       config = load_test_config
 
       blockchyp = BlockChyp.new(
-        config[:apiKey],
-        config[:bearerToken],
-        config[:signingKey]
+        config['apiKey'],
+        config['bearerToken'],
+        config['signingKey']
       )
-      blockchyp.gateway_host = config[:gatewayHost]
-      blockchyp.test_gateway_host = config[:testGatewayHost]
-      blockchyp.dashboard_host = config[:dashboardHost]
-
-      test_delay(blockchyp, 'boolean_prompt_test', config[:defaultTerminalName])
-
+      blockchyp.gateway_host = config['gatewayHost']
+      blockchyp.test_gateway_host = config['testGatewayHost']
+
+      test_delay(blockchyp, 'BooleanPromptTest')
+      # setup request object
+      request = {}
+      request['test'] = true
+      request['terminalName'] = 'Test Terminal'
+      request['prompt'] = 'Would you like to become a member?'
+      request['yesCaption'] = 'Yes'
+      request['noCaption'] = 'No'
+      response = blockchyp.booleanPrompt(request)
 
-
-
-      # Set request parameters
-      request = {
-        test: true,
-        terminalName: config[:defaultTerminalName],
-        prompt: 'Would you like to become a member?',
-        yesCaption: 'Yes',
-        noCaption: 'No'
-      }
-
-      response = blockchyp.boolean_prompt(request)
       assert_not_nil(response)
       # response assertions
-      assert(response[:success])
-      assert(response[:response])
+      assert(response['success'])
+      assert(response['response'])
     end
+
   end
 end

data/test/heartbeat_test.rb

@@ -8,20 +8,20 @@ module BlockChyp
       config = load_test_config
 
       blockchyp = BlockChyp.new(
-        config[:apiKey],
-        config[:bearerToken],
-        config[:signingKey]
+        config['apiKey'],
+        config['bearerToken'],
+        config['signingKey']
       )
-      blockchyp.gateway_host = config[:gatewayHost]
-      blockchyp.test_gateway_host = config[:testGatewayHost]
+      blockchyp.gatewayHost = config['gatewayHost']
+      blockchyp.testGatewayHost = config['testGatewayHost']
 
       response = blockchyp.heartbeat(true)
       assert_not_nil(response)
-      assert(response[:success])
-      assert(!response[:timestamp].empty?)
-      assert(!response[:clockchain].empty?)
-      assert(!response[:latestTick].empty?)
-      assert(!response[:merchantPk].empty?)
+      assert(response['success'])
+      assert(!response['timestamp'].empty?)
+      assert(!response['clockchain'].empty?)
+      assert(!response['latestTick'].empty?)
+      assert(!response['merchantPk'].empty?)
     end
   end
 end

data/test/new_transaction_display_test.rb

@@ -1,64 +1,70 @@
 # frozen_string_literal: true
 
-# Copyright 2019-2022 BlockChyp, Inc. All rights reserved. Use of this code is
-# governed by a license that can be found in the LICENSE file.
-#
-# This file was generated automatically by the BlockChyp SDK Generator.
-# Changes to this file will be lost every time the code is regenerated.
-
 require ::File.expand_path('test_helper', __dir__)
 
 module BlockChyp
   class NewTransactionDisplayTest < TestCase
     def test_new_transaction_display
-
-      puts "Running test_new_transaction_display..."
-
       config = load_test_config
 
       blockchyp = BlockChyp.new(
-        config[:apiKey],
-        config[:bearerToken],
-        config[:signingKey]
+        config['apiKey'],
+        config['bearerToken'],
+        config['signingKey']
       )
-      blockchyp.gateway_host = config[:gatewayHost]
-      blockchyp.test_gateway_host = config[:testGatewayHost]
-      blockchyp.dashboard_host = config[:dashboardHost]
+      blockchyp.gateway_host = config['gatewayHost']
+      blockchyp.test_gateway_host = config['testGatewayHost']
 
-      test_delay(blockchyp, 'new_transaction_display_test', config[:defaultTerminalName])
+      test_delay(blockchyp, 'NewTransactionDisplayTest')
+      # setup request object
+      request = {}
+      request['test'] = true
+      request['terminalName'] = 'Test Terminal'
+      request['transaction'] = new_transaction_display_transaction
+      response = blockchyp.newTransactionDisplay(request)
 
+      assert_not_nil(response)
+      # response assertions
+      assert(response['success'])
+    end
 
+    def new_transaction_display_transaction
+      val = {}
+      val['subtotal'] = '35.00'
+      val['tax'] = '5.00'
+      val['total'] = '70.00'
+      val['items'] = new_transaction_display_items
+      val
+    end
 
+    def new_transaction_display_items
+      val = []
+      val.push(new_transaction_display_item_2)
+      val
+    end
 
-      # Set request parameters
-      request = {
-        test: true,
-        terminalName: config[:defaultTerminalName],
-        transaction: {
-          subtotal: '35.00',
-          tax: '5.00',
-          total: '70.00',
-          items: [
-            {
-              description: 'Leki Trekking Poles',
-              price: '35.00',
-              quantity: 2,
-              extended: '70.00',
-              discounts: [
-                {
-                  description: 'memberDiscount',
-                  amount: '10.00'
-                }
-              ]
-            }
-          ]
-        }
-      }
+    def new_transaction_display_item_2
+      val = {}
+      val['description'] = 'Leki Trekking Poles'
+      val['price'] = '35.00'
+      val['quantity'] = 2
+      val['extended'] = '70.00'
+      val['discounts'] = new_transaction_display_discounts
+      val
+    end
+          
+    def new_transaction_display_discounts
+      val = []
+      val.push(new_transaction_display_discount_2)
+      val
+    end
 
-      response = blockchyp.new_transaction_display(request)
-      assert_not_nil(response)
-      # response assertions
-      assert(response[:success])
+    def new_transaction_display_discount_2
+      val = {}
+      val['description'] = 'memberDiscount'
+      val['amount'] = '10.00'
+      val
     end
+            
   end
 end