vaulted_billing 1.0.2 → 1.1.0

data/lib/vaulted_billing/gateways/ipcommerce.rb

@@ -0,0 +1,372 @@
+require 'multi_json'
+require 'multi_xml'
+require 'net/http'
+
+module VaultedBilling
+  module Gateways
+    ##
+    # Interface to IPCommerce.
+    #
+    # == Example
+    #
+    #   VaultedBilling::Gateways::IPCommerce.new(:username => 'identity-token', :service_key_store => XXX).tap do |ipc|
+    #     customer = ipc.add_customer(Customer.new)
+    #     credit_card = ipc.add_credit_card(customer, CreditCard.new)
+    #     ipc.purchase(customer, credit_card, 10.00)
+    #   end
+    #
+    class Ipcommerce
+      include VaultedBilling::Gateway
+
+      Companies = {
+        2 => /^4\d{12}(\d{3})?$/, # Visa
+        3 => /^(5[1-5]\d{4}|677189)\d{10}$/, # MasterCard
+        4 => /^3[47]\d{13}$/, # American Express
+        5 => /^3(0[0-5]|[68]\d)\d{11}$/, # Diners Club
+        6 => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/, # Discover
+        7 => /^35(28|29|[3-8]\d)\d{12}$/ # JCB
+      }.freeze
+
+      class ServiceKeyStore
+        UnavailableKeyError = Class.new(VaultedBilling::CredentialError)
+        
+        attr_reader :identity_token
+
+        def initialize(identity_token)
+          @identity_token = identity_token
+          @expires_at = nil
+        end
+
+        def key
+          renew! unless valid?
+          read_key || raise(UnavailableKeyError, 'A service key could not be retrieved for this session.')
+        end
+
+        def read_key
+          @key
+        end
+
+        def store_key(key)
+          @key = key
+        end
+
+        def valid?
+          @expires_at && (@expires_at > Time.now + 5.minutes)
+        end
+
+        def before_request(request)
+          request.delete "accept"
+        end
+
+        def renew!
+          @expires_at = Time.now + 30.minutes
+          @key = http.get.body.try(:[], 1...-1)
+        end
+        
+        private
+        def http
+          @request ||= begin
+            urls = ["https://cws-01.cert.ipcommerce.com/REST/2.0.15/SvcInfo/token",
+                    "https://cws-02.cert.ipcommerce.com/REST/2.0.15/SvcInfo/token"]
+            VaultedBilling::HTTP.new(self, urls, {
+              :headers => {'Content-Type' => 'application/json'},
+              :before_request => :before_request,
+              :basic_auth => [@identity_token, ""]
+            })
+          end
+        end
+      end
+
+      attr_reader :service_key_store
+
+      def initialize(options = {})
+        @identity_token = options[:username] || VaultedBilling.config.ipcommerce.username
+        @raw_options = options[:raw_options] || VaultedBilling.config.ipcommerce.raw_options
+        @test_mode = options.has_key?(:test) ? options[:test] : (VaultedBilling.config.ipcommerce.test_mode || VaultedBilling.config.test_mode)
+        @application_id = options[:application_id] || @raw_options["application_id"]
+        @service_id = options[:service_id] || @raw_options["service_id"]
+        @service_key_store = options[:service_key_store] || ServiceKeyStore.new(@identity_token)
+      end
+
+
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      def add_customer(customer)
+        respond_with customer.to_vaulted_billing
+      end
+
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      #--
+      # TODO: If necessary, this may be implemented by Authorizing the given card for $1.00, then voiding immediately.
+      #++
+      # 
+      def add_customer_credit_card(customer, credit_card)
+        respond_with credit_card.to_vaulted_billing
+      end
+
+      def authorize(customer, credit_card, amount, options = {})
+        data = {
+          "__type" => "AuthorizeTransaction:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest",
+          :ApplicationProfileId => @application_id,
+          :MerchantProfileId => options[:merchant_profile_id],
+          :Transaction => {
+            :"__type" => "BankcardTransaction:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard",
+            :TransactionData => {
+              :Amount => "%.2f" % amount,
+              :CurrencyCode => 4,
+              :TransactionDateTime => Time.now.xmlschema,
+              :CustomerPresent => 0,
+              :EntryMode => 1,
+              :GoodsType => 0,
+              :IndustryType => 2,
+              :SignatureCaptured => false,
+              :OrderNumber => options[:order_id] || generate_order_number
+            },
+            :TenderData => {
+              :CardData => {
+                :CardholderName => nil,
+                :CardType => self.class.credit_card_type_id(credit_card.card_number),
+                :Expire => credit_card.expires_on.try(:strftime, "%m%y"),
+                :PAN => credit_card.card_number
+              }
+            }
+          }
+        }
+        
+        response = http(options[:workflow_id] || @service_id).post(data)
+        transaction = new_transaction_from_response(response) 
+        respond_with(transaction,
+                     response,
+                     :success => (transaction.code == 1))
+      end
+
+      def capture(transaction_id, amount, options = {})
+        data = {
+          :"__type" => "Capture:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest",
+          :ApplicationProfileId => @application_id,
+          :DifferenceData => {
+            :"__type" => "BankcardCapture:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard",
+            :TransactionId => transaction_id,
+            :Addendum => nil,
+            :Amount => "%.2f" % amount
+          }
+        }
+        
+        response = http(options[:workflow_id] || @service_id, transaction_id).put(data)
+        transaction = new_transaction_from_response(response)
+        respond_with(transaction,
+                     response,
+                     :success => (transaction.code == 1))
+      end
+
+      def purchase(customer, credit_card, amount, options = {})
+        data = {
+          "__type" => "AuthorizeAndCaptureTransaction:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest",
+          :ApplicationProfileId => @application_id,
+          :MerchantProfileId => options[:merchant_profile_id],
+          :Transaction => {
+            :"__type" => "BankcardTransaction:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard",
+            :TransactionData => {
+              :Amount => "%.2f" % amount,
+              :CurrencyCode => 4,
+              :TransactionDateTime => Time.now.xmlschema,
+              :CustomerPresent => 0,
+              :EmployeeId => options[:employee_id],
+              :EntryMode => 1,
+              :GoodsType => 0,
+              :IndustryType => 2,
+              :OrderNumber => options[:order_id] || generate_order_number,
+              :SignatureCaptured => false
+            },
+            :TenderData => {
+              :CardData => {
+                :CardholderName => nil,
+                :CardType => self.class.credit_card_type_id(credit_card.card_number),
+                :Expire => credit_card.expires_on.try(:strftime, "%m%y"),
+                :PAN => credit_card.card_number
+              }
+            }
+          }
+        }
+        response = http(options[:workflow_id] || @service_id).post(data)
+        transaction = new_transaction_from_response(response)
+        respond_with(transaction,
+                     response,
+                     :success => (transaction.code == 1))
+      end
+
+      def refund(transaction_id, amount, options = {})
+        data = {
+          :"__type" => "ReturnById:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest",
+          :ApplicationProfileId => @application_id,
+          :MerchantProfileId => options[:merchant_profile_id],
+          :DifferenceData => {
+            :"__type" => "BankcardReturn:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard",
+            :TransactionId => transaction_id,
+            :Addendum => nil,
+            :Amount => "%.2f" % amount
+          }
+        }
+        
+        response = http(options[:workflow_id] || @service_id).post(data)
+        transaction = new_transaction_from_response(response)
+        respond_with(transaction,
+                     response,
+                     :success => (transaction.code == 1))
+      end
+      
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      def remove_customer(customer)
+        respond_with customer.to_vaulted_billing
+      end
+
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      def remove_customer_credit_card(customer, credit_card)
+        respond_with credit_card.to_vaulted_billing
+      end
+
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      def update_customer(customer)
+        respond_with customer.to_vaulted_billing
+      end
+
+      ##
+      # A stub, since the IP Commerce only generates tokens during
+      # successful authorization transactions.
+      #
+      def update_customer_credit_card(customer, credit_card)
+        respond_with credit_card.to_vaulted_billing
+      end
+    
+      def void(transaction_id, options = {})
+        data = {
+          :"__type" => "Undo:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest",
+          :ApplicationProfileId => @application_id,
+          :DifferenceData => {
+            :"__type" => "BankcardUndo:http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard",
+            :TransactionId => transaction_id,
+            :Addendum => nil
+          }
+        }
+
+        response = http(options[:workflow_id] || @service_id, transaction_id).put(data)
+        transaction = new_transaction_from_response(response)
+        respond_with(transaction,
+                     response,
+                     :success => (transaction.code == 1))
+      end
+
+
+      private
+
+
+      ##
+      # Returns the name of the card company based on the given number, or
+      # nil if it is unrecognized.
+      #
+      # This was heavily lifted from ActiveMerchant.
+      #
+      def self.credit_card_type_id(number)
+        Companies.each do |company, pattern|
+          return company if number =~ pattern
+        end
+        return 1
+      end
+
+
+      def generate_order_number
+        (Time.now.to_f * 100000).to_i.to_s(36) + rand(60000000).to_s(36)
+      end
+
+      def http(*params)
+        urls = %W(
+          https://cws-01.cert.ipcommerce.com/REST/2.0.15/Txn/#{params.join('/')}
+          https://cws-02.cert.ipcommerce.com/REST/2.0.15/Txn/#{params.join('/')}
+        )
+        VaultedBilling::HTTP.new(self, urls, {
+          :headers => { 'Content-Type' => 'application/json' },
+          :before_request => :before_request,
+          :basic_auth => [@service_key_store.key, ""],
+          :on_success => :on_success
+        })
+      end
+      
+      def before_request(request)
+        request.body = MultiJson.encode(request.body)
+        # request.delete "accept"
+      end
+      
+      def on_success(response)
+        response.body = decode_body(response.body) || {}
+        response.success = [1, 2].include?(response.body['Status'])
+      end
+      
+      def decode_body(string)
+        MultiJson.decode(string)
+      rescue MultiJson::DecodeError
+        parse_error(string)
+      end
+      
+      def new_transaction_from_response(response)
+        if response.success?
+          Transaction.new({
+            :id => response.body['TransactionId'],
+            :avs_response => response.body['AVSResult'] == 1,
+            :cvv_response => response.body['CVResult'] == 1,
+            :authcode => response.body['ApprovalCode'],
+            :message => response.body['StatusMessage'],
+            :code => response.body['Status'],
+            :masked_card_number => response.body['MaskedPAN']
+          })
+        else
+          if errors = parse_validation_errors(response)
+            Transaction.new({
+              :message => errors.join("\n"),
+              :code => (response.body['ErrorResponse'] || {})['ErrorId']
+            })
+          else
+            Transaction.new({
+              :message => response.body ? (response.body['ErrorResponse'] || {})['Reason'] : nil,
+              :code => response.body ? (response.body['ErrorResponse'] || {})['ErrorId'] : nil
+            })
+          end
+        end
+      end
+      
+      def parse_validation_errors(response)
+        errors = ChainableHash.new.merge(response.body || {})
+        if errors['ErrorResponse']['ValidationErrors'].present?
+          [errors['ErrorResponse']['ValidationErrors']['ValidationError']].flatten.collect { |e| e['RuleMessage'] }
+        end
+      end
+      
+      def parse_error(response_body)
+        MultiXml.parse(response_body)
+      rescue MultiXml::ParseError
+      end
+      
+      def respond_with(object, response = nil, options = {}, &block)
+        super(object, options, &block).tap do |o|
+          if response
+            o.raw_response = response.raw_response.try(:body)
+            o.connection_error = response.connection_error
+          end
+        end
+      end
+    end    
+  end
+end

