fat_zebra 2.0.13 → 3.0.0

data/lib/fat_zebra/request/multipart/part.rb

@@ -0,0 +1,28 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Part
+  #
+  # Define one part
+  class Request
+    module Multipart
+      module Part
+
+        LINE_BREAK = "\r\n".freeze
+
+        def boundary
+          '----FatZebraMultipartPost'
+        end
+
+        def length
+          @io.length
+        end
+
+        def to_io
+          @io
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/stream.rb

@@ -0,0 +1,55 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Steam
+  #
+  # Steam the multipart
+  class Request
+    module Multipart
+      class Stream
+
+        BINARY_ENCODING = 'BINARY'.freeze
+
+        def initialize(*ios)
+          @ios   = ios.flatten
+          @index = 0
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def read(length = nil, outbuf = nil)
+          got_result = false
+          outbuf = outbuf ? outbuf.replace('') : ''
+
+          while current_io
+            result = current_io.read(length)
+
+            if result
+              got_result ||= !result.nil?
+              result.force_encoding(BINARY_ENCODING) if result.respond_to?(:force_encoding)
+              outbuf << result
+
+              length -= result.length if length
+              break if length == 0
+            end
+
+            next_io
+          end
+
+          !got_result && length ? nil : outbuf
+        end
+
+        private
+
+        def current_io
+          @ios[@index]
+        end
+
+        def next_io
+          @index += 1
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/request.rb

@@ -0,0 +1,162 @@
+require 'fat_zebra/request/multipart/part'
+require 'fat_zebra/request/multipart/stream'
+require 'fat_zebra/request/multipart/epilogue'
+require 'fat_zebra/request/multipart/file_io'
+require 'fat_zebra/request/multipart/param'
+
+module FatZebra
+  ##
+  # == FatZebra \Request
+  #
+  # Build request
+  class Request
+    class << self
+
+      def execute(params = {})
+        klass = new(params)
+
+        if params[:method] == :post
+          klass.post
+        elsif params[:method] == :put
+          klass.put
+        elsif params[:method] == :delete
+          klass.delete
+        elsif params[:method] == :get
+          klass.get
+        else
+          raise FatZebra::UnknownRequestMethod, "#{params[:method]} haven't been implemented"
+        end
+      end
+
+      def post(params = {})
+        new(params).post
+      end
+
+      def put(params = {})
+        new(params).put
+      end
+
+      def get(params = {})
+        new(params).get
+      end
+
+      def delete(params = {})
+        new(params).delete
+      end
+    end
+
+    attr_reader :params, :http, :request
+
+    def initialize(params = {})
+      @params = params
+      @http   = Net::HTTP.new(uri.host, uri.port, uri_proxy.host, uri_proxy.port)
+
+      setup_ssl if params[:use_ssl]
+    end
+
+    def post
+      @request = Net::HTTP::Post.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+
+      if params[:payload] && params[:payload][:multipart]
+        build_multipart_post
+      else
+        set_header
+        request.body = params[:payload].to_json
+      end
+
+      handle_request
+    end
+
+    def put
+      @request = Net::HTTP::Put.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+      request.body = params[:payload].to_json
+
+      handle_request
+    end
+
+    def get
+      @request = Net::HTTP::Get.new(uri)
+
+      setup_auth_basic if params[:basic_auth]
+      set_header
+
+      handle_request
+    end
+
+    def delete
+      @request = Net::HTTP::Delete.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+      request.body = params[:payload].to_json
+
+      handle_request
+    end
+
+    private
+
+    def handle_request
+      response = http.request(request)
+
+      case [response.code_type]
+      when [Net::HTTPBadRequest]
+        raise RequestError, 'Bad Data'
+      when [Net::HTTPUnauthorized]
+        raise RequestError, 'Unauthorized, please check your username and token'
+      when [Net::HTTPNotFound]
+        raise RequestError, 'Requested Resource not found'
+      when [Net::HTTPInternalServerError]
+        raise RequestError, 'Server Error, please check with Gateway'
+      when [Net::HTTPNotImplemented]
+        raise RequestError, 'Problem processing your request - please check your data'
+      else
+        response
+      end
+    end
+
+    def build_multipart_post
+      parts = []
+      Util.hash_except(params[:payload], :multipart, :content_type).each do |(key, value)|
+        parts << (value.is_a?(File) ? Multipart::FileIO.new(params[:payload]) : Multipart::Param.new(key, value))
+      end
+      parts << Multipart::Epilogue.new
+
+      request.content_length = parts.inject(0) { |sum, part| sum + part.length }
+      request.content_type = 'multipart/form-data; boundary=' + parts.first.boundary
+      request.body_stream = Multipart::Stream.new(parts.map(&:to_io))
+    end
+
+    def setup_auth_basic
+      request.basic_auth(params[:basic_auth][:user], params[:basic_auth][:password])
+    end
+
+    def set_header
+      params[:headers].each do |(type, value)|
+        request[type.to_s] = value
+      end
+    end
+
+    def setup_ssl
+      http.use_ssl     = true
+      http.ca_file     = params[:ca_file]
+      http.verify_mode = params[:verify_mode]
+    end
+
+    def uri
+      @uri ||= URI(params[:url])
+    end
+
+    def uri_proxy
+      @uri_proxy ||=
+        if params[:proxy]
+          URI(params[:proxy])
+        else
+          OpenStruct.new
+        end
+    end
+
+  end
+end

