fat_zebra_multi 3.1.0.1

data/lib/fat_zebra/api_operation/save.rb

@@ -0,0 +1,67 @@
+module FatZebra
+  class APIOperation
+    ##
+    # == Save (create or update) a resource for the API
+    #
+    module Save
+      module ClassMethods
+
+        ##
+        # Create an API Resource and validate the params for the API.
+        #
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [FatZebra::Object] response from the API
+        def create(params = {}, options = {})
+          valid!(params, :create) if respond_to?(:valid!)
+
+          response = request(:post, resource_path, params, options)
+          initialize_from(response)
+        end
+
+        ##
+        # Update an API Resource and validate params for the API
+        #
+        # @param [String] id for the request
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [FatZebra::Object] response from the API
+        def update(id, params = {}, options = {})
+          valid!(params, :update) if respond_to?(:valid!)
+
+          response = request(:put, "#{resource_path}/#{id}", params, options)
+          initialize_from(response)
+        end
+
+      end
+
+      ##
+      # Create or Update an API Resource
+      #
+      # @param [Hash] params for the request
+      # @param [Hash] Additional options for the request
+      #
+      # @return [FatZebra::Object] response from the API
+      def save(params = {}, options = {})
+        path   = singleton_methods.include?(:id) ? "#{resource_path}/#{id}" : resource_path
+        method = singleton_methods.include?(:id) ? :put : :post
+
+        params_for_save = to_hash.merge(params)
+
+        # Remove the id from the params to save, it should not be updated.
+        params_for_save.delete('id')
+
+        response = request(method, path, params_for_save, options)
+        update_from(response)
+      end
+      alias update save
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/api_operation/search.rb

@@ -0,0 +1,39 @@
+module FatZebra
+  class APIOperation
+    ##
+    # == Search resources for the API
+    #
+    module Search
+
+      ##
+      # Default params for the API
+      DEFAULT_PARAMS = {
+        offset: 0,
+        limit: 10
+      }.freeze
+
+      module ClassMethods
+
+        ##
+        # Search for API Resources
+        #
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [FatZebra::Object] response from the API
+        def search(params = {}, options = {})
+          params = DEFAULT_PARAMS.merge(params)
+
+          response = request(:get, resource_path, params, options)
+          initialize_from(response)
+        end
+
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/api_operation/void.rb

@@ -0,0 +1,52 @@
+module FatZebra
+  class APIOperation
+    ##
+    # == Void a resource for the API
+    #
+    module Void
+      module ClassMethods
+
+        ##
+        # Void an API Resource and validate params for the API
+        #
+        # @param [String] id for the request
+        # @param [Hash] params for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [FatZebra::Object] response from the API
+        def void(id, params = {}, options = {})
+          valid!(params, :void) if respond_to?(:valid!)
+
+          params = {
+            id: id
+          }.merge(params)
+
+          response = request(:post, "#{resource_path}/void", params, options)
+          initialize_from(response)
+        end
+
+      end
+
+      ##
+      # Void an API Resource
+      #
+      # @param [Hash] params for the request
+      # @param [Hash] Additional options for the request
+      #
+      # @return [FatZebra::Object] response from the API
+      def void(params = {}, options = {})
+        params = {
+          id: id
+        }.merge(params)
+
+        response = request(:post, "#{resource_path}/void", params, options)
+        update_from(response)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/api_resource.rb

@@ -0,0 +1,88 @@
+module FatZebra
+  ##
+  # == FatZebra \API \Resource
+  #
+  # Define the API requests methods
+  class APIResource < FatZebraObject
+    include APIHelper
+
+    class << self
+
+      def base_path(account)
+        "#{account.api_version}/"
+      end
+
+      ##
+      # Send a request to the API
+      #
+      # @param [Symbol] method for the request
+      # @param [String] endpoint for the request
+      # @param [Hash] options
+      # @param [Hash] Payload
+      #
+      # @return [Hash] response
+      # @raise [FatZebra::RequestError] if the request is invalid
+      # rubocop:disable Metrics/AbcSize
+      def request(method, path, payload = {}, options = {})
+        account = get_account options
+        full_path = "/#{base_path account}#{path}"
+
+        payload[:test] = true if account.test_mode
+        payload        = Util.format_dates_in_hash(payload)
+        url_params     = URI.encode_www_form(payload) if method == :get
+        uri            = build_endpoint_url(account.gateway, full_path, url_params, http_secure: account.http_secure)
+
+        request_options = Util.compact(
+          method:  method,
+          url:     uri.to_s,
+          payload: payload,
+          proxy:   account.proxy,
+          use_ssl: account.http_secure
+        ).merge(authentication(account)).merge(default_headers).merge(account.global_options).merge(options)
+
+        Request.execute(request_options).body
+      rescue FatZebra::RequestError => error
+        return error.http_body if error.http_status == 422
+        raise
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def ssl_options
+        return {} unless get_account.http_secure
+        {
+          ca_file:     File.expand_path(File.dirname(__FILE__) + '/../../vendor/cacert.pem'),
+          verify_mode: OpenSSL::SSL::VERIFY_PEER
+        }
+      end
+
+      def authentication(account)
+        {
+          basic_auth: {
+            user:     account.username,
+            password: account.token
+          }
+        }
+      end
+
+      def configurations
+        FatZebra.configurations
+      end
+
+      def get_account(options)
+        case [options[:account].nil?, configurations.nil?]
+        when [true, false]
+          configurations
+        when [false, true]
+          options[:account]
+        when [true, true]
+          raise ConfigurationError, 'No account specified'
+        else # [false, false]
+          raise ConfigurationError, 'Ambiguous accounts specified' if options[:account] != configurations
+          configurations
+        end
+      end
+    end
+  end
+end

