spreedly 1.4.0 → 2.0.0

data/lib/spreedly/environment.rb

@@ -0,0 +1,176 @@
+require 'base64'
+require 'nokogiri'
+
+module Spreedly
+  class Environment
+
+    include SslRequester
+    include Urls
+
+    attr_reader :key, :currency_code
+
+    def initialize(environment_key, access_secret, options={})
+      @key, @access_secret = environment_key, access_secret
+      @currency_code = options[:currency_code] || 'USD'
+    end
+
+    def transparent_redirect_form_action
+      "#{base_url}/v1/payment_methods"
+    end
+
+    def find_payment_method(token)
+      xml_doc = ssl_get(find_payment_method_url(token), headers)
+      PaymentMethod.new_from(xml_doc)
+    end
+
+    def find_transaction(token)
+      xml_doc = ssl_get(find_transaction_url(token), headers)
+      Transaction.new_from(xml_doc)
+    end
+
+    def find_gateway(token)
+      xml_doc = ssl_get(find_gateway_url(token), headers)
+      Gateway.new(xml_doc)
+    end
+
+    def purchase_on_gateway(gateway_token, payment_method_token, amount, options = {})
+      body = auth_purchase_body(amount, payment_method_token, options)
+      api_post(purchase_url(gateway_token), body)
+    end
+
+    def authorize_on_gateway(gateway_token, payment_method_token, amount, options = {})
+      body = auth_purchase_body(amount, payment_method_token, options)
+      api_post(authorize_url(gateway_token), body)
+    end
+
+    def capture_transaction(authorization_token, options = {})
+      api_post(capture_url(authorization_token), capture_body(options))
+    end
+
+    def void_transaction(token, options = {})
+      api_post(void_transaction_url(token), void_body(options))
+    end
+
+    def refund_transaction(token, options = {})
+      api_post(refund_transaction_url(token), refund_body(options))
+    end
+
+    def retain_payment_method(payment_method_token)
+      xml_doc = ssl_put(retain_payment_method_url(payment_method_token), '', headers)
+      Transaction.new_from(xml_doc)
+    end
+
+    def redact_payment_method(payment_method_token, options = {})
+      body = redact_payment_method_body(options)
+      xml_doc = ssl_put(redact_payment_method_url(payment_method_token), body, headers)
+      Transaction.new_from(xml_doc)
+    end
+
+    def list_transactions(since_token = nil)
+      xml_doc = ssl_get(list_transactions_url(since_token), headers)
+      Transaction.new_list_from(xml_doc)
+    end
+
+    def add_gateway(gateway_type, options = {})
+      body = add_gateway_body(gateway_type, options)
+      xml_doc = ssl_post(add_gateway_url, body, headers)
+      Gateway.new(xml_doc)
+    end
+
+    def add_credit_card(options)
+      api_post(add_payment_method_url, add_credit_card_body(options))
+    end
+
+    private
+    def headers
+      {
+        'Authorization' => ('Basic ' + Base64.strict_encode64("#{@key}:#{@access_secret}").chomp),
+        'Content-Type' => 'text/xml'
+      }
+    end
+
+    def auth_purchase_body(amount, payment_method_token, options)
+      build_xml_request('transaction') do |doc|
+        doc.amount amount
+        doc.currency_code(options[:currency_code] || currency_code)
+        doc.payment_method_token(payment_method_token)
+        add_to_doc(doc, options, :retain_on_success)
+        add_extra_options_for_basic_ops(doc, options)
+      end
+    end
+
+    def capture_body(options)
+      return '' if options.empty?
+
+      build_xml_request('transaction') do |doc|
+        add_to_doc(doc, options, :amount, :currency_code)
+        add_extra_options_for_basic_ops(doc, options)
+      end
+    end
+
+    def void_body(options)
+      return '' if options.empty?
+
+      build_xml_request('transaction') do |doc|
+        add_extra_options_for_basic_ops(doc, options)
+      end
+    end
+
+    def refund_body(options)
+      return '' if options.empty?
+
+      build_xml_request('transaction') do |doc|
+        add_to_doc(doc, options, :amount, :currency_code)
+        add_extra_options_for_basic_ops(doc, options)
+      end
+    end
+
+    def redact_payment_method_body(options)
+      return '' if options.empty?
+      build_xml_request('transaction') do |doc|
+        add_to_doc(doc, options, :remove_from_gateway)
+      end
+    end
+
+    def add_gateway_body(gateway_type, options)
+      build_xml_request('gateway') do |doc|
+        doc.gateway_type gateway_type
+      end
+    end
+
+    def add_credit_card_body(options)
+      build_xml_request('payment_method') do |doc|
+        add_to_doc(doc, options, :data, :retained, :email)
+        doc.credit_card do
+          add_to_doc(doc, options, :number, :month, :first_name, :last_name, :year,
+                     :address1, :address2, :city, :state, :zip, :country, :phone_number)
+        end
+      end
+    end
+
+    def add_to_doc(doc, options, *attributes)
+      attributes.each do |attr|
+        doc.send(attr, options[attr.to_sym]) if options[attr.to_sym]
+      end
+    end
+
+    def add_extra_options_for_basic_ops(doc, options)
+      add_to_doc(doc, options, :order_id, :description, :ip, :merchant_name_descriptor,
+                               :merchant_location_descriptor)
+    end
+
+    def build_xml_request(root)
+      builder = Nokogiri::XML::Builder.new
+      builder.__send__(root) do |doc|
+        yield(doc)
+      end
+      builder.to_xml
+    end
+
+    def api_post(url, body)
+      xml_doc = ssl_post(url, body, headers)
+      Transaction.new_from(xml_doc)
+    end
+
+  end
+end

