webpay 2.4.1 → 3.0.0

data/lib/webpay/error.rb

@@ -0,0 +1,68 @@
+class WebPay
+  class ApiError < StandardError
+  end
+
+  class InvalidRequestError < ApiError
+    attr_reader :bad_value
+
+    def initialize(message, bad_value)
+      super(message)
+      @bad_value = bad_value
+    end
+  end
+
+  class InvalidResponseError < ApiError
+  end
+
+  class ApiConnectionError < ApiError
+    attr_reader :cause
+
+    def self.in_request(cause)
+      self.new("API request failed with #{cause}", cause)
+    end
+
+    def self.invalid_json(cause)
+      self.new("Server responded invalid JSON string", cause)
+    end
+
+    def initialize(message, cause)
+      @cause = cause
+      super(message)
+    end
+  end
+
+  module ErrorResponse
+    class InvalidRequestError < WebPay::ApiError
+      attr_reader :status, :data
+      def initialize(status, raw_data)
+        @status = status
+        @data = WebPay::ErrorData.new(raw_data)
+        super(sprintf('%s: %s', 'InvalidRequestError', data.error.message))
+      end
+    end
+    class AuthenticationError < WebPay::ApiError
+      attr_reader :status, :data
+      def initialize(status, raw_data)
+        @status = status
+        @data = WebPay::ErrorData.new(raw_data)
+        super(sprintf('%s: %s', 'AuthenticationError', data.error.message))
+      end
+    end
+    class CardError < WebPay::ApiError
+      attr_reader :status, :data
+      def initialize(status, raw_data)
+        @status = status
+        @data = WebPay::ErrorData.new(raw_data)
+        super(sprintf('%s: %s', 'CardError', data.error.message))
+      end
+    end
+    class ApiError < WebPay::ApiError
+      attr_reader :status, :data
+      def initialize(status, raw_data)
+        @status = status
+        @data = WebPay::ErrorData.new(raw_data)
+        super(sprintf('%s: %s', 'ApiError', data.error.message))
+      end
+    end
+  end
+end

data/lib/webpay/event.rb

@@ -1,19 +1,22 @@
-module WebPay
-
-  # Object for API response hash object with <code>hash['object'] = event</code>
-  class Event < Entity
-    install_class_operations :retrieve, :all
-
-    # @return [String] Relative path to API root
-    # @api private
-    def self.path
-      '/events'
-    end
+class WebPay::Event < WebPay::ApiResource
+  # Retrieve an event object by event id.
+  #
+  # @param params [EventIdRequest|Hash] Parameters to API call
+  # @return [EventResponse]
+  def retrieve(params = {})
+    req = WebPay::EventIdRequest.create(params)
+    raw_response = @client.request(:get, 'events/:id', req)
+    WebPay::EventResponse.new(raw_response)
+  end
 
-    # Entity object for <code>event.data</code>
-    # This entity has <code>object</code> on which event occurred,
-    # and <code>previous_attributes</code> if some of attributes are modified on the event.
-    class Data < Entity
-    end
+  # List events filtered by params
+  #
+  # @param params [ListRequestWithEventType|Hash] Parameters to API call
+  # @return [EventResponseList]
+  def all(params = {})
+    req = WebPay::ListRequestWithEventType.create(params)
+    raw_response = @client.request(:get, 'events', req)
+    WebPay::EventResponseList.new(raw_response)
   end
+
 end

data/lib/webpay/recursion.rb

@@ -1,52 +1,53 @@
-module WebPay
-
-  # Object for API response hash object with <code>hash['object'] = recursion</code>
-  class Recursion < Entity
-    install_class_operations :create, :all
-
-    # @return [String] Relative path to API root
-    # @api private
-    def self.path
-      '/recursions'
-    end
-
-    # @return [Entity] WebPay::Recursion or WebPay::DeletedEntity. <code>deleted?</code> is to classify.
-    def self.retrieve(id)
-      id = id.to_s
-      if id.strip == ''
-        raise InvalidRequestError.invalid_id(id)
-      end
-      response = WebPay.client.get([path, id].join('/'))
-      if response['deleted']
-        DeletedEntity.new(response)
-      else
-        convert(response)
-      end
-    end
+class WebPay::Recursion < WebPay::ApiResource
+  # Create a recursion object with given parameters.
+  #
+  # @param params [RecursionRequestCreate|Hash] Parameters to API call
+  # @return [RecursionResponse]
+  def create(params = {})
+    req = WebPay::RecursionRequestCreate.create(params)
+    raw_response = @client.request(:post, 'recursions', req)
+    WebPay::RecursionResponse.new(raw_response)
+  end
 
