activemerchant 1.29.3 → 1.30.0

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

@@ -65,6 +65,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, options)
         add_customer_data(post, options)
+        add_optional_data(post, options)
 
         commit(:purchase, post)
       end
@@ -79,6 +80,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, options)
         add_customer_data(post, options)
+        add_optional_data(post, options)
 
         commit(:authorization, post)
       end
@@ -156,6 +158,10 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :ClientIPAddress, options[:ip])
       end
 
+      def add_optional_data(post, options)
+        add_pair(post, :GiftAidPayment, options[:gift_aid_payment]) unless options[:gift_aid_payment].blank?
+      end
+
       def add_address(post, options)
         if billing_address = options[:billing_address] || options[:address]
           first_name, last_name = parse_first_and_last_name(billing_address[:name])

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

@@ -221,7 +221,7 @@ module ActiveMerchant #:nodoc:
         parameters[:amount]  = amount(money) if money
         response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
         Response.new(response["response"] == "1", message_from(response), response,
-          :authorization => response["transactionid"],
+          :authorization => (response["transactionid"] || response["customer_vault_id"]),
           :test => test?,
           :cvv_result => response["cvvresponse"],
           :avs_result => { :code => response["avsresponse"] }

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

@@ -0,0 +1,235 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Public: This gateway allows you to interact with any gateway you've
+    # created in Spreedly Core (https://spreedlycore.com).  It's an adapter
+    # which can be particularly useful if you already have code interacting with
+    # ActiveMerchant and want to easily take advantage of Core's vault.
+    class SpreedlyCoreGateway < Gateway
+      self.live_url = 'https://spreedlycore.com/v1'
+
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK EE EG ES FI FR GB
+                                    GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU LV MC
+                                    MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM
+                                    TR TT UM US VA VN ZA)
+
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://spreedlycore.com'
+      self.display_name = 'Spreedly Core'
+      self.money_format = :cents
+      self.default_currency = 'USD'
+
+      # Public: Create a new Spreedly Core Gateway.
+      #
+      # options - A hash of options:
+      #           :login         - Your Spreedly Core API login.
+      #           :password      - Your Spreedly Core API secret.
+      #           :gateway_token - The token of the gateway you've created in
+      #                            Spreedly Core.
+      def initialize(options = {})
+        requires!(options, :login, :password, :gateway_token)
+        super
+      end
+
+      # Public: Run a purchase transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly Core payment method
+      #                  token.
+      # options        - A standard ActiveMerchant options hash
+      def purchase(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          purchase_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { purchase_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      # Public: Run an authorize transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly Core payment method
+      #                  token.
+      # options        - A standard ActiveMerchant options hash
+      def authorize(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          authorize_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { authorize_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/capture.xml", request)
+      end
+
+      def refund(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/credit.xml", request)
+      end
+
+      def void(authorization, options={})
+        commit("transactions/#{authorization}/void.xml", '')
+      end
+
+      # Public: Store a credit card in the Spreedly Core vault and retain it.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def store(credit_card, options={})
+        save_card(true, credit_card, options)
+      end
+
+      # Public: Redact the CreditCard in Spreedly Core.  This wipes the
+      # sensitive payment information from the card.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def unstore(authorization, options={})
+        commit("payment_methods/#{authorization}/redact.xml", '', :put)
+      end
+
+      private
+      def save_card(retain, credit_card, options)
+        request = build_xml_request('payment_method') do |doc|
+          add_credit_card(doc, credit_card, options)
+          add_data(doc, options)
+          doc.retained(true) if retain
+        end
+
+        commit("payment_methods.xml", request, :post, :payment_method_token)
+      end
+
+      def purchase_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/purchase.xml", request)
+      end
+
+      def authorize_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/authorize.xml", request)
+      end
+
+      def auth_purchase_request(money, payment_method_token, options)
+        build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+          doc.payment_method_token(payment_method_token)
+        end
+      end
+
+      def add_invoice(doc, money, options)
+        doc.amount amount(money)
+        doc.currency_code(options[:currency] || currency(money) || default_currency)
+      end
+
+      def add_credit_card(doc, credit_card, options)
+        doc.credit_card do
+          doc.number(credit_card.number)
+          doc.first_name(credit_card.first_name)
+          doc.last_name(credit_card.last_name)
+          doc.month(credit_card.month)
+          doc.year(credit_card.year)
+          doc.email(options[:email])
+          doc.address1(options[:billing_address].try(:[], :address1))
+          doc.address2(options[:billing_address].try(:[], :address2))
+          doc.city(options[:billing_address].try(:[], :city))
+          doc.state(options[:billing_address].try(:[], :state))
+          doc.zip(options[:billing_address].try(:[], :zip))
+        end
+      end
+
+      def add_data(doc, options)
+        doc.data do
+          data_to_doc(doc, options[:data])
+        end
+      end
+
+      def data_to_doc(doc, value)
+        return doc.text value unless value.kind_of? Hash
+        value.each do |k, v|
+          doc.send(k) do
+            data_to_doc(doc, v)
+          end
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath('*').each do |node|
+          if (node.elements.empty?)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              childnode_to_response(response, node, childnode)
+            end
+          end
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, node, childnode)
+        name = "#{node.name.downcase}_#{childnode.name.downcase}"
+        if name == 'payment_method_data' && !childnode.elements.empty?
+          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        else
+          response[name.to_sym] = childnode.text
+        end
+      end
+
+      def build_xml_request(root)
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__(root) do |doc|
+          yield(doc)
+        end
+        builder.to_xml
+      end
+
+      def commit(relative_url, request, method = :post, authorization_field = :token)
+        begin
+          raw_response = ssl_request(method, "#{live_url}/#{relative_url}", request, headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+
+        response_from(raw_response, authorization_field)
+      end
+
+      def response_from(raw_response, authorization_field)
+        parsed = parse(raw_response)
+        options = {
+          :authorization => parsed[authorization_field],
+          :test => (parsed[:on_test_gateway] == 'true'),
+          :avs_result => { :code => parsed[:response_avs_code] },
+          :cvv_result => parsed[:response_cvv_code]
+        }
+
+        Response.new(parsed[:succeeded] == 'true', parsed[:message] || parsed[:error], parsed, options)
+      end
+
+      def headers
+        {
+          'Authorization' => ('Basic ' + Base64.strict_encode64("#{@options[:login]}:#{@options[:password]}").chomp),
+          'Content-Type' => 'text/xml'
+        }
+      end
+    end
+  end
+end
+

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

@@ -50,6 +50,7 @@ module ActiveMerchant #:nodoc:
         add_customer(post, options)
         add_customer_data(post,options)
         post[:description] = options[:description] || options[:email]
+        post[:application_fee] = options[:application_fee] if options[:application_fee]
         add_flags(post, options)
 
         meta = generate_meta(options)

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

@@ -16,7 +16,7 @@ module ActiveMerchant #:nodoc:
         'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
       }
 
-      PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
+      PERMITTED_TRANSACTIONS = %w[ PREAUTHORIZATION CAPTURE PURCHASE ]
 
       RETURN_CODES = %w[ ACK NOK ]
 
@@ -63,13 +63,13 @@ module ActiveMerchant #:nodoc:
       # Authorization
       def authorize(money, creditcard, options = {})
         options[:credit_card] = creditcard
-        commit(:authorization, money, options)
+        commit(:preauthorization, money, options)
       end
 
       # Capture Authorization
       def capture(money, authorization, options = {})
-        options[:authorization] = authorization
-        commit(:capture_authorization, money, options)
+        options[:preauthorization] = authorization
+        commit(:capture, money, options)
       end
 
       # Purchase
@@ -148,16 +148,17 @@ module ActiveMerchant #:nodoc:
         options[:order_id] ||= generate_unique_id
 
         xml.tag! "FNC_CC_#{options[:action].to_s.upcase}" do
-          xml.tag! 'FunctionID', options[:description]
+          xml.tag! 'FunctionID', options[:description].to_s.slice(0,32)
           xml.tag! 'CC_TRANSACTION' do
             xml.tag! 'TransactionID', options[:order_id]
             case options[:action]
-            when :authorization, :purchase
+            when :preauthorization, :purchase
               add_invoice(xml, money, options)
               add_creditcard(xml, options[:credit_card])
               add_address(xml, options[:billing_address])
-            when :capture_authorization
-              xml.tag! 'GuWID', options[:authorization]
+            when :capture
+              xml.tag! 'GuWID', options[:preauthorization]
+              add_amount(xml, money)
             end
           end
         end
@@ -165,7 +166,7 @@ module ActiveMerchant #:nodoc:
 
       # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
-        xml.tag! 'Amount', amount(money)
+        add_amount(xml, money)
         xml.tag! 'Currency', options[:currency] || currency(money)
         xml.tag! 'CountryCode', options[:billing_address][:country]
         xml.tag! 'RECURRING_TRANSACTION' do
@@ -173,6 +174,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # Include the amount in the transaction-xml
+      def add_amount(xml, money)
+        xml.tag! 'Amount', amount(money)
+      end
+
       # Includes the credit-card data to the transaction-xml
       def add_creditcard(xml, creditcard)
         raise "Creditcard must be supplied!" if creditcard.nil?

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

@@ -20,7 +20,6 @@ module ActiveMerchant #:nodoc:
           mapping :credential2, 'pwd'
           mapping :credential3, 'partner'
           mapping :order, 'user1'
-          mapping :description, 'description'
 
           mapping :amount, 'amt'
 
@@ -35,6 +34,10 @@ module ActiveMerchant #:nodoc:
 
           mapping :customer, :name => 'name'
 
+          def description(value)
+            add_field('description', "#{value}".delete("#"))
+          end
+
           def customer(params = {})
             add_field(mappings[:customer][:name], [params.delete(:first_name), params.delete(:last_name)].compact.join(' '))
           end

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

@@ -1,16 +1,17 @@
 require 'net/http'
+require 'time'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module Integrations #:nodoc:
       module Paypal
-        # Parser and handler for incoming Instant payment notifications from paypal. 
+        # Parser and handler for incoming Instant payment notifications from paypal.
         # The Example shows a typical handler in a rails application. Note that this
         # is an example, please read the Paypal API documentation for all the details
         # on creating a safe payment controller.
         #
         # Example
-        #  
+        #
         #   class BackendController < ApplicationController
         #     include ActiveMerchant::Billing::Integrations
         #
@@ -20,28 +21,28 @@ module ActiveMerchant #:nodoc:
         #       if notify.masspay?
         #         masspay_items = notify.items
         #       end
-        #   
+        #
         #       order = Order.find(notify.item_id)
-        #     
-        #       if notify.acknowledge 
+        #
+        #       if notify.acknowledge
         #         begin
-        #           
+        #
         #           if notify.complete? and order.total == notify.amount
-        #             order.status = 'success' 
-        #             
+        #             order.status = 'success'
+        #
         #             shop.ship(order)
         #           else
         #             logger.error("Failed to verify Paypal's notification, please investigate")
         #           end
-        #   
+        #
         #         rescue => e
-        #           order.status        = 'failed'      
+        #           order.status        = 'failed'
         #           raise
         #         ensure
         #           order.save
         #         end
         #       end
-        #   
+        #
         #       render :nothing
         #     end
         #   end
@@ -52,7 +53,7 @@ module ActiveMerchant #:nodoc:
             super
             extend MassPayNotification if masspay?
           end
-          
+
           # Was the transaction complete?
           def complete?
             status == "Completed"
@@ -63,13 +64,20 @@ module ActiveMerchant #:nodoc:
             type == "masspay"
           end
 
-          # When was this payment received by the client. 
-          # sometimes it can happen that we get the notification much later. 
-          # One possible scenario is that our web application was down. In this case paypal tries several 
+          # When was this payment received by the client.
+          # sometimes it can happen that we get the notification much later.
+          # One possible scenario is that our web application was down. In this case paypal tries several
           # times an hour to inform us about the notification
           def received_at
-            parsed_time_fields = DateTime._strptime(params['payment_date'], "%H:%M:%S %b %d, %Y %z")
-            Time.mktime(*parsed_time_fields.values_at(:year, :mon, :mday, :hour, :min, :sec, :zone))
+            parsed_time_fields = DateTime._strptime(params['payment_date'], "%H:%M:%S %b %d, %Y %Z")
+            Time.gm(
+              parsed_time_fields[:year],
+              parsed_time_fields[:mon],
+              parsed_time_fields[:mday],
+              parsed_time_fields[:hour],
+              parsed_time_fields[:min],
+              parsed_time_fields[:sec]
+            ) + Time.zone_offset(parsed_time_fields[:zone])
           end
 
           # Status of transaction. List of possible values:
@@ -94,8 +102,8 @@ module ActiveMerchant #:nodoc:
             params['txn_id']
           end
 
-          # What type of transaction are we dealing with? 
-          #  "cart" "send_money" "web_accept" are possible here. 
+          # What type of transaction are we dealing with?
+          #  "cart" "send_money" "web_accept" are possible here.
           def type
             params['txn_type']
           end
@@ -115,37 +123,37 @@ module ActiveMerchant #:nodoc:
             params['mc_currency']
           end
 
-          # This is the item number which we submitted to paypal 
+          # This is the item number which we submitted to paypal
           # The custom field is also mapped to item_id because PayPal
           # doesn't return item_number in dispute notifications
           def item_id
             params['item_number'] || params['custom']
           end
 
-          # This is the invoice which you passed to paypal 
+          # This is the invoice which you passed to paypal
           def invoice
             params['invoice']
-          end   
+          end
 
           # Was this a test transaction?
           def test?
             params['test_ipn'] == '1'
           end
-          
+
           def account
             params['business'] || params['receiver_email']
           end
 
-          # Acknowledge the transaction to paypal. This method has to be called after a new 
-          # ipn arrives. Paypal will verify that all the information we received are correct and will return a 
-          # ok or a fail. 
-          # 
+          # Acknowledge the transaction to paypal. This method has to be called after a new
+          # ipn arrives. Paypal will verify that all the information we received are correct and will return a
+          # ok or a fail.
+          #
           # Example:
-          # 
+          #
           #   def paypal_ipn
           #     notify = PaypalNotification.new(request.raw_post)
           #
-          #     if notify.acknowledge 
+          #     if notify.acknowledge
           #       ... process order ... if notify.complete?
           #     else
           #       ... log possible hacking attempt ...
@@ -153,11 +161,11 @@ module ActiveMerchant #:nodoc:
           def acknowledge
             payload =  raw
 
-            response = ssl_post(Paypal.service_url + '?cmd=_notify-validate', payload, 
+            response = ssl_post(Paypal.service_url + '?cmd=_notify-validate', payload,
               'Content-Length' => "#{payload.size}",
               'User-Agent'     => "Active Merchant -- http://activemerchant.org"
             )
-            
+
             raise StandardError.new("Faulty paypal result: #{response}") unless ["VERIFIED", "INVALID"].include?(response)
 
             response == "VERIFIED"