activemerchant 1.29.1 → 1.31.0

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/gateways/worldpay.rb

@@ -16,6 +16,9 @@ module ActiveMerchant #:nodoc:
         'master'           => 'ECMC-SSL',
         'discover'         => 'DISCOVER-SSL',
         'american_express' => 'AMEX-SSL',
+        'jcb'              => 'JCB-SSL',
+        'maestro'          => 'MAESTRO-SSL',
+        'laser'            => 'LASER-SSL'
       }
 
       def initialize(options = {})
@@ -38,6 +41,10 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         MultiResponse.run do |r|
           r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
+          if r.params
+            authorization_currency = r.params['amount_currency_code']
+            options = options.merge(:currency => authorization_currency) if authorization_currency.present?
+          end
           r.process{capture_request(money, authorization, options)}
         end
       end
@@ -80,7 +87,7 @@ module ActiveMerchant #:nodoc:
 
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct!
+        xml.instruct! :xml, :encoding => 'ISO-8859-1'
         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
@@ -148,10 +155,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount(xml, money, options)
-        xml.tag! 'amount',
-          :value => amount(money),
-          'currencyCode' => (options[:currency] || currency(money)),
-          'exponent' => 2
+        currency = options[:currency] || currency(money)
+        amount   = localized_amount(money, currency)
+
+        xml.tag! 'amount', :value => amount, 'currencyCode' => currency, 'exponent' => 2
       end
 
       def add_payment_method(xml, amount, payment_method, options)
@@ -261,6 +268,13 @@ module ActiveMerchant #:nodoc:
         credentials = "#{@options[:login]}:#{@options[:password]}"
         "Basic #{[credentials].pack('m').strip}"
       end
+
+      def localized_amount(money, currency)
+        amount = amount(money)
+        return amount unless CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
+        
+        amount.to_i / 100 * 100
+      end
     end
   end
 end

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"

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

@@ -7,39 +7,40 @@ module ActiveMerchant #:nodoc:
           def initialize(order, account, options = {})
             md5secret options.delete(:credential2)
             super
-            add_field('protocol', '3')
+            add_field('protocol', '6')
             add_field('msgtype', 'authorize')
             add_field('language', 'da')
             add_field('autocapture', 0)
             add_field('testmode', test? ? 1 : 0)
             add_field('ordernumber', format_order_number(order))
           end
-              
+
           def md5secret(value)
             @md5secret = value
           end
-          
+
           def form_fields
             @fields.merge('md5check' => generate_md5check)
           end
-            
+
           def generate_md5string
             MD5_CHECK_FIELDS.map {|key| @fields[key.to_s]} * "" + @md5secret
           end
-          
+
           def generate_md5check
             Digest::MD5.hexdigest(generate_md5string)
           end
 
           # Limited to 20 digits max
           def format_order_number(number)
-            number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]
+            number.to_s.gsub(/[^\w]/, '').rjust(4, "0")[0...20]
           end
-          
+
           MD5_CHECK_FIELDS = [
-            :protocol, :msgtype, :merchant, :language, :ordernumber, 
+            :protocol, :msgtype, :merchant, :language, :ordernumber,
             :amount, :currency, :continueurl, :cancelurl, :callbackurl,
-            :autocapture, :cardtypelock, :description, :ipaddress, :testmode
+            :autocapture, :cardtypelock, :description, :ipaddress, :testmode,
+            :deadline, :cardhash
           ]
 
           mapping :protocol, 'protocol'
@@ -48,7 +49,7 @@ module ActiveMerchant #:nodoc:
           mapping :language, 'language'
           mapping :amount, 'amount'
           mapping :currency, 'currency'
-          
+
           mapping :return_url, 'continueurl'
           mapping :cancel_return_url, 'cancelurl'
           mapping :notify_url, 'callbackurl'
@@ -59,6 +60,8 @@ module ActiveMerchant #:nodoc:
           mapping :description, 'description'
           mapping :ipaddress, 'ipaddress'
           mapping :testmode, 'testmode'
+          mapping :deadline, 'deadline'
+          mapping :cardhash, 'cardhash'
 
           mapping :customer, ''
           mapping :billing_address, {}