data/lib/vaulted_billing/gateways/nmi_customer_vault.rb

@@ -13,16 +13,16 @@ module VaultedBilling
     # 
     class NmiCustomerVault
       include VaultedBilling::Gateway
-      include VaultedBilling::HttpsInterface
+      attr_accessor :use_test_uri
 
       def initialize(options = {})
-        self.live_uri = self.test_uri = "https://secure.nmi.com/api/transact.php"
+        @live_uri = "https://secure.nmi.com/api/transact.php"
 
         options = HashWithIndifferentAccess.new(options)
         @username = options[:username] || VaultedBilling.config.nmi_customer_vault.username
         @password = options[:password] || VaultedBilling.config.nmi_customer_vault.password
         @raw_options = options[:raw_options] || VaultedBilling.config.nmi_customer_vault.raw_options
-        self.use_test_uri = options.has_key?(:test) ? options[:test] : (VaultedBilling.config.nmi_customer_vault.test_mode || VaultedBilling.config.test_mode)
+        @use_test_uri = options.has_key?(:test) ? options[:test] : (VaultedBilling.config.nmi_customer_vault.test_mode || VaultedBilling.config.test_mode)
       end
 
       ##
@@ -53,79 +53,91 @@ module VaultedBilling
       end
 
       def add_customer_credit_card(customer, credit_card)