data/lib/fat_zebra/util.rb

@@ -0,0 +1,70 @@
+module FatZebra
+  module Util
+    class << self
+
+      DATE_FORMAT = '%Y/%m/%d'.freeze
+
+      ##
+      # Remove nil value from hash
+      #
+      # @return [Hash]
+      def compact(hash)
+        hash.reject { |_, value| value.nil? }
+      end
+
+      ##
+      # Encodes a hash of parameters in a way that's suitable for use as query
+      # parameters in a URI or as form parameters in a request body. This mainly
+      # involves escaping special characters from parameter keys and values (e.g.
+      # `&`).
+      def encode_parameters(params)
+        params.map { |k, v| "#{url_encode(k)}=#{url_encode(v)}" }.join('&')
+      end
+
+      ##
+      # Encodes a string in a way that makes it suitable for use in a set of
+      # query parameters in a URI or in a set of form parameters in a request
+      # body.
+      def url_encode(key)
+        CGI.escape(key.to_s).gsub('%5B', '[').gsub('%5D', ']')
+      end
+
+      ##
+      # Convert string to underscore
+      #
+      # @param [String]
+      #
+      # @example
+      #   underscore('MyModel') => 'my_model'
+      def underscore(string)
+        string
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      def hash_except(hash, *keys)
+        copy = hash.dup
+        keys.each { |key| copy.delete(key) }
+        copy
+      end
+
+      ##
+      # Format Date attribute in the params
+      #
+      # @param [Hash] params
+      #
+      # @return [Hash] date formated params
+      def format_dates_in_hash(hash)
+        hash.each do |(key, value)|
+          hash[key] = value.strftime(DATE_FORMAT) if value.is_a?(DateTime) || value.is_a?(Time) || value.is_a?(Date)
+        end
+
+        hash
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/validation.rb

@@ -0,0 +1,47 @@
+module FatZebra
+  module Validation
+
+    def validates(name, options = {})
+      validations[name] = options
+    end
+
+    def valid?(params, action = nil)
+      @errors = []
+
+      validations.each do |(field, options)|
+        next unless options[:on] == action
+
+        Util.hash_except(options, :on).each do |(validation_attribute, validation_options)|
+          send("validate_#{validation_attribute}", field, validation_options, params)
+        end
+      end
+
+      errors.empty?
+    end
+
+    def valid!(params, action = nil)
+      raise RequestValidationError, "The following errors prevent the transaction from being submitted: #{errors.join(', ')}" unless valid?(params, action)
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    private
+
+    def validations
+      @validations ||= {}
+    end
+
+    def validate_required(field, options, params)
+      return if options.is_a?(Hash) && options[:unless] && options[:unless].any? { |f| params[f] }
+
+      errors << "'#{field}' is required" if params[field].nil? || params[field] == ''
+    end
+
+    def validate_class_type(field, options, params)
+      errors << "'#{field}' is not a '#{options}'" unless params[field].is_a?(options)
+    end
+
+  end
+end

data/lib/fat_zebra/version.rb

@@ -1,3 +1,3 @@
 module FatZebra
-  VERSION = "2.0.13"
+  VERSION = '3.0.0'.freeze
 end

data/lib/fat_zebra/web_hook.rb

