jamm 0.0.1 → 1.0.2

data/lib/jamm/api/models/v1_url.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+# #api/v1/common.proto
+#
+# No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+#
+# The version of the OpenAPI document: version not set
+#
+# Generated by: https://openapi-generator.tech
+# Generator version: 7.9.0
+#
+
+require 'date'
+require 'time'
+
+module Api
+  class URL
+    # URL to redirect the customer from Jamm to shop after payment is successful.  決済が成功した場合に、顧客をJammからショップへリダイレクトするURLです。  @gotags: validate:\"required,http_url\"
+    attr_accessor :success_url
+
+    # URL to redirect the customer from Jamm to shop after payment is failed.  決済が失敗した場合に、顧客をJammからショップへリダイレクトするURLです。  @gotags: validate:\"required,http_url\"
+    attr_accessor :failure_url
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :success_url => :successUrl,
+        :failure_url => :failureUrl
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :success_url => :String,
+        :failure_url => :String
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      raise ArgumentError, 'The input argument (attributes) must be a hash in `Api::URL` initialize method' unless attributes.is_a?(Hash)
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) do |(k, v), h|
+        raise ArgumentError, "`#{k}` is not a valid attribute in `Api::URL`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect unless self.class.attribute_map.key?(k.to_sym)
+
+        h[k.to_sym] = v
+      end
+
+      self.success_url = attributes[:success_url] if attributes.key?(:success_url)
+
+      return unless attributes.key?(:failure_url)
+
+      self.failure_url = attributes[:failure_url]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      []
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        success_url == other.success_url &&
+        failure_url == other.failure_url
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [success_url, failure_url].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash[key.to_s] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          transformed_hash[key.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) } if attributes[attribute_map[key]].is_a?(Array)
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = Api.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end

data/lib/jamm/api/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# #api/v1/common.proto
+#
+# No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+#
+# The version of the OpenAPI document: version not set
+#
+# Generated by: https://openapi-generator.tech
+# Generator version: 7.9.0
+#
+
+module Api
+  VERSION = '1.0.0'
+end

data/lib/jamm/api.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# #api/v1/common.proto
+#
+# No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+#
+# The version of the OpenAPI document: version not set
+#
+# Generated by: https://openapi-generator.tech
+# Generator version: 7.9.0
+#
+
+# Common files
+require 'jamm/api/api_client'
+require 'jamm/api/api_error'
+require 'jamm/api/version'
+require 'jamm/api/configuration'
+
+# Models
+require 'jamm/api/models/customer_service_update_customer_body'
+require 'jamm/api/models/protobuf_any'
+require 'jamm/api/models/rpc_status'
+require 'jamm/api/models/v1_buyer'
+require 'jamm/api/models/v1_charge'
+require 'jamm/api/models/v1_contract'
+require 'jamm/api/models/v1_create_contract_with_charge_request'
+require 'jamm/api/models/v1_create_contract_with_charge_response'
+require 'jamm/api/models/v1_create_contract_without_charge_request'
+require 'jamm/api/models/v1_create_contract_without_charge_response'
+require 'jamm/api/models/v1_create_customer_request'
+require 'jamm/api/models/v1_create_customer_response'
+require 'jamm/api/models/v1_customer'
+require 'jamm/api/models/v1_delete_customer_response'
+require 'jamm/api/models/v1_get_contract_response'
+require 'jamm/api/models/v1_get_customer_response'
+require 'jamm/api/models/v1_initial_charge'
+require 'jamm/api/models/v1_merchant'
+require 'jamm/api/models/v1_merchant_customer'
+require 'jamm/api/models/v1_payment_link'
+require 'jamm/api/models/v1_ping_response'
+require 'jamm/api/models/v1_url'
+require 'jamm/api/models/v1_update_customer_response'
+
+# APIs
+require 'jamm/api/api/customer_api'
+require 'jamm/api/api/healthcheck_api'
+require 'jamm/api/api/payment_api'
+
+module Api
+  class << self
+    # Customize default settings for the SDK using block.
+    #   Api.configure do |config|
+    #     config.username = "xxx"
+    #     config.password = "xxx"
+    #   end
+    # If no block given, return the default Configuration object.
+    def configure
+      if block_given?
+        yield(Configuration.default)
+      else
+        Configuration.default
+      end
+    end
+  end
+end

data/lib/jamm/client.rb

@@ -0,0 +1,14 @@
+module Jamm
+  module Client
+    def self.handler
+      base = Jamm::ApiClient.new
+
+      # Configure
+      base.config.host = Jamm.openapi.config.host
+      base.config.scheme = Jamm.openapi.config.scheme
+      base.default_headers['Authorization'] = "Bearer #{Jamm::OAuth.token}"
+
+      base
+    end
+  end
+end

data/lib/jamm/customer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'base64'
+require 'jamm/errors'
+
+module Jamm
+  module Customer
+    def self.get(customer:)
+      Jamm::CustomerApi.new(Jamm::Client.handler).get customer
+    rescue Jamm::ApiError => e
+      puts e
+    end
+
+    def self.update(**params)
+      Jamm::CustomerApi.new(Jamm::Client.handler).update(params[:id], params)
+    rescue Jamm::ApiError => e
+      puts e
+    end
+
+    def self.delete(customer:)
+      Jamm::CustomerApi.new(Jamm::Client.handler).delete customer
+    rescue Jamm::ApiError => e
+      puts e
+    end
+  end
+end

