blockchyp 2.0.0.pre.alpha7 → 2.0.1.pre.rc8

data/lib/blockchyp.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# Copyright 2019 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. Changes to this file will be lost
+# every time the code is regenerated.
+
 require_relative 'blockchyp_client'
 
 module CardType
@@ -29,79 +35,84 @@ module BlockChyp
   class BlockChyp < BlockChypClient
 
     def heartbeat(test)
-      gateway_get('/api/heartbeat', test)
+      gateway_request('GET', '/api/heartbeat', {'test' => test})
     end
 
     # Executes a standard direct preauth and capture.
     def charge(request)
-      route_terminal_request(request, '/api/charge', '/api/charge', 'POST')
+      route_terminal_request('POST', '/api/charge', '/api/charge', request)
     end
 
     # Executes a preauthorization intended to be captured later.
     def preauth(request)
-      route_terminal_request(request, '/api/preauth', '/api/preauth', 'POST')
+      route_terminal_request('POST', '/api/preauth', '/api/preauth', request)
     end
 
     # Tests connectivity with a payment terminal.
     def ping(request)
-      route_terminal_request(request, '/api/test', '/api/terminal-test', 'POST')
+      route_terminal_request('POST', '/api/test', '/api/terminal-test', request)
     end
 
     # Checks the remaining balance on a payment method.
     def balance(request)
-      route_terminal_request(request, '/api/balance', '/api/balance', 'POST')
+      route_terminal_request('POST', '/api/balance', '/api/balance', request)
     end
 
     # Clears the line item display and any in progress transaction.
     def clear(request)
-      route_terminal_request(request, '/api/clear', '/api/terminal-clear', 'POST')
+      route_terminal_request('POST', '/api/clear', '/api/terminal-clear', request)
     end
 
     # Prompts the user to accept terms and conditions.
     def terms_and_conditions(request)
-      route_terminal_request(request, '/api/tc', '/api/terminal-tc', 'POST')
+      route_terminal_request('POST', '/api/tc', '/api/terminal-tc', request)
     end
 
-    # Appends items to an existing transaction display Subtotal, Tax, and
+    # Appends items to an existing transaction display. Subtotal, Tax, and
     # Total are overwritten by the request. Items with the same description
     # are combined into groups.
     def update_transaction_display(request)
-      route_terminal_request(request, '/api/txdisplay', '/api/terminal-txdisplay', 'PUT')
+      route_terminal_request('PUT', '/api/txdisplay', '/api/terminal-txdisplay', request)
     end
 
     # Displays a new transaction on the terminal.
     def new_transaction_display(request)
-      route_terminal_request(request, '/api/txdisplay', '/api/terminal-txdisplay', 'POST')
+      route_terminal_request('POST', '/api/txdisplay', '/api/terminal-txdisplay', request)
     end
 
-    # Asks the consumer text based question.
+    # Asks the consumer a text based question.
     def text_prompt(request)
-      route_terminal_request(request, '/api/text-prompt', '/api/text-prompt', 'POST')
+      route_terminal_request('POST', '/api/text-prompt', '/api/text-prompt', request)
     end
 
     # Asks the consumer a yes/no question.
     def boolean_prompt(request)
-      route_terminal_request(request, '/api/boolean-prompt', '/api/boolean-prompt', 'POST')
+      route_terminal_request('POST', '/api/boolean-prompt', '/api/boolean-prompt', request)
     end
 
     # Displays a short message on the terminal.
     def message(request)
-      route_terminal_request(request, '/api/message', '/api/message', 'POST')
+      route_terminal_request('POST', '/api/message', '/api/message', request)
     end
 
     # Executes a refund.
     def refund(request)
-      route_terminal_request(request, '/api/refund', '/api/refund', 'POST')
+      route_terminal_request('POST', '/api/refund', '/api/refund', request)
     end
 
     # Adds a new payment method to the token vault.
     def enroll(request)
-      route_terminal_request(request, '/api/enroll', '/api/enroll', 'POST')
+      route_terminal_request('POST', '/api/enroll', '/api/enroll', request)
     end
 
     # Activates or recharges a gift card.
     def gift_activate(request)
