judopay 1.0.0.pre

data/lib/judopay/core_ext/hash.rb

@@ -0,0 +1,29 @@
+require 'addressable/uri'
+require_relative 'string'
+
+class Hash
+  # Convert hash keys to camelcase
+  #
+  #  {'this_key' => 1}.camel_case_keys! #=> { 'thisKey' => 1 }
+  def camel_case_keys!
+    output_hash = {}
+    each do |key, value|
+      camel_case_key = key.to_s.camel_case
+      if value.is_a?(Hash)
+        output_hash[camel_case_key] = value.camel_case_keys!
+      else
+        output_hash[key.to_s.camel_case] = value
+      end
+    end
+    replace(output_hash)
+  end
+
+  # Produce a URL query string from the hash
+  #
+  #  {'this_key' => 1}.to_query_string #=> this_key=1
+  def to_query_string
+    uri = Addressable::URI.new
+    uri.query_values = self
+    uri.query
+  end
+end

data/lib/judopay/core_ext/string.rb

@@ -0,0 +1,31 @@
+class String
+  # Convert to camel case
+  #
+  #   "foo_bar".camel_case          #=> "fooBar"
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map { |e| e.capitalize }.join.uncapitalize
+  end
+
+  # Convert first letter to lower case
+  #
+  #   "BananaMan".uncapitalize      #=> "bananaMan"
+  def uncapitalize
+    self[0, 1].downcase + self[1..-1]
+  end
+
+  # Converts a camel_cased string to a underscored string
+  # Replaces spaces with underscores, and strips whitespace
+  #
+  #   "BananaMan".underscore        #=> "banana_man"
+  def underscore
+    to_s.strip
+      .gsub(' ', '_')
+      .gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .squeeze('_')
+      .downcase
+  end
+end

data/lib/judopay/error.rb

@@ -0,0 +1,153 @@
+require 'json'
+
+module Judopay
+  # Base error class
+  class Error < StandardError
+    attr_writer :message
+
+    def initialize(message = nil)
+      @message = message
+    end
+
+    def message
+      @message || self.class.name
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  # Custom error class for rescuing from all API errors
+  class APIError < StandardError
+    attr_accessor :response, :error_type, :model_errors, :message, :parsed_body
+
+    def initialize(response = nil)
+      @response = response
+
+      # Log the error
+      Judopay.log(Logger::ERROR, self.class.name + ' ' + @message.to_s)
+
+      # If we got a JSON response body, set variables
+      return if parsed_body.nil?
+
+      @message = body_attribute('errorMessage')
+      @error_type = body_attribute('errorType').to_i
+      api_model_errors = body_attribute('modelErrors')
+      return if api_model_errors.nil?
+
+      process_api_model_errors(api_model_errors)
+    end
+
+    def http_status
+      @response.status.to_i if @response
+    end
+
+    def http_body
+      @response.body if @response
+    end
+
+    def to_s
+      return @message if model_errors.nil?
+
+      summary = []
+      model_errors.each do |_key, value|
+        summary.push(value.join('; '))
+      end
+
+      @message + ' (' + summary.join('; ') + ')'
+    end
+
+    def message
+      @message || self.class.name
+    end
+
+    def parsed_body
+      @parsed_body ||= parse_body
+    end
+
+    protected
+
+    def parse_body
+      return unless @response.respond_to?('response_headers')
+      return unless @response.response_headers.include?('Content-Type')
+      return unless @response.response_headers['Content-Type'].include?('application/json')
+
+      ::JSON.parse(@response.body)
+    end
+
+    def body_attribute(attribute)
+      return nil if parsed_body.nil? || !parsed_body.include?(attribute)
+      parsed_body[attribute]
+    end
+
+    # Turn API model errors into a more ActiveRecord-like format
+    def process_api_model_errors(api_model_errors)
+      @model_errors = {}
+      api_model_errors.each do |api_model_error|
+        next unless api_model_error.is_a?(Hash)
+        field_name = api_model_error['fieldName'].underscore.to_sym
+        @model_errors[field_name] = [] if @model_errors[field_name].nil?
+        @model_errors[field_name].push(api_model_error['errorMessage'])
+      end
+    end
+  end
+
+  # Raised when API returns the HTTP status code 400
+  class BadRequest < APIError; end
+
+  # Raised when API returns the HTTP status code 401/403
+  class NotAuthorized < APIError
+    def message
+      'Authorization has been denied for this request'
+    end
+  end
+
+  # Raised when API returns the HTTP status code 404
+  class NotFound < APIError; end
+
+  # Raised when API returns the HTTP status code 409
+  class Conflict < APIError; end
+
+  # Raised when API returns the HTTP status code 500
+  class InternalServerError < APIError; end
+
+  # Raised when API returns the HTTP status code 502
+  class BadGateway < APIError; end
+
+  # Raised when API returns the HTTP status code 503
+  class ServiceUnavailable < APIError; end
+
+  # Raised when API returns the HTTP status code 504
+  class GatewayTimeout < APIError; end
+
+  # A validation error that hasn't reached the API
+  class ValidationError < StandardError
+    attr_accessor :errors, :message
+
+    def initialize(errors)
+      @errors = errors
+      @message = 'Missing required fields' + model_errors_summary
+    end
+
+    def to_s
+      @message
+    end
+
+    def model_errors
+      return if @errors.nil?
+      @errors.messages
+    end
+
+    protected
+
+    def model_errors_summary
+      summary = []
+      model_errors.each do |key, value|
+        summary.push(key.to_s + ' ' + value.join('; '))
+      end
+
+      ' (' + summary.join('; ') + ')'
+    end
+  end
+end

