global_collect 0.1.0

data/lib/global_collect/requests/set_payment.rb

@@ -0,0 +1,9 @@
+module GlobalCollect::Requests
+  class SetPayment < GlobalCollect::Requests::Composite
+    # WDL §5.33 requires a PAYMENT node and allows more optional nodes
+    def initialize(payment_and_builder, *extra_pairs)
+      all_pairs = [payment_and_builder] + extra_pairs
+      super("SET_PAYMENT", all_pairs)
+    end
+  end
+end

data/lib/global_collect/requests/simple.rb

@@ -0,0 +1,39 @@
+module GlobalCollect::Requests
+  class Simple < GlobalCollect::Requests::Base
+    
+    def initialize(action, fields_hash)
+      super(action)
+      @contents = fields_hash
+    end
+    
+    def to_xml
+      validate!
+      super do |params_node|
+        if wrapper
+          params_node.tag!(wrapper) {|wrapper_node| build_keys(wrapper_node) }
+        else
+          build_keys(params_node)
+        end
+      end
+    end
+    
+    protected
+    def fields; {}; end
+    
+    def wrapper; nil; end
+    
+    def validate!
+      fields.each do |key, validations|
+        validator = GlobalCollect::FieldValidator.new(*validations)
+        raise "Invalid field '#{key}'!" unless validator.validate(@contents[key])
+      end
+    end
+    
+    private
+    
+    def build_keys(node)
+      fields.keys.each {|key| node.tag!(key, @contents[key]) }
+    end
+    
+  end
+end

data/lib/global_collect/requests/test_connection.rb

@@ -0,0 +1,8 @@
+module GlobalCollect::Requests
+  class TestConnection < GlobalCollect::Requests::Simple
+    # WDL §5.36
+    def initialize
+      super("TEST_CONNECTION", {})
+    end
+  end
+end

data/lib/global_collect/responses/base.rb

@@ -0,0 +1,73 @@
+require 'time'
+
+module GlobalCollect::Responses
+  # WDL §4 specifies the generalized response
+  # This base class is sufficient for many responses that don't include anything
+  # more than the basic META, RESULT and/or ERROR nodes.
+  # It is also a useful fallback if you want basic hash access to the actual
+  # content of the response with just a few helper methods for traversal.
+  class Base
+    attr_reader :response_hash, :raw_response
+    def initialize(response_hash, raw_response)
+      @response_hash = response_hash
+      @raw_response  = raw_response
+    end
+    
+    def success?
+      RESPONSE_STATUS_SUCCESS[result]
+    end
+    
+    def action
+      request['ACTION']
+    end
+    
+    def response_datetime
+      Time.parse(meta['RESPONSEDATETIME']) if meta['RESPONSEDATETIME']
+    end
+    
+    def request_id
+      meta['REQUESTID']
+    end
+    
+    def version
+      meta['VERSION']
+    end
+    
+    def errors
+      return [] if success?
+      errs = response['ERROR'].is_a?(Array) ? response['ERROR'] : [response['ERROR']]
+      return errs.map{|err| RequestError.new(err['CODE'].to_i, err['MESSAGE']) }
+    end
+    
+    def malformed?
+      !response_hash['XML']
+    end
+    
+    protected
+
+    def result
+      response['RESULT']
+    end
+    
+    def meta
+      response['META']
+    end
+
+    # this structure is general to successful and unsuccessful response
+    def response
+      request['RESPONSE']
+    end
+    
+    def request
+      response_hash['XML']['REQUEST']
+    end
+    
+    private
+    
+    RESPONSE_STATUS_SUCCESS = {
+      'OK'  => true,
+      'NOK' => false
+    }
+    class RequestError < Struct.new(:code, :message); end
+  end
+end

data/lib/global_collect/responses/convert_amount/response_methods.rb

@@ -0,0 +1,8 @@
+module GlobalCollect::Responses::ConvertAmount
+  # WDL §5.7.2 specifies the possible return keys
+  module ResponseMethods
+    def converted_amount
+      row["CONVERTEDAMOUNT"]
+    end
+  end
+end

data/lib/global_collect/responses/do_refund/response_methods.rb

@@ -0,0 +1,24 @@
+module GlobalCollect::Responses::DoRefund
+  # WDL §5.16.2 specifies the possible return keys
+  module ResponseMethods
+    [
+      "MERCHANT ID"          ,
+      "ORDER ID"             ,
+      "EFFORT ID"            ,
+      "ATTEMPT ID"           ,
+      "STATUS ID"            ,
+      "STATUS DATE"          ,
+      "PAYMENT REFERENCE"    ,
+      "ADDITIONAL REFERENCE" ,
+      "EXTERNAL REFERENCE"
+    ].each do |meth|
+      define_method meth.downcase.gsub(/\s+/, "_") do
+        row[meth.gsub(/\s+/, "")]
+      end
+    end
+    
+    def payment_status
+      GlobalCollect::Const::PaymentStatus.from_code(status_id)
+    end
+  end
+end

