fat_zebra 2.0.13 → 3.0.0

data/lib/fat_zebra/gateway.rb

@@ -1,292 +0,0 @@
-module FatZebra
-	class Gateway
-		attr_accessor :username, :token, :gateway_server, :options
-		
-		DEFAULT_OPTIONS = {:secure => true, :version => API_VERSION}
-
-		class << self
-			def configure(config)
-				g = Gateway.new(config.username, config.token, config.gateway || GATEWAY_SERVER)
-				g.options ||= {}
-				g.options[:test_mode] = config.test_mode
-				g.options.merge!(config.options || {})
-				g.proxy = g.options[:proxy]
-
-				g
-			end
-		end
-
-		# Initializes a new gateway object
-		#
-		# @param [String] merchants username
-		# @param [String] merchants token for authentication
-		# @param [String] the server for the gateway, defaults to 'gateway.fatzebra.com.au'
-		# @param [Hash] the options for the gateway connection (e.g. secure, version etc)
-		#
-		# @return FatZebra::Gateway instance
-		def initialize(username, token, gateway_server = GATEWAY_SERVER, options = {})
-			self.username = username
-			self.token = token
-			self.gateway_server = gateway_server
-			self.options = DEFAULT_OPTIONS.merge(options)
-			self.proxy = self.options[:proxy]
-
-			require_field :username, :token, :gateway_server
-		end
-
-		# Set the proxy for RestClient
-		#
-		# @param [String] val the proxy
-		#
-		# @return Nil
-		def proxy=(val)
-			self.options[:proxy] = val
-		end
-
-		# Get the proxy set for RestClient
-		#
-		# @return [String] the proxy set for RestClient
-		def proxy
-			self.options[:proxy]
-		end
-
-		# Performs a purchase transaction against the gateway
-		#
-		# amount - the amount as an integer e.g. (1.00 * 100).to_i
-		# card_data - a hash of the card data (example: {:card_holder => "John Smith", :number => "...", :expiry => "...", :cvv => "123"} or {:token => "abcdefg1"})
-		# card_holder - the card holders name
-		# card_number - the customers credit card number
-		# card_expiry - the customers card expiry date (as Date or string [mm/yyyy])
-		# cvv - the credit card verification value (cvv, cav, csc etc)
-		# reference - a reference for the purchase
-		# customer_ip - the customers IP address (for fraud prevention)
-		# currency - the currency of the transaction, ISO 4217 code (http://en.wikipedia.org/wiki/ISO_4217)
-		#
-		# Returns a new FatZebra::Models::Response (purchase) object
-		def purchase(amount, card_data, reference, customer_ip, currency = "AUD")
-			warn "[DEPRECATED] Gateway#purchase is deprecated, please use Purchase.create instead" unless options[:silence]
-			Models::Purchase.create(amount, card_data, reference, customer_ip, currency)
-		end
-
-		# Retrieves purchases specified by the options hash
-		#
-		# @param [Hash] options for lookup
-		#               includes: 
-		#                 - id (unique purchase ID)
-		#                 - reference (merchant reference)
-		# 				  - from (Date)
-		# 				  - to (Date)
-		#                 - offset (defaults to 0) - for pagination
-		#                 - limit (defaults to 10) for pagination
-		# @return [Array<Purchase>] array of purchases
-		# @deprecated Please use Purchase.find(options) instead
-		def purchases(options = {})
-			warn "[DEPRECATED] Gateway#purchases is deprecated, please use Purchase.find instead" unless options[:silence]
-			Models::Purchase.find(options)
-		end
-
-		# Public: Performs an authorization transaction against the gateway
-		# Note: Successful transactions must then be captured for funds to settle.
-		#
-		# amount - the amount as an integer e.g. (1.00 * 100).to_i
-		# card_number - the customers credit card number
-		# card_expiry - the customers card expiry date
-		# cvv - the credit card verification value (cvv, cav, csc etc)
-		# reference - a reference for the purchase
-		# customer_ip - the customers IP address (for fraud prevention)
-		#
-		# Returns a new FatZebra::Models::Purchase object
-		def authorize(amount, card_number, card_expiry, cvv, reference, customer_ip)
-			raise "Sorry we haven't compelted this functionality yet."
-		end
-
-		# Public: Captures a pre-authorized transaction
-		#
-		# transaction_id - the authorization ID
-		# amount - the amount to capture, as an integer
-		#
-		# Returns a new FatZebra::Models::Purchase object
-		def capture(transaction_id, amount)
-			raise "Sorry we haven't compelted this functionality yet."
-		end
-
-		# Refunds a transaction
-		#
-		# @param [String] the ID of the original transaction to be refunded
-		# @param [Integer] the amount to be refunded, as an integer
-		# @param [String] the reference for the refund
-		#
-		# @return [Refund] refund result object
-		# @deprecated Please use Refund.create or Purchase#refund instead
-		def refund(transaction_id, amount, reference)
-			warn "[DEPRECATED] Gateway#refund is deprecated, please use Refund.create or Purchase#refund instead`" unless options[:silence]
-			Models::Refund.create(transaction_id, amount, reference)
-		end
-
-		# Pings the Fat Zebra service
-		# 
-		# @param [String] the data to be echoed back
-		#
-		# @return true if reply is valid, false if the request times out, or otherwise
-		def ping(nonce = SecureRandom.hex)	
-			begin
-				response = RestClient.get(build_url("ping") + "?echo=#{nonce}")
-				response = JSON.parse(response)
-
-				response["echo"] == nonce
-			rescue => e
-				return false
-			end
-		end
-
-		# Tokenizes a credit card
-		# 
-		# @param [String] the credit card holder name
-		# @param [String] the card number
-		# @param [String] the credit card expiry date (mm/yyyy)
-		# @param [String] the card CVV
-		#
-		# @return Response
-		# @deprecated Please use Card.create instead
-		def tokenize(card_holder, card_number, expiry, cvv)
-			warn "[DEPRECATED] Gateway#tokenize is deprecated, please use Card.create instead" unless options[:silence]
-			Models::Card.create(card_holder, card_number, expiry, cvv)
-		end
-
-		# Public: Performs the HTTP(s) request and returns a response object, handing errors etc
-		#
-		# method - the request method (:post or :get)
-		# resource - the resource for the request
-		# data - a hash of the data for the request
-		#
-		# Returns hash of response data
-		def make_request(method, resource, data = nil)
-			resource = get_resource(resource, method, data)
-
-			if [:post, :put, :patch].include?(method)
-				data[:test] = options[:test_mode] if options[:test_mode]
-				payload = data.to_json
-			else
-				payload = {}
-			end
-
-			headers = options[:headers] || {}
-
-			if method == :get
-				resource.send(method, headers) do |response, request, result, &block|
-					handle_response(response)
-				end
-			else
-				# Add in test flag is test mode...
-				resource.send(method, payload, headers) do |response, request, result, &block|
-					handle_response(response)
-				end
-			end
-		end
-
-		private
-		# Private: Extracts the date value from a Date/DateTime value
-		#
-		# value - the string or date value to extract the value from
-		#
-		# Returns date string as MM/YYYY
-		def extract_date(value)
-			return nil if value.nil?
-
-			if value.is_a?(String)
-				return value
-			elsif value.respond_to?(:strftime)
-				return value.strftime("%m/%Y")
-			end
-		end
-
-		# Private: Verifies a require field is present and has a value
-		#
-		# fields - array of fields required to be present
-		#
-		# Returns nil
-		# Raises InvalidArgumentError if field is missing
-		def require_field(*fields)
-			fields.each do |field|
-				val = self.send(field)
-				raise InvalidArgumentError, "Parameter #{field} is required", caller if (val.nil? || val.to_s.length == 0)
-			end
-		end
-
-		# Public: Builds the URL for the request
-		# If data is provided it will append as name/value pairs for a get request
-		#
-		# resource - the resource to append to the URL (e.g. purchases for https://something.com/purchases)
-		# data (optional) - a hash of the data name value pairs - if nil it will be ignored
-		#
-		# Returns the URL as a string
-		def build_url(resource, data = nil)
-			proto = case options[:secure]
-			when true
-				"https://"
-			when false
-				"http://"
-			end
-			version = options[:version]
-			if version.nil?
-				url = "#{proto}#{self.gateway_server}/#{resource}"
-			else
-				url = "#{proto}#{self.gateway_server}/v#{version}/#{resource}"
-			end
-
-			unless data.nil?
-				url = url + "?" + 
-				data.map do |key, value|
-					"#{key}=#{value}" # TODO: URL Encode this
-				end.join("&")
-			end
-
-			url
-		end
-
-		# Public: Builds a new RestClient resource object
-		#
-		# uri - the full URI for the request
-		# method - the method for the request - either :post or :get
-		# data - the data for the request - only required for :get methods
-		#
-		# Returns a new RestClient resource
-		def get_resource(uri, method = :post, data = nil)
-			url = build_url(uri, (method == :get ? data : nil))
-			ssl_options = options[:secure] ? {
-				:ssl_ca_file =>  File.expand_path(File.dirname(__FILE__) + "/../../vendor/cacert.pem"),
-  				:verify_ssl => OpenSSL::SSL::VERIFY_PEER
-  			} : {}
-
-  			opts = {:user => self.username, :password => self.token, proxy: self.options[:proxy]}
-			if method == :get
-				url = build_url(uri, data)
-			else
-				url = build_url(uri)
-			end
-
-			RestClient::Resource.new(url, opts.merge(ssl_options))
-		end
-
-		def handle_response(response)
-			case response.code
-			when 201
-				JSON.parse(response)
-			when 200
-				JSON.parse(response)
-			when 422
-				JSON.parse(response)
-			when 400
-				raise RequestError, "Bad Data"
-			when 401
-				raise RequestError, "Unauthorized, please check your username and token"
-			when 404	
-				raise RequestError, "Requested Resource not found"
-			when 500
-				raise RequestError, "Server Error, please check with Gateway"
-			when 501
-				raise RequestError, "Problem processing your request - please check your data"
-			end
-		end
-	end
-end