-        response = post_data(storage_data('add_customer', customer.to_vaulted_billing, credit_card.to_vaulted_billing))
+        data = storage_data('add_customer', customer.to_vaulted_billing, credit_card.to_vaulted_billing)
+        response = http.post(data)
         respond_with(credit_card, response, :success => response.success?) do |c|
           c.vault_id = response.body['customer_vault_id']
         end
       end
 
       def update_customer_credit_card(customer, credit_card)
-        response = post_data(storage_data('update_customer', customer.to_vaulted_billing, credit_card.to_vaulted_billing))
+        data = storage_data('update_customer', customer.to_vaulted_billing, credit_card.to_vaulted_billing)
+        response = http.post(data)
         respond_with(credit_card, response, :success => response.success?)
       end
 
       def remove_customer_credit_card(customer, credit_card)
-        response = post_data(core_data.merge({
+        data = core_data.merge({
           :customer_vault => 'delete_customer',
           :customer_vault_id => credit_card.to_vaulted_billing.vault_id
-        }).to_querystring)
+        }).to_querystring
+        response = http.post(data)
         respond_with(credit_card, response, :success => response.success?)
       end
 
-      def purchase(customer, credit_card, amount)
-        response = post_data(transaction_data('sale', {
+      def purchase(customer, credit_card, amount, options = {})
+        data = transaction_data('sale', {
           :customer_vault_id => credit_card.to_vaulted_billing.vault_id,
           :amount => amount
-        }))
+        })
+        response = http.post(data)
         respond_with(new_transaction_from_response(response.body),
                      response,
                      :success => response.success?)
       end
 