data/lib/jamm/errors.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module Jamm
   class JammError < StandardError
     attr_reader :message, :http_body, :http_headers, :http_status, :json_body
 
     def initialize(message = nil, http_status: nil, http_headers: nil, http_body: nil, json_body: nil)
+      super(message)
+
       @message = message
       @http_status = http_status
       @http_headers = http_headers
@@ -19,18 +23,4 @@ module Jamm
   # OAuthError is raised when a request to AWS cognito failed
   class OAuthError < JammError
   end
-
-  # ApiConnectionError is raised when a request to Jamm api failed
-  class ApiConnectionError < JammError
-  end
-
-  # ApiError is raised when Jamm api failed with an unexpected reason
-  class ApiError < JammError
-  end
-
-  class InvalidRequestError < JammError
-  end
-
-  class AuthenticationError < JammError
-  end
 end

data/lib/jamm/oauth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rest-client'
 require 'json'
 require 'base64'
@@ -5,16 +7,14 @@ 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?
+    def self.token
+      if Jamm.client_id.nil? || Jamm.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)
+      fetch_oauth_token(Jamm.client_id, Jamm.client_secret)
     end
 
     def self.fetch_oauth_token(client_id, client_secret)

data/lib/jamm/payment.rb

@@ -1,18 +1,26 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'base64'
+require 'jamm/errors'
+
 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]
+  module Payment
+    def self.contract_with_charge(**params)
+      request = Jamm::CreateContractWithChargeRequest.new(params)
 
-      request_jamm_api(
-        method: :post,
-        path: resource_url,
-        params: params,
-        headers: headers
-      )
+      begin
+        Jamm::PaymentApi.new(Jamm::Client.handler).create_contract_with_charge(request)
+      rescue Jamm::ApiError => e
+        puts e
+      end
     end
 
-    def self.resource_url
-      '/payments'
+    def self.get_contract(contract:)
+      Jamm::PaymentApi.new(Jamm::Client.handler).get_contract(contract)
+    rescue Jamm::ApiError => e
+      puts e
     end
   end
 end

data/lib/jamm/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jamm
-  VERSION = '0.0.1'
+  VERSION = '1.0.2'
 end

data/lib/jamm.rb

@@ -1,146 +1,66 @@
-# FIXME: remove this line once manual testing completed
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+# frozen_string_literal: true
+
 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/api'
+require 'jamm/client'
+require 'jamm/errors'
 require 'jamm/oauth'
-require 'jamm/request'
-require 'jamm/api_resource'
-require 'jamm/token'
+require 'jamm/version'
+
+# OpenAPI wrappers
+require 'jamm/customer'
 require 'jamm/payment'
-require 'jamm/charge'
-require 'jamm/util'
-require 'jamm/jamm_object'
-require 'jamm/errors'
-require 'jamm/time_util'
 
+# Jamm Ruby SDK
 module Jamm
-  @api_base = 'http://api.jamm-pay.jp/api/v0'
-  @oauth_base = 'https://jamm-merchant-sandbox.auth.ap-northeast-1.amazoncognito.com'
+  # Configurable attributes.
+  @oauth_base = nil
+  @openapi = nil
   @open_timeout = 30
   @read_timeout = 90
   @max_retry = 0
-  @retry_initial_delay = 0.1
-  @retry_max_delay = 32
+
+  # Include OpenAPI generated module into root Jamm namespace.
+  # The OpenAPI sub-modules and methods can be accessed via Jamm::{foo}
+  include Api
 
   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
+    attr_accessor :api, :client_id, :client_secret, :api_base, :env, :oauth_base, :api_version, :connect_base,
+                  :openapi, :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
+  def self.configure(client_id:, client_secret:, env:)
+    Jamm.client_id = client_id
+    Jamm.client_secret = client_secret
 
-      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
+    case env
+    when 'prod'
+      self.oauth_base = 'https://merchant-identity.jamm-pay.jp'
 
-    parse(response)
-  end
+      self.openapi = Jamm::ApiClient.new
+      openapi.config.host = 'api.jamm-pay.jp'
 
-  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
+    # Debugger mode, uncomment when needed
+    # when 'develop'
+    #   self.oauth_base = "https://merchant-identity.#{env}.jamm-pay.jp"
+    #
+    #   self.openapi = Jamm::ApiClient.new
+    #   openapi.config.host = 'api.jamm.test'
 
-    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
+      self.oauth_base = "https://merchant-identity.#{env}.jamm-pay.jp"
 
-  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
+      self.openapi = Jamm::ApiClient.new
+      openapi.config.host = "api.#{env}.jamm-pay.jp"
     end
 
-    converted_response = Util.symbolize_names(response)
-    Util.convert_to_jamm_object(converted_response)
+    openapi.config.scheme = 'https'
   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