data/lib/fat_zebra/models/base.rb

@@ -1,33 +0,0 @@
-module FatZebra
-  module Models
-    class Base
-      @@attributes = []
-      def self.attribute(*values)
-        @@attributes ||= []
-        values.each do |val|
-          @@attributes << val
-        end
-        attr_accessor *values
-      end
-
-      def initialize(attrs = {})
-        attrs.each do |key, val|
-          self.send("#{key}=", val) if self.respond_to?("#{key}=")
-        end
-
-        self.raw = attrs if self.respond_to?(:raw=)
-      end
-
-      def inspect
-        inspection = @@attributes.collect { |name|
-                        "#{name}: #{instance_variable_get("@#{name}")}"
-                      }.compact.join(", ")
-        "#<#{self.class} #{inspection}>"
-      end
-
-      def to_s
-        inspect
-      end
-    end
-  end
-end

data/lib/fat_zebra/models/card.rb

@@ -1,49 +0,0 @@
-module FatZebra
-  module Models
-    class Card < Base
-      attribute :token, :card_holder, :card_number, :card_expiry, :transaction_count, :raw
-
-      def successful; true; end
-
-      class << self
-        # Tokenizes a credit card
-        # 
-        # @param [String] the credit card holder name
-        # @param [String] the card number
-        # @param [String] the credit card expiry date (mm/yyyy)
-        # @param [String] the card CVV
-        # @param [Hash] optional any additional data which should be merged into the request
-        #
-        # @return Response
-        def create(card_holder, card_number, expiry, cvv, optional = {})
-          params = {
-            :card_holder => card_holder,
-            :card_number => card_number,
-            :card_expiry => expiry,
-            :cvv => cvv
-          }
-
-          params.merge!(optional)
-          
-          response = FatZebra.gateway.make_request(:post, "credit_cards", params)
-          Response.new(response, :card)
-        end
-
-        # Update the credit card expiry date
-        #
-        # @param [String] token the credit card token
-        # @param [String] expiry the new expiry date (format: mm/yyyy)
-        #
-        # @return [Response]
-        def update_expiry(token, expiry)
-          params = {
-                  card_expiry: expiry
-          }
-
-          response = FatZebra.gateway.make_request(:put, "credit_cards/#{token}", params)
-          Response.new(response, :card)
-        end
-      end
-    end
-  end
-end

