coinbase_commerce 0.8.7

data/examples/checkout.rb

@@ -0,0 +1,61 @@
+require 'coinbase_commerce'
+
+client = CoinbaseCommerce::Client.new(api_key: 'your_api_key')
+
+# create checkout
+data = {
+    "name": "The Sovereign Individual",
+    "description": "Mastering the Transition to the Information Age",
+    "pricing_type": "fixed_price",
+    "local_price": {
+        "amount": "1.00",
+        "currency": "USD"
+    },
+    "requested_info": ["name", "email"]
+}
+checkout = client.checkout.create(data)
+
+# or retrieve it if you know checkout id
+checkout = client.checkout.retrieve checkout.id
+
+# update checkout with modify method
+upd_checkout = client.checkout.modify(checkout.id, "local_price": {
+    "amount": "10000.00",
+    "currency": "USD"
+})
+
+# or with save method if you already have checkout object
+upd_checkout.name
+upd_checkout.description = "foo"
+upd_checkout.to_hash
+upd_checkout.name = "bar"
+amount = "1000.00"
+upd_checkout.local_price.amount = amount
+upd_checkout.save
+
+# get checkouts list
+checkouts_list = client.checkout.list
+
+# in case you need provide additional params
+checkouts_list = client.checkout.list(limit: 10)
+
+# or get results from another page
+checkouts_list = client.checkout.list(starting_after: checkout.id, limit: 3)
+
+# checkout list could be iterated like
+checkouts_list.data.each do |ch|
+  # work with each checkout
+  puts ch.id
+end
+
+# iterate over all checkouts and modify them with per-page limitation
+client.checkout.auto_paging limit: 20 do |ch|
+  puts ch.id
+  ch.name = 'name updated'
+  ch.save
+  # also could be deleted by
+  # ch.delete
+end
+
+# delete checkout
+upd_checkout.delete

data/examples/event.rb

@@ -0,0 +1,26 @@
+require 'coinbase_commerce'
+
+client = CoinbaseCommerce::Client.new(api_key: 'your_api_key')
+
+# get events list
+events_list = client.event.list
+
+# in case you need provide additional params
+events_list = client.event.list(limit: 10)
+
+# or get results from another page
+event = events_list.data[0]
+events_list = client.event.list(starting_after: event.id, limit: 3)
+
+# event list could be iterated like
+events_list.data.each do |event|
+  puts event.id
+end
+
+# retrieve single event
+event = client.event.retrieve event.id
+
+# iterate over all events with per-page limitation
+client.event.auto_paging limit: 20 do |event|
+  puts event.id
+end

data/examples/webhook.rb

@@ -0,0 +1,35 @@
+# Sinatra server example to test webhooks
+# You may need tunnels to localhost webhook development tool and debugging tool.
+# f.e. you could try ngrok
+
+require 'sinatra'
+require 'coinbase_commerce'
+
+set :port, 5000
+WEBHOOK_SECRET = 'your_webhook_secret'
+
+# Using Sinatra
+post '/webhooks' do
+  payload = request.body.read
+  sig_header = request.env['HTTP_X_CC_WEBHOOK_SIGNATURE']
+
+  begin
+    event = CoinbaseCommerce::Webhook.construct_event(payload, sig_header, WEBHOOK_SECRET)
+    # event handle
+    puts "Received event id=#{event.id}, type=#{event.type}"
+    status 200
+  # errors handle
+  rescue JSON::ParserError => e
+    puts "json parse error"
+    status 400
+    return
+  rescue CoinbaseCommerce::Errors::SignatureVerificationError => e
+    puts "signature verification error"
+    status 400
+    return
+  rescue CoinbaseCommerce::Errors::WebhookInvalidPayload => e
+    puts "missing request or headers data"
+    status 400
+    return
+  end
+end

data/lib/coinbase_commerce.rb

@@ -0,0 +1,42 @@
+# general
+require "json"
+require "uri"
+require "faraday"
+require "openssl"
+
+# version
+require "coinbase_commerce/version"
+
+# client
+require "coinbase_commerce/client"
+
+# api response and errors
+require "coinbase_commerce/api_errors"
+require "coinbase_commerce/api_response"
+
+# api base object
+require "coinbase_commerce/api_resources/base/api_object"
+
+# api resource base model
+require "coinbase_commerce/api_resources/base/api_resource"
+
+# api base operations
+require "coinbase_commerce/api_resources/base/create"
+require "coinbase_commerce/api_resources/base/update"
+require "coinbase_commerce/api_resources/base/save"
+require "coinbase_commerce/api_resources/base/list"
+require "coinbase_commerce/api_resources/base/delete"
+
+# api resources
+require "coinbase_commerce/api_resources/checkout"
+require "coinbase_commerce/api_resources/charge"
+require "coinbase_commerce/api_resources/event"
+
+# webhooks
+require "coinbase_commerce/webhooks"
+
+# utils
+require "coinbase_commerce/util"
+
+module CoinbaseCommerce
+end