-    # @return [Boolean] false
-    def deleted?
-      false
-    end
+  # Retrieve a recursion object by recursion id.
+  # If the recursion is already deleted, "deleted" attribute becomes true.
+  #
+  # @param params [RecursionIdRequest|Hash] Parameters to API call
+  # @return [RecursionResponse]
+  def retrieve(params = {})
+    req = WebPay::RecursionIdRequest.create(params)
+    raw_response = @client.request(:get, 'recursions/:id', req)
+    WebPay::RecursionResponse.new(raw_response)
+  end
 
-    # Send resume request.
-    # @return [Recursion] this object, resumed
-    def resume(params = {})
-      update_attributes(WebPay.client.post([path, 'resume'].join('/'), params))
-    end
+  # Resume a suspended recursion
+  #
+  # @param params [RecursionRequestResume|Hash] Parameters to API call
+  # @return [RecursionResponse]
+  def resume(params = {})
+    req = WebPay::RecursionRequestResume.create(params)
+    raw_response = @client.request(:post, 'recursions/:id/resume', req)
+    WebPay::RecursionResponse.new(raw_response)
+  end
 
-    # Delete this recursion.
-    # This operation cannot be undone.
-    # @return [Boolean] true if operation succeeded
-    def delete
-      response = WebPay.client.delete(path)
-      response['deleted']
-    end
+  # Delete an existing recursion
+  #
+  # @param params [RecursionIdRequest|Hash] Parameters to API call
+  # @return [RecursionResponse]
+  def delete(params = {})
+    req = WebPay::RecursionIdRequest.create(params)
+    raw_response = @client.request(:delete, 'recursions/:id', req)
+    WebPay::RecursionResponse.new(raw_response)
+  end
 
-    # @return [String] Relative path of instance to API root
-    # @api private
-    def path
-      "/recursions/#{id}"
-    end
+  # List recursions filtered by params
+  #
+  # @param params [ListRequestWithCustomerAndSuspended|Hash] Parameters to API call
+  # @return [RecursionResponseList]
+  def all(params = {})
+    req = WebPay::ListRequestWithCustomerAndSuspended.create(params)
+    raw_response = @client.request(:get, 'recursions', req)
+    WebPay::RecursionResponseList.new(raw_response)
   end
+
 end

data/lib/webpay/shop.rb

@@ -1,73 +1,42 @@
-module WebPay
-
-  # Object for API response hash object with <code>hash['object'] = shop</code>
-  class Shop < Entity
-    install_class_operations :create, :retrieve, :all
-
-    # Attributes which can be updated and read by access.
-    # These attributes are sent on save if changed.
-    attr_accessor :read_attributes
-
-    # @return [String] Relative path to API root
-    # @api private
-    def self.path
-      '/shops'
-    end
-
-    # @api private
-    def initialize(attributes)
-      @read_attributes = {}
-      super(attributes)
-    end
-
-    # <code>object['key']=</code> is wrapper for <code>object.key =</code>.
-    # Method call style is recommended.
-    # @return [Object] Given value
-    def []=(key, value)
-      send("#{key}=", value)
-    end
-
-    # <code>object['key']</code> is wrapper for <code>object.key</code>.
-    # Method call style is recommended.
-    # @return [Object] The attribute's value
-    def [](key)
-      send(key)
-    end
-
-    [:description, :details].each do |attr|
-      define_method("#{attr}=") do |value|
-        @read_attributes[attr.to_s] = value
-      end
-      define_method("#{attr}") do
-        obj = @attributes[attr.to_s]
-        copyable = !(obj == nil || obj == true || obj == false || obj.is_a?(Symbol) || obj.is_a?(Integer))
-        @read_attributes[attr.to_s] ||= copyable ? obj.dup : obj
-      end
-    end
-
-    # Return a hash similar to the response from API.
-    # If an attribute's value is updated, the updated value is used.
-    # @return [Hash] a hash similar to the response from API
-    def to_hash
-      Hash[@attributes.merge(@read_attributes).map { |k, v| [k, v.is_a?(Entity) ? v.to_hash : v] }]
-    end
+class WebPay::Shop < WebPay::ApiResource
+  # Create a shop object with given parameters.
+  #
+  # @param params [ShopRequestCreate|Hash] Parameters to API call
+  # @return [ShopResponse]
+  def create(params = {})
+    req = WebPay::ShopRequestCreate.create(params)
+    raw_response = @client.request(:post, 'shops', req)
+    WebPay::ShopResponse.new(raw_response)
+  end
 