-      def authorize(customer, credit_card, amount)
-        response = post_data(transaction_data('auth', {
+      def authorize(customer, credit_card, amount, options = {})
+        data = transaction_data('auth', {
           :customer_vault_id => credit_card.to_vaulted_billing.vault_id,
           :amount => amount
-        }))
+        })
+        response = http.post(data)
         respond_with(new_transaction_from_response(response.body),
                      response,
                      :success => response.success?)
       end
 
-      def capture(transaction_id, amount)
-        response = post_data(transaction_data('capture', {
+      def capture(transaction_id, amount, options = {})
+        data = transaction_data('capture', {
           :transactionid => transaction_id,
           :amount => amount
-        }))
+        })
+        response = http.post(data)
         respond_with(new_transaction_from_response(response.body),
                      response,
                      :success => response.success?)
       end
 
       def refund(transaction_id, amount, options = {})
-        response = post_data(transaction_data('refund', {
+        data = transaction_data('refund', {
           :transactionid => transaction_id,
           :amount => amount
-        }))
+        })
+        response = http.post(data)
         respond_with(new_transaction_from_response(response.body),
                      response,
                      :success => response.success?)
       end
 
-      def void(transaction_id)
-        response = post_data(transaction_data('void', {
+      def void(transaction_id, options = {})
+        data = transaction_data('void', {
           :transactionid => transaction_id
-        }))
+        })
+        response = http.post(data)
         respond_with(new_transaction_from_response(response.body),
                      response,
                      :success => response.success?)
       end
 
+      def uri
+        @live_uri
+      end
+
 
       protected
 
 
