genba-ruby 0.1.4 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2e99dbb1f55b724834d4c840f90996c2eb86c0d1
-  data.tar.gz: 63cc23761d42d2d1b348132162191e0726f09d85
+SHA256:
+  metadata.gz: b26858cbcdf74806c55c285a886a950f147311c4c0551315e7b5ab4953c38176
+  data.tar.gz: a328a76b1d1165e4ccecc2c9d44b5623321a461a060d81114fdb7e7edd5a8909
 SHA512:
-  metadata.gz: 4b8768b0c971dc99c510cc7bf924723cb56bd6a2df11308550f4c730122b1277e0a03338fedab4e6065ac3a3a43d4cd2b5f6a236f5b7c2ede123ab1cf7bd4e2f
-  data.tar.gz: ae8bcb761b18971fa5ea8254dc6db40e3e66b0d83dbcfed3e24c57e47fd2bbfcfc62cc38d260c98bc2a9697e5b3581270ef84ba53a72da695d2aa911c26432d5
+  metadata.gz: 5a7139d2357bae3b9771d5adcdd5fbece38f9e0f07a42e4df4c434bafa093832698b9f947a1987ae7d9a0a7be2545be3ae2a9678dcfb78da049dff3274addfbe
+  data.tar.gz: 87256758cf9225fa6465306ccb9012daae5d6436618404ec23ecbeff5d06fa04d2db07e7a7c55eaee539b6014afe6b3fc69ec295a3e36a98566c7d4f7642e109

data/.circleci/config.yml

@@ -0,0 +1,29 @@
+version: 2
+
+.build_template: &build_definition
+  steps:
+    - checkout
+    - run:
+        name: Install libmcrypt-dev
+        command: apt-get update && apt-get install libmcrypt-dev -y
+    - run:
+        name: Bundle version
+        command: gem install bundler
+    - run:
+        name: Bundle Install
+        command: bundle check || bundle install
+    - run:
+        name: Run tests
+        command: |
+          bundle exec rspec
+  working_directory: ~/app
+workflows:
+  version: 2
+  build_ruby_versions:
+    jobs:
+      - build_ruby2_5
+jobs:
+  build_ruby2_5:
+    <<: *build_definition
+    docker:
+      - image: ruby:2.3.8-jessie

data/.gitignore

@@ -10,3 +10,6 @@
 # rspec failure tracking
 .rspec_status
 .byebug_history
+*.log
+.DS_Store
+*.txt

data/Gemfile

@@ -10,6 +10,7 @@ gem 'activemodel', require: 'active_model'
 group :development do
   gem 'rake'
   gem 'webmock'
+  gem 'uuidtools'
 
   platforms :mri do
     # to avoid problems, bring Byebug in on just versions of Ruby under which

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    genba-ruby (0.1.3)
-      oj (~> 2.18)
+    genba-ruby (0.1.11)
+      oj (~> 3.5)
       rest-client (~> 2.0)
       ruby-mcrypt (= 0.2.0)
 
@@ -32,12 +32,12 @@ GEM
     i18n (1.0.1)
       concurrent-ruby (~> 1.0)
     method_source (0.9.0)
-    mime-types (3.1)
+    mime-types (3.2.2)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2016.0521)
+    mime-types-data (3.2019.0331)
     minitest (5.11.3)
     netrc (0.11.0)
-    oj (2.18.5)
+    oj (3.7.12)
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -70,7 +70,8 @@ GEM
       thread_safe (~> 0.1)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.5)
+    unf_ext (0.0.7.6)
+    uuidtools (2.1.5)
     webmock (3.4.1)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
@@ -88,7 +89,8 @@ DEPENDENCIES
   pry-byebug
   rake
   rspec (~> 3.0)
+  uuidtools
   webmock
 
 BUNDLED WITH
-   1.16.1
+   1.17.3

data/README.md