data/lib/judopay/mash.rb

@@ -0,0 +1,7 @@
+require 'hashie'
+require 'rash'
+
+module Judopay
+  class Mash < ::Hashie::Rash
+  end
+end

data/lib/judopay/model.rb

@@ -0,0 +1,109 @@
+require 'addressable/uri'
+require 'virtus'
+require 'active_model'
+require_relative 'core_ext/hash'
+require_relative 'error'
+
+module Judopay
+  # Base model for Judopay API model objects
+  class Model
+    send :include, Virtus.model
+    include ActiveModel::Validations
+    VALID_PAGING_OPTIONS = [:sort, :offset, :page_size]
+
+    class << self
+      @resource_path = nil
+      @valid_api_methods = []
+      attr_accessor :resource_path, :valid_api_methods
+    end
+
+    # List all records
+    #
+    # @param options [Hash] Paging options (sort, offset and page_size)
+    # @return [Judopay::Mash] Mash of the API response
+    def self.all(options = {})
+      check_api_method_is_supported(__method__)
+      api = Judopay::API.new
+      valid_options = self.valid_options(options).camel_case_keys!
+      uri = resource_path + '?' + valid_options.to_query_string
+      api.get(uri)
+    end
+
+    # Retrieve a specific record
+    #
+    # @param receipt_id [Integer] Paging options (sort, offset and page_size)
+    # @return [Judopay::Mash] Mash of the API response
+    def self.find(receipt_id)
+      check_api_method_is_supported(__method__)
+      api = Judopay::API.new
+      api.get(resource_path + receipt_id.to_i.to_s)
+    end
+
+    # Create a new record
+    #
+    # @return [Judopay::Mash] Mash of the API response
+    def create
+      check_api_method_is_supported(__method__)
+      check_judo_id
+      check_validation
+      api = Judopay::API.new
+      api.post(resource_path, self)
+    end
+
+    # Retrieve the current API resource path (e.g. /transactions/payments)
+    #
+    # @return [String] Resource path
+    def resource_path
+      self.class.resource_path
+    end
+
+    # Retrieve an array of valid API methods for the current model
+    # e.g [:find, :create]
+    #
+    # @return [Array<Symbol>] Valid API methods
+    def valid_api_methods
+      self.class.valid_api_methods
+    end
+
+    # Verify if an API method is supported for the current model
+    def check_api_method_is_supported(method)
+      self.class.check_api_method_is_supported(method)
+    end
+
+    # Use judo_id from configuration if it hasn't been explicitly set
+    def check_judo_id
+      return unless self.respond_to?('judo_id') && judo_id.nil?
+      self.judo_id = Judopay.configuration.judo_id
+    end
+
+    protected
+
+    # Has the pre-validation found any problems?
+    # We check the basics have been completed to avoid round trip to API
+    #
+    # @return nil
+    # @raise [Judopay::ValidationError] if there are validation errors on the model
+    def check_validation
+      fail Judopay::ValidationError, errors unless valid?
+    end
+
+    # Check if the specified API method is supported by the current model
+    #
+    # @raise [Judopay::Error] if the API method is not supported
+    def self.check_api_method_is_supported(method)
+      if valid_api_methods.nil? || !valid_api_methods.include?(method.to_sym)
+        fail Judopay::Error, 'API method not supported'
+      end
+    end
+
+    # Take an paging options hash and filter all but the valid keys
+    def self.valid_options(options)
+      valid_options = {}
+      options.each do |key, value|
+        next unless VALID_PAGING_OPTIONS.include?(key)
+        valid_options[key] = value
+      end
+      valid_options
+    end
+  end
+end

