fat_zebra 2.0.13 → 3.0.0

data/lib/fat_zebra/config.rb

@@ -1,38 +1,78 @@
 module FatZebra
+  ##
+  # == FatZebra \Config
+  #
+  # Represent the FatZebra configuration for the API
   class Config
 
-    # Returns the config values in a hash
-    def config
-      @config ||= {}
-    end
+    ##
+    # @return [String] Username
+    attr_accessor :username
 
-    [:username, :token, :test_mode, :sandbox, :options, :gateway, :proxy].each do |attr|
-      define_method "#{attr}" do |value = nil|
-        if value.nil?
-          config[attr.to_s]
-        else
-          config[attr.to_s] = value
-        end
-      end
-    end
+    ##
+    # @return [String] Token
+    attr_accessor :token
+
+    ##
+    # @return [String] Test mode
+    attr_accessor :test_mode
+
+    ##
+    # @return [String] Sandbox
+    attr_accessor :sandbox
+
+    ##
+    # @return [String] Options
+    attr_accessor :options
 
-    # Validates the configuration
-    def validate!
-      @errors = []
+    ##
+    # @return [String] Gateway url
+    attr_accessor :gateway
 
-      @errors << "Username is required" if self.username.nil?
-      @errors << "Token is required" if self.token.nil?
+    ##
+    # @return [String] Proxy url
+    attr_accessor :proxy
 
-      raise "The following errors were raised during configuration: #{@errors.join(", ")}}" unless @errors.empty?
+    ##
+    # @return [String] http secure
+    attr_accessor :http_secure
+
+    ##
+    # @return [String] api version
+    attr_accessor :api_version
+
+    ##
+    # @param [Hash{Symbol=>Object}]
+    # Initialize and validate the configuration
+    def initialize(options = {})
+      self.token       = options[:token]
+      self.username    = options[:username]
+      self.gateway     = options[:gateway] || 'gateway.fatzebra.com.au'
+      self.test_mode   = options[:test_mode] || false
+      self.http_secure = options[:http_secure] || true
+      self.api_version = options[:api_version] || 'v1.0'
+      self.sandbox     = options[:sandbox]
+      self.options     = options[:options]
+      self.proxy       = options[:proxy]
     end
 
-    def self.from_hash(hash)
-      c = new
-      hash.each do |key, value|
-        c.send key, value
+    ##
+    # validate the configuration
+    # Raise when configuration is not valid
+    # @return [Boolean] true
+    def valid!
+      %i[username token].each do |field|
+        validate_presence(field)
       end
 
-      c
+      true
+    end
+
+    private
+
+    def validate_presence(field)
+      raise FatZebra::ConfigurationError, "#{field} can't be blank" if send(field).nil? || send(field).empty?
     end
+
   end
-end
+end

data/lib/fat_zebra/customer.rb

@@ -0,0 +1,27 @@
+module FatZebra
+  ##
+  # == FatZebra \Customer
+  #
+  # Manage customer for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * delete
+  #
+  class Customer < APIResource
+
+    extend FatZebra::APIOperation::Search
+    extend FatZebra::APIOperation::Find
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :first_name, required: true, on: :create
+    validates :last_name, required: true, on: :create
+    validates :reference, required: true, on: :create
+    validates :email, required: true, on: :create
+    validates :ip_address, required: true, on: :create
+
+  end
+end

data/lib/fat_zebra/direct_credit.rb

@@ -0,0 +1,27 @@
+module FatZebra
+  ##
+  # == FatZebra \Direct \Credit
+  #
+  # Manage direct credit for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * delete
+  #
+  class DirectCredit < APIResource
+
+    extend FatZebra::APIOperation::Find
+    extend FatZebra::APIOperation::Search
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :description, required: true, on: :create
+    validates :amount, required: true, class_type: Integer, on: :create
+    validates :bsb, required: true, on: :create
+    validates :account_name, required: true, on: :create
+    validates :account_number, required: true, on: :create
+
+  end
+end

data/lib/fat_zebra/direct_debit.rb