data/lib/fat_zebra/bank_account.rb

@@ -0,0 +1,20 @@
+module FatZebra
+  ##
+  # == FatZebra \Bank \Account
+  #
+  # Manage bank account for the API
+  #
+  # * search
+  # * save
+  #
+  class BankAccount < APIResource
+
+    include FatZebra::APIOperation::Search
+    include FatZebra::APIOperation::Save
+
+    validates :account_name, required: true, on: :create
+    validates :account_number, required: true, on: :create
+    validates :bsb, required: true, on: :create
+
+  end
+end

data/lib/fat_zebra/batch.rb

@@ -0,0 +1,60 @@
+module FatZebra
+  ##
+  # == FatZebra \Batch
+  #
+  # Manage Batch for the API
+  #
+  # * create
+  # * search
+  # * find
+  # * result
+  #
+  class Batch < APIResource
+    @resource_name = 'batches'
+
+    include FatZebra::APIOperation::Search
+    include FatZebra::APIOperation::Find
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Delete
+
+    validates :filename, required: true, type: :batch_filename, on: :create
+    validates :file, required: true, type: :file_type, on: :create
+    validates :multipart, required: true, type: :boolean, on: :create
+
+    class << self
+
+      ##
+      # Upload a batch file
+      #
+      # @param [Hash] params for the request
+      # @param [Hash] Additional options for the request
+      #
+      # @return [FatZebra::Batch] response from the API
+      def create(params, options = {})
+        params[:multipart] = true
+        params[:content_type] = 'text/csv'
+        params[:file] = File.new(params.delete(:path)) if params.key?(:path)
+        @resource_name = "batches/#{params[:filename]}"
+        super(params, options)
+      ensure
+        @resource_name = 'batches'
+      end
+
+    end
+
+    ##
+    # Return result from the batch
+    #
+    # @param [Hash] params for capture API (Optional)
+    # @param [Hash] options for the request, and configurations (Optional)
+    #
+    # @return [String] formated as CSV
+    def result(params = {}, options = {})
+      request(:get, "#{resource_path}/#{id}/result.csv", params, options)
+    rescue FatZebra::RequestError => error
+      return error.http_body if error.http_status == 422
+      raise
+    end
+
+  end
+end

data/lib/fat_zebra/card.rb

@@ -0,0 +1,23 @@
+module FatZebra
+  ##
+  # == FatZebra \Card
+  #
+  # Manage credit card for the API
+  #
+  # * save
+  #
+  class Card < APIResource
+    @resource_name = 'credit_cards'
+
+    include FatZebra::APIOperation::Save
+
+    validates :card_holder, required: { unless: %i[wallet] }, on: :create
+    validates :card_number, required: { unless: %i[wallet] }, on: :create
+    validates :card_expiry, required: { unless: %i[wallet] }, on: :create
+
+    validates :wallet, required: { unless: %i[card_number] }, on: :create
+
+    validates :card_expiry, required: true, on: :update
+
+  end
+end

data/lib/fat_zebra/config.rb

@@ -0,0 +1,90 @@
+module FatZebra
+  ##
+  # == FatZebra \Config
+  #
+  # Represent the FatZebra configuration for the API
+  class Config
+
+    GATEWAY_URLS = {
+      production: 'gateway.fatzebra.com.au',
+      sandbox:    'gateway.sandbox.fatzebra.com.au'
+    }.freeze
+
+    ##
+    # @return [String] Username
+    attr_accessor :username
+
+    ##
+    # @return [String] Token
+    attr_accessor :token
+
+    ##
+    # @return [String] Test mode
+    attr_accessor :test_mode
+
+    ##
+    # @return [String] Gateway url
+    attr_accessor :gateway
+
+    ##
+    # @return [String] Proxy url
+    attr_accessor :proxy
+
+    ##
+    # @return [String] http secure
+    attr_accessor :http_secure
+
+    ##
+    # @return [String] api version
+    attr_accessor :api_version
+
+    ##
+    # @return [String] global request options
+    attr_accessor :global_options
+
+    ##
+    # @param [Hash{Symbol=>Object}]
+    # Initialize and validate the configuration
+    def initialize(options = {})
+      self.token          = options[:token]
+      self.username       = options[:username]
+      self.gateway        = options[:gateway] || :production
+      self.test_mode      = options[:test_mode] || false
+      self.http_secure    = options[:http_secure] || true
+      self.api_version    = options[:api_version] || 'v1.0'
+      self.proxy          = options[:proxy]
+      self.global_options = options[:global_options] || {}
+
+      valid! unless options.empty?
+    end
+
+    ##
+    # validate the configuration
+    # Raise when configuration is not valid
+    # Remove "http://" or "https://" from urls
+    #
+    # @return [Boolean] true
+    def valid!
+      format!
+
+      %i[username token gateway api_version].each do |field|
+        validate_presence(field)
+      end
+
+      true
+    end
+
+    private
+
+    def format!
+      self.gateway = GATEWAY_URLS[gateway] if gateway.is_a?(Symbol)
+
+      self.gateway = Util.cleanup_host(gateway)
+    end
+
+    def validate_presence(field)
+      raise FatZebra::ConfigurationError, "#{field} can't be blank" if send(field).nil? || send(field).empty?
+    end
+
+  end
+end