-      route_terminal_request(request, '/api/gift-activate', '/api/gift-activate', 'POST')
+      route_terminal_request('POST', '/api/gift-activate', '/api/gift-activate', request)
+    end
+
+    # Returns the current status of a terminal.
+    def terminal_status(request)
+      route_terminal_request('POST', '/api/terminal-status', '/api/terminal-status', request)
     end
     
     # Executes a manual time out reversal.
@@ -115,22 +126,22 @@ module BlockChyp
     # an id, you wouldn't know what it is because your request to the terminal
     # timed out before you got a response.
     def reverse(request)
-      gateway_request('/api/reverse', request, 'POST')
+      gateway_request('POST', '/api/reverse', request)
     end
 
     # Captures a preauthorization.
     def capture(request)
-      gateway_request('/api/capture', request, 'POST')
+      gateway_request('POST', '/api/capture', request)
     end
 
     # Closes the current credit card batch.
     def close_batch(request)
-      gateway_request('/api/close-batch', request, 'POST')
+      gateway_request('POST', '/api/close-batch', request)
     end
 
     # Discards a previous preauth transaction.
     def void(request)
-      gateway_request('/api/void', request, 'POST')
+      gateway_request('POST', '/api/void', request)
     end
 
   end

data/lib/blockchyp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BlockChyp
-  VERSION = '2.0.0.pre.alpha7'
+  VERSION = '2.0.1.pre.rc8'
 end

data/lib/blockchyp_client.rb

@@ -46,25 +46,6 @@ module BlockChyp
     attr_accessor :terminal_connect_timeout
     attr_accessor :route_cache_location
 
-    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
       tsp = CryptoUtils.timestamp
@@ -84,14 +65,14 @@ module BlockChyp
       OpenSSL::HMAC.hexdigest('SHA256', CryptoUtils.hex2bin(signing_key), canonical_string)
     end
 
-    def resolve_gateway_url(path, test)
-      url = if test
-              test_gateway_host
-            else
+    def resolve_gateway_uri(path, request)
+      url = if request.nil? || !request['test']
               gateway_host
+            else
+              test_gateway_host
             end
 
-      url + path
+      URI.parse(url + path)
     end
 
     def generate_error_response(msg)
@@ -102,69 +83,74 @@ module BlockChyp
       ]
     end
 
-    def route_terminal_request(request, terminal_path, gateway_path, method)
+    def route_terminal_request(method, terminal_path, gateway_path, request)
       if request['terminalName'].nil?
-        return gateway_request(gateway_path, request, method)
+        return gateway_request(method, gateway_path, request)
       end
 
       route = resolve_terminal_route(request['terminalName'])
       if !route
         return generate_error_response('Unkown Terminal')
       elsif route['cloudRelayEnabled']
-        return gateway_request(gateway_path, request, method)
+        return gateway_request(method, gateway_path, request, relay: true)
       end
 
-      terminal_request(route, terminal_path, request, method, true)
+      terminal_request(method, route, terminal_path, request, true)
     end
 
-    def terminal_request(route, path, request, method, open_retry)
-      url = resolve_terminal_url(route, path)
+    def terminal_request(method, route, path, request, open_retry)
+      uri = resolve_terminal_uri(route, path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      timeout = get_timeout(request, terminal_timeout)
+      http.open_timeout = timeout
+      http.read_timeout = timeout
 
       tx_creds = route['transientCredentials']
 
-      terminal_request = {
+      wrapped_request = {
         'apiKey' => tx_creds['apiKey'],
         'bearerToken' => tx_creds['bearerToken'],
         'signingKey' => tx_creds['signingKey'],
         'request' => request
       }
 
-      puts method + ': ' + url
-      puts terminal_request.to_json
+      req = get_http_request(method, uri)
 
-      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['User-Agent'] = user_agent
+      json = wrapped_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
-        res = http.start do |inner_http|
-          inner_http.request(req)
-        end
+        response = http.request(req)
       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(route, path, request, method, false)
+          return terminal_request(method, route, path, request, false)
         end
+        raise
       end
-      if res.is_a?(Net::HTTPSuccess)
-        puts 'Response: ' + res.body
-        JSON.parse(res.body)
+      if response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body)
       else
-        raise res.message
+        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)
       end
     end
 
