activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,194 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SoEasyPayGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.soeasypay.com/gateway.asmx'
+      self.money_format = :cents
+
+      self.supported_countries = [
+        'US', 'CA', 'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE',
+        'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU',
+        'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'GB',
+        'IS', 'NO', 'CH'
+      ]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :maestro, :jcb, :solo, :diners_club]
+      self.homepage_url = 'http://www.soeasypay.com/'
+      self.display_name = 'SoEasyPay'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('AuthorizeTransaction', do_authorization(money, payment_source, options), options)
+        else
+          commit('ReauthorizeTransaction', do_reauthorization(money, payment_source, options), options)
+        end
+      end
+
+      def purchase(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('SaleTransaction', do_sale(money, payment_source, options), options)
+        else
+          commit('RebillTransaction', do_rebill(money, payment_source, options), options)
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        commit('CaptureTransaction', do_capture(money, authorization, options), options)
+      end
+
+      def refund(money, authorization, options={})
+        commit('RefundTransaction', do_refund(money, authorization, options), options)
+      end
+
+      def void(authorization, options={})
+        commit('CancelTransaction', do_void(authorization, options), options)
+      end
+
+      private
+
+      def do_authorization(money, card, options)
+        build_soap('AuthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_sale(money, card, options)
+        build_soap('SaleTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_reauthorization(money, authorization, options)
+        build_soap('ReauthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_rebill(money, authorization, options)
+        build_soap('RebillTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_capture(money, authorization, options)
+        build_soap('CaptureTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_refund(money, authorization, options)
+        build_soap('RefundTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_void(authorization, options)
+        build_soap('CancelTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def fill_credentials(soap, options)
+        soap.tag!('websiteID', @options[:login].to_s)
+        soap.tag!('password', @options[:password].to_s)
+      end
+
+      def fill_cardholder(soap, card, options)
+        ch_info = options[:billing_address] || options[:address]
+
+        soap.tag!('customerIP',options[:ip].to_s)
+        name = card.name || ch_info[:name]
+        soap.tag!('cardHolderName', name.to_s)
+        address = ch_info[:address1] || ''
+        address << ch_info[:address2] if ch_info[:address2]
+        soap.tag!('cardHolderAddress', address.to_s)
+        soap.tag!('cardHolderZipcode', ch_info[:zip].to_s)
+        soap.tag!('cardHolderCity', ch_info[:city].to_s)
+        soap.tag!('cardHolderState', ch_info[:state].to_s)
+        soap.tag!('cardHolderCountryCode', ch_info[:country].to_s)
+        soap.tag!('cardHolderPhone', ch_info[:phone].to_s)
+        soap.tag!('cardHolderEmail', options[:email].to_s)
+      end
+
+      def fill_transaction_id(soap, transaction_id)
+        soap.tag!('transactionID', transaction_id.to_s)
+      end
+
+      def fill_card(soap, card)
+        soap.tag!('cardNumber', card.number.to_s)
+        soap.tag!('cardSecurityCode', card.verification_value.to_s)
+        soap.tag!('cardExpireMonth', card.month.to_s.rjust(2, "0"))
+        soap.tag!('cardExpireYear', card.year.to_s)
+      end
+
+      def fill_order_info(soap, money, options, skip_currency=false)
+        soap.tag!('orderID', options[:order_id].to_s)
+        soap.tag!('orderDescription', "Order #{options[:order_id]}")
+        soap.tag!('amount', amount(money).to_s)
+        soap.tag!('currency', (options[:currency] || currency(money)).to_s) unless skip_currency
+      end
+
+      def parse(response, action)
+        result = {}
+        document = REXML::Document.new(response)
+        response_element = document.root.get_elements("//[@xsi:type='tns:#{action}Response']").first
+        response_element.elements.each do |element|
+          result[element.name.underscore] = element.text
+        end
+        result
+      end
+
+      def commit(soap_action, soap, options)
+        headers = {"SOAPAction" => "\"urn:Interface##{soap_action}\"",
+                   "Content-Type" => "text/xml; charset=utf-8"}
+        response_string = ssl_post(test? ? self.test_url : self.live_url, soap, headers)
+        response = parse(response_string, soap_action)
+        return Response.new(response['errorcode'] == '000',
+                            response['errormessage'],
+                            response,
+                            :test => test?,
+                            :authorization => response['transaction_id'])
+      end
+
+      def build_soap(request)
+        retval = Builder::XmlMarkup.new(:indent => 2)
+        retval.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+        retval.tag!('soap:Envelope', {
+            'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+            'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+            'xmlns:soapenc' => 'http://schemas.xmlsoap.org/soap/encoding/',
+            'xmlns:tns' => 'urn:Interface',
+            'xmlns:types' => 'urn:Interface/encodedTypes',
+            'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/'}) do
+          retval.tag!('soap:Body', {'soap:encodingStyle'=>'http://schemas.xmlsoap.org/soap/encoding/'}) do
+            retval.tag!("tns:#{request}") do
+              retval.tag!("#{request}Request", {'xsi:type'=>"tns:#{request}Request"}) do
+                yield retval
+              end
+            end
+          end
+        end
+        retval.target!
+      end
+
+    end
+  end
+end

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

@@ -36,7 +36,9 @@ module ActiveMerchant #:nodoc:
       #
       # money          - The monetary amount of the transaction in cents.
       # payment_method - The CreditCard or the Spreedly payment method token.
-      # options        - A standard ActiveMerchant options hash
+      # options        - A hash of options:
+      #                  :store - Retain the payment method if the purchase
+      #                           succeeds.  Defaults to false.  (optional)
       def purchase(money, payment_method, options = {})
         if payment_method.is_a?(String)
           purchase_with_token(money, payment_method, options)
@@ -52,7 +54,9 @@ module ActiveMerchant #:nodoc:
       #
       # money          - The monetary amount of the transaction in cents.
       # payment_method - The CreditCard or the Spreedly payment method token.
-      # options        - A standard ActiveMerchant options hash
+      # options        - A hash of options:
+      #                  :store - Retain the payment method if the authorize
+      #                           succeeds.  Defaults to false.  (optional)
       def authorize(money, payment_method, options = {})
         if payment_method.is_a?(String)
           authorize_with_token(money, payment_method, options)
@@ -89,7 +93,8 @@ module ActiveMerchant #:nodoc:
       # credit_card    - The CreditCard to store
       # options        - A standard ActiveMerchant options hash
       def store(credit_card, options={})
-        save_card(true, credit_card, options)
+        retain = (options.has_key?(:retain) ? options[:retain] : true)
+        save_card(retain, credit_card, options)
       end
 
       # Public: Redact the CreditCard in Spreedly. This wipes the sensitive
@@ -101,11 +106,24 @@ module ActiveMerchant #:nodoc:
         commit("payment_methods/#{authorization}/redact.xml", '', :put)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<number>).+(</number>)), '\1[FILTERED]\2').
+          gsub(%r((<verification_value>).+(</verification_value>)), '\1[FILTERED]\2').
+          gsub(%r((<payment_method_token>).+(</payment_method_token>)), '\1[FILTERED]\2')
+      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)
+          add_extra_options(:data, doc, options)
           doc.retained(true) if retain
         end
 
@@ -114,7 +132,7 @@ module ActiveMerchant #:nodoc:
 
       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)
+        commit("gateways/#{options[:gateway_token] || @options[:gateway_token]}/purchase.xml", request)
       end
 
       def authorize_with_token(money, payment_method_token, options)
@@ -125,18 +143,25 @@ module ActiveMerchant #:nodoc:
       def auth_purchase_request(money, payment_method_token, options)
         build_xml_request('transaction') do |doc|
           add_invoice(doc, money, options)
+          doc.ip(options[:ip])
+          add_extra_options(:gateway_specific_fields, doc, options)
           doc.payment_method_token(payment_method_token)
+          doc.retain_on_success(true) if options[:store]
         end
       end
 
       def add_invoice(doc, money, options)
         doc.amount amount(money)
         doc.currency_code(options[:currency] || currency(money) || default_currency)
+        doc.order_id(options[:order_id])
+        doc.ip(options[:ip])
+        doc.description(options[:description])
       end
 
       def add_credit_card(doc, credit_card, options)
         doc.credit_card do
           doc.number(credit_card.number)
+          doc.verification_value(credit_card.verification_value)
           doc.first_name(credit_card.first_name)
           doc.last_name(credit_card.last_name)
           doc.month(credit_card.month)
@@ -147,20 +172,21 @@ module ActiveMerchant #:nodoc:
           doc.city(options[:billing_address].try(:[], :city))
           doc.state(options[:billing_address].try(:[], :state))
           doc.zip(options[:billing_address].try(:[], :zip))
+          doc.country(options[:billing_address].try(:[], :country))
         end
       end
 
-      def add_data(doc, options)
-        doc.data do
-          data_to_doc(doc, options[:data])
+      def add_extra_options(type, doc, options)
+        doc.send(type) do
+          extra_options_to_doc(doc, options[type])
         end
       end
 
-      def data_to_doc(doc, value)
+      def extra_options_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)
+            extra_options_to_doc(doc, v)
           end
         end
       end
@@ -230,4 +256,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-