data/lib/judopay/models/card_address.rb

@@ -0,0 +1,11 @@
+require_relative '../model'
+
+module Judopay
+  class CardAddress < Model
+    attribute :line1, String
+    attribute :line2, String
+    attribute :line3, String
+    attribute :town, String
+    attribute :postcode, String
+  end
+end

data/lib/judopay/models/card_payment.rb

@@ -0,0 +1,39 @@
+require_relative '../model'
+require_relative 'payment'
+require_relative 'card_address'
+require_relative 'consumer_location'
+
+module Judopay
+  class CardPayment < Model
+    @resource_path = 'transactions/payments'
+    @valid_api_methods = [:create]
+
+    attribute :your_consumer_reference, String # required
+    attribute :your_payment_reference, String # required
+    attribute :your_payment_meta_data, Hash
+    attribute :judo_id, String # required
+    attribute :amount, Float # required
+    attribute :card_number, String # required for card transactions
+    attribute :expiry_date, String # required for card transactions
+    attribute :cv2, String  # required for card transactions
+    attribute :card_address, Judopay::CardAddress
+    attribute :consumer_location, Judopay::ConsumerLocation
+    attribute :mobile_number, String
+    attribute :email_address, String
+
+    validates_presence_of :your_consumer_reference,
+                          :your_payment_reference,
+                          :judo_id,
+                          :amount,
+                          :card_number,
+                          :expiry_date,
+                          :cv2
+
+    def validate
+      check_judo_id
+      check_validation
+      api = Judopay::API.new
+      api.post(resource_path + '/validate', self)
+    end
+  end
+end

data/lib/judopay/models/card_preauth.rb

@@ -0,0 +1,12 @@
+require_relative '../model'
+require_relative 'payment'
+require_relative 'card_address'
+require_relative 'consumer_location'
+
+module Judopay
+  # Inherit from CardPayment - attributes are identical
+  class CardPreauth < CardPayment
+    @resource_path = 'transactions/preauths'
+    @valid_api_methods = [:create]
+  end
+end

data/lib/judopay/models/collection.rb

@@ -0,0 +1,16 @@
+require_relative '../model'
+
+module Judopay
+  class Collection < Model
+    @resource_path = 'transactions/collections'
+    @valid_api_methods = [:all, :create]
+
+    attribute :receipt_id, Integer
+    attribute :amount, Float
+    attribute :your_payment_reference, String
+
+    validates_presence_of :receipt_id,
+                          :amount,
+                          :your_payment_reference
+  end
+end

data/lib/judopay/models/consumer_location.rb

@@ -0,0 +1,8 @@
+require_relative '../model'
+
+module Judopay
+  class ConsumerLocation < Model
+    attribute :latitude, Float
+    attribute :longitude, Float
+  end
+end

data/lib/judopay/models/market/collection.rb

@@ -0,0 +1,10 @@
+require_relative '../../model'
+
+module Judopay
+  module Market
+    class Collection < Judopay::Collection
+      @resource_path = 'market/transactions/collections'
+      @valid_api_methods = [:all, :create]
+    end
+  end
+end

data/lib/judopay/models/market/payment.rb

@@ -0,0 +1,10 @@
+require_relative '../../model'
+
+module Judopay
+  module Market
+    class Payment < Model
+      @resource_path = 'market/transactions/payments'
+      @valid_api_methods = [:all]
+    end
+  end
+end