-    def resolve_terminal_url(route, path)
+    def resolve_terminal_uri(route, path)
       url = if https
               'https://'
             else
@@ -176,37 +162,37 @@ module BlockChyp
              else
                ':8080'
              end
-      url + port + path
+      URI.parse(url + port + path)
     end
 
-    def gateway_request(path, request, method)
-      url = resolve_gateway_url(path, request['test'])
-
-      puts method + ': ' + url
-      puts request.to_json
+    def gateway_request(method, path, request = nil, relay = false)
+      uri = resolve_gateway_uri(path, request)
+      http = Net::HTTP.new(uri.host, uri.port)
+      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
 
-      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
-      req.body = json
-      res = Net::HTTP.new(uri.host, uri.port).start do |http|
-        http.request(req)
-      end
-      if res.is_a?(Net::HTTPSuccess)
-        puts 'Response: ' + res.body
-        JSON.parse(res.body)
+
+      response = http.request(req)
+
+      if response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body)
       else
-        raise res.message
+        raise response.message
       end
     end
 
@@ -237,17 +223,19 @@ module BlockChyp
         offline_entry = route_cache_entry.clone
         route = route_cache_entry['route'].clone
         tx_creds = route['transientCredentials'].clone
-        tx_creds['apiKey'] = encrypt(tx_creds['api_key'])
+        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[apiKey + route['terminalName']] = offline_entry
+        offline_cache[api_key + 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
@@ -257,8 +245,12 @@ 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])
 
@@ -275,7 +267,7 @@ module BlockChyp
     end
 
     def request_route_from_gateway(terminal_name)
-      route = gateway_get('/api/terminal-route?terminal=' + CGI.escape(terminal_name), false)
+      route = gateway_request('GET', '/api/terminal-route?terminal=' + CGI.escape(terminal_name))
       if !route.nil? && !route['ipAddress'].empty?
         route['exists'] = true
       end
@@ -305,22 +297,24 @@ module BlockChyp
         tx_creds['bearerToken'] = decrypt(tx_creds['bearerToken'])
         tx_creds['signingKey'] = decrypt(tx_creds['signingKey'])
         route['transientCredentials'] = tx_creds
-        routeCacheEntry['route'] = route
+        route_cache_entry['route'] = route
       end
 
       if route_cache_entry
         now = Time.new
-        ttl = Time.parse(route_cache_entry['ttl'])
+        raw_ttl = route_cache_entry['ttl']
+        if raw_ttl.instance_of?(Time)
+          ttl = raw_ttl
+        else
+          ttl = Time.parse(route_cache_entry['ttl'])
+        end
         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)
@@ -330,5 +324,21 @@ module BlockChyp
       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['timeout'].nil? || request['timeout'].zero?
+        return default
+      end
+
+      request['timeout']
+    end
   end
 end

data/test/boolean_prompt_test.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# Copyright 2019 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. Changes to this file will be lost
+# every time the code is regenerated.
+
 require ::File.expand_path('test_helper', __dir__)
 
 module BlockChyp
@@ -15,7 +21,8 @@ module BlockChyp
       blockchyp.gateway_host = config['gatewayHost']
       blockchyp.test_gateway_host = config['testGatewayHost']
 
-      test_delay(blockchyp, 'BooleanPromptTest')
+      test_delay(blockchyp, 'boolean_prompt_test')
+
       # setup request object
       request = {}
       request['test'] = true
@@ -23,7 +30,8 @@ module BlockChyp
       request['prompt'] = 'Would you like to become a member?'
       request['yesCaption'] = 'Yes'
       request['noCaption'] = 'No'
-      response = blockchyp.booleanPrompt(request)
+
+      response = blockchyp.boolean_prompt(request)
 
       assert_not_nil(response)
       # response assertions