data/lib/spreedly/error.rb

@@ -0,0 +1,50 @@
+module Spreedly
+  class Error < StandardError
+  end
+
+  class XmlErrorsList < Error
+    attr_reader :errors
+    include ErrorsParser
+
+    def initialize(xml_doc)
+      @errors = errors_from(xml_doc)
+    end
+
+    def message
+      @errors.map { |each| each[:message] }.join("\n")
+    end
+  end
+
+  class AuthenticationError < XmlErrorsList
+  end
+
+  class NotFoundError < XmlErrorsList
+  end
+
+  class TransactionCreationError < XmlErrorsList
+  end
+
+  class PaymentRequiredError < XmlErrorsList
+  end
+
+  class TimeoutError < Error
+    def initialize(message = "The payment system is not responding.")
+      super
+    end
+  end
+
+  class UnexpectedResponseError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+end
+
+

data/lib/spreedly/gateway.rb

@@ -0,0 +1,10 @@
+
+module Spreedly
+
+  class Gateway < Model
+
+    field :gateway_type, :state, :name
+
+  end
+
+end

data/lib/spreedly/model.rb

@@ -0,0 +1,17 @@
+
+module Spreedly
+
+  class Model
+
+    include Fields
+
+    field :token
+    field :created_at, :updated_at, type: :date_time
+
+    def initialize(xml_doc)
+      initialize_fields(xml_doc)
+    end
+
+  end
+
+end

data/lib/spreedly/payment_methods/credit_card.rb

@@ -0,0 +1,9 @@
+module Spreedly
+
+  class CreditCard < PaymentMethod
+    field :first_name, :last_name, :full_name, :month, :year
+    field :number, :last_four_digits, :card_type, :verification_value
+    field :address1, :address2, :city, :state, :zip, :country, :phone_number
+  end
+
+end

data/lib/spreedly/payment_methods/payment_method.rb

@@ -0,0 +1,34 @@
+require 'time'
+
+module Spreedly
+
+  class PaymentMethod < Model
+
+    include ErrorsParser
+
+    field :email, :storage_state, :data
+    attr_reader :errors
+
+    def initialize(xml_doc)
+      super
+      @errors = errors_from(xml_doc)
+    end
+
+    def self.new_from(xml_doc)
+      case xml_doc.at_xpath('.//payment_method_type').inner_text
+      when 'credit_card'
+        return CreditCard.new(xml_doc)
+      when 'paypal'
+        return Paypal.new(xml_doc)
+      when 'sprel'
+        return Sprel.new(xml_doc)
+      end
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+  end
+
+end