data/lib/global_collect/responses/get_order_status/v1_response_methods.rb

@@ -0,0 +1,49 @@
+module GlobalCollect::Responses::GetOrderStatus
+  # WDL §5.23.2 specifies the possible return keys
+  module V1ResponseMethods
+    
+    def statuses
+      row_hashes.map{|row_hash| OrderStatus.new(row_hash) }
+    end
+    
+    private
+    
+    def row_hashes
+      response['ROW'].is_a?(Array) ? response['ROW'] : [response['ROW']]
+    end
+    
+    class OrderStatus < Struct.new(:row_hash)
+      [
+        "MERCHANT ID"           ,
+        "ORDER ID"              ,
+        "EFFORT ID"             ,
+        "ATTEMPT ID"            ,
+        "PAYMENT REFERENCE"     ,
+        "MERCHANT REFERENCE"    ,
+        "STATUS ID"             ,
+        "STATUS DATE"           ,
+        "AMOUNT"                ,
+        "CURRENCY CODE"         ,
+        "PAYMENT METHOD ID"     ,
+        "PAYMENT PRODUCT ID"    
+      ].each do |meth|
+        define_method meth.downcase.gsub(/\s+/, "_") do
+          row_hash[meth.gsub(/\s+/, "")]
+        end
+      end
+      
+      def payment_status
+        GlobalCollect::Const::PaymentStatus.from_code(status_id)
+      end
+     
+      # NOTE: these error fields correspond to the potential errors on the order
+      # or payment, not on this response.
+      # Those can be found in the #error object of the response.
+      def errors
+        return [] unless row_hash['ERRORNUMBER'] || row_hash['ERRORMESSAGE']
+        [OrderStatusError.new(row_hash['ERRORNUMBER'].to_i, row_hash['ERRORMESSAGE'])]
+      end
+    end
+    class OrderStatusError < Struct.new(:code, :message); end
+  end
+end

data/lib/global_collect/responses/get_order_status/v2_response_methods.rb

@@ -0,0 +1,67 @@
+module GlobalCollect::Responses::GetOrderStatus
+  # WDL §5.23.3 specifies the possible return keys
+  module V2ResponseMethods
+    
+    def statuses
+      status_hashes.map{|status_hash| OrderStatus.new(status_hash) }
+    end
+    
+    private
+    
+    def status_hashes
+      response['STATUS'].is_a?(Array) ? response['STATUS'] : [response['STATUS']]
+    end
+    
+    class OrderStatus < Struct.new(:status_hash)
+      [
+        "MERCHANT ID"           ,
+        "ORDER ID"              ,
+        "EFFORT ID"             ,
+        "ATTEMPT ID"            ,
+        "PAYMENT METHOD ID"     ,
+        "PAYMENT PRODUCT ID"    ,
+        "PAYMENT REFERENCE"     ,
+        "MERCHANT REFERENCE"    ,
+        "STATUS ID"             ,
+        "STATUS DATE"           ,
+        "CURRENCY CODE"         ,
+        "AMOUNT"                ,
+        "TOTAL AMOUNT PAID"     ,
+        "TOTAL AMOUNT REFUNDED" ,
+        "FRAUD RESULT"          ,
+        "FRAUD CODE"            ,
+        "FRAUD NEURAL"          ,
+        "FRAUD RCF"             ,
+        "AVS RESULT"            ,
+        "CVV RESULT"            ,
+        "AUTHORISATION CODE"    ,
+        "ECI"                   ,
+        "CAVV"                  ,
+        "XID"
+      ].each do |meth|
+        define_method meth.downcase.gsub(/\s+/, "_") do
+          status_hash[meth.gsub(/\s+/, "")]
+        end
+      end
+      
+      def payment_status
+        GlobalCollect::Const::PaymentStatus.from_code(status_id)
+      end
+      
+      def payment_product
+        GlobalCollect::Const::PaymentProduct.from_code(payment_product_id)
+      end
+     
+      # NOTE: these error fields correspond to the potential errors on the order
+      # or payment, not on this response.
+      # Those can be found in the #error object of the response.
+      def errors
+        return [] unless status_hash['ERRORS']
+        errs = status_hash['ERRORS']['ERROR'].is_a?(Array) ? status_hash['ERRORS']['ERROR'] : [status_hash['ERRORS']['ERROR']]
+        errs.map{|err| OrderStatusError.new(err['CODE'].to_i, err['MESSAGE']) }
+      end
+    end
+    class OrderStatusError < Struct.new(:code, :message); end
+  end
+end
+

data/lib/global_collect/responses/insert_order_with_payment/credit_card_online_payment_response_methods.rb