@@ -0,0 +1,27 @@
+module FatZebra
+  ##
+  # == FatZebra \Direct \Debit
+  #
+  # Manage direct debit for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * delete
+  #
+  class DirectDebit < APIResource
+
+    extend FatZebra::APIOperation::Find
+    extend FatZebra::APIOperation::Search
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :description, required: true, on: :create
+    validates :amount, required: true, class_type: Integer, on: :create
+    validates :bsb, required: true, on: :create
+    validates :account_name, required: true, on: :create
+    validates :account_number, required: true, on: :create
+
+  end
+end

data/lib/fat_zebra/errors.rb

@@ -1,5 +1,19 @@
 module FatZebra
-	class InvalidArgumentError < StandardError; end
-	class RequestError < StandardError; end
-  class GatewayError < StandardError; end
-end
+
+  ##
+  # Configuration Error
+  class ConfigurationError < StandardError; end
+
+  ##
+  # Request to API Error
+  class RequestError < StandardError; end
+
+  ##
+  # Validations for the request
+  class RequestValidationError < StandardError; end
+
+  ##
+  # Method unknown for the request
+  class UnknownRequestMethod < StandardError; end
+
+end

data/lib/fat_zebra/fat_zebra_object.rb

@@ -0,0 +1,179 @@
+module FatZebra
+  ##
+  # == FatZebra \Object
+  #
+  # Define the API objects
+  class FatZebraObject
+    extend Validation
+
+    ##
+    # @return [Hash] JSON parsed response
+    attr_reader :raw
+
+    ##
+    # @return [Hash] JSON parsed response
+    attr_reader :data
+
+    attr_reader :successful
+    alias successful? successful
+
+    attr_reader :errors
+
+    class << self
+
+      ##
+      # Initialize from the API response
+      #
+      # @return [FatZebra::FatZebraObject]
+      def initialize_from(response)
+        object = new
+
+        object.load_response_api(response.is_a?(Hash) ? response : JSON.parse(response))
+
+        if object.raw['response']
+          if object.raw['response'].is_a?(Array)
+            object.raw['response'].each { |response_object| object.add_data(initialize_from(response_object)) }
+          else
+            object.update_attributes(object.raw['response'])
+          end
+        else
+          object.update_attributes(object.raw)
+        end
+
+        object
+      end
+
+    end
+
+    ##
+    # Initialize and create accessor for values
+    #
+    # @params [Hash] values
+    def initialize(values = {})
+      @data   = []
+      @values = {}
+
+      update_attributes(values)
+    end
+
+    ##
+    # Update the object based on the response from the API
+    # Remove and new acessor
+    #
+    # @param [Hash] response
+    #
+    # @return [FatZebra::FatZebraObject]
+    def update_from(response)
+      load_response_api(response.is_a?(Hash) ? response : JSON.parse(response))
+
+      # attributes to remove
+      (@values.keys - raw['response'].keys).each { |key| remove_accessor(key) }
+
+      update_attributes(raw['response'])
+
+      self
+    end
+
+    ##
+    # get attribute value
+    def [](key)
+      @values[key.to_sym]
+    end
+
+    ##
+    # set attribute value
+    def []=(key, value)
+      send(:"#{key}=", value)
+    end
+
+    ##
+    # @return [Array] all the keys
+    def keys
+      @values.keys
+    end
+
+    ##
+    # @return [Hash] values to hash
+    def to_hash
+      @values
+    end
+
+    ##
+    # @return [JSON] values to JSON
+    def to_json
+      JSON.generate(@values)
+    end
+
+    ##
+    # Update the attribute and add accessor for new attributes
+    #
+    # @param [Hash] values
+    def update_attributes(attributes)
+      attributes.each do |(key, value)|
+        add_accessor(key, value)
+      end
+    end
+
+    ##
+    # Load the root components for the API response
+    #
+    # @param [Hash] values
+    def load_response_api(response)
+      @raw        = response
+      @successful = response['successful']
+      @errors     = response['errors']
+    end
+
+    ##
+    # Add data for sub-object
+    #
+    # @param [Object] data
+    def add_data(data)
+      @data << data
+    end
+
+    protected
+
+    def inspect
+      id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
+
+    def method_missing(name, *args)
+      super unless name.to_s.end_with?('=')
+
+      attribute = name.to_s[0...-1].to_sym
+      value     = args.first
+
+      add_accessor(attribute, value)
+    end
+
+    private
+
+    def add_accessors(keys, payload = raw)
+      keys.each do |key|
+        add_accessor(key, payload[key])
+      end
+    end
+
+    def add_accessor(name, value)
+      @values[name] = value
+
+      define_singleton_method(name) { @values[name] }
+      define_singleton_method(:"#{name}=") do |v|
+        @values[name] = v
+      end
+
+      define_singleton_method(:"#{name}?") { value } if [FalseClass, TrueClass].include?(value.class)
+    end
+
+    def remove_accessor(name)
+      @values.delete(name)
+
+      singleton_class.class_eval { remove_method name.to_sym } if singleton_methods.include?(name.to_sym)
+      singleton_class.class_eval { remove_method "#{name}=".to_sym } if singleton_methods.include?("#{name}=".to_sym)
+      singleton_class.class_eval { remove_method "#{name}?".to_sym } if singleton_methods.include?("#{name}?".to_sym)
+    end
+
+  end
+end

