jamm 0.0.1

data/lib/jamm/jamm_object.rb

@@ -0,0 +1,249 @@
+module Jamm
+  class JammObject
+    include Enumerable
+
+    @@permanent_attributes = Set.new([:id]) # rubocop:disable Style/ClassVars
+
+    # The default :id method is deprecated and isn't useful to us
+    undef :id if method_defined?(:id)
+
+    def initialize(id = nil)
+      # parameter overloading!
+      if id.is_a?(Hash)
+        @retrieve_params = id.dup
+        @retrieve_params.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_params = {}
+      end
+
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      @values[:id] = id if id
+    end
+
+    def self.construct_from(values)
+      new(values[:id]).refresh_from(values)
+    end
+
+    def to_s(*_args)
+      JSON.pretty_generate(@values)
+    end
+
+    def inspect
+      id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
+
+    def refresh_from(values, partial: false)
+      @original_values = Marshal.load(Marshal.dump(values)) # deep copy
+      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = Util.convert_to_jamm_object(v)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+
+      self
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*_a)
+      JSON.generate(@values)
+    end
+
+    def as_json(*a)
+      @values.as_json(*a)
+    end
+
+    def to_hash
+      @values.transform_values do |value|
+        value.respond_to?(:to_hash) ? value.to_hash : value
+      end
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    def _dump(_level)
+      Marshal.dump(@values)
+    end
+
+    def self._load(args)
+      values = Marshal.load(args)
+      construct_from(values)
+    end
+
+    def serialize_nested_object(key)
+      new_value = @values[key]
+      return {} if new_value.is_a?(APIResource)
+
+      if @unsaved_values.include?(key)
+        # the object has been reassigned
+        # e.g. as object.key = {foo => bar}
+        update = new_value
+        new_keys = update.keys.map(&:to_sym)
+
+        # remove keys at the server, but not known locally
+        if @original_values.include?(key)
+          keys_to_unset = @original_values[key].keys - new_keys
+          keys_to_unset.each { |unset_key| update[unset_key] = '' }
+        end
+
+        update
+      else
+        # can be serialized normally
+        self.class.serialize_params(new_value)
+      end
+    end
+
+    def self.serialize_params(obj, original_value = nil)
+      case obj
+      when nil
+        ''
+      when JammObject
+        unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+        obj_values = obj.instance_variable_get(:@values)
+        update_hash = {}
+
+        unsaved_keys.each do |k|
+          update_hash[k] = serialize_params(obj_values[k])
+        end
+
+        obj_values.each do |k, v|
+          if v.is_a?(JammObject) || v.is_a?(Hash)
+            update_hash[k] = obj.serialize_nested_object(k)
+          elsif v.is_a?(Array)
+            original_value = obj.instance_variable_get(:@original_values)[k]
+            if original_value && original_value.length > v.length
+              # url params provide no mechanism for deleting an item in an array,
+              # just overwriting the whole array or adding new items. So let's not
+              # allow deleting without a full overwrite until we have a solution.
+              raise ArgumentError, 'You cannot delete an item from an array, you must instead set a new array'
+            end
+
+            update_hash[k] = serialize_params(v, original_value)
+          end
+        end
+
+        update_hash
+      when Array
+        update_hash = {}
+        obj.each_with_index do |value, index|
+          update = serialize_params(value)
+          update_hash[index] = update if update != {} && (!original_value || update != original_value[index])
+        end
+
+        if update_hash == {}
+          nil
+        else
+          update_hash
+        end
+      else
+        obj
+      end
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            if v == ''
+              raise ArgumentError, "You cannot set #{k} to an empty string." \
+                'We interpret empty strings as nil in requests.' \
+                "You may set #{self}.#{k} = nil to delete the property."
+            end
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        add_accessors([attr])
+        begin
+          mth = method(name)
+        rescue NameError
+          raise NoMethodError,
+                "Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}"
+        end
+        return mth.call(args[0])
+      elsif @values.key?(name)
+        return @values[name]
+      end
+
+      begin
+        super
+      rescue NoMethodError => e
+        if @transient_values.include?(name)
+          raise NoMethodError,
+                e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Jamm's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}"
+        end
+
+        raise
+      end
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      @values&.key?(symbol) || super
+    end
+  end
+end

data/lib/jamm/oauth.rb