@@ -0,0 +1,31 @@
+module GlobalCollect::Responses::InsertOrderWithPayment
+  # WDL §5.28.2 TABLE 115 specifies the possible return keys
+  module CreditCardOnlinePaymentResponseMethods
+    [
+      "PAYMENT REFERENCE"    ,
+      "ADDITIONAL REFERENCE" ,
+      "EXTERNAL REFERENCE"   ,
+      "ORDER ID"             ,
+      "STATUS ID"            ,
+      "EFFORT ID"            ,
+      "MERCHANT ID"          ,
+      "ATTEMPT ID"           ,
+      "STATUS DATE"          ,
+      "AVS RESULT"           ,
+      "CVV RESULT"           ,
+      "FRAUD RESULT"         ,
+      "FRAUD CODE"           ,
+      "FRAUD NEURAL"         ,
+      "FRAUD RCF"            ,
+      "AUTHORISATION CODE"
+    ].each do |meth|
+      define_method meth.downcase.gsub(/\s+/, "_") do
+        row[meth.gsub(/\s+/, "")]
+      end
+    end
+    
+    def payment_status
+      GlobalCollect::Const::PaymentStatus.from_code(status_id)
+    end
+  end
+end

data/lib/global_collect/responses/insert_order_with_payment/hosted_merchant_link_payment_response_methods.rb

@@ -0,0 +1,16 @@
+module GlobalCollect::Responses::InsertOrderWithPayment
+  # WDL §5.28.2 TABLE 125 specifies the possible return keys
+  module HostedMerchantLinkPaymentResponseMethods
+    [
+      "FORM METHOD"  ,
+      "FORM ACTION"  ,
+      "REF"          ,
+      "MAC"          ,
+      "RETURN MAC"
+    ].each do |meth|
+      define_method meth.downcase.gsub(/\s+/, "_") do
+        row[meth.gsub(/\s+/, "")]
+      end
+    end
+  end
+end

data/lib/global_collect/responses/success_row.rb

@@ -0,0 +1,15 @@
+module GlobalCollect::Responses
+  # This is one of the classes of response that you can get from the API, which
+  # if successful returns a structure like:
+  # <RESPONSE>
+  #     <META>...</META>
+  #     <RESULT>...</RESULT>
+  #     <ROW> RELEVANT NODES HERE </ROW>
+  # </RESPONSE>
+  module SuccessRow
+    def row
+      return nil unless success?
+      response['ROW']
+    end
+  end
+end

data/lib/global_collect.rb

@@ -0,0 +1,81 @@
+require 'builder'
+require 'httparty'
+require 'find'
+require 'logger'
+require 'benchmark'
+
+module GlobalCollect;end
+module GlobalCollect::Builders;end
+module GlobalCollect::RequestModels;end
+module GlobalCollect::Responses;end
+
+lib_dir = File.dirname(__FILE__)
+[
+  %w[api_client]                                                                       ,
+  %w[builders do_refund payment]                                                       ,
+  %w[builders do_refund credit_card_payment]                                           ,
+  %w[builders insert_order_with_payment order]                                         ,
+  %w[builders insert_order_with_payment payment]                                       ,
+  %w[builders insert_order_with_payment credit_card_online_payment]                    ,
+  %w[builders insert_order_with_payment hosted_credit_card_online_payment]             ,
+  %w[builders set_payment payment]                                                     ,
+  %w[const payment_product]                                                            ,
+  %w[const payment_status]                                                             ,
+  %w[field_validator]                                                                  ,
+  %w[request_models base]                                                              ,
+  %w[request_models insert_order_with_payment order]                                   ,
+  %w[request_models insert_order_with_payment payment]                                 ,
+  %w[request_models insert_order_with_payment credit_card_online_payment]              ,
+  %w[request_models insert_order_with_payment hosted_credit_card_online_payment]       ,
+  %w[request_models do_refund payment]                                                 ,
+  %w[request_models do_refund credit_card_payment]                                     ,
+  %w[request_models set_payment payment]                                               ,
+  %w[requests base]                                                                    ,
+  %w[requests simple]                                                                  ,
+  %w[requests composite]                                                               ,
+  %w[requests insert_order_with_payment]                                               ,
+  %w[requests get_order_status]                                                        ,
+  %w[requests test_connection]                                                         ,
+  %w[requests do_refund]                                                               ,
+  %w[requests set_payment]                                                             ,
+  %w[requests cancel_payment]                                                          ,
+  %w[requests process_challenged]                                                      ,
+  %w[requests convert_amount]                                                          ,
+  %w[responses base]                                                                   ,
+  %w[responses success_row]                                                            ,
+  %w[responses insert_order_with_payment credit_card_online_payment_response_methods]  ,
+  %w[responses insert_order_with_payment hosted_merchant_link_payment_response_methods],
+  %w[responses do_refund response_methods]                                             ,
+  %w[responses get_order_status v1_response_methods]                                   ,
+  %w[responses get_order_status v2_response_methods]                                   ,
+  %w[responses convert_amount response_methods]
+
+].each do |f|
+  require File.join(lib_dir, 'global_collect', *f)
+end
+
+module GlobalCollect
+  extend self
+  
+  attr_accessor :merchant_id
+  attr_accessor :authentication_scheme
+  attr_accessor :ip_address # only used if authentication_scheme is :ip_check
+  attr_accessor :environment
+  attr_accessor :default_api_version
+  attr_accessor :wire_log_file
+  attr_accessor :wire_logger
+
+  def merchant_link_client
+    GlobalCollect::ApiClient.new(:merchant_link, environment, authentication_scheme)
+  end
+  
+  def wire_logger
+    @wire_logger ||= if self.wire_log_file
+      Logger.new(self.wire_log_file)
+    else
+      Logger.new(STDOUT)
+    end
+  end
+end
+
+GlobalCollect.default_api_version ||= "1.0"