data/lib/fat_zebra/information.rb

@@ -0,0 +1,25 @@
+module FatZebra
+  ##
+  # == FatZebra \Information
+  #
+  # Manage information for the API
+  #
+  # * ping
+  #
+  class Information < APIResource
+    class << self
+
+      ##
+      # Ping the API
+      #
+      # @param [String] echo param
+      #
+      # @return [FatZebra::Information] response
+      def ping(nonce = SecureRandom.hex)
+        response = request(:get, '/ping', echo: nonce)
+        initialize_from(response)
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/payment_plan.rb

@@ -0,0 +1,62 @@
+module FatZebra
+  ##
+  # == FatZebra \Payment \Plan
+  #
+  # Manage payment plan for the API
+  #
+  # * save
+  # * find
+  # * delete
+  # * suspend!
+  # * active!
+  #
+  class PaymentPlan < APIResource
+
+    extend FatZebra::APIOperation::Find
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :payment_method, required: true, on: :create
+    validates :customer, required: true, on: :create
+    validates :reference, required: true, on: :create
+    validates :setup_fee, required: true, on: :create
+    validates :amount, required: true, on: :create
+    validates :start_date, required: true, on: :create
+    validates :frequency, required: true, on: :create
+    validates :anniversary, required: true, on: :create
+    validates :total_count, required: true, on: :create
+    validates :total_amount, required: true, on: :create
+
+    ##
+    # Suspend a payment plan
+    #
+    # @param [Hash] params
+    # @param [Hash] options for the request, and configurations (Optional)
+    #
+    # @return [FatZebra::PaymentPlan]
+    def suspend!(params = {}, options = {})
+      params = {
+        new_status: 'Suspended'
+      }.merge(params)
+
+      save(params, options)
+    end
+
+    ##
+    # Activate a payment plan
+    #
+    # @param [Hash] params
+    # @param [Hash] options for the request, and configurations (Optional)
+    #
+    # @return [FatZebra::PaymentPlan]
+    def active!(params = {}, options = {})
+      params = {
+        new_status: 'Active'
+      }.merge(params)
+
+      save(params, options)
+    end
+
+  end
+end

data/lib/fat_zebra/purchase.rb