@@ -0,0 +1,23 @@
+module FatZebra
+  ##
+  # == FatZebra \Web \Hook
+  #
+  # Manage web hook for the API
+  #
+  # * search
+  # * save
+  # * delete
+  #
+  class WebHook < APIResource
+
+    extend FatZebra::APIOperation::Search
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :events, required: true, on: :create
+    validates :mode, required: true, on: :create
+    validates :address, required: true, on: :create
+
+  end
+end

data/lib/fat_zebra.rb

@@ -1,61 +1,57 @@
+# Libraries
 require 'securerandom'
-require 'json'
-require 'rest_client'
-require 'active_support'
-require 'active_support/core_ext'
-require 'forwardable'
-
-require_relative 'rest-client/request_ext'
-require_relative 'fat_zebra/config'
-require_relative 'fat_zebra/errors'
-require_relative 'fat_zebra/version'
-require_relative 'fat_zebra/constants'
-require_relative 'fat_zebra/gateway'
-require_relative 'fat_zebra/models/base'
-require_relative 'fat_zebra/models/purchase'
-require_relative 'fat_zebra/models/refund'
-require_relative 'fat_zebra/models/card'
-require_relative 'fat_zebra/models/response'
-
-RestClient::Request.class_eval do
-  include RestClientExt::ProxyRequest
-end
 
+require 'fat_zebra/version'
+require 'fat_zebra/util'
+require 'fat_zebra/config'
+require 'fat_zebra/errors'
+require 'fat_zebra/validation'
+require 'fat_zebra/fat_zebra_object'
+require 'fat_zebra/request'
+require 'fat_zebra/api_resource'
+
+# API Operations
+require 'fat_zebra/api_operation/find'
+require 'fat_zebra/api_operation/search'
+require 'fat_zebra/api_operation/save'
+require 'fat_zebra/api_operation/delete'
+require 'fat_zebra/api_operation/void'
+
+# API Resources
+require 'fat_zebra/purchase'
+require 'fat_zebra/information'
+require 'fat_zebra/card'
+require 'fat_zebra/refund'
+require 'fat_zebra/payment_plan'
+require 'fat_zebra/customer'
+require 'fat_zebra/direct_debit'
+require 'fat_zebra/direct_credit'
+require 'fat_zebra/bank_account'
+require 'fat_zebra/web_hook'
+require 'fat_zebra/batch'
+
+##
+# Implementation of the FatZebra
 module FatZebra
-  extend self
-  extend Forwardable
-
-	attr_accessor :config
-  attr_accessor :_gateway
-
-  # Configure the Fat Zebra gateway
-  def configure(auth = nil, &block)
-		raise ArgumentError, "missing authentication parameters or block" unless auth || block_given?
-
-  	if !auth
-      self.config = Config.new
-      if (block.arity > 0)
-        block.call(self.config)
-      else
-        self.config.instance_eval(&block)
-      end
-    else
-      self.config = Config.from_hash(auth)
+  class << self
+
+    ##
+    # @return [FatZebra::Config] configurations
+    attr_reader :configurations
+
+    ##
+    # Configures the FatZebra API
+    #
+    # @example Default configuration
+    #   FatZebra.configure do |config|
+    #     config.username = 'my-username'
+    #     config.token    = 'my-token'
+    #   end
+    def configure
+      yield @configurations = FatZebra::Config.new
+
+      FatZebra.configurations.valid!
     end
 
-    self.config.validate!
-
-    self.configure_gateway
-
-    self.config
-	end
-
-  def configure_gateway
-    self._gateway = Gateway.configure(self.config)
   end
-
-  def gateway
-    raise GatewayError.new("Please configure the Gateway before use. See FatZebra.configure { }") if self.config.nil?
-    self._gateway
-  end
-end	
+end

data/spec/cassettes/FatZebra_BankAccount/_create/1_1_1.yml