-    alias_method :to_h, :to_hash
+  # Retrieve a shop object by shop id.
+  #
+  # @param params [ShopIdRequest|Hash] Parameters to API call
+  # @return [ShopResponse]
+  def retrieve(params = {})
+    req = WebPay::ShopIdRequest.create(params)
+    raw_response = @client.request(:get, 'shops/:id', req)
+    WebPay::ShopResponse.new(raw_response)
+  end
 
-    # Send update request of modified attributes.
-    # description and details are modifiable.
-    # @return [Shop] this object with attributes updated
-    def save
-      changed_attributes = @read_attributes.select { |k,v| @attributes[k] != v }
-      update_attributes(WebPay.client.post(path, changed_attributes))
-      @read_attributes = {}
-      self
-    end
+  # Update an existing shop with specified parameters
+  #
+  # @param params [ShopRequestUpdate|Hash] Parameters to API call
+  # @return [ShopResponse]
+  def update(params = {})
+    req = WebPay::ShopRequestUpdate.create(params)
+    raw_response = @client.request(:post, 'shops/:id', req)
+    WebPay::ShopResponse.new(raw_response)
+  end
 
-    # @return [String] Relative path of instance to API root
-    # @api private
-    def path
-      "/shops/#{id}"
-    end
+  # List shops filtered by params
+  #
+  # @param params [ListRequestWithLive|Hash] Parameters to API call
+  # @return [ShopResponseList]
+  def all(params = {})
+    req = WebPay::ListRequestWithLive.create(params)
+    raw_response = @client.request(:get, 'shops', req)
+    WebPay::ShopResponseList.new(raw_response)
   end
+
 end

data/lib/webpay/token.rb

@@ -1,13 +1,22 @@
-module WebPay
-
-  # Object for API response hash object with <code>hash['object'] = token</code>
-  class Token < Entity
-    install_class_operations :create, :retrieve
+class WebPay::Token < WebPay::ApiResource
+  # Create a token object with given parameters.
+  #
+  # @param params [TokenRequestCreate|Hash] Parameters to API call
+  # @return [TokenResponse]
+  def create(params = {})
+    req = WebPay::TokenRequestCreate.create(params)
+    raw_response = @client.request(:post, 'tokens', req)
+    WebPay::TokenResponse.new(raw_response)
+  end
 
-    # @return [String] Relative path to API root
-    # @api private
-    def self.path
-      '/tokens'
-    end
+  # Retrieve a token object by token id.
+  #
+  # @param params [TokenIdRequest|Hash] Parameters to API call
+  # @return [TokenResponse]
+  def retrieve(params = {})
+    req = WebPay::TokenIdRequest.create(params)
+    raw_response = @client.request(:get, 'tokens/:id', req)
+    WebPay::TokenResponse.new(raw_response)
   end
+
 end

data/lib/webpay.rb

@@ -1,95 +1,132 @@
-require 'webpay/version'
+require 'faraday'
+begin
+  require 'mutli_json'
+  JSON_CLASS = MultiJson
+rescue LoadError
+  require 'json'
+  JSON_CLASS = JSON
+end
 