data/lib/fat_zebra/models/purchase.rb

@@ -1,185 +0,0 @@
-module FatZebra
-  module Models
-    class Purchase < Base
-      attribute :id, :amount, :reference, :message, :authorization, :transaction_id, :card_number,
-            :card_holder, :card_expiry, :authorized, :successful, :card_token, :currency, :raw, :captured, :captured_amount,
-            :response_code, :rrn, :cvv_match, :fraud_result, :fraud_messages, :settlement_date, :transaction_date, :metadata
-  
-      # Refunds the current transaction
-      #
-      # @param [Integer] amount the amount to be refunded
-      # @param [String] reference the refund reference
-      #
-      # @return Response (Refund) object
-      def refund(amount, reference)
-        Refund.create(self.id, amount, reference)
-      end
-
-      # Captures an authorization
-      #
-      # @param [Integer] amount the amount to capture. (Optional)
-      #
-      # @return [Response] Purchase response object
-      def capture(amount = nil)
-        if amount.nil?
-          params = {}
-        else
-          params = {
-            :amount => amount
-          }
-        end
-        response = FatZebra.gateway.make_request(:post, "purchases/#{self.id}/capture", params)
-        resp = Response.new(response)
-
-        if resp.successful && resp.purchase.successful
-          self.captured_amount = amount || self.amount
-          return true
-        else
-          raise StandardError, "Unable to capture purchase - #{resp.errors.join(',')}"
-        end
-      end
-
-      # Returns the record as a Hash
-      #
-      # @return [Hash]
-      def to_hash
-        {
-          id: self.id,
-          amount: self.amount,
-          reference: self.reference,
-          message: self.message,
-          authorization: self.authorization,
-          card_number: self.card_number,
-          card_holder: self.card_holder,
-          card_expiry: self.card_expiry,
-          card_token: self.card_token,
-          currency: self.currency,
-          authorized: self.authorized,
-          successful: self.successful,
-          captured: self.captured,
-          captured_amount: self.captured_amount,
-          response_code: self.response_code,
-          cvv_match: self.cvv_match,
-          rrn: self.rrn,
-          fraud_result: self.fraud_result,
-          fraud_messages: self.fraud_messages,
-          settlement_date: self.settlement_date,
-          transaction_date: self.transaction_date,
-          metadata: self.metadata || {}
-        }
-      end
-
-      class << self
-        # Performs a purchase transaction against the gateway
-        #
-        # @param [Integer] amount the amount as an integer e.g. (1.00 * 100).to_i
-        # @param [Hash] card_data a hash of the card data (example: {:card_holder => "John Smith", :number => "...", :expiry => "...", :cvv => "123"} or {:token => "abcdefg1"})
-        # @option card_data [String] card_holder the card holders name
-        # @option card_data [String] card_number the customers credit card number
-        # @option card_data [Date] expiry the customers card expiry date (as Date or string [mm/yyyy])
-        # @option card_data [String] cvv the credit card verification value (cvv, cav, csc etc)
-        # @param [String] reference a reference for the purchase
-        # @param [String] customer_ip the customers IP address (for fraud prevention)
-        # @param [String] currency currency code ("AUD", "USD", etc)
-        # @param [Hash] optional any optional parameters to be included in the payload
-        #
-        # @return [Response] response (purchase) object
-        def create(amount, card_data, reference, customer_ip, currency = 'AUD', optional = {})
-          params = {
-            :amount => amount,
-            :card_holder => card_data.delete(:card_holder),
-            :card_number => card_data.delete(:number),
-            :card_expiry => extract_date(card_data.delete(:expiry)),
-            :cvv => card_data.delete(:cvv),
-            :card_token => card_data.delete(:token),
-            :reference => reference,
-            :customer_ip => customer_ip,
-            :currency => currency
-          }
-
-          params.delete_if {|_, value| value.nil? } # If token is nil, remove, otherwise, remove card values
-          params.merge!(optional)
-          validate_params!(params)
-          response = FatZebra.gateway.make_request(:post, 'purchases', params)
-          Response.new(response)
-        end
-
-        # Retrieves purchases specified by the options hash
-        #
-        # @param [Hash] options for lookup
-        # @option options [String] id the unique purchase ID
-        # @option options [String] reference the merchant reference
-        # @option options [DateTime] from the start date to search from
-        # @option options [DateTime] to the end date time to search to
-        # @option options [Integer] offset the start page for pagination
-        # @option options [Integer] limit the maximum number of records to return in the query. Maximum 10
-        #
-        # @return [Array<Purchase>] array of purchases
-        def find(options = {})
-          id = options.delete(:id)
-          options.merge!({:offets => 0, :limit => 10})
-
-          # Format dates for the request
-          options[:from] = options[:from].strftime('%Y%m%dT%H%M') if options[:from]
-          options[:to] = options[:to].strftime('%Y%m%dT%H%M') if options[:to]
-
-
-          if id.nil?
-            response = FatZebra.gateway.make_request(:get, 'purchases', options)
-            if response['successful']
-              purchases = []
-              response['response'].each do |purchase|
-                purchases << Purchase.new(purchase)
-              end
-
-              purchases.size == 1 ? purchases.first : purchases
-            else
-              # TODO: This should raise a defined exception
-              raise StandardError, "Unable to query purchases, #{response['errors'].inspect}"
-            end
-          else
-            response = FatZebra.gateway.make_request(:get, "purchases/#{id}.json")
-            if response['successful']
-              Purchase.new(response['response'])
-            else
-              raise StandardError, "Unable to query purchases - #{response['errors'].inspect}"
-            end
-          end
-        end
-
-        private
-        # Private: Extracts the date value from a Date/DateTime value
-        #
-        # value - the string or date value to extract the value from
-        #
-        # Returns date string as MM/YYYY
-        def extract_date(value)
-          return nil if value.nil?
-
-          if value.is_a?(String)
-            return value
-          elsif value.respond_to?(:strftime)
-            return value.strftime('%m/%Y')
-          end
-        end
-
-        # Private: Validates the parameters provided meet the gateway requirements
-        #
-        # params - the parameter hash to be validated
-        #
-        # Returns nil
-        # Raises FatZebra::RequestError if errors are present.
-        def validate_params!(params)
-          @errors = []
-          @errors << 'number or token must be provided' unless params[:card_number].present? || params[:card_token].present? || params[:wallet].present?
-          @errors << 'amount must be provided' unless params[:amount].present? && params[:amount].to_f >= 0
-          @errors << 'expiry must be provided' unless params[:card_token].present? || params[:card_expiry].present? || params[:wallet].present?
-          @errors << 'reference must be provided' unless params[:reference].present?
-          @errors << 'customer_ip must be provided' unless params[:customer_ip].present?
-
-          raise FatZebra::RequestError.new("The following errors prevent the transaction from being submitted: #{@errors.to_sentence}") if @errors.any?
-        end
-      end
-    end
-  end
-end