data/spec/api_client_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+module TestResponseMethods
+  def foobar;end
+end
+
+describe 'the api client' do
+  it "should not accept an invalid environment" do
+    lambda {
+      GlobalCollect::ApiClient.new(:merchant_link, :foo, :ip_check)
+    }.should raise_error(ArgumentError)
+  end
+  it "should not accept an invalid service" do
+    lambda {
+      GlobalCollect::ApiClient.new(:foo, :test, :ip_check)
+    }.should raise_error(ArgumentError)
+  end
+  it "should not accept an invalid auth scheme" do
+    lambda {
+      GlobalCollect::ApiClient.new(:merchant_link, :test, :foo)
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should post to the correct url" do
+    FakeWeb.register_uri(:post, "https://ps.gcsip.nl/wdl/wdl", :body => read_canned_response('successful_iowp_response.xml'))
+    client = GlobalCollect::ApiClient.new(:merchant_link, :test, :ip_check)
+    
+    request = mock(
+      :action => 'foo',
+      :version => '1.0',
+      :to_xml => "<XML></XML>",
+      :suggested_response_mixins => []
+    )
+    response = client.make_request(request)
+    response.success?.should == true
+  end
+  
+  it "should mix in the proper mixins to the response by default" do
+    FakeWeb.register_uri(:post, "https://ps.gcsip.nl/wdl/wdl", :body => read_canned_response('successful_iowp_response.xml'))
+    client = GlobalCollect::ApiClient.new(:merchant_link, :test, :ip_check)
+    
+    request = mock(
+      :action => 'foo',
+      :version => '1.0',
+      :to_xml => "<XML></XML>",
+      :suggested_response_mixins => [TestResponseMethods]
+    )
+    response = client.make_request(request)
+    lambda { response.foobar }.should_not raise_error
+  end
+  
+  it "should not mix in anything if directed not to" do
+    FakeWeb.register_uri(:post, "https://ps.gcsip.nl/wdl/wdl", :body => read_canned_response('successful_iowp_response.xml'))
+    client = GlobalCollect::ApiClient.new(:merchant_link, :test, :ip_check)
+    
+    request = mock(
+      :action => 'foo',
+      :version => '1.0',
+      :to_xml => "<XML></XML>",
+      :suggested_response_mixins => [TestResponseMethods]
+    )
+    response = client.make_request(request, false)
+    lambda { response.foobar }.should raise_error(NoMethodError)
+  end
+  
+  it "should error on no response" do
+    FakeWeb.register_uri(:post, "https://ps.gcsip.nl/wdl/wdl", :body => read_canned_response('successful_iowp_response.xml'))
+    client = GlobalCollect::ApiClient.new(:merchant_link, :test, :ip_check)
+    client.class.should_receive(:post).and_return(nil)
+    request = mock(
+      :action => 'foo',
+      :version => '1.0',
+      :to_xml => "<XML></XML>",
+      :suggested_response_mixins => []
+    )
+    lambda { client.make_request(request) }.should raise_error(Exception, /No response/)
+  end
+  
+  it "should error on a malformed response" do
+    FakeWeb.register_uri(:post, "https://ps.gcsip.nl/wdl/wdl", :body => read_canned_response('successful_iowp_response.xml'))
+    client = GlobalCollect::ApiClient.new(:merchant_link, :test, :ip_check)
+    response = mock(:response, :body => "Foo bar", :code => "200", :delegate => {})
+    client.class.should_receive(:post).and_return(response)
+    
+    request = mock(
+      :action => 'foo',
+      :version => '1.0',
+      :to_xml => "<XML></XML>",
+      :suggested_response_mixins => []
+    )
+    lambda { client.make_request(request) }.should raise_error(Exception, /Malformed/)
+  end
+end