activemerchant 1.13.0 → 1.14.0

data/lib/active_merchant/billing/gateways/sage_pay.rb

@@ -105,8 +105,8 @@ module ActiveMerchant #:nodoc:
         commit(action, post)
       end
 
-      # Crediting requires a new order_id to passed in, as well as a description
-      def credit(money, identification, options = {})
+      # Refunding requires a new order_id to passed in, as well as a description
+      def refund(money, identification, options = {})
         requires!(options, :order_id, :description)
         
         post = {}
@@ -117,6 +117,11 @@ module ActiveMerchant #:nodoc:
         
         commit(:credit, post)
       end
+
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
       
       private
       def add_reference(post, identification)

data/lib/active_merchant/billing/gateways/secure_pay_au.rb

@@ -33,7 +33,7 @@ module ActiveMerchant #:nodoc:
         :authorization => 10,
         :capture => 11,
         :void => 6,
-        :credit => 4
+        :refund => 4
       }
       
       SUCCESS_CODES = [ '00', '08', '11', '16', '77' ]
@@ -49,9 +49,32 @@ module ActiveMerchant #:nodoc:
       end
       
       def purchase(money, credit_card, options = {})
+        requires!(options, :order_id)
         commit :purchase, build_purchase_request(money, credit_card, options)
       end                       
     
+      def authorize(money, credit_card, options = {})
+        requires!(options, :order_id)
+        commit :authorization, build_purchase_request(money, credit_card, options)
+      end
+      
+      def capture(money, reference)
+        commit :capture, build_reference_request(money, reference)
+      end
+      
+      def refund(money, reference)
+        commit :refund, build_reference_request(money, reference)
+      end
+
+      def credit(money, reference)
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, reference)
+      end
+
+      def void(reference)
+        commit :void, build_reference_request(nil, reference)
+      end
+      
       private
       
       def build_purchase_request(money, credit_card, options)
@@ -70,6 +93,19 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
       
+      def build_reference_request(money, reference)
+        xml = Builder::XmlMarkup.new
+        
+        transaction_id, order_id, preauth_id, original_amount = reference.split("*")
+        xml.tag! 'amount', (money ? amount(money) : original_amount)
+        xml.tag! 'currency', options[:currency] || currency(money)
+        xml.tag! 'txnID', transaction_id
+        xml.tag! 'purchaseOrderNo', order_id
+        xml.tag! 'preauthID', preauth_id
+        
+        xml.target!
+      end
+      
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
         xml.instruct!
@@ -115,7 +151,7 @@ module ActiveMerchant #:nodoc:
       end
       
       def authorization_from(response)
-        response[:txn_id]
+        [response[:txn_id], response[:purchase_order_no], response[:preauth_id], response[:amount]].join('*')
       end
           
       def message_from(response)

data/lib/active_merchant/billing/gateways/smart_ps.rb

@@ -69,10 +69,10 @@ module ActiveMerchant #:nodoc:
         commit('credit', money, post)
       end
       
-      def refund(auth, options = {})
+      def refund(money, auth, options = {})
         post = {}
         add_transaction(post, auth)
-        commit('refund', options.delete(:amount), post)
+        commit('refund', money, post)
       end
       
       

data/lib/active_merchant/billing/gateways/trust_commerce.rb

@@ -187,9 +187,9 @@ module ActiveMerchant #:nodoc:
         commit('postauth', parameters)
       end
       
-      # credit() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
+      # refund() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
       # that you want to refund, and a TC transid for the transaction that you are refunding.
-      def credit(money, identification, options = {})  
+      def refund(money, identification, options = {})  
         parameters = {
           :amount => amount(money),
           :transid => identification
@@ -197,6 +197,11 @@ module ActiveMerchant #:nodoc:
                                                   
         commit('credit', parameters)
       end
+
+      def credit(money, identification, options = {})  
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
       
       # void() clears an existing authorization and releases the reserved fund
       # s back to the cardholder. The TC API refers to this transaction as a 

data/lib/active_merchant/billing/gateways/verifi.rb

@@ -87,7 +87,7 @@ module ActiveMerchant #:nodoc:
       
       def credit(money, credit_card_or_authorization, options = {})
         if credit_card_or_authorization.is_a?(String)
-          warn CREDIT_DEPRECATION_MESSAGE
+          deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, credit_card_or_authorization, options)
         else
           sale_authorization_or_credit_template(:credit, money, credit_card_or_authorization, options)

data/lib/active_merchant/billing/gateways/worldpay.rb