data/lib/coinbase_commerce/api_errors.rb

@@ -0,0 +1,157 @@
+module CoinbaseCommerce
+  module Errors
+    class APIError < StandardError
+      attr_reader :message
+
+      # Response contains a CoinbaseCommerceResponse object
+      attr_accessor :response
+
+      attr_reader :http_body
+      attr_reader :http_headers
+      attr_reader :http_status
+      attr_reader :json_body
+      attr_reader :request_id
+
+      # Initializes a API error.
+      def initialize(message = nil, http_status: nil, http_body: nil,
+                     json_body: nil, http_headers: nil)
+        @message = message
+        @http_status = http_status
+        @http_body = http_body
+        @http_headers = http_headers || {}
+        @json_body = json_body
+        @request_id = @http_headers["x-request-id"]
+      end
+
+      def to_s
+        status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+        id_string = @request_id.nil? ? "" : "(Request #{@request_id}) "
+        "#{status_string}#{id_string}#{@message}"
+      end
+    end
+
+    # in case error connecting to coinbase commerce server
+    class APIConnectionError < APIError
+    end
+
+    # Status 400
+    class BadRequestError < APIError
+    end
+
+    class ParamRequiredError < APIError
+    end
+
+    class InvalidRequestError < APIError
+    end
+
+    # Status 401
+    class AuthenticationError < APIError
+    end
+
+    # Status 404
+    class ResourceNotFoundError < APIError
+    end
+
+    # Status 422
+    class ValidationError < APIError
+    end
+
+    # Status 429
+    class RateLimitExceededError < APIError
+    end
+
+    # Status 500
+    class InternalServerError < APIError
+    end
+
+    # Status 503
+    class ServiceUnavailableError < APIError
+    end
+
+    # Webhook errors
+    class WebhookError < APIError
+      attr_accessor :sig_header
+
+      def initialize(message, sig_header, http_body: nil)
+        super(message, http_body: http_body)
+        @sig_header = sig_header
+      end
+    end
+
+    class SignatureVerificationError < WebhookError
+    end
+
+    class WebhookInvalidPayload < WebhookError
+    end
+
+    # Errors handling
+    def self.handle_error_response(http_resp)
+      begin
+        resp = CoinbaseCommerceResponse.from_faraday_hash(http_resp)
+        error_data = resp.data[:error]
+
+        raise APIError, "Unknown error" unless error_data
+      rescue JSON::ParserError, APIError
+        raise general_api_error(http_resp[:status], http_resp[:body])
+      end
+      error = specific_api_error(resp, error_data)
+      error.response = resp
+      raise(error)
+    end
+
+    def self.general_api_error(status, body)
+      APIError.new("Invalid response object from API: #{body.inspect} " +
+                       "(HTTP response code: #{status} http_body: #{body}")
+    end
+
+    def self.specific_api_error(resp, error_data)
+      opts = {
+          http_body: resp.http_body,
+          http_headers: resp.http_headers,
+          http_status: resp.http_status,
+          json_body: resp.data,
+      }
+      case resp.http_status
+      when 400
+        # in case of known error code
+        case error_data[:type]
+        when 'param_required'
+          ParamRequiredError.new(error_data[:message], opts)
+        when 'validation_error'
+          ValidationError.new(error_data[:message], opts)
+        when 'invalid_request'
+          InvalidRequestError.new(error_data[:message], opts)
+        else
+          InvalidRequestError.new(error_data[:message], opts)
+        end
+      when 401 then
+        AuthenticationError.new(error_data[:message], opts)
+      when 404
+        ResourceNotFoundError.new(error_data[:message], opts)
+      when 429
+        RateLimitExceededError.new(error_data[:message], opts)
+      when 500
+        InternalServerError.new(error_data[:message], opts)
+      when 503
+        ServiceUnavailableError.new(error_data[:message], opts)
+      else
+        APIError.new(error_data[:message], opts)
+      end
+    end
+
+    def self.handle_network_error(e, api_base = nil)
+      api_base ||= @api_uri
+      case e
+      when Faraday::ConnectionFailed
+        message = "Unexpected error communicating when trying to connect to Coinbase Commerce."
+      when Faraday::SSLError
+        message = "Could not establish a secure connection to Coinbase Commerce."
+      when Faraday::TimeoutError
+        message = "Could not connect to Coinbase Commerce (#{api_base})."
+      else
+        message = "Unexpected error communicating with Coinbase Commerce."
+      end
+      raise APIConnectionError, message + "\n\n(Network error: #{e.message})"
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module CoinbaseCommerce
+  module APIResources
+    module Base
+      # Base APIObject class
+      # Used to work and display with all the data
+      # that Coinbase Commerce API returns
+      class APIObject
+        include Enumerable
+
+        def initialize(id = nil, client = nil)
+          @data = {}
+          @data[:id] = id if id
+          @client = client
+          @unsaved_values = Set.new
+          @transient_values = Set.new
+        end
+
+        # Base object options section
+        def [](k)
+          @data[k.to_sym]
+        end
+
+        def []=(k, v)
+          send(:"#{k}=", v)
+        end
+
+        def keys
+          @data.keys
+        end
+
+        def values
+          @data.values
+        end
+
+        def each(&blk)
+          @data.each(&blk)
+        end
+
+        def to_s(*_args)
+          JSON.pretty_generate(to_hash)
+        end
+
+        def to_hash
+          @data.each_with_object({}) do |(key, value), output|
+            case value
+            when Array
+              output[key] = value.map {|v| v.respond_to?(:to_hash) ? v.to_hash : v}
+            else
+              output[key] = value.respond_to?(:to_hash) ? value.to_hash : value
+            end
+          end
+        end
+
+        def to_json(*_a)
+          JSON.generate(@data)
+        end
+
+        def inspect
+          item_id = respond_to?(:id) && !id.nil? ? "id=#{id}" : "No ID"
+          "#{self.class}: #{item_id}> Serialized: " + JSON.pretty_generate(@data)
+        end
+
+        def respond_to_missing?(symbol, include_private = false)
+          @data && @data.key?(symbol) || super
+        end
+
+        def method_missing(name, *args)
+          if name.to_s.end_with?("=")
+
+            attr = name.to_s[0...-1].to_sym
+            val = args.first
+            add_accessors([attr], attr => val)
+
+            begin
+              mth = method(name)
+            rescue NameError
+              raise NoMethodError, "Cannot set #{attr} on this object."
+            end
+
+            return mth.call(args[0])
+
+          elsif @data.key?(name)
+            return @data[name]
+          end
+
+          begin
+            super
+          rescue NoMethodError => e
+            raise unless @transient_values.include?(name)
+            raise NoMethodError, e.message + " Available attributes: #{@data.keys.join(', ')}"
+          end
+        end
+
+        # Object serialize section
+        def serialize_params(options = {})
+          update_hash = {}
+
+          @data.each do |k, v|
+            if options[:push] || @unsaved_values.include?(k) || v.is_a?(APIObject)
+              push = options[:push] || @unsaved_values.include?(k)
+              update_hash[k.to_sym] = serialize_params_value(@data[k], push)
+            end
+          end
+
+          update_hash.reject! {|_, v| v.nil? || v.empty?}
+          update_hash
+        end
+
+        def serialize_params_value(value, push)
+          if value.nil?
+            ""
+          elsif value.is_a?(Array)
+            value.map {|v| serialize_params_value(v, push)}
+
+          elsif value.is_a?(Hash)
+            Util.convert_to_api_object(value, @opts).serialize_params
+
+          elsif value.is_a?(APIObject)
+            value.serialize_params(push: push)
+          else
+            value
+          end
+        end
+
+        # Object initialize/update section
+        def self.create_from(values, client = nil)
+          values = Util.symbolize_names(values)
+          new(values[:id], client).send(:initialize_from, values)
+        end
+
+        def initialize_from(values, partial = false)
+          removed = partial ? Set.new : Set.new(@data.keys - values.keys)
+          added = Set.new(values.keys - @data.keys)
+
+          remove_accessors(removed)
+          add_accessors(added, values)
+
+          removed.each do |k|
+            @data.delete(k)
+            @transient_values.add(k)
+            @unsaved_values.delete(k)
+          end
+
+          update_attributes(values)
+          values.each_key do |k|
+            @transient_values.delete(k)
+            @unsaved_values.delete(k)
+          end
+
+          self
+        end
+
+        def update_attributes(values)
+          values.each do |k, v|
+            add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
+            @data[k] = Util.convert_to_api_object(v, @client)
+            @unsaved_values.add(k)
+          end
+        end
+
+
+        protected
+
+        def metaclass
+          class << self
+            self
+          end
+        end
+
+        def remove_accessors(keys)
+          metaclass.instance_eval do
+            keys.each do |k|
+              # Remove methods for the accessor's reader and writer.
+              [k, :"#{k}=", :"#{k}?"].each do |method_name|
+                remove_method(method_name) if method_defined?(method_name)
+              end
+            end
+          end
+        end
+
+        def add_accessors(keys, values)
+          metaclass.instance_eval do
+            keys.each do |k|
+              if k == :method
+                define_method(k) {|*args| args.empty? ? @data[k] : super(*args)}
+              else
+                define_method(k) {@data[k]}
+              end
+
+              define_method(:"#{k}=") do |v|
+                if v != ""
+                  @data[k] = Util.convert_to_api_object(v, @opts)
+                  @unsaved_values.add(k)
+                end
+              end
+
+              if [FalseClass, TrueClass].include?(values[k].class)
+                define_method(:"#{k}?") {@data[k]}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end