mollie-api-ruby 2.2.1 → 3.1.0

data/examples/apis/refunds.rb

@@ -11,7 +11,7 @@ class Application < Sinatra::Application
   end
 
   get '/v1/refunds' do
-    refunds = client.refunds.all(params[:offset], params[:limit], testmode: params[:test_mode])
+    refunds = Mollie::Refund.all(params[:offset], params[:limit], testmode: params[:test_mode])
     JSON.pretty_generate(refunds.attributes)
   end
 end

data/examples/apis/settlements.rb

@@ -52,7 +52,7 @@ class Application < Sinatra::Application
   end
 
   get '/v1/settlements' do
-    settlements = client.settlements.all(params[:offset], params[:count],
+    settlements = Mollie::Settlement.all(params[:offset], params[:count],
                                          reference: params[:reference],
                                          testmode:  params[:testmode]
     )
@@ -60,23 +60,23 @@ class Application < Sinatra::Application
   end
 
   get '/v1/settlements/:id' do
-    settlement = client.settlements.get(params[:id], testmode: params[:testmode])
+    settlement = Mollie::Settlement.get(params[:id], testmode: params[:testmode])
     JSON.pretty_generate(settlement.attributes)
   end
 
   get '/v1/settlements/next' do
-    settlement = client.settlements.next(testmode: params[:testmode])
+    settlement = Mollie::Settlement.next(testmode: params[:testmode])
     JSON.pretty_generate(settlement.attributes)
   end
 
   get '/v1/settlements/open' do
-    settlement = client.settlements.open(testmode: params[:testmode])
+    settlement = Mollie::Settlement.open(testmode: params[:testmode])
     JSON.pretty_generate(settlement.attributes)
   end
 
 
   get '/v1/settlements/:settlement_id/payments' do
-    payments = client.settlements_payments.with(params[:settlement_id]).all(params[:offset], params[:count], testmode: params[:testmode])
+    payments = Mollie::Settlement::Payment.all(params[:offset], params[:count], testmode: params[:testmode], settlement_id: params[:settlement_id])
     JSON.pretty_generate(payments.attributes)
   end
 

data/examples/apis/subscriptions.rb

@@ -102,7 +102,7 @@ class Application < Sinatra::Application
   end
 
   post '/v1/subscriptions/first_payment' do
-    payment = client.payments.create(
+    payment = Mollie::Payment.create(
       amount:         json_params['amount'],
       customer_id:    json_params['customer_id'],
       description:    json_params['description'],
@@ -116,12 +116,12 @@ class Application < Sinatra::Application
   end
 
   get '/v1/subscriptions/mandates/:customer_id' do
-    mandates = client.customers_mandates.with(params[:customer_id]).all
+    mandates = Mollie::Customer::Mandates.all(customer_id: params[:customer_id])
     JSON.pretty_generate(mandates.attributes)
   end
 
   post '/v1/subscriptions/on_demand' do
-    payment = client.payments.create(
+    payment = Mollie::Payment.create(
       amount:         json_params['amount'],
       customer_id:    json_params['customer_id'],
       description:    json_params['description'],
@@ -135,17 +135,17 @@ class Application < Sinatra::Application
   end
 
   get '/v1/customers/:customer_id/subscriptions' do
-    subscriptions = client.customers_subscriptions.with(params[:customer_id]).all(params[:offset], params[:count], testmode: params[:testmode])
+    subscriptions = Mollie::Customer::Subscription.all(params[:offset], params[:count], testmode: params[:testmode], customer_id: params[:customer_id])
     JSON.pretty_generate(subscriptions.attributes)
   end
 
   get '/v1/customers/:customer_id/subscriptions/:id' do
-    payment = client.customers_subscriptions.with(params[:customer_id]).get(params[:id], testmode: params[:testmode])
+    payment = Mollie::Customer::Subscription.get(params[:id], testmode: params[:testmode], customer_id: params[:customer_id])
     JSON.pretty_generate(payment.attributes)
   end
 
   post '/v1/customers/:customer_id/subscriptions' do
-    subscription = client.customers_subscriptions.with(params[:customer_id]).create(
+    subscription = Mollie::Customer::Subscription.create(
       amount:      json_params['amount'],
       times:       json_params['times'],
       interval:    json_params['interval'],
@@ -159,7 +159,7 @@ class Application < Sinatra::Application
   end
 
   delete '/v1/customers/:customer_id/subscriptions/:id' do
-    client.customers_subscriptions.with(params[:customer_id]).delete(params[:id], testmode: params[:testmode])
+    Mollie::Customer::Subscription.delete(params[:id], testmode: params[:testmode], customer_id: params[:customer_id])
     "deleted"
   end
 end

data/examples/config.ru

@@ -5,7 +5,7 @@ require 'sinatra/namespace'
 require 'sinatra/cross_origin'
 require "swagger/blocks"
 
-require File.expand_path "../lib/mollie/api/client", File.dirname(__FILE__)
+require File.expand_path "../lib/mollie-api-ruby", File.dirname(__FILE__)
 
 require 'ngrok/tunnel'
 
@@ -17,6 +17,9 @@ class Application < Sinatra::Application
   before do
     headers "Access-Control-Allow-Origin" => "*"
     headers["Access-Control-Allow-Headers"] = "X-Requested-With, X-HTTP-Method-Override, Content-Type, Cache-Control, Accept, X-Mollie-Api-Key"
+    Mollie::Client.configure do |config|
+      config.api_key = request.env["HTTP_X_MOLLIE_API_KEY"] || ENV["API_KEY"]
+    end
   end
 
   configure :production, :development do
@@ -31,7 +34,7 @@ class Application < Sinatra::Application
     also_reload File.expand_path "./apis/*.rb", File.dirname(__FILE__)
   end
 
-  error {|err| Rack::Response.new([{ 'error' => err.message }.to_json], 500, { 'Content-type' => 'application/json' }).finish}
+  error { |err| Rack::Response.new([{ 'error' => err.message }.to_json], 500, { 'Content-type' => 'application/json' }).finish }
 
   options "*" do
     response.headers["Allow"] = "HEAD,GET,PUT,POST,DELETE,OPTIONS"
@@ -41,17 +44,13 @@ class Application < Sinatra::Application
     200
   end
 
-  def client
-    @client ||= Mollie::API::Client.new(request.env["HTTP_X_MOLLIE_API_KEY"] || ENV["API_KEY"])
-  end
-
   def json_params
     @json_params ||= JSON.parse request.body.read
   end
 
 end
 
-Dir[File.join('apis', '*.rb')].each {|file| require File.expand_path(file)}
+Dir[File.join('apis', '*.rb')].each { |file| require File.expand_path(file) }
 
 run Application.new
 

data/lib/mollie-api-ruby.rb

@@ -0,0 +1 @@
+require_relative './mollie'

data/lib/mollie.rb

@@ -0,0 +1,39 @@
+require 'json'
+require 'time'
+require 'ostruct'
+require 'bigdecimal'
+require 'net/https'
+
+module Mollie
+
+end
+
+require 'mollie/exception'
+require 'mollie/util'
+require 'mollie/version'
+
+require 'mollie/base'
+require 'mollie/relation'
+require 'mollie/chargeback'
+require 'mollie/client'
+require 'mollie/customer'
+require 'mollie/customer/mandate'
+require 'mollie/customer/subscription'
+require 'mollie/invoice'
+require 'mollie/issuer'
+require 'mollie/list'
+require 'mollie/method'
+require 'mollie/organization'
+require 'mollie/payment'
+require 'mollie/permission'
+require 'mollie/profile'
+require 'mollie/profile/api_key'
+require 'mollie/refund'
+require 'mollie/settlement'
+
+require 'mollie/customer/payment'
+require 'mollie/payment/chargeback'
+require 'mollie/payment/refund'
+require 'mollie/settlement/chargeback'
+require 'mollie/settlement/payment'
+require 'mollie/settlement/refund'

data/lib/mollie/base.rb

@@ -0,0 +1,91 @@
+module Mollie
+  class Base
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+      assign_attributes(attributes)
+    end
+
+    def assign_attributes(attributes)
+      attributes.each do |key, value|
+        public_send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+    class << self
+      def create(data = {})
+        request("POST", nil, data) do |response|
+          new(response)
+        end
+      end
+
+      def all(*args)
+        options       = args.last.is_a?(Hash) ? args.pop : {}
+        offset, limit = args
+        request("GET", nil, {}, { offset: offset || 0, count: limit || 50 }.merge(options)) do |response|
+          Mollie::List.new(response, self)
+        end
+      end
+
+      def get(id, options = {})
+        request("GET", id, {}, options) do |response|
+          new(response)
+        end
+      end
+
+      def update(id, data = {})
+        request("POST", id, data) do |response|
+          new(response)
+        end
+      end
+
+      def delete(id, options = {})
+        request("DELETE", id, options)
+      end
+
+      def request(method, id = 0, data = {}, query = {})
+        parent_id = query.delete(self.parent_id) || data.delete(self.parent_id)
+        response  = Mollie::Client.instance.perform_http_call(method, resource_name(parent_id), id, data, query)
+        yield(response) if block_given?
+      end
+
+      def id_param
+        "#{name.downcase.split("::")[-1]}_id".to_sym
+      end
+
+      def parent_id
+        "#{name.downcase.split("::")[-2]}_id".to_sym
+      end
+
+      def resource_name(parent_id = nil)
+        path = name.downcase.split("::").slice(1..-1).map(&Util.method(:pluralize))
+
+        if path.size == 2 && parent_id
+          path.join("/#{parent_id}/")
+        else
+          path.last
+        end
+      end
+    end
+
+    def update(data = {})
+      if (parent_id = attributes[self.class.parent_id])
+        data[self.class.parent_id] = parent_id
+      end
+
+      if (resource = self.class.update(id, data))
+        !!assign_attributes(resource.attributes)
+      else
+        resource
+      end
+    end
+
+    def delete(options = {})
+      if (parent_id = attributes[self.class.parent_id])
+        options[self.class.parent_id] = parent_id
+      end
+      self.class.delete(id, options)
+    end
+  end
+end

data/lib/mollie/chargeback.rb

@@ -0,0 +1,36 @@
+module Mollie
+  class Chargeback < Base
+
+    attr_accessor :id,
+                  :payment,
+                  :amount,
+                  :chargeback_datetime,
+                  :settlement_id,
+                  :reversed_datetime
+
+
+    def reversed?
+      !!reversed_datetime
+    end
+
+    def reversed_datetime=(reversed_datetime)
+      @reversed_datetime = Time.parse(reversed_datetime) rescue nil
+    end
+
+    def chargeback_datetime=(chargeback_datetime)
+      @chargeback_datetime = Time.parse(chargeback_datetime) rescue nil
+    end
+
+    def amount=(amount)
+      @amount = BigDecimal.new(amount.to_s) if amount
+    end
+
+    def payment=(payment)
+      if payment.is_a?(Hash)
+        @payment = Payment.new(payment)
+      else
+        @payment = payment
+      end
+    end
+  end
+end

data/lib/mollie/client.rb

@@ -0,0 +1,125 @@
+module Mollie
+  class Client
+    API_ENDPOINT = 'https://api.mollie.nl'
+    API_VERSION  = 'v1'
+
+    MODE_TEST = 'test'
+    MODE_LIVE = 'live'
+
+    class << self
+      attr_accessor :configuration
+    end
+
+    class Configuration
+      attr_accessor :api_key
+
+      def initialize
+        @api_key = ''
+      end
+    end
+
+    def self.configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    # @return [Mollie::Client]
+    def self.instance
+      Thread.current['MOLLIE_CLIENT'] ||= new(configuration.api_key)
+    end
+
+    def self.with_api_key(api_key)
+      Thread.current['MOLLIE_API_KEY'] = instance.api_key
+      instance.api_key                 = api_key
+      yield
+    ensure
+      instance.api_key                 = Thread.current['MOLLIE_API_KEY']
+      Thread.current['MOLLIE_API_KEY'] = nil
+    end
+
+    attr_accessor :api_key,
+                  :api_endpoint
+
+    def initialize(api_key = nil)
+      @api_endpoint    = API_ENDPOINT
+      @api_key         = api_key
+      @version_strings = []
+
+      add_version_string 'Mollie/' << VERSION
+      add_version_string 'Ruby/' << RUBY_VERSION
+      add_version_string OpenSSL::OPENSSL_VERSION.split(' ').slice(0, 2).join '/'
+    end
+
+    def api_endpoint=(api_endpoint)
+      @api_endpoint = api_endpoint.chomp('/')
+    end
+
+    def add_version_string(version_string)
+      @version_strings << version_string.gsub(/\s+/, '-')
+    end
+
+    def perform_http_call(http_method, api_method, id = nil, http_body = {}, query = {})
+      path         = "/#{API_VERSION}/#{api_method}/#{id}".chomp('/')
+      api_key      = http_body.delete(:api_key) || query.delete(:api_key) || @api_key
+      api_endpoint = http_body.delete(:api_endpoint) || query.delete(:api_endpoint) || @api_endpoint
+
+      if query.length > 0
+        camelized_query = Util.camelize_keys(query)
+        path            += "?#{URI.encode_www_form(camelized_query)}"
+      end
+
+      uri                = URI.parse(api_endpoint)
+      client             = Net::HTTP.new(uri.host, uri.port)
+      client.use_ssl     = true
+      client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      client.ca_file     = (File.expand_path '../cacert.pem', File.dirname(__FILE__))
+
+      case http_method
+      when 'GET'
+        request = Net::HTTP::Get.new(path)
+      when 'POST'
+        http_body.delete_if { |k, v| v.nil? }
+        request      = Net::HTTP::Post.new(path)
+        request.body = Util.camelize_keys(http_body).to_json
+      when 'DELETE'
+        http_body.delete_if { |k, v| v.nil? }
+        request      = Net::HTTP::Delete.new(path)
+        request.body = Util.camelize_keys(http_body).to_json
+      else
+        raise Mollie::Exception.new("Invalid HTTP Method: #{http_method}")
+      end
+
+      request['Accept']        = 'application/json'
+      request['Content-Type']  = 'application/json'
+      request['Authorization'] = "Bearer #{api_key}"
+      request['User-Agent']    = @version_strings.join(' ')
+
+      begin
+        response = client.request(request)
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+        Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        raise Mollie::Exception.new(e.message)
+      end
+
+      http_code = response.code.to_i
+      case http_code
+      when 200, 201
+        Util.nested_underscore_keys(JSON.parse(response.body))
+      when 204
+        {} # No Content
+      else
+        response = JSON.parse(response.body)
+        if response['error']
+          exception       = Mollie::Exception.new response['error']['message']
+          exception.field = response['error']['field'] unless response['error']['field'].nil?
+        elsif response['errors']
+          exception = Mollie::Exception.new response['errors'].values.join(', ')
+        else
+          exception = Mollie::Exception.new response.body
+        end
+        exception.code = http_code
+        raise exception
+      end
+    end
+  end
+end

data/lib/mollie/customer.rb

@@ -0,0 +1,36 @@
+module Mollie
+  class Customer < Base
+    attr_accessor :id,
+                  :mode,
+                  :name,
+                  :email,
+                  :locale,
+                  :metadata,
+                  :recently_used_methods,
+                  :created_datetime
+
+    def created_datetime=(created_datetime)
+      @created_datetime = Time.parse(created_datetime.to_s)
+    end
+
+    def recently_used_methods=(methods)
+      @recently_used_methods = Array(methods).map(&:to_s)
+    end
+
+    def metadata=(metadata)
+      @metadata = OpenStruct.new(metadata) if metadata.is_a?(Hash)
+    end
+
+    def payments
+      Relation.new(self, Customer::Payment)
+    end
+
+    def mandates
+      Relation.new(self, Customer::Mandate)
+    end
+
+    def subscriptions
+      Relation.new(self, Customer::Subscription)
+    end
+  end
+end