@@ -0,0 +1,280 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WorldpayGateway < Gateway
+      TEST_URL = 'https://secure-test.wp3.rbsworldpay.com/jsp/merchant/xml/paymentService.jsp'
+      LIVE_URL = 'https://secure.wp3.rbsworldpay.com/jsp/merchant/xml/paymentService.jsp'
+
+      self.default_currency = 'GBP'
+      self.money_format = :cents
+      self.supported_countries = ['HK', 'US', 'GB', 'AU']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.worldpay.com/'
+      self.display_name = 'WorldPay'
+
+      CARD_CODES = {
+        'visa'             => 'VISA-SSL',
+        'master'           => 'ECMC-SSL',
+        'discover'         => 'DISCOVER-SSL',
+        'american_express' => 'AMEX-SSL',
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      def purchase(money, payment_method, options = {})
+        response = MultiResponse.new
+        response << authorize(money, payment_method, options)
+        response << capture(money, response.authorization, :authorization_validated => true) if response.success?
+        response
+      end
+
+      def authorize(money, payment_method, options = {})
+        requires!(options, :order_id)
+        commit 'authorize', build_authorization_request(money, payment_method, options)
+      end
+
+      def capture(money, authorization, options = {})
+        response = MultiResponse.new
+        response << inquire(authorization, options) unless options[:authorization_validated]
+        response << commit('capture', build_capture_request(money, authorization, options)) if response.success?
+        response
+      end
+
+      def void(authorization, options = {})
+        response = MultiResponse.new
+        response << inquire(authorization, options)
+        response << commit('cancel', build_void_request(authorization, options)) if response.success?
+        response        
+      end
+
+      def refund(money, authorization, options = {})
+        response = MultiResponse.new
+        response << inquire(authorization, options)
+        response << commit('refund', build_refund_request(money, authorization, options)) if response.success?
+        response        
+      end
+
+      private
+
+      def inquire(authorization, options={})
+        commit 'inquiry', build_order_inquiry_request(authorization, options)
+      end
+
+      def build_request
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.wp3.rbsworldpay.com/paymentService_v1.dtd"
+        xml.tag! 'paymentService', 'version' => "1.4", 'merchantCode' => @options[:login] do
+          yield xml
+        end
+        xml.target!
+      end
+
+      def build_order_modify_request(authorization)
+        build_request do |xml|
+          xml.tag! 'modify' do
+            xml.tag! 'orderModification', 'orderCode' => authorization do
+              yield xml
+            end
+          end
+        end
+      end
+
+      def build_order_inquiry_request(authorization, options)
+        build_request do |xml|
+          xml.tag! 'inquiry' do
+            xml.tag! 'orderInquiry', 'orderCode' => authorization
+          end
+        end
+      end
+
+      def build_authorization_request(money, payment_method, options)
+        build_request do |xml|
+          xml.tag! 'submit' do
+            xml.tag! 'order', {'orderCode' => options[:order_id], 'installationId' => @options[:inst_id]}.reject{|_,v| !v} do
+              xml.description(options[:description].blank? ? "Purchase" : options[:description])
+              add_amount(xml, money, options)
+              if options[:order_content]
+                xml.tag! 'orderContent' do
+                  xml.cdata! options[:order_content]
+                end
+              end
+              add_payment_method(xml, money, payment_method, options)
+            end
+          end
+        end
+      end
+
+      def build_capture_request(money, authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'capture' do
+            time = Time.now
+            xml.tag! 'date', 'dayOfMonth' => time.day, 'month' => time.month, 'year'=> time.year
+            add_amount(xml, money, options)
+          end
+        end
+      end
+
+      def build_void_request(authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'cancel'
+        end
+      end
+
+      def build_refund_request(money, authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'refund' do
+            add_amount(xml, money, options)
+          end
+        end
+      end
+
+      def add_amount(xml, money, options)
+        xml.tag! 'amount',
+          :value => amount(money),
+          'currencyCode' => (options[:currency] || currency(money)),
+          'exponent' => 2
+      end
+
+      def add_payment_method(xml, amount, payment_method, options)
+        if payment_method.is_a?(String)
+          xml.tag! 'payAsOrder', 'orderCode' => payment_method do
+            add_amount(xml, amount, options)
+          end
+        else
+          xml.tag! 'paymentDetails' do
+            xml.tag! CARD_CODES[card_brand(payment_method)] do
+              xml.tag! 'cardNumber', payment_method.number
+              xml.tag! 'expiryDate' do
+                xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+              end
+
+              xml.tag! 'cardHolderName', payment_method.name
+              xml.tag! 'cvc', payment_method.verification_value
+
+              add_address(xml, 'cardAddress', (options[:billing_address] || options[:address]))
+            end
+          end
+        end
+      end
+
+      def add_address(xml, element, address)
+        return if address.nil?
+
+        xml.tag! element do
+          xml.tag! 'address' do
+            if m = /^\s*([^\s]+)\s+(.+)$/.match(address[:name])
+              xml.tag! 'firstName', m[1]
+              xml.tag! 'lastName', m[2]
+            end
+            if m = /^\s*(\d+)\s+(.+)$/.match(address[:address1])
+              xml.tag! 'street', m[2]
+              house_number = m[1]
+            else
+              xml.tag! 'street', address[:address1]
+            end
+            xml.tag! 'houseName', address[:address2] if address[:address2]
+            xml.tag! 'houseNumber', house_number if house_number.present?
+            xml.tag! 'postalCode', (address[:zip].present? ? address[:zip] : "0000")
+            xml.tag! 'city', address[:city] if address[:city]
+            xml.tag! 'state', (address[:state].present? ? address[:state] : 'N/A')
+            xml.tag! 'countryCode', address[:country]
+            xml.tag! 'telephoneNumber', address[:phone] if address[:phone]
+          end
+        end
+      end
+
+      def parse(action, xml)
+        parse_element({:action => action}, REXML::Document.new(xml))
+      end
+
+      def parse_element(raw, node)
+        node.attributes.each do |k, v|
+          raw["#{node.name.underscore}_#{k.underscore}".to_sym] = v
+        end
+        if node.has_elements?
+          raw[node.name.underscore.to_sym] = true unless node.name.blank?
+          node.elements.each{|e| parse_element(raw, e) }
+        else
+          raw[node.name.underscore.to_sym] = node.text unless node.text.nil?
+        end
+        raw
+      end
+
+      def commit(action, request)
+        xmr = ssl_post((test? ? TEST_URL : LIVE_URL),
+          request,
+          'Content-Type' => 'text/xml',
+          'Authorization' => encoded_credentials)
+
+        raw = parse(action, xmr)
+
+        Response.new(
+          success_from(raw),
+          message_from(raw),
+          raw,
+          :authorization => authorization_from(raw),
+          :test => test?)
+
+      rescue ActiveMerchant::ResponseError => e
+        if e.response.code.to_s == "401"
+          return Response.new(false, "Invalid credentials", {}, :test => test?)
+        else
+          raise e
+        end
+      end
+
+      def success_from(raw)
+        (raw[:last_event] == "AUTHORISED" ||
+          raw[:ok].present?)
+      end
+
+      def message_from(raw)
+        (raw[:iso8583_return_code_description] ||
+          raw[:error] ||
+          "SUCCESS")
+      end
+
+      def authorization_from(raw)
+        pair = raw.detect{|k,v| k.to_s =~ /_order_code$/}
+        (pair ? pair.last : nil)
+      end
+
+      def encoded_credentials
+        credentials = "#{@options[:login]}:#{@options[:password]}"
+        "Basic #{[credentials].pack('m').strip}"
+      end
+
+      class MultiResponse < Response
+        attr_reader :responses
+
+        def initialize
+          @responses = []
+        end
+
+        def <<(response)
+          if response.is_a?(MultiResponse)
+            response.responses.each{|r| @responses << r}
+          else
+            @responses << response
+          end
+        end
+
+        def success?
+          @responses.all?{|r| r.success?}
+        end
+
+        %w(params message test authorization avs_result cvv_result test? fraud_review?).each do |m|
+          class_eval %(
+            def #{m}
+              @responses.last.#{m}
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/moneybookers/helper.rb

@@ -40,7 +40,6 @@ module ActiveMerchant #:nodoc:
 
             add_field('merchant_fields', 'platform')
             add_field('platform', application_id)
-            puts @fields.inspect
           end
         end
       end

data/lib/active_merchant/billing/integrations/return.rb

@@ -14,7 +14,12 @@ module ActiveMerchant #:nodoc:
         def success?
           true
         end
-      
+
+        # Not cancelled by default.  Overridden in the child class.
+        def cancelled?
+          false
+        end
+
         def message
           
         end

data/lib/active_merchant/billing/integrations/sage_pay_form/notification.rb

@@ -19,6 +19,12 @@ module ActiveMerchant #:nodoc:
             status_code == 'OK'
           end
 
+          # Was the transaction cancelled?
+          # Unfortunately, we can't distinguish "user abort" from "idle too long".
+          def cancelled?
+            status_code == 'ABORT'
+          end
+
           # Text version of #complete?, since we don't support Pending.
           def status
             complete? ? 'Completed' : 'Failed'