coinbase_commerce 0.8.7

data/lib/coinbase_commerce/api_resources/base/api_resource.rb

@@ -0,0 +1,25 @@
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # Base resource class
+      # if you need to add additional API resource, inherit from APIResource
+      class APIResource < APIObject
+        class << self
+          attr_accessor :client
+        end
+
+        @client = nil
+
+        def self.retrieve(id, params = {})
+          resp = @client.request(:get, "#{self::RESOURCE_PATH}/#{id}", params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+
+        def refresh(params = {})
+          resp = @client.request(:get, "#{self.class::RESOURCE_PATH}/#{self[:id]}", params)
+          initialize_from(resp.data)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/base/create.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # create operations mixin
+      module Create
+        def create(params = {})
+          response = @client.request(:post, "#{self::RESOURCE_PATH}", params)
+          Util.convert_to_api_object(response.data, @client, self)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/base/delete.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # delete opertaions mixin
+      module Delete
+        def delete
+          response = @client.request(:delete, "#{self.class::RESOURCE_PATH}/#{self[:id]}")
+          initialize_from(response.data)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/base/list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # list operations mixin
+      module List
+        def list(params = {})
+          resp = @client.request(:get, "#{self::RESOURCE_PATH}", params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+
+        def auto_paging(params = {}, &blk)
+          loop do
+            page = list(params)
+            last_id = page.data.empty? ? nil : page.data.last.id
+            break if last_id.nil?
+            params[:starting_after] = last_id
+            page.data.each(&blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/base/save.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # save operations mixin
+      module Save
+        def save
+          values = serialize_params(self)
+          values.delete(:id)
+          resp = @client.request(:put, "#{self.class::RESOURCE_PATH}/#{self[:id]}", self)
+          initialize_from(resp.data)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/base/update.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # update operations mixin
+      module Update
+        def modify(id, params = {})
+          resp = @client.request(:put, "#{self::RESOURCE_PATH}/#{id}", params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/charge.rb

@@ -0,0 +1,14 @@
+module CoinbaseCommerce
+  module APIResources
+    # Class that allows you to work with Charge resource
+    class Charge < Base::APIResource
+      # class methods
+      extend Base::List
+      extend Base::Create
+
+      # class constants
+      OBJECT_NAME = "charge".freeze
+      RESOURCE_PATH = "charges".freeze
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/checkout.rb

@@ -0,0 +1,19 @@
+module CoinbaseCommerce
+  module APIResources
+    # Class that allows you to work with Checkout resource
+    class Checkout < Base::APIResource
+      # class methods
+      extend Base::List
+      extend Base::Create
+      extend Base::Update
+
+      # instance methods
+      include Base::Save
+      include Base::Delete
+
+      # class constants
+      OBJECT_NAME = "checkout".freeze
+      RESOURCE_PATH = "checkouts".freeze
+    end
+  end
+end

data/lib/coinbase_commerce/api_resources/event.rb

@@ -0,0 +1,13 @@
+module CoinbaseCommerce
+  module APIResources
+    # Class that allows you to work with Event resource
+    class Event < Base::APIResource
+      # class methods
+      extend Base::List
+
+      # class constants
+      OBJECT_NAME = "event".freeze
+      RESOURCE_PATH = "events".freeze
+    end
+  end
+end

data/lib/coinbase_commerce/api_response.rb

@@ -0,0 +1,48 @@
+module CoinbaseCommerce
+  class CoinbaseCommerceResponse
+    attr_accessor :data
+
+    attr_accessor :http_body
+
+    attr_accessor :http_headers
+
+    attr_accessor :http_status
+
+    attr_accessor :request_id
+
+    # Initializes a CoinbaseCommerceResponse object
+    # from a Hash like the kind returned as part of a Faraday exception.
+    def self.from_faraday_hash(http_resp)
+      resp = CoinbaseCommerceResponse.new
+      resp.data = JSON.parse(http_resp[:body], symbolize_names: true)
+      resp.http_body = http_resp[:body]
+      resp.http_headers = http_resp[:headers]
+      resp.http_status = http_resp[:status]
+      resp.request_id = http_resp[:headers]["x-request-id"]
+      resp
+    end
+
+    # Initializes a CoinbaseCommerceResponse object
+    # from a Faraday HTTP response object.
+    def self.from_faraday_response(http_resp)
+      resp = CoinbaseCommerceResponse.new
+      resp.data = JSON.parse(http_resp.body, symbolize_names: true)
+      resp.http_body = http_resp.body
+      resp.http_headers = http_resp.headers
+      resp.http_status = http_resp.status
+      resp.request_id = http_resp.headers["x-request-id"]
+
+      # unpack nested data field if it exist
+      if resp.data.is_a? Hash and resp.data.fetch(:data, nil).is_a? Hash
+        resp.data.update(resp.data.delete(:data))
+      end
+
+      # warn in there warnings in response
+      if resp.data.is_a? Hash and resp.data.fetch(:warnings, nil).is_a? Array
+        warn(resp.data[:warnings].first.to_s)
+      end
+
+      resp
+    end
+  end
+end

data/lib/coinbase_commerce/client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  BASE_API_URL = "https://api.commerce.coinbase.com/"
+  API_VERSION = "2018-03-22"
+
+  class Client
+    # API Client for the Coinbase API.
+    # Entry point for making requests to the Coinbase API.
+    # Full API docs available here: https://commerce.coinbase.com/docs/api/
+
+    def initialize(options = {})
+      # set API key and API URL
+      check_api_key!(options[:api_key])
+      @api_key = options[:api_key]
+      @api_uri = URI.parse(options[:api_url] || BASE_API_URL)
+      @api_ver = options[:api_ver] || API_VERSION
+      # create client obj
+      @conn = Faraday.new do |c|
+        c.use Faraday::Request::Multipart
+        c.use Faraday::Request::UrlEncoded
+        c.use Faraday::Response::RaiseError
+        c.adapter Faraday.default_adapter
+      end
+    end
+
+    # Set client-resource relations with all API resources
+    # provide client instance to each resource
+    def charge
+      APIResources::Charge.client = self
+      APIResources::Charge
+    end
+
+    def checkout
+      APIResources::Checkout.client = self
+      APIResources::Checkout
+    end
+
+    def event
+      APIResources::Event.client = self
+      APIResources::Event
+    end
+
+    def api_url(url = "", api_base = nil)
+      (api_base || CoinbaseCommerce::BASE_API_URL) + url
+    end
+
+    def request_headers(api_key)
+      {
+          "User-Agent" => "CoinbaseCommerce/#{CoinbaseCommerce::VERSION}",
+          "Accept" => "application/json",
+          "X-CC-Api-Key" => api_key,
+          "X-CC-Version" => @api_ver,
+          "Content-Type" => "application/json",
+      }
+    end
+
+    def check_api_key!(api_key)
+      raise AuthenticationError, "No API key provided" unless api_key
+    end
+
+    # request section
+    def request(method, path, params = {})
+      @last_response = nil
+      url = api_url(path, @api_uri)
+      headers = request_headers(@api_key)
+
+      body = nil
+      query_params = nil
+
+      case method.to_s.downcase.to_sym
+      when :get, :head, :delete
+        query_params = params
+      else
+        body = params.to_json
+      end
+
+      u = URI.parse(path)
+      unless u.query.nil?
+        query_params ||= {}
+        query_params = Hash[URI.decode_www_form(u.query)].merge(query_params)
+      end
+
+
+      http_resp = execute_request_with_rescues(@api_uri) do
+        @conn.run_request(method, url, body, headers) do |req|
+          req.params = query_params unless query_params.nil?
+        end
+      end
+
+      begin
+        resp = CoinbaseCommerceResponse.from_faraday_response(http_resp)
+      rescue JSON::ParserError
+        raise Errors.general_api_error(http_resp.status, http_resp.body)
+      end
+
+      @last_response = resp
+      resp
+    end
+
+    # сollect errors during request execution if they occurred
+    def execute_request_with_rescues(api_base)
+      begin
+        resp = yield
+      rescue StandardError => e
+        case e
+        when Faraday::ClientError
+          if e.response
+            Errors.handle_error_response(e.response)
+          else
+            Errors.handle_network_error(e, api_base)
+          end
+        else
+          raise
+        end
+      end
+      resp
+    end
+  end
+end

data/lib/coinbase_commerce/util.rb

@@ -0,0 +1,59 @@
+module CoinbaseCommerce
+  module Util
+
+    def self.object_classes
+      # Class mappings for api responce fetching
+      @object_classes ||= {
+          # API Resources
+          APIResources::Checkout::OBJECT_NAME => APIResources::Checkout,
+          APIResources::Charge::OBJECT_NAME => APIResources::Charge,
+          APIResources::Event::OBJECT_NAME => APIResources::Event,
+      }
+    end
+
+
+    def self.convert_to_api_object(data, client = nil, klass = nil)
+      # Converts a hash of fields or an array of hashes into a
+      # appropriate APIResources of APIObjects form
+      case data
+      when Array
+        data.map {|i| convert_to_api_object(i, client, klass)}
+      when Hash
+        # If class received in params, create instance
+        if klass
+          klass.create_from(data, client)
+        else
+          # Try converting to a known object class.
+          # If none available, fall back to generic APIObject
+          klass = object_classes.fetch(data[:resource], APIResources::Base::APIObject)
+          # Provide client relation only for APIResource objects
+          klass != APIResources::Base::APIObject ? klass.create_from(data, client) : klass.create_from(data)
+        end
+      else
+        data
+      end
+    end
+
+    def self.symbolize_names(object)
+      # Convert object key and values to symbols if its possible
+      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
+  end
+end

data/lib/coinbase_commerce/version.rb

@@ -0,0 +1,3 @@
+module CoinbaseCommerce
+  VERSION = "0.8.7"
+end

data/lib/coinbase_commerce/webhooks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CoinbaseCommerce
+  module Webhook
+    # Analyze and construct appropriate event object based on webhook notification
+    def self.construct_event(payload, sig_header, secret)
+      data = JSON.parse(payload, symbolize_names: true)
+      if data.key?(:event)
+        WebhookSignature.verify_header(payload, sig_header, secret)
+        CoinbaseCommerce::APIResources::Event.create_from(data[:event])
+      else
+        raise CoinbaseCommerce::Errors::WebhookInvalidPayload.new("no event in payload",
+                                                                  sig_header, http_body: payload)
+      end
+    end
+
+    module WebhookSignature
+      def self.verify_header(payload, sig_header, secret)
+        unless [payload, sig_header, secret].all?
+          raise CoinbaseCommerce::Errors::WebhookInvalidPayload.new(
+              "Missing payload or signature",
+              sig_header, http_body: payload)
+        end
+        expected_sig = compute_signature(payload, secret)
+        unless secure_compare(expected_sig, sig_header)
+          raise CoinbaseCommerce::Errors::SignatureVerificationError.new(
+              "No signatures found matching the expected signature for payload",
+              sig_header, http_body: payload
+          )
+        end
+        true
+      end
+
+      def self.secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack "C#{a.bytesize}"
+        res = 0
+        b.each_byte {|byte| res |= byte ^ l.shift}
+        res.zero?
+      end
+
+      private_class_method :secure_compare
+
+      def self.compute_signature(payload, secret)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), secret, payload)
+      end
+
+      private_class_method :compute_signature
+    end
+  end
+end