@@ -0,0 +1,57 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://gateway.sandbox.fatzebra.com.au/v1.0/bank_accounts
+    body:
+      encoding: UTF-8
+      string: '{"bsb":"123-123","account_name":"Test name","account_number":"012345678","test":true}'
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Content-Type:
+      - application/json
+      Content-Length:
+      - '85'
+      User-Agent:
+      - Ruby
+      Authorization:
+      - Basic VEVTVDpURVNU
+  response:
+    status:
+      code: 201
+      message: Created
+    headers:
+      Date:
+      - Tue, 27 Jun 2017 06:03:13 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Status:
+      - 201 Created
+      Cache-Control:
+      - no-store
+      X-Request-Version:
+      - 1.19.41
+      Pragma:
+      - no-cache
+      X-Request-Id:
+      - de3cf0db3bb8c6a56e6e9ad1614a2558
+      X-Runtime:
+      - '0.042060'
+      X-Rack-Cache:
+      - invalidate, pass
+      X-Backend:
+      - sbox-priv-gateway-a
+    body:
+      encoding: UTF-8
+      string: '{"successful":true,"response":{"id":"071-B-A3LWXEL7","account_name":"Test
+        name","account_number":"012345678","bsb":"123-123","created_at":"2017-06-27T16:03:13+10:00"},"errors":[],"test":true}'
+    http_version: 
+  recorded_at: Tue, 27 Jun 2017 06:03:13 GMT
+recorded_with: VCR 3.0.3

data/spec/cassettes/FatZebra_BankAccount/_create/1_1_2.yml

@@ -0,0 +1,57 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://gateway.sandbox.fatzebra.com.au/v1.0/bank_accounts
+    body:
+      encoding: UTF-8
+      string: '{"bsb":"123-123","account_name":"Test name","account_number":"012345678","test":true}'
+    headers:
+      Accept:
+      - application/json
+      Accept-Encoding:
+      - gzip, deflate
+      Content-Type:
+      - application/json
+      Content-Length:
+      - '85'
+      User-Agent:
+      - Ruby
+      Authorization:
+      - Basic VEVTVDpURVNU
+  response:
+    status:
+      code: 201
+      message: Created
+    headers:
+      Date:
+      - Tue, 27 Jun 2017 06:03:13 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Status:
+      - 201 Created
+      X-Rack-Cache:
+      - invalidate, pass
+      Cache-Control:
+      - no-store
+      X-Request-Version:
+      - 1.19.41
+      X-Runtime:
+      - '0.036444'
+      Pragma:
+      - no-cache
+      X-Request-Id:
+      - 45e878faeee4a085eebe7adf4fea65d6
+      X-Backend:
+      - sbox-priv-gateway-a
+    body:
+      encoding: UTF-8
+      string: '{"successful":true,"response":{"id":"071-B-BSDDYDAK","account_name":"Test
+        name","account_number":"012345678","bsb":"123-123","created_at":"2017-06-27T16:03:13+10:00"},"errors":[],"test":true}'
+    http_version: 
+  recorded_at: Tue, 27 Jun 2017 06:03:13 GMT
+recorded_with: VCR 3.0.3

data/spec/cassettes/FatZebra_BankAccount/_create/validations/1_1_3_1.yml

@@ -0,0 +1,57 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://gateway.sandbox.fatzebra.com.au/v1.0/bank_accounts
+    body:
+      encoding: UTF-8
+      string: '{"test":true}'
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - application/json
+      User-Agent:
+      - Ruby
+      Authorization:
+      - Basic VEVTVDpURVNU
+      Content-Type:
+      - application/json
+  response:
+    status:
+      code: 422
+      message: Unprocessable Entity
+    headers:
+      Date:
+      - Mon, 03 Jul 2017 03:55:54 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Status:
+      - 422 Unprocessable Entity
+      Cache-Control:
+      - no-store
+      X-Request-Version:
+      - 1.19.41
+      Pragma:
+      - no-cache
+      X-Request-Id:
+      - 9f14b2bf87766520c5c867e4ab88dc69
+      X-Runtime:
+      - '0.035684'
+      X-Rack-Cache:
+      - invalidate, pass
+      X-Backend:
+      - sbox-priv-gateway-a
+    body:
+      encoding: UTF-8
+      string: '{"successful":false,"response":{"id":"071-B-X3Z3G0QG","account_name":"","account_number":"","bsb":"","created_at":null},"errors":["Number
+        can''t be blank","Number is too short (minimum is 4 characters)","Number is
+        not a number","Bsb can''t be blank","Bsb is the incorrect format - please
+        use 123-456","Name can''t be blank"],"test":true}'
+    http_version: 
+  recorded_at: Mon, 03 Jul 2017 03:55:54 GMT
+recorded_with: VCR 3.0.3