data/lib/fat_zebra/models/refund.rb

@@ -1,46 +0,0 @@
-module FatZebra
-	module Models
-		class Refund < Base
-			attribute :amount, :reference, :refunded, :id, :message, :transaction_id, :original_transaction_id, :transaction_date, :settlement_date,
-								:response_code, :message, :rrn, :authorisation, :raw
-
-			# Returns the original transaction for this refund
-			#
-			# @return Purchase
-			def original_transaction
-				@original_transaction ||= Purchase.find(self.original_transaction_id)
-			end
-
-			# Indicates if the refund was successful or not
-			#
-			# @return Boolean
-			def successful
-				self.refunded == "Approved"
-			end
-			alias successful? successful
-
-			class << self
-				# Refunds a transaction
-				#
-				# @param [String] the ID of the original transaction to be refunded
-				# @param [Integer] the amount to be refunded, as an integer
-				# @param [String] the reference for the refund
-				# @param [Hash] optional optional parameters to be included in the request
-				#
-				# @return [Refund] refund result object
-				def create(transaction_id, amount, reference, optional = {})
-					params = {
-						:transaction_id => transaction_id,
-						:amount => amount,
-						:reference => reference
-					}
-
-					params.merge!(optional)
-
-					response = FatZebra.gateway.make_request(:post, "refunds", params)
-					Response.new(response, :refund)
-				end
-			end
-		end
-	end
-end