data/lib/spreedly/payment_methods/paypal.rb

@@ -0,0 +1,7 @@
+module Spreedly
+
+  class Paypal < PaymentMethod
+
+  end
+
+end

data/lib/spreedly/payment_methods/sprel.rb

@@ -0,0 +1,7 @@
+module Spreedly
+
+  class Sprel < PaymentMethod
+
+  end
+
+end

data/lib/spreedly/ssl_requester.rb

@@ -0,0 +1,65 @@
+module Spreedly
+
+  module SslRequester
+
+    def ssl_get(endpoint, headers = {})
+      ssl_request(:get, endpoint, nil, headers)
+    end
+
+    def ssl_post(endpoint, body, headers = {})
+      ssl_request(:post, endpoint, body, headers)
+    end
+
+    def ssl_put(endpoint, body, headers = {})
+      ssl_request(:put, endpoint, body, headers)
+    end
+
+    private
+    def ssl_request(method, endpoint, body, headers)
+      raw_response = Timeout::timeout(70) do
+        raw_ssl_request(method, endpoint, body, headers)
+      end
+
+      show_raw_response(raw_response)
+      handle_response(raw_response)
+
+    rescue Timeout::Error => e
+      raise Spreedly::TimeoutError.new
+    end
+
+    def raw_ssl_request(method, endpoint, body, headers = {})
+      connection = Spreedly::Connection.new(endpoint)
+      connection.request(method, body, headers)
+    end
+
+    def handle_response(response)
+      xml_doc = Nokogiri::XML(response.body)
+
+      case response.code.to_i
+      when 200...300
+        xml_doc
+      when 401
+        raise AuthenticationError.new(xml_doc)
+      when 404
+        raise NotFoundError.new(xml_doc)
+      when 402
+        raise PaymentRequiredError.new(xml_doc)
+      when 422
+        if xml_doc.at_xpath('.//errors/error')
+          raise TransactionCreationError.new(xml_doc)
+        else
+          xml_doc
+        end
+      else
+        raise UnexpectedResponseError.new(response)
+      end
+    end
+
+    def show_raw_response(raw_response)
+      return unless ENV['SHOW_RAW_RESPONSE'] == 'true'
+      puts "\nraw_response.code: #{raw_response.code}\nraw_response.body:\n#{raw_response.body}"
+    end
+
+  end
+
+end

data/lib/spreedly/transactions/add_payment_method.rb

@@ -0,0 +1,16 @@
+module Spreedly
+
+  class AddPaymentMethod < Transaction
+
+    field :retained, type: :boolean
+
+    attr_reader :payment_method
+
+    def initialize(xml_doc)
+      super
+      @payment_method = PaymentMethod.new_from(xml_doc.at_xpath('.//payment_method'))
+    end
+
+  end
+
+end

data/lib/spreedly/transactions/auth_purchase.rb

@@ -0,0 +1,17 @@
+module Spreedly
+
+  class AuthPurchase < GatewayTransaction
+
+    field :currency_code
+    field :amount, type: :integer
+
+    attr_reader :payment_method
+
+    def initialize(xml_doc)
+      super
+      @payment_method = PaymentMethod.new_from(xml_doc.at_xpath('.//payment_method'))
+    end
+
+  end
+
+end

data/lib/spreedly/transactions/authorization.rb

@@ -0,0 +1,7 @@
+module Spreedly
+
+  class Authorization < AuthPurchase
+
+  end
+
+end

data/lib/spreedly/transactions/capture.rb

@@ -0,0 +1,14 @@
+module Spreedly
+
+  class Capture < GatewayTransaction
+
+    field :currency_code, :reference_token
+    field :amount, type: :integer
+
+    def initialize(xml_doc)
+      super
+    end
+
+  end
+
+end