@@ -0,0 +1,66 @@
+require 'rest-client'
+require 'json'
+require 'base64'
+require 'jamm/errors'
+
+module Jamm
+  module OAuth
+    def self.oauth_token
+      client_id = Jamm.client_id
+      client_secret = Jamm.client_secret
+      if client_id.nil? || client_secret.nil?
+        raise OAuthError, 'No client_id or client_secret is set. ' \
+         'Set your merchant client id and client secret using' \
+         'Jamm.client_id=<your client id> and Jamm=<your client secret>'
+      end
+
+      fetch_oauth_token(client_id, client_secret)
+    end
+
+    def self.fetch_oauth_token(client_id, client_secret)
+      oauth_base = Jamm.oauth_base
+      oauth_endpoint = "#{oauth_base}/oauth2/token"
+      read_timeout = Jamm.read_timeout
+      open_timeout = Jamm.open_timeout
+
+      headers = {
+        authorization: "Basic #{Base64.strict_encode64("#{client_id}:#{client_secret}")}",
+        content_type: 'application/x-www-form-urlencoded'
+      }
+      payload = {
+        grant_type: 'client_credentials',
+        client_id: client_id
+      }
+      begin
+        response = Jamm.execute_request(method: :post, url: oauth_endpoint, payload: payload, headers: headers,
+                                        read_timeout: read_timeout, open_timeout: open_timeout)
+      rescue SocketError
+        raise OAuthError, 'An unexpected error happens while communicating to OAuth server. Check your network setting'
+      rescue RestClient::RequestTimeout
+        raise OAuthError, "Timed out over #{read_timeout} sec."
+      rescue RestClient::ExceptionWithResponse => e
+        raise OAuthError.new 'An unsuccessful response was returned', http_status: e.http_code, http_body: e.http_body
+      rescue RestClient::Exception => e
+        raise OAuthError, "An unexpected error happens while communicating to OAuth server. #{e}"
+      end
+
+      parse_oauth_response(response)
+    end
+
+    def self.parse_oauth_response(response)
+      begin
+        body = JSON.parse(response.body)
+      rescue JSON::ParserError
+        raise OAuthError.new 'Failed to parse the response from the OAuth server', http_status: response.code,
+                                                                                   http_body: response.body
+      end
+      access_token = body['access_token']
+      if access_token.nil?
+        raise OAuthError.new 'An access token was not found in the response from the OAuth server',
+                             http_status: response.code, http_body: response.body
+      end
+
+      access_token
+    end
+  end
+end

data/lib/jamm/payment.rb

@@ -0,0 +1,18 @@
+module Jamm
+  class Payment < APIResource
+    def self.create(params = {}, headers = {})
+      params[:redirect][:expired_at] = TimeUtil.relative_time_to_iso(params[:redirect][:expired_in]) if params[:redirect] && params[:redirect][:expired_in]
+
+      request_jamm_api(
+        method: :post,
+        path: resource_url,
+        params: params,
+        headers: headers
+      )
+    end
+
+    def self.resource_url
+      '/payments'
+    end
+  end
+end

data/lib/jamm/request.rb

@@ -0,0 +1,13 @@
+module Jamm
+  module Request
+    module ClassMethods
+      def request_jamm_api(method:, path:, params: {}, headers: {})
+        Jamm.request_jamm_api(method, path, params, headers)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/jamm/time_util.rb

@@ -0,0 +1,41 @@
+require 'time'
+module Jamm
+  class TimeUtil
+    def self.relative_time_to_iso(relative_time)
+      # Check if the input string is in ISO format
+      return relative_time if iso_format?(relative_time)
+
+      # Parse the relative time string
+      quantity, unit = relative_time.split
+      quantity = quantity.to_i
+
+      # Calculate the time delta
+      case unit.downcase
+      when 'second', 'seconds'
+        time_delta = quantity
+      when 'minute', 'minutes'
+        time_delta = quantity * 60
+      when 'hour', 'hours'
+        time_delta = quantity * 60 * 60
+      when 'day', 'days'
+        time_delta = quantity * 60 * 60 * 24
+      when 'week', 'weeks'
+        time_delta = quantity * 60 * 60 * 24 * 7
+      else
+        raise ArgumentError, "Unknown time unit: #{unit}"
+      end
+
+      # Calculate the ISO datetime string
+      iso_time = Time.now + time_delta
+      iso_time.strftime('%Y-%m-%dT%H:%M:%SZ')
+    end
+
+    def self.iso_format?(string)
+      # Check if the string matches the ISO 8601 datetime format
+
+      !!Time.iso8601(string)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/jamm/token.rb