@@ -0,0 +1,99 @@
+module FatZebra
+  ##
+  # == FatZebra \Purchase
+  #
+  # Manage purchase for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * void
+  # * settlement
+  # * refund
+  # * capture
+  #
+  class Purchase < APIResource
+
+    extend FatZebra::APIOperation::Find
+    extend FatZebra::APIOperation::Search
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Void
+
+    validates :card_number, required: { unless: %i[card_token wallet] }, on: :create
+    validates :card_token, required: { unless: %i[card_number wallet] }, on: :create
+    validates :card_expiry, required: { unless: %i[card_token wallet] }, on: :create
+    validates :amount, required: true, class_type: Integer, on: :create
+    validates :reference, required: true, on: :create
+    validates :customer_ip, required: true, on: :create
+
+    validates :from, required: true, on: :settlement
+    validates :to, required: true, on: :settlement
+
+    class << self
+
+      ##
+      # Create a payment plan
+      # Default currency to AUD
+      #
+      # @param [Hash] params
+      # @param [Hash] options for the request, and configurations (Optional)
+      #
+      # @return [FatZebra::PaymentPlan]
+      def create(params, options = {})
+        params[:currency] ||= 'AUD'
+
+        super(params, options)
+      end
+
+      ##
+      # Return all the settlements
+      #
+      # @param [Hash] params (from and to are date required)
+      # @param [Hash] options for the request, and configurations (Optional)
+      #
+      # @return [FatZebra::Purchase]
+      def settlement(params = {}, options = {})
+        valid!(params, :settlement)
+
+        params = Util.format_dates_in_hash(params)
+
+        response = request(:get, "#{resource_path}/settlement", params, options)
+        initialize_from(response)
+      end
+
+    end
+
+    ##
+    # Refunds the current purchase
+    #
+    # @param [Hash] params for refund API (Optional)
+    # @param [Hash] options for the request, and configurations (Optional)
+    #
+    # @return [FatZebra::Refund] object
+    def refund(params = {}, options = {})
+      Refund.create({
+        transaction_id: id,
+        amount:         amount,
+        reference:      reference
+      }.merge(params), options)
+    end
+
+    ##
+    # Captures an authorization
+    #
+    # @param [Hash] params for capture API (Optional)
+    # @param [Hash] options for the request, and configurations (Optional)
+    #
+    # @return [Response] Purchase response object
+    def capture(params = {}, options = {})
+      params = {
+        amount: amount
+      }.merge(params)
+
+      response = request(:post, resource_path("purchases/#{id}/capture"), params, options)
+      update_from(response)
+    end
+
+  end
+end

data/lib/fat_zebra/refund.rb

@@ -0,0 +1,25 @@
+module FatZebra
+  ##
+  # == FatZebra \Refund
+  #
+  # Manage refund for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * void
+  #
+  class Refund < APIResource
+
+    extend FatZebra::APIOperation::Find
+    extend FatZebra::APIOperation::Search
+
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Void
+
+    validates :transaction_id, required: true, on: :create
+    validates :amount, required: true, on: :create
+    validates :reference, required: true, on: :create
+
+  end
+end

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

@@ -0,0 +1,23 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Epilogue
+  #
+  # Add the epilogue to the multipart
+  class Request
+    module Multipart
+      class Epilogue
+        include Part
+
+        def initialize
+          @io = StringIO.new(footer)
+        end
+
+        private
+
+        def footer
+          "--#{boundary}--#{LINE_BREAK}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \FileIO
+  #
+  # Add file to the multipart
+  class Request
+    module Multipart
+      class FileIO
+        include Part
+
+        attr_reader :length, :stream
+
+        def initialize(options)
+          @filename     = options[:filename]
+          @file         = options[:file]
+          @content_type = options[:content_type]
+          @options      = options
+          @file_size    = File.size(@file)
+          @footer       = LINE_BREAK
+          @length       = header.bytesize + @file_size + @footer.length
+          @io           = Stream.new(StringIO.new(header), @file, StringIO.new(@footer))
+        end
+
+        def header
+          part = []
+          part << "--#{boundary}"
+          part << "Content-Disposition: form-data; name=\"#{@filename}\"; filename=\"#{@filename}\""
+          part << "Content-Length: #{@size}"
+          part << "Content-Type: #{@content_type}"
+          part << 'Content-Transfer-Encoding: binary'
+          part << LINE_BREAK
+
+          part.join(LINE_BREAK)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Param
+  #
+  # Add param to the multipart
+  class Request
+    module Multipart
+      class Param
+        include Part
+
+        def initialize(name, value)
+          @name  = name
+          @value = value
+          @io    = StringIO.new(part)
+        end
+
+        def length
+          part.bytesize
+        end
+
+        private
+
+        def part
+          part = []
+          part << "--#{boundary}"
+          part << "Content-Disposition: form-data; name=\"#{@name}\""
+          part << ''
+          part << @value
+
+          part.join(LINE_BREAK)
+        end
+
+      end
+
+    end
+  end
+end