-      def after_post_on_exception(response, exception)
+      def on_error(response, exception)
         response.body = {
           'response' => '3',
           'responsetext' => 'A communication problem has occurred.',
@@ -134,14 +146,21 @@ module VaultedBilling
         response.success = false
       end
 
-      def after_post(response)
-        response.body = Hash.from_querystring(response.body)
+      def on_complete(response)
+        response.body = Hash.from_querystring(response.body.to_s) unless response.body.is_a?(Hash)
         response.success = response.body['response'] == '1'
       end
 
 
       private
 
+      def http
+        VaultedBilling::HTTP.new(self, uri, {
+          :headers => {'Content-Type' => 'text/xml'},
+          :on_complete => :on_complete,
+          :on_error => :on_error
+        })
+      end
 
       def core_data
         {

data/lib/vaulted_billing/http.rb

@@ -0,0 +1,157 @@
+require 'uri'
+
+module VaultedBilling
+  class HTTP
+    HTTP_ERRORS = [
+      Timeout::Error,
+      Errno::ETIMEDOUT,
+      Errno::EINVAL,
+      Errno::ECONNRESET,
+      Errno::ECONNREFUSED,
+      Errno::EHOSTUNREACH,
+      EOFError,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError
+    ] unless defined?(HTTP_ERRORS)
+    
+    
+     class Response
+        attr_accessor :code
+        attr_accessor :message
+        attr_accessor :body
+        attr_accessor :success
+        attr_accessor :raw_response
+        attr_accessor :connection_error
+        alias :connection_error? :connection_error
+
+        def initialize(http_response)
+          if http_response
+            self.raw_response = http_response
+            self.code = http_response.code
+            self.message = http_response.message
+            self.body = http_response.body
+            self.success = ((http_response.code =~ /^2\d{2}/) == 0)
+            self.connection_error = false
+          end
+        end
+
+        alias :success? :success
+        alias :status_code :code
+      end
+    
+    attr_reader :uri
+    
+    def initialize(caller, uri, options = {})
+      @uri = [uri].flatten.compact.collect { |u| URI.parse(u.to_s).normalize }
+      @headers = options[:headers] || {}
+      @basic_auth = options[:basic_auth]
+      @content_type = options[:content_type]
+      @caller = caller
+      @before_request = options[:before_request]
+      @on_success = options[:on_success]
+      @on_error = options[:on_error]
+      @on_complete = options[:on_complete]
+    end
+    
+    def post(body, options = {})
+      request(:post, uri.dup, body, options)
+    end
+    
+    def get(options = {})
+      request(:get, uri.dup, nil, options)
+    end
+
+    def put(body, options = {})
+      request(:put, uri.dup, body, options)
+    end
+    
+    private
+    
+    
+    def log(level, string)
+      if VaultedBilling.logger?
+        VaultedBilling.logger.send(level) { string }
+      end
+    end
+    
+    def request(method, uris, body = nil, options = {})
+      uri = uris.shift || raise(ArgumentError, "URI is empty")
+
+      request = case method
+      when :get
+        Net::HTTP::Get
+      when :put
+        Net::HTTP::Put
+      when :post
+        Net::HTTP::Post
+      else
+        raise ArugmentError
+      end.new(uri.path)
+
+      request.initialize_http_header(@headers.merge(options[:headers] || {}).reverse_merge({
+         'User-Agent' => user_agent_string
+      }))
+
+      request.body = body if body
+      set_basic_auth request, options[:basic_auth] || @basic_auth
+      set_content_type request, options[:content_type] || @content_type
+
+      response = Net::HTTP.new(uri.host, uri.port).tap do |https|
+        https.read_timeout = options[:read_timeout] || 60
+        https.open_timeout = options[:open_timeout] || 60
+        https.use_ssl = true
+        https.ca_file = VaultedBilling.config.ca_file
+        https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      run_callback(:before_request, options[:before_request] || @before_request, request)
+      http_response = run_request(request, response, options)
+
+      if http_response.connection_error && uris.present?
+        request(method, uris, body, options)
+      else
+        run_callback(:on_complete, options[:on_complete] || @on_complete, http_response)
+        http_response
+      end
+    end
+    
+    def run_callback(type, callback, *payload)
+      case callback
+      when Proc
+        callback.call(*payload)
+      when String, Symbol
+        @caller.send(callback, *payload)
+      end
+    end
+    
+    def run_request(request, response, options)
+      log :debug, "%s %s to %s" % [request.class.name.split('::').last, request.body.inspect, uri.to_s]
+      
+      http_response = Response.new(response.request(request))
+      log :info, "Response code %s (HTTP %s), %s" % [http_response.message, http_response.code.presence || '0', http_response.body.inspect]
+      run_callback(:on_success, options[:on_success] || @on_success, http_response)
+      http_response
+    rescue *HTTP_ERRORS
+      log :info, "HTTP Error: %s - %s" % [$!.class.name, $!.message]
+      Response.new(nil).tap do |request_response|
+        request_response.success = false
+        request_response.message = "%s - %s" % [$!.class.name, $!.message]
+        request_response.connection_error = true
+        run_callback(:on_error, options[:on_error] || @on_error, request_response, $!)
+      end
+    end
+    
+    def set_content_type(request, content)
+      request.set_content_type(content) if content
+    end
+    
+    def set_basic_auth(request, auth)
+      request.basic_auth(auth.first, auth.last) if auth
+    end
+
+    def user_agent_string
+      "vaulted_billing/%s (Rubygems; Ruby %s %s)" % [VaultedBilling::Version, RUBY_VERSION, RUBY_PLATFORM]
+    end
+  end
+end

data/lib/vaulted_billing/version.rb

@@ -1,3 +1,3 @@
 module VaultedBilling
-  Version = '1.0.2'
+  Version = '1.1.0'
 end