@@ -0,0 +1,10 @@
+module Jamm
+  class Token < APIResource
+    extend Jamm::APIOperations::List
+    extend Jamm::APIOperations::Get
+
+    def self.resource_url
+      '/payments/tokens'
+    end
+  end
+end

data/lib/jamm/util.rb

@@ -0,0 +1,76 @@
+module Jamm
+  module Util
+    def self.convert_to_jamm_object(response)
+      case response
+      when Array
+        response.map { |i| convert_to_jamm_object(i) }
+      when Hash
+        JammObject.construct_from(response)
+      else
+        response
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new_hash = {}
+        object.each do |key, value|
+          key = begin
+            key.to_sym
+          rescue StandardError
+            key
+          end || key
+          new_hash[key] = symbolize_names(value)
+        end
+        new_hash
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+    def self.url_encode(key)
+      # URI.escape is obsolete, so just use the code fragment in URI library
+      # (from URI::RFC2396_Parser#escape)
+      key.to_s.gsub(Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")) do
+        us = ::Regexp.last_match(0)
+        tmp = ''
+        us.each_byte do |uc|
+          tmp << format('%%%02X', uc)
+        end
+        tmp
+      end.force_encoding(Encoding::US_ASCII)
+    end
+
+    def self.flatten_params(params, parent_key = nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+  end
+end

data/lib/jamm/version.rb

@@ -0,0 +1,3 @@
+module Jamm
+  VERSION = '0.0.1'
+end

data/lib/jamm.rb

@@ -0,0 +1,146 @@
+# FIXME: remove this line once manual testing completed
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rest-client'
+require 'openssl'
+require 'json'
+
+require 'jamm/api_operations/create'
+require 'jamm/api_operations/get'
+require 'jamm/api_operations/list'
+require 'jamm/api_operations/update'
+require 'jamm/version'
+require 'jamm/oauth'
+require 'jamm/request'
+require 'jamm/api_resource'
+require 'jamm/token'
+require 'jamm/payment'
+require 'jamm/charge'
+require 'jamm/util'
+require 'jamm/jamm_object'
+require 'jamm/errors'
+require 'jamm/time_util'
+
+module Jamm
+  @api_base = 'http://api.jamm-pay.jp/api/v0'
+  @oauth_base = 'https://jamm-merchant-sandbox.auth.ap-northeast-1.amazoncognito.com'
+  @open_timeout = 30
+  @read_timeout = 90
+  @max_retry = 0
+  @retry_initial_delay = 0.1
+  @retry_max_delay = 32
+
+  class << self
+    attr_accessor :client_id, :client_secret, :api_base, :oauth_base, :api_version, :connect_base,
+                  :open_timeout, :read_timeout, :max_retry, :retry_initial_delay, :retry_max_delay
+  end
+
+  def self.request_jamm_api(method, path, params = {}, headers = {})
+    access_token = OAuth.oauth_token
+    api_base_url = @api_base
+    open_timeout = @open_timeout
+    read_timeout = @read_timeout
+    max_retry = @max_retry
+    retry_initial_delay = @retry_initial_delay
+    retry_max_delay = @retry_max_delay
+
+    headers = {
+      authorization: "Bearer #{access_token}",
+      content_type: 'application/json',
+      X_JAMM_SDK_VERSION: "Ruby_#{VERSION}"
+    }.update(headers)
+    error_on_invalid_params(params)
+
+    url = api_url(path, api_base_url)
+
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      # Make params into GET parameters
+      url + "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params&.any?
+      payload = nil
+    else
+      payload = params.to_json
+    end
+
+    retry_count = 1
+
+    begin
+      response = execute_request(method: method, url: url, payload: payload, headers: headers,
+                                 read_timeout: read_timeout, open_timeout: open_timeout)
+    rescue SocketError
+      raise ApiConnectionError,
+            'An unexpected error happens while communicating to OAuth server. Check your network setting'
+    rescue RestClient::RequestTimeout
+      raise ApiConnectionError, "Timed out over #{read_timeout} sec."
+    rescue RestClient::ExceptionWithResponse => e
+      if (e.http_code == 429) && (retry_count <= max_retry)
+        sleep get_retry_delay(retry_count, retry_initial_delay, retry_max_delay)
+        retry_count += 1
+        retry
+      end
+
+      handle_api_error(e.http_code, e.http_body)
+    rescue RestClient::Exception => e
+      raise ApiError, "An unexpected error happens while communicating to Jamm server. #{e}"
+    end
+
+    parse(response)
+  end
+
+  def self.handle_api_error(http_code, http_body)
+    begin
+      error_obj = JSON.parse(http_body)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj[:error] or raise(ApiError) # escape from parsing
+    rescue JSON::ParserError, ApiError => e
+      raise ApiError.new "An unexpected error happens while parsing the error response. #{e}", http_status: http_code,
+                                                                                               http_body: http_body
+    end
+
+    case http_code
+    when 400, 404
+      raise InvalidRequestError.new error, http_status: http_code, http_body: http_body, json_body: error_obj
+    when 401
+      raise AuthenticationError.new error, http_status: http_code, http_body: http_body, json_body: error_obj
+    else
+      raise ApiError.new error, http_status: http_code, http_body: http_body, json_body: error_obj
+    end
+  end
+
+  def self.parse(response)
+    begin
+      response = JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise ApiError.new "Invalid response object from API: #{response.inspect}. HTTP response code: #{response.code})",
+                         http_status: response.code, http_body: response.body
+    end
+
+    converted_response = Util.symbolize_names(response)
+    Util.convert_to_jamm_object(converted_response)
+  end
+
+  def self.execute_request(option)
+    RestClient::Request.execute(option)
+  end
+
+  def self.get_retry_delay(retry_count, retry_initial_delay, retry_max_delay)
+    # Exponential backoff
+    [retry_max_delay, retry_initial_delay * 2**retry_count].min
+  end
+
+  def self.uri_encode(params)
+    Util.flatten_params(params)
+        .map { |k, v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+  end
+
+  def self.api_url(url, api_base_url)
+    api_base_url + url
+  end
+
+  def self.error_on_invalid_params(params)
+    return if params.nil? || params.is_a?(Hash)
+
+    raise ArgumentError,
+          'request params should be either a Hash or nil ' \
+          "(was a #{params.class})"
+  end
+end

data/test/jamm/charge_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../test_helper', __dir__)
+
+module Jamm
+  class ChargeTest < Test::Unit::TestCase
+    should 'return a list of charge when Charge.list return valid response' do
+      # Arrange
+      @mock.expects(:post).once.returns(test_response(test_cognito_response))
+      @mock.expects(:get).once.returns(test_response(test_charges))
+      # Act
+      actual = Jamm::Charge.list
+      # Assert
+      assert actual.is_a? Array
+      assert_equal actual[0].charge_id, 'ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef'
+      assert_equal actual[0].contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
+      assert_equal actual[0].status, 'CREATED'
+      assert_equal actual[0].description, 'Gold Gym'
+      assert_equal actual[0].currency, 'JPY'
+      assert_equal actual[0].amount, 1000
+      assert_equal actual[0].amount_refunded, 800
+      assert_equal actual[0].merchant_metadata.key1, 'value1'
+      assert_equal actual[0].merchant_metadata.key2, 'value2'
+      assert_equal actual[0].created_at, '2023-11-07T15:30:00.000+03:00'
+      assert_equal actual[0].updated_at, '2023-11-11T15:30:00.000+03:00'
+    end
+
+    should 'raise an error when Charge.list return timeout' do
+      # Arrange
+      @mock.expects(:post).once.returns(test_response(test_cognito_response))
+      @mock.expects(:get).once.raises(RestClient::RequestTimeout)
+      # Assert
+      assert_raise ApiConnectionError do
+        Jamm::Charge.list
+      end
+    end
+
+    should 'return a charge when Charge.get return valid response' do
+      # Arrange
+      @mock.expects(:post).once.returns(test_response(test_cognito_response))
+      @mock.expects(:get).once.returns(test_response(test_charge))
+      # Act
+      actual = Jamm::Charge.get('ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef')
+      # Assert
+      assert_equal actual.charge_id, 'ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef'
+      assert_equal actual.contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
+      assert_equal actual.status, 'CREATED'
+      assert_equal actual.description, 'Gold Gym'
+      assert_equal actual.currency, 'JPY'
+      assert_equal actual.amount, 1000
+      assert_equal actual.amount_refunded, 800
+      assert_equal actual.merchant_metadata.key1, 'value1'
+      assert_equal actual.merchant_metadata.key2, 'value2'
+      assert_equal actual.created_at, '2023-11-07T15:30:00.000+03:00'
+      assert_equal actual.updated_at, '2023-11-11T15:30:00.000+03:00'
+    end
+  end
+end