-# Toplevel module of WebPay gem.
-# This is the start point.
-module WebPay
-  autoload(:Client, 'webpay/client')
-  autoload(:Operations, 'webpay/operations')
-  autoload(:WebPayError, 'webpay/webpay_error')
-  autoload(:APIConnectionError, 'webpay/webpay_error')
-  autoload(:APIError, 'webpay/webpay_error')
-  autoload(:AuthenticationError, 'webpay/webpay_error')
-  autoload(:CardError, 'webpay/webpay_error')
-  autoload(:InvalidRequestError, 'webpay/webpay_error')
-  autoload(:Entity, 'webpay/entity')
-  autoload(:EntityList, 'webpay/entity_list')
-  autoload(:DeletedEntity, 'webpay/deleted_entity')
-  autoload(:Account, 'webpay/account')
-  autoload(:Card, 'webpay/card')
-  autoload(:Charge, 'webpay/charge')
-  autoload(:Customer, 'webpay/customer')
-  autoload(:Event, 'webpay/event')
-  autoload(:Fee, 'webpay/fee')
-  autoload(:Token, 'webpay/token')
-  autoload(:Shop, 'webpay/shop')
-  autoload(:Recursion, 'webpay/recursion')
-  autoload(:ResponseConverter, 'webpay/response_converter')
+class WebPay
+  attr_reader :conn
+  attr_accessor :charge
+  attr_accessor :customer
+  attr_accessor :token
+  attr_accessor :event
+  attr_accessor :shop
+  attr_accessor :recursion
+  attr_accessor :account
 
-  @api_base = 'https://api.webpay.jp'
-  @api_version = '/v1'
-  @api_key = nil
-  @api_proxy = nil
-  @language = :en
+  # Initialize client
+  #
+  # @param options [Hash] options
+  def initialize(options)
+    options = options.each_with_object({}) { |kv, obj| k,v = kv; obj[k.to_s] = v }
 
-  class << self
-    # Absolute path to SSL CA file.
-    # This gem includes SSL CA file as lib/data/ca-certificates.crt.
-    def ssl_ca_file
-      File.join(File.dirname(File.expand_path(__FILE__)), 'data', 'ca-certificates.crt')
+    connection_options = options['faraday_options'] || {}
+    connection_options['headers'] = {
+      "Content-Type" => "application/json",
+      "Accept" => "application/json",
+      "User-Agent" => "Apipa-webpay/3.0.0 ruby",
+      "Accept-Language" => "en",
+    }
+    connection_options['url'] = options['api_base'] || 'https://api.webpay.jp/v1'
+    @conn = Faraday.new(connection_options) do |builder|
+      builder.request :url_encoded
+      builder.adapter Faraday.default_adapter
     end
 
-    # Current client object.
-    # client is memoized, and nullified when @api_base or @api_key is modified.
-    def client
-      @client ||= Client.new(@api_key, @api_base, @api_version, @api_proxy, @language)
-    end
 
-    # Set api_base, the base URL of API.
-    # Configure this before sending any request.
-    # Take care when using unofficial WebPay API.
-    def api_base=(new_value)
-      @api_base = new_value
-      @client = nil
-    end
+    @conn.authorization(:Bearer, options['api_key'])
 
-    # Set api_key, your token for accessing API.
-    # Configure this before sending any request.
-    def api_key=(new_value)
-      @api_key = new_value
-      @client = nil
-    end
+    @charge = WebPay::Charge.new(self)
+    @customer = WebPay::Customer.new(self)
+    @token = WebPay::Token.new(self)
+    @event = WebPay::Event.new(self)
+    @shop = WebPay::Shop.new(self)
+    @recursion = WebPay::Recursion.new(self)
+    @account = WebPay::Account.new(self)
+  end
 
-    # Set proxy for connecting to @api_base
-    def api_proxy=(new_value)
-      @api_proxy = new_value
-      @client = nil
-    end
+  def set_accept_language(value)
+    @conn.headers['Accept-Language'] = value
+  end
 