@@ -1,68 +1,94 @@
 # Genba Ruby
 
 [![Build Status](https://travis-ci.org/iscreen/genba-ruby.svg)](https://travis-ci.org/iscreen/genba-ruby)
-[![CircleCI](https://circleci.com/gh/iscreen/genba-ruby.svg?style=shield)](https://circleci.com/gh/iscreen/genba-ruby)
+[![CircleCI](https://circleci.com/gh/iscreen/genba-ruby.svg?style=svg)](https://circleci.com/gh/iscreen/genba-ruby)
 [![Gem Version](https://badge.fury.io/rb/genba-ruby.svg)](https://badge.fury.io/rb/genba-ruby)
 
-The Genba Library provides convenient access to the [Genba API](https://api.genbagames.com/doc/) from applications written in the Ruby language. 
+The Genba Library provides convenient access to the [Genba API](https://api.genbagames.com/doc/) from applications written in the Ruby language.
 
 ## Basic Usage
 
+```ruby
     require 'genba'
 
     genba_client = Genba.client(
       username: 'api_genba_user',
-      app_id: '79cf9bb2-e7f5-448f-b996-c52e4b2bb351',
-      api_key: 'e6a69096fb94d91971ccc69b1770b9f3'
+      app_id: '00000000-0000-0000-0000-000000000000',
+      api_key: '00000000000000000000000000000000',
+      customer_account_id: '00000000-0000-0000-0000-000000000000'
     )
+```
 
 ## Products
 [Genba Products API](https://api.genbagames.com/doc/#api-Product)
 
-Call products.get_products to get all products.
+### Product - Changes
+
+Return a list of products which have changed since a given date, including basic or advanced metadata.
 
 ```ruby
 payload = {
-  countryISO: 'US',
-  includeMeta: false
+  from_date: DateTime.now - 1,
+  country_iso: 'US',
+  include_meta: false
+}
+
+response = genba_client.products.get_changes(payload)
+```
+
+```ruby
+payload = {
+  include_meta: false
+}
+
+response = genba_client.products.get_changes(payload)
+```
+
+### Product - Get
+
+Return a list of product objects, including basic or advanced metadata.
+
+```ruby
+payload = {
+  include_meta: false
 }
 
 response = genba_client.products.get_products(payload)
 ```
 
-Retrieve an existing product
+Return a list of product objects with countryISO
 
 ```ruby
 payload = {
-  skuId: '79cf9bb2-e7f5-448f-b996-c52e4b2bb351',
-  countryISO: 'US',
-  includeMeta: false
+  country_iso: 'US',
+  include_meta: false
 }
-  
-product = genba_client.products.get_products(payload)
+
+response = genba_client.products.get_products(payload)
 ```
 
-Return a list of products which have changed since a given date, including basic or advanced metadata.
+Retrieve an existing product
 
 ```ruby
 payload = {
-  fromDate: 1.days.ago.strftime('%FT%T'),
-  countryISO: 'US',
-  includeMeta: false
+  sku_id: '79cf9bb2-e7f5-448f-b996-c52e4b2bb351',
+  include_meta: true
 }
-  
-response = genba_client.products.get_changes(payload)
+
+product = genba_client.products.get_products(payload)
 ```
 
+### Product - Removed
+
 Return a list of products which have been removed since a given date.
 
 ```ruby
 payload = {
-  fromDate: 1.days.ago.strftime('%FT%T'),
-  countryISO: 'US',
-  includeMeta: false
+  from_date: DateTime.now - 1,
+  country_iso: 'US',
+  include_meta: false
 }
-  
+
 response = genba_client.products.get_removed(payload)
 ```
 
@@ -78,22 +104,39 @@ response = genba_client.prices.get_prices
 ## Restrictions
 [Genba Restrictions API](https://api.genbagames.com/doc/#api-Restrictions)
 
+### Restrictions - Get
+
 Returns a list of product sku restrictions, whitelist - can only sold in countries, blacklist - cannot be sold in countries.
 
+Returns a list of product sku restrictions by countryISO
+
 ```ruby
 payload = {
-  productId: '84d90a06-f458-4ed8-8f3d-91aa84cc6577',
-  fromDate: 1.days.ago.strftime('%FT%T'),
-  countryISO: 'US'
+  country_iso: 'US'
 }
 
-response = genba_client.restrictions.get_restrictions
+response = genba_client.restrictions.get_restrictions(payload)
+response[:productRestriction]
+```
+
+Returns a list of product sku restrictions by countryISO, productID and fromDate
+
+```ruby
+payload = {
+  product_id: '84d90a06-f458-4ed8-8f3d-91aa84cc6577',
+  from_date: 1.days.ago.strftime('%FT%T'),
+  country_iso: 'US'
+}
+
+response = genba_client.restrictions.get_restrictions(payload)
 response[:productRestriction]
 ```
 
 ## Keys
 [Genba Keys API](https://api.genbagames.com/doc/#api-Keys)
 
+### Keys - Get Test Keys
+
 Request Product Test Keys for a SKU
 
 ```ruby
@@ -106,8 +149,89 @@ response[:keys]
 Request Product Keys for a SKU
 
 ```ruby
-response = genba_client.keys.get_keys('84d90a06-f458-4ed8-8f3d-91aa84cc6577', 1)
+
+response = genba_client.keys.get_keys('84d90a06-f458-4ed8-8f3d-91aa84cc6577', 1, customerAccountId)
 
 response[:status]
 response[:keys]
 ```
+
+### Keys - Report Usage
+
+Report usage with keyCode
+
+```ruby
+key = KeyReportRequest.new(
+  key: '00000000000000000000000000000000',
+  country_iso: 'US',
+  sale_date: DateTime.now,
+  user_ip_address: '182.212.212.22',
+  e_tailer_buying_price: 3.8,
+  e_tailer_buying_price_currency_code: 'USD',
+  e_tailer_selling_price_net: 3.2,
+  e_tailer_selling_price_gross: 3.8,
+  e_tailer_selling_price_currency_code: 'USD'
+)
+
+response = genba_client.keys.get_report_usage([key])
+
+response[:acceptedCount]
+response[:rejectedCount]
+```
+
+Report usage with key
+```ruby
+key = KeyReportRequest.new(
+  key_id: '00000000-ffff-2222-3333-444444444444',
+  country_iso: 'US',
+  sale_date: DateTime.now,
+  user_ip_address: '182.212.212.22',
+  e_tailer_buying_price: 3.8,
+  e_tailer_buying_price_currency_code: 'USD',
+  e_tailer_selling_price_net: 3.2,
+  e_tailer_selling_price_gross: 3.8,
+  e_tailer_selling_price_currency_code: 'USD'
+)
+key_res = @client.keys.get_report_usage([key])
+response = genba_client.keys.get_report_usage([key])
+
+response[:acceptedCount]
+response[:rejectedCount]
+```
+
+## DirectEntitlement
+
+### DirectEntitlement - Activate
+
+Use this method to get and activate keys for a Direct Entitlement SKU. You will be charged at the point of calling this method.
+
+```ruby
+payload = {
+  sku_id: 'd972e0c7-5ddb-4e0d-9138-a78a6b269e99',
+  country_iso: 'US',
+  end_user_ip_address: '182.212.212.22',
+  sale_date: DateTime.now,
+  end_user_id: '0000001',
+  end_user_ticket: 'ticket0000001',
+  e_tailer_buying_price: 18.29,
+  e_tailer_buying_price_currency_code: 'USD',
+  e_tailer_selling_price_net: 19.89,
+  e_tailer_selling_price_gross: 20.29,
+  e_tailer_selling_price_currency_code: 'USD',
+}
+key_res = @client.direct_entitlements.activate(payload)
+```
+
+### DirectEntitlement - Redeem
+
+Use this method to redeem keys already sold for a Direct Entitlement SKU and link them to the end-user's account. You will not be charged at the point of calling this method.
+
+```ruby
+payload = {
+  sku_id: 'd972e0c7-5ddb-4e0d-9138-a78a6b269e99',
+  key_id: '00000000-0000-0000-0000-000000000000',
+  end_user_id: '00001',
+  end_user_ticket: 'ticket00001'
+}
+key_res = @client.direct_entitlements.redeem(payload)
+```

data/{genba-ruby.gemspec → genba.gemspec}

@@ -30,10 +30,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'oj', '~> 3.5'
   spec.add_runtime_dependency 'rest-client', '~> 2.0'
   spec.add_runtime_dependency 'ruby-mcrypt', '0.2.0'
-  spec.add_runtime_dependency 'oj', '~> 2.18'
-
 
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/genba.rb

@@ -2,24 +2,74 @@ require 'base64'
 require 'digest'
 require 'mcrypt'
 require 'rest-client'
+require 'logger'
 require 'oj'
 require 'active_model'
 
-# Engine (for rails)
-require 'genba/engine' if defined?(Rails)
-
 require 'genba/version'
 require 'genba/key_black_list_request'
 require 'genba/key_report_request'
+require 'genba/util'
+require 'genba/client/direct_entitlements'
 require 'genba/client/keys'
 require 'genba/client/prices'
 require 'genba/client/products'
+require 'genba/client/reports'
 require 'genba/client/restrictions'
 require 'genba/client'
 
 # Genba API module
 module Genba
+  @logger = nil
+
+  # map to the same values as the standard library's logger
+  LEVEL_DEBUG = Logger::DEBUG
+  LEVEL_ERROR = Logger::ERROR
+  LEVEL_INFO = Logger::INFO
+
   def self.client(credentials = {})
     Client.new(credentials)
   end
+
+  # When set prompts the library to log some extra information to $stdout and
+  # $stderr about what it's doing. For example, it'll produce information about
+  # requests, responses, and errors that are received. Valid log levels are
+  # `debug` and `info`, with `debug` being a little more verbose in places.
+  #
+  # Use of this configuration is only useful when `.logger` is _not_ set. When
+  # it is, the decision what levels to print is entirely deferred to the logger.
+  def self.log_level
+    @log_level
+  end
+
+  def self.log_level=(val)
+    # Backwards compatibility for values that we briefly allowed
+    if val == 'debug'
+      val = LEVEL_DEBUG
+    elsif val == 'info'
+      val = LEVEL_INFO
+    end
+
+    if !val.nil? && ![LEVEL_DEBUG, LEVEL_ERROR, LEVEL_INFO].include?(val)
+      raise ArgumentError, "log_level should only be set to `nil`, `debug` or `info`"
+    end
+    @log_level = val
+  end
+
+  # Sets a logger to which logging output will be sent. The logger should
+  # support the same interface as the `Logger` class that's part of Ruby's
+  # standard library (hint, anything in `Rails.logger` will likely be
+  # suitable).
+  #
+  # If `.logger` is set, the value of `.log_level` is ignored. The decision on
+  # what levels to print is entirely deferred to the logger.
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
 end
+
+Genba.log_level = ENV['GENBA_LOG'] unless ENV['GENBA_LOG'].nil?

data/lib/genba/client.rb

@@ -3,6 +3,9 @@
 module Genba
   # Genba API Client
   class Client
+    attr_accessor :customer_account_id,
+                  :open_timeout, :read_timeout, :max_retry, :retry_delay
+
     API_URL = 'https://api.genbagames.com/api'.freeze
 
     @expires_on = nil
@@ -15,10 +18,15 @@ module Genba
     # * +config+ - Genba API credential attribute
     #
     # ==== Options
-    def initialize(config = {})
-      @app_id = config[:app_id]
-      @username = config[:username]
-      @api_key = config[:api_key]
+    def initialize(app_id:, username:, api_key:, customer_account_id:, options: {})
+      @app_id = app_id.strip
+      @username = username.strip
+      @api_key = api_key.strip
+      @customer_account_id = customer_account_id.strip
+      @open_timeout = options[:open_timeout] || 15
+      @read_timeout = options[:read_timeout] || 60
+      @max_retry = options[:max_retry] || 0
+      @retry_delay = options[:retry_delay] || 2
     end
 
     def generate_token
@@ -27,7 +35,7 @@ module Genba
         response = RestClient.post(
           "#{API_URL}/token",
           body,
-          headers: { accept: 'application/json' }
+          headers: { accept: 'application/json', 'Content-Type': 'application/json' }
         )
         parsed_response = decode_json(response.body)
         @id_token = parsed_response['token']
@@ -36,25 +44,71 @@ module Genba
       raw_token
     end
 
-    def rest_get_with_token(path, query_params = {}, headers = {})
+    def rest_get_with_token(path, query_params = {}, headers = {}, options = {})
       genba_headers = token.merge(headers)
-      headers[:params] = query_params unless query_params.empty?
-      response = RestClient.get("#{API_URL}#{path}", genba_headers)
+      api_url = "#{API_URL}#{path}"
+      api_url += "?#{query_params.to_query}" unless query_params.empty?
+      response = execute_request(method: :get, url: api_url,
+                                 headers: genba_headers, options: options)
       from_rest_client_response(response)
     end
 
-    def rest_put_with_token(path, body = {}, headers = {})
+    def rest_put_with_token(path, body = {}, headers = {}, options = {})
       genba_headers = token.merge(headers)
-      response = RestClient.put("#{API_URL}#{path}", encode_json(body), genba_headers)
+      response = execute_request(method: :put, url: "#{API_URL}#{path}",
+                                 payload: encode_json(body), headers: genba_headers, options: options)
       from_rest_client_response(response)
     end
 
-    def rest_post_with_token(path, body = {}, headers = {})
+    def rest_post_with_token(path, body = {}, headers = {}, options = {})
       genba_headers = token.merge(headers)
-      response = RestClient.post("#{API_URL}#{path}", encode_json(body), genba_headers)
+      response = execute_request(method: :post, url: "#{API_URL}#{path}",
+                                 payload: encode_json(body), headers: genba_headers, options: options)
       from_rest_client_response(response)
     end
 
+    def execute_request(method:, url:, payload: {}, headers: {}, options: {})
+      request_opts = {
+        headers: headers,
+        method: method,
+        payload: payload,
+        url: url
+      }
+      other_opts = {
+        open_timeout: options[:open_timeout] || @open_timeout,
+        read_timeout: options[:read_timeout] || @read_timeout,
+        max_retry: options[:max_retry] || @max_retry
+      }
+
+      Genba::Util.log_debug "API Headers: #{headers.inspect}"
+      Genba::Util.log_debug "Options: #{other_opts}"
+      Genba::Util.log_info "#{method.upcase}: #{url}"
+      Genba::Util.log_info "payload: #{payload}" if payload.present?
+
+      request_opts.merge! other_opts
+      execute_request_with_rescues(request_opts, other_opts[:max_retry])
+    end
+
+    def execute_request_with_rescues(request_opts, max_retry)
+      num_try = 0
+      begin
+        response = RestClient::Request.execute(request_opts)
+      rescue StandardError => e
+        Genba::Util.log_error "#{e.class} => #{e.message}"
+
+        num_try += 1
+        sleep @retry_delay
+
+        if num_try <= max_retry
+          Genba::Util.log_error "retry ====> #{num_try}"
+          retry
+        end
+
+        raise e
+      end
+      response
+    end
+
     def products
       Products.new(self)
     end
@@ -71,6 +125,14 @@ module Genba
       Keys.new(self)
     end
 
+    def direct_entitlements
+      DirectEntitlements.new(self)
+    end
+
+    def reports
+      Reports.new(self)
+    end
+
     private
 
     def encode_json(data)
@@ -97,7 +159,8 @@ module Genba
         {
           token: @id_token,
           appId: @app_id,
-          accept: 'application/json'
+          accept: 'application/json',
+          'Content-Type': 'application/json'
         }
       else
         {}
@@ -116,12 +179,15 @@ module Genba
     def from_rest_client_response(response)
       if response.code < 200 &&
          response.code >= 400
+        Genba::Util.log_error "Invalid response object from API: #{response.body}" \
+            "(HTTP response code was #{response.code})"
         raise "Invalid response object from API: #{response.body}" \
               "(HTTP response code was #{response.code})"
       end
       # default decode by json
       return decode_json(response.body) unless response.headers[:content_type]
-      if (response.headers[:content_type] =~ %r{application\/json}) > 0
+      if (response.headers[:content_type] =~ %r{application\/json}) >= 0
+        Genba::Util.log_info "response body\n#{response.body}"
         decode_json(response.body)
       end
     end

data/lib/genba/client/direct_entitlements.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Genba
+  class Client
+    # DirectEntitlements client
+    class DirectEntitlements
+      def initialize(client)
+        @client = client
+      end
+
+      def activate(
+        sku_id:,
+        country_iso:,
+        end_user_ip_address:,
+        sale_date: DateTime.now,
+        end_user_id: nil,
+        end_user_ticket: nil,
+        e_tailer_buying_price:,
+        e_tailer_buying_price_currency_code:,
+        e_tailer_selling_price_net:,
+        e_tailer_selling_price_gross:,
+        e_tailer_selling_price_currency_code:,
+        headers: {},
+        options: {}
+      )
+        params = {
+          skuId: sku_id,
+          customerAccountId: @client.customer_account_id,
+          countryISO: country_iso,
+          endUserIpAddress: end_user_ip_address,
+          endUserId: end_user_id,
+          endUserTicket: end_user_ticket,
+          ETailerBuyingPrice: e_tailer_buying_price,
+          ETailerBuyingPriceCurrencyCode: e_tailer_buying_price_currency_code,
+          ETailerSellingPriceNet: e_tailer_selling_price_net,
+          ETailerSellingPriceGross: e_tailer_selling_price_gross,
+          ETailerSellingPriceCurrencyCode: e_tailer_selling_price_currency_code
+        }.select { |_, v| !v.nil? }
+        params[:saleDate] = sale_date.strftime('%FT%T') if sale_date
+        Genba::Util.log_debug "DirectEntitlements activate payload: #{params.inspect}"
+        @client.rest_get_with_token('/directentitlement/activate', params, headers, options)
+      end
+
+      # Use this method to redeem keys already sold for a Direct Entitlement SKU and link them to the
+      # end-user's account. You will not be charged at the point of calling this method.
+      def redeem(sku_id:, key_id:, end_user_id:, end_user_ticket:, headers: {}, options: {})
+        params = {
+          customerAccountId: @client.customer_account_id,
+          skuId: sku_id,
+          keyId: key_id,
+          endUserId: end_user_id,
+          endUserTicket: end_user_ticket
+        }
+        @client.rest_get_with_token('/directentitlement/redeem', params, headers, options)
+      end
+    end
+  end
+end

data/lib/genba/client/keys.rb

@@ -15,36 +15,35 @@ module Genba
         @client.rest_get_with_token('/testKeys', params, headers)
       end
 
-      def get_keys(sku_id, quantity = 1, params = {}, headers = {})
+      def get_keys(sku_id, quantity = 1, params = {}, headers = {}, options: {})
         payload = params.merge(
           skuId: sku_id,
-          quantity: quantity
+          quantity: quantity,
+          customerAccountId: @client.customer_account_id
         )
-        @client.rest_get_with_token('/keys', payload, headers)
+        @client.rest_get_with_token('/keys', payload, headers, options)
       end
 
-      def get_key_code_status(key_code, params = {}, headers = {})
+      def get_key_code_status(key_code, params = {}, headers = {}, options: {})
         payload = params.merge(
           keyCode: key_code
         )
-        @client.rest_get_with_token('/keys', payload, headers)
+        @client.rest_get_with_token('/keys', payload, headers, options)
       end
 
-      def get_key_status(key_id, params = {}, headers = {})
-        payload = params.merge(
-          id: key_id
-        )
-        @client.rest_get_with_token('/keys', payload, headers)
+      def get_key_status(key_id, params = {}, headers = {}, options: {})
+        @client.rest_get_with_token("/keys/#{key_id}", params, headers, options)
       end
 
-      def get_report_usage(keys = nil, headers = {})
+      def get_report_usage(keys = nil, headers = {}, options: {})
         raise 'ReportUsage keys should be array' unless keys.is_a?(Array)
         raise 'ReportUseag keys should be a KeyReportRequest class' unless key_report_request?(keys)
         payload = keys.map(&:to_genba_json_payload)
-        @client.rest_post_with_token('/keyReport', payload, headers)
+        Genba::Util.log_debug "get_report_usage payload: #{payload.inspect}"
+        @client.rest_post_with_token('/keyReport', payload, headers, options)
       end
 
-      def black_list(keys = nil, headers = {})
+      def black_list(keys = nil, headers = {}, options: {})
         raise 'Blacklist keys should be array' unless keys.is_a?(Array)
         raise 'Blacklist keys should be a KeyBlackListRequest class' unless key_black_list_request?(keys)
 
@@ -53,7 +52,7 @@ module Genba
         end
 
         payload = keys.map(&:to_genba_json_payload)
-        @client.rest_post_with_token('/blackListKeys', payload, headers)
+        @client.rest_post_with_token('/blackListKeys', payload, headers, options)
       end
 
       private

data/lib/genba/client/prices.rb

@@ -8,11 +8,11 @@ module Genba
         @client = client
       end
 
-      def get_prices(customer_account_id, headers = {})
-        params = {
-          customerAccountId: customer_account_id
-        }
-        @client.rest_get_with_token('/prices', params, headers)
+      def get_prices(params = {}, headers = {})
+        payload = params.merge(
+          customerAccountId: @client.customer_account_id
+        )
+        @client.rest_get_with_token('/prices', payload, headers)
       end
     end
   end

data/lib/genba/client/products.rb

@@ -8,19 +8,32 @@ module Genba
         @client = client
       end
 
-      def get_products(params = {}, headers = {})
-        @client.rest_get_with_token('/product', params, headers)
+      def get_products(sku_id: nil, country_iso: nil, include_meta: false, headers: {})
+        payload = {
+          skuId: sku_id,
+          countryISO: country_iso,
+          includeMeta: include_meta
+        }.select { |_, v| !v.nil? }
+
+        @client.rest_get_with_token('/product', payload, headers)
       end
 
-      def get_changes(from_date, params = {}, headers = {})
+      def get_changes(from_date: nil, country_iso: nil, include_meta: false, params: {}, headers: {})
         payload = params.merge(
-          fromDate: from_date
-        )
+          countryISO: country_iso,
+          includeMeta: include_meta
+        ).select { |_, v| !v.nil? }
+        payload[:fromDate] = from_date.strftime('%FT%T') if from_date
         @client.rest_get_with_token('/product/changes', payload, headers)
       end
 
-      def get_removed(params = {}, headers = {})
-        @client.rest_get_with_token('/product/removed', params, headers)
+      def get_removed(from_date: nil, country_iso: nil, params: {}, headers: {})
+        payload = params.merge(
+          countryISO: country_iso,
+          customerAccountId: @client.customer_account_id
+        ).select { |_, v| !v.nil? }
+        payload[:fromDate] = from_date.strftime('%FT%T') if from_date
+        @client.rest_get_with_token('/product/removed', payload, headers)
       end
     end
   end

data/lib/genba/client/reports.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Genba
+  class Client
+    # Reports client
+    class Reports
+      def initialize(client)
+        @client = client
+      end
+
+      def publisher_raw_data(year = nil, params = {}, headers = {})
+        payload = params.merge({
+          Year: year || Time.now.strftime('%Y')
+        })
+        @client.rest_get_with_token('/report/publisher/rawdata', payload, headers)
+      end
+    end
+  end
+end

data/lib/genba/client/restrictions.rb

@@ -8,8 +8,13 @@ module Genba
         @client = client
       end
 
-      def get_restrictions(params = {}, headers = {})
-        @client.rest_get_with_token('/restrictions', params, headers)
+      def get_restrictions(product_id: nil, country_iso: nil, from_date: nil, params: {}, headers: {})
+        payload = params.merge(
+          productId: product_id,
+          countryISO: country_iso
+        ).select { |_, v| !v.nil? }
+        payload[:fromDate] = from_date.strftime('%FT%T') if from_date
+        @client.rest_get_with_token('/restrictions', payload, headers)
       end
     end
   end

data/lib/genba/key_report_request.rb

@@ -5,27 +5,44 @@ class KeyReportRequest
   attr_accessor :key, :key_id, :country_iso, :sale_date, :user_ip_address,
                 :e_tailer_buying_price, :e_tailer_buying_price_currency_code,
                 :e_tailer_selling_price_net, :e_tailer_selling_price_gross,
-                :e_tailer_selling_price_currency_code
+                :e_tailer_selling_price_currency_code,
+                :e_tailer_subsidiary
 
-  def initialize(data = {})
-    @key = data[:key]
-    @key_id = data[:key_id]
-    @country_iso = data[:country_iso]
-    @user_ip_address = data[:user_ip_address]
+  def initialize(
+    key: nil, key_id: nil, country_iso:, user_ip_address:, sale_date: nil,
+    e_tailer_buying_price:, e_tailer_buying_price_currency_code:,
+    e_tailer_selling_price_net:, e_tailer_selling_price_gross:, e_tailer_selling_price_currency_code:,
+    e_tailer_subsidiary: nil
+  )
+    @key = key
+    @key_id = key_id
+    @country_iso = country_iso
+    @user_ip_address = user_ip_address
+    @sale_date = sale_date
+    @e_tailer_buying_price = e_tailer_buying_price
+    @e_tailer_buying_price_currency_code = e_tailer_buying_price_currency_code
+    @e_tailer_selling_price_net = e_tailer_selling_price_net
+    @e_tailer_selling_price_gross = e_tailer_selling_price_gross
+    @e_tailer_selling_price_currency_code = e_tailer_selling_price_currency_code
+    @e_tailer_subsidiary = e_tailer_subsidiary
+    raise 'at least one of key or key_id' if key.nil? && key_id.nil?
   end
 
   def to_genba_json_payload
-    {
+    payload ={
       key: @key,
       keyId: @key_id,
       countryISO: @country_iso,
-      saleDate: @sale_date,
       userIpAddress: @user_ip_address,
       ETailerBuyingPrice: @e_tailer_buying_price,
       ETailerBuyingPriceCurrencyCode: @e_tailer_buying_price_currency_code,
       ETailerSellingPriceNet: @e_tailer_selling_price_net,
       ETailerSellingPriceGross: @e_tailer_selling_price_gross,
-      ETailerSellingPriceCurrencyCode: @e_tailer_selling_price_currency_code
+      ETailerSellingPriceCurrencyCode: @e_tailer_selling_price_currency_code,
+      EtailerSubsidiary: @e_tailer_subsidiary
     }.select { |_, v| !v.nil? }
+
+    payload[:saleDate] = @sale_date.strftime('%FT%T') if @sale_date
+    payload
   end
 end

data/lib/genba/util.rb

@@ -0,0 +1,106 @@
+require 'cgi'
+
+module Genba
+  module Util
+    def self.log_error(message, data = {})
+      if !Genba.log_level.nil? && Genba.log_level <= Genba::LEVEL_ERROR
+        log_internal(message, data, color: :cyan,
+                                    level: Genba::LEVEL_ERROR, logger: Genba.logger, out: $stderr)
+      end
+    end
+
+    def self.log_info(message, data = {})
+      if !Genba.log_level.nil? && Genba.log_level <= Genba::LEVEL_INFO
+        log_internal(message, data, color: :cyan,
+                                    level: Genba::LEVEL_INFO, logger: Genba.logger, out: $stdout)
+      end
+    end
+
+    def self.log_debug(message, data = {})
+      if !Genba.log_level.nil? && Genba.log_level <= Genba::LEVEL_DEBUG
+        log_internal(message, data, color: :blue,
+                                    level: Genba::LEVEL_DEBUG, logger: Genba.logger, out: $stdout)
+      end
+    end
+
+    COLOR_CODES = {
+      black:   0, light_black:   60,
+      red:     1, light_red:     61,
+      green:   2, light_green:   62,
+      yellow:  3, light_yellow:  63,
+      blue:    4, light_blue:    64,
+      magenta: 5, light_magenta: 65,
+      cyan:    6, light_cyan:    66,
+      white:   7, light_white:   67,
+      default: 9
+    }.freeze
+    private_constant :COLOR_CODES
+
+    # Uses an ANSI escape code to colorize text if it's going to be sent to a
+    # TTY.
+    def self.colorize(val, color, isatty)
+      return val unless isatty
+
+      mode = 0 # default
+      foreground = 30 + COLOR_CODES.fetch(color)
+      background = 40 + COLOR_CODES.fetch(:default)
+
+      "\033[#{mode};#{foreground};#{background}m#{val}\033[0m"
+    end
+    private_class_method :colorize
+
+    # Turns an integer log level into a printable name.
+    def self.level_name(level)
+      case level
+      when LEVEL_DEBUG then 'debug'
+      when LEVEL_ERROR then 'error'
+      when LEVEL_INFO  then 'info'
+      else level
+      end
+    end
+    private_class_method :level_name
+
+    # TODO: Make these named required arguments when we drop support for Ruby
+    # 2.0.
+    def self.log_internal(message, data = {}, color: nil, level: nil, logger: nil, out: nil)
+      data_str = data.reject { |_k, v| v.nil? }
+                     .map do |(k, v)|
+        format("%s=%s", colorize(k, color, logger.nil? && !out.nil? && out.isatty), wrap_logfmt_value(v))
+      end.join(' ')
+
+      if !logger.nil?
+        # the library's log levels are mapped to the same values as the
+        # standard library's logger
+        logger.log(level, message)
+      elsif out.isatty
+        out.puts format("%s %s %s", colorize(level_name(level)[0, 4].upcase, color, out.isatty), message, data_str)
+      else
+        out.puts format("message=%s level=%s %s", wrap_logfmt_value(message), level_name(level), data_str)
+      end
+    end
+    private_class_method :log_internal
+
+    # Wraps a value in double quotes if it looks sufficiently complex so that
+    # it can be read by logfmt parsers.
+    def self.wrap_logfmt_value(val)
+      # If value is any kind of number, just allow it to be formatted directly
+      # to a string (this will handle integers or floats).
+      return val if val.is_a?(Numeric)
+
+      # Hopefully val is a string, but protect in case it's not.
+      val = val.to_s
+
+      if %r{[^\w\-/]} =~ val
+        # If the string contains any special characters, escape any double
+        # quotes it has, remove newlines, and wrap the whole thing in quotes.
+        format(%("%s"), val.gsub('"', '\"').delete("\n"))
+      else
+        # Otherwise use the basic value if it looks like a standard set of
+        # characters (and allow a few special characters like hyphens, and
+        # slashes)
+        val
+      end
+    end
+    private_class_method :wrap_logfmt_value
+  end
+end

data/lib/genba/version.rb

@@ -1,3 +1,3 @@
 module Genba
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.1.11'.freeze
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: genba-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.11
 platform: ruby
 authors:
 - Dean Lin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-11 00:00:00.000000000 Z
+date: 2019-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rest-client
+  name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
-  name: ruby-mcrypt
+  name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: oj
+  name: ruby-mcrypt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.18'
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.18'
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -101,6 +101,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -113,16 +114,18 @@ files:
 - bin/console
 - bin/setup
 - circle.yml
-- genba-ruby.gemspec
+- genba.gemspec
 - lib/genba.rb
 - lib/genba/client.rb
+- lib/genba/client/direct_entitlements.rb
 - lib/genba/client/keys.rb
 - lib/genba/client/prices.rb
 - lib/genba/client/products.rb
+- lib/genba/client/reports.rb
 - lib/genba/client/restrictions.rb
-- lib/genba/engine.rb
 - lib/genba/key_black_list_request.rb
 - lib/genba/key_report_request.rb
+- lib/genba/util.rb
 - lib/genba/version.rb
 homepage: https://api.genbagames.com/doc/
 licenses:
@@ -145,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: genba api for ruby version

data/lib/genba/engine.rb

@@ -1,5 +0,0 @@
-module Genba
-  class Engine < ::Rails::Engine
-    isolate_namespace Genba
-  end
-end