privacygate 1.1.1

data/lib/privacygate/api_errors.rb

@@ -0,0 +1,157 @@
+module PrivacyGate
+  module Errors
+    class APIError < StandardError
+      attr_reader :message
+
+      # Response contains a PrivacyGateResponse 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 privacygate 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 = PrivacyGateResponse.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 PrivacyGate."
+      when Faraday::SSLError
+        message = "Could not establish a secure connection to PrivacyGate."
+      when Faraday::TimeoutError
+        message = "Could not connect to PrivacyGate (#{api_base})."
+      else
+        message = "Unexpected error communicating with PrivacyGate."
+      end
+      raise APIConnectionError, message + "\n\n(Network error: #{e.message})"
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module PrivacyGate
+  module APIResources
+    module Base
+      # Base APIObject class
+      # Used to work and display with all the data
+      # that PrivacyGate 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

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

@@ -0,0 +1,25 @@
+module PrivacyGate
+  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/privacygate/api_resources/base/create.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  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/privacygate/api_resources/base/delete.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  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/privacygate/api_resources/base/list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  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/privacygate/api_resources/base/save.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  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/privacygate/api_resources/base/update.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  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/privacygate/api_resources/charge.rb

@@ -0,0 +1,14 @@
+module PrivacyGate
+  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/privacygate/api_resources/checkout.rb

@@ -0,0 +1,19 @@
+module PrivacyGate
+  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/privacygate/api_resources/event.rb

@@ -0,0 +1,13 @@
+module PrivacyGate
+  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/privacygate/api_response.rb

@@ -0,0 +1,48 @@
+module PrivacyGate
+  class PrivacyGateResponse
+    attr_accessor :data
+
+    attr_accessor :http_body
+
+    attr_accessor :http_headers
+
+    attr_accessor :http_status
+
+    attr_accessor :request_id
+
+    # Initializes a PrivacyGateResponse object
+    # from a Hash like the kind returned as part of a Faraday exception.
+    def self.from_faraday_hash(http_resp)
+      resp = PrivacyGateResponse.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 PrivacyGateResponse object
+    # from a Faraday HTTP response object.
+    def self.from_faraday_response(http_resp)
+      resp = PrivacyGateResponse.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/privacygate/client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  BASE_API_URL = "https://api.privacygate.io/"
+  API_VERSION = "2018-03-22"
+
+  class Client
+    # API Client for the PrivacyGate API.
+    # Entry point for making requests to the PrivacyGate API.
+    # Full API docs available here: https://api.privacygate.io/docs/
+
+    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 || PrivacyGate::BASE_API_URL) + url
+    end
+
+    def request_headers(api_key)
+      {
+          "User-Agent" => "PrivacyGate/#{PrivacyGate::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 = PrivacyGateResponse.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