data/lib/fat_zebra/models/response.rb

@@ -1,33 +0,0 @@
-module FatZebra
-	module Models
-		class Response
-			attr_accessor :successful, :result, :errors, :test, :raw
-			def initialize(response, type = :purchase)
-				self.raw = response.dup unless response.nil?
-				self.test = response["test"]
-				self.successful = response["successful"]
-				self.errors = response["errors"]
-				
-				case type
-					when :purchase
-						self.result = Purchase.new(response["response"])
-						alias purchase result
-					when :refund
-						self.result = Refund.new(response["response"])
-						alias refund result
-					when :card
-						self.result = Card.new(response["response"])
-						alias card result
-				end
-			end
-
-			def successful?
-				self.successful
-			end
-
-			def test?
-				self.test
-			end
-		end
-	end
-end

data/lib/rest-client/request_ext.rb

@@ -1,15 +0,0 @@
-module RestClientExt
-  module ProxyRequest
-     def net_http_class
-      if RestClient.proxy
-        proxy_uri = URI.parse(RestClient.proxy)
-        Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
-      elsif @args[:proxy]
-        proxy_uri = URI.parse(@args[:proxy])
-        Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
-      else
-        Net::HTTP
-      end
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Config do
-  it "should configure with a block" do
-    FatZebra.configure do
-      username "TEST"
-      token "TEST"
-      sandbox true
-    end
-
-    FatZebra.config.username.should == "TEST"
-    FatZebra.config.token.should == "TEST"
-    FatZebra.config.sandbox.should be_true
-  end
-
-  it "should configure from a hash" do
-    config = FatZebra.configure(:username => "TEST", :token => "TEST", :sandbox => true)
-    config.username.should == 'TEST'
-  end
-
-  it "should prepare a new gateway when configured" do
-    FatZebra.configure do
-      username "TEST"
-      token "TEST"
-      test_mode true
-      sandbox true
-      options :headers => {"A" => "B"}
-    end
-
-    FatZebra.gateway.should_not be_nil
-  end
-
-  it "should raise an error when trying to access the gateway before it is configured" do
-    FatZebra.config = nil
-    lambda { FatZebra.gateway }.should raise_exception(FatZebra::GatewayError)
-  end
-end