-    # Set value of accept-language request header
-    # Currently WebPay API handles :en and :ja
-    def language=(new_value)
-      @language = new_value
-      @client = nil
-    end
 
-    # Get current api_base
-    def api_base
-      @api_base
+  # Convert faraday response to a hash by decoding JSON.
+  # This raises error if the response indicates error status.
+  #
+  # @api private
+  # @param response [Faraday::Response]
+  # @return [Hash] Raw object
+  # @raise [WebPay::WebPayError] For invalid requests (4xx) or internal server error (5xx)
+  def handle_response(response)
+    data =
+      begin
+        JSON_CLASS.load(response.body.force_encoding(infer_encoding(response)))
+      rescue JSON_CLASS::ParserError => e
+        raise WebPay::ApiConnectionError.invalid_json(e)
+      end
+    status = response.status
+    case status
+    when 200..299
+      data
+    else
+      if  status == 400
+        raise WebPay::ErrorResponse::InvalidRequestError.new(status, data)
+      end
+      if  status == 401
+        raise WebPay::ErrorResponse::AuthenticationError.new(status, data)
+      end
+      if  status == 402
+        raise WebPay::ErrorResponse::CardError.new(status, data)
+      end
+      if  status == 404
+        raise WebPay::ErrorResponse::InvalidRequestError.new(status, data)
+      end
+      if  true
+        raise WebPay::ErrorResponse::ApiError.new(status, data)
+      end
+      raise "Unknown error is returned"
     end
+  end
 
-    # Get current api_key
-    def api_key
-      @api_key
+  def request(method, url_pattern ,params)
+    url = url_pattern.gsub(/:([[:alnum:]]+)/) { |name| params.__send__(name[1..-1]) }
+    begin
+      response = @conn.__send__(method, url, [:get, :delete].include?(method) ? params.to_h : JSON.dump(params.to_h))
+    rescue Faraday::Error::ClientError, URI::InvalidURIError => e
+      raise WebPay::ApiConnectionError.in_request(e)
     end
+    handle_response(response)
+  end
 
-    # Get current api_proxy
-    def api_proxy
-      @api_proxy
-    end
+  private
 
-    # Get current language
-    def language
-      @language
+  # Infer encoding from response
+  #
+  # @param response [Faraday::Response]
+  # @return [Encoding]
+  def infer_encoding(response)
+    unless (type = response.headers['content-type']) &&
+        (charset = type.split(';').find { |field| field.include?('charset=') })
+      return Encoding.default_external
     end
+
+    encoding_string = charset.split('=', 2).last.strip
+    Encoding.find(encoding_string)
+  rescue
+    Encoding.default_external
   end
 end
+
+require 'webpay/api_resource'
+require 'webpay/error'
+require 'webpay/charge'
+require 'webpay/customer'
+require 'webpay/token'
+require 'webpay/event'
+require 'webpay/shop'
+require 'webpay/recursion'
+require 'webpay/account'
+require 'webpay/data_types'

data/webpay.gemspec

@@ -1,29 +1,22 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'webpay/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'webpay'
-  spec.version       = WebPay::VERSION
+  spec.version       = '3.0.0'
   spec.authors       = ['webpay', 'tomykaira']
   spec.email         = ['administrators@webpay.jp', 'tomykaira@webpay.jp']
   spec.description   = 'WebPay is payment gateway service in Japan. see also https://webpay.jp/'
-  spec.summary       = 'Ruby bindings of WebPay API'
+  spec.summary       = 'Bindings of WebPay API'
   spec.homepage      = 'https://webpay.jp'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = File.read(File.expand_path(File.join(__FILE__, "..", "FILELIST"))).split("\n")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'faraday', '~> 0.8'
+  spec.add_dependency 'faraday', '~> 0.9'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'yard', '~> 0.8.6.2'
-  spec.add_development_dependency 'redcarpet', '~> 3.0.0'
-  spec.add_development_dependency 'rspec', '~> 2.14.0'
-  spec.add_development_dependency 'webmock', '~> 1.13.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.3.1'
 end