start_activemerchant 1.50.0

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

@@ -0,0 +1,20 @@
+require 'active_merchant/billing/gateways/smart_ps.rb'
+require 'active_merchant/billing/gateways/braintree/braintree_common'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BraintreeOrangeGateway < SmartPs
+      include BraintreeCommon
+
+      self.display_name = 'Braintree (Orange Platform)'
+      self.supported_countries = ["US"]
+
+      self.live_url = self.test_url = 'https://secure.braintreepaymentgateway.com/api/transact.php'
+
+      def add_processor(post, options)
+        post[:processor_id] = options[:processor] unless options[:processor].nil?
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,189 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BridgePayGateway < Gateway
+      self.display_name = "BridgePay"
+      self.homepage_url = "http://www.bridgepaynetwork.com/"
+
+      self.test_url = "https://gatewaystage.itstgate.com/SmartPayments/transact.asmx/ProcessCreditCard"
+      self.live_url = "https://gateway.itstgate.com/SmartPayments/transact.asmx/ProcessCreditCard"
+
+      self.supported_countries = ["CA", "US"]
+      self.default_currency = "USD"
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+
+      def initialize(options={})
+        requires!(options, :user_name, :password)
+        super
+      end
+
+      def purchase(amount, creditcard, options={})
+        post = post_required_fields("Sale")
+
+        # Allow the same amount in multiple transactions.
+        post[:ExtData] = "<Force>T</Force>"
+        add_invoice(post, amount, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def authorize(amount, creditcard, options={})
+        post = post_required_fields("Auth")
+
+        add_invoice(post, amount, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = post_required_fields("Force")
+
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = post_required_fields("Return")
+
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+
+        commit(post)
+      end
+
+      def void(authorization, options={})
+        post = post_required_fields("Void")
+
+        add_reference(post, authorization)
+
+        commit(post)
+      end
+
+      def verify(creditcard, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, creditcard, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      private
+
+      def post_required_fields(transaction_type)
+        post = {}
+        post[:TransType] = transaction_type
+        post[:Amount] = ""
+        post[:PNRef] = ""
+        post[:InvNum] = ""
+        post[:CardNum] = ""
+        post[:ExpDate] = ""
+        post[:MagData] = ""
+        post[:NameOnCard] = ""
+        post[:Zip] = ""
+        post[:Street] = ""
+        post[:CVNum] = ""
+        post[:MagData] = ""
+        post[:ExtData] = ""
+        post
+      end
+
+      def add_customer_data(post, options)
+        if(billing_address = (options[:billing_address] || options[:address]))
+          post[:Street] = billing_address[:address1]
+          post[:Zip]    = billing_address[:zip]
+        end
+      end
+
+      def add_invoice(post, amount, options)
+        post[:Amount] = amount(amount)
+        post[:InvNum] = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:NameOnCard] = creditcard.name if creditcard.name
+        post[:ExpDate]    = expdate(creditcard)
+        post[:CardNum]    = creditcard.number
+        post[:CVNum]      = creditcard.verification_value
+      end
+
+      def expdate(creditcard)
+        "#{format(creditcard.month, :two_digits)}#{format(creditcard.year, :two_digits)}"
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath("*").each do |node|
+          if (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end unless doc.root.nil?
+
+        response
+      end
+
+      def commit(parameters)
+        url = (test? ? test_url : live_url)
+        data = post_data(parameters)
+        raw = parse(ssl_post(url, data))
+
+        Response.new(
+          success_from(raw[:respmsg]),
+          message_from(raw),
+          raw,
+          authorization: authorization_from(raw),
+          test: test?
+        )
+      end
+
+      def success_from(result)
+        case result
+        when "Approved"
+          true
+        else
+          false
+        end
+      end
+
+      def message_from(response)
+        response[:respmsg]
+      end
+
+      def authorization_from(response)
+        [response[:authcode], response[:pnref]].join("|")
+      end
+
+      def split_authorization(authorization)
+        authcode, pnref = authorization.split("|")
+        [authcode, pnref]
+      end
+
+      def add_reference(post, authorization)
+        authcode, pnref = split_authorization(authorization)
+        post[:AuthCode] = authcode
+        post[:PNRef] = pnref
+      end
+
+      def post_data(post)
+        {
+          :UserName => @options[:user_name],
+          :Password => @options[:password]
+        }.merge(post).collect{|k,v| "#{k}=#{CGI.escape(v.to_s)}"}.join("&")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardSaveGateway < IridiumGateway
+      #CardSave lets you handle failovers on payments by providing 3 gateways in case one happens to be down
+      #URLS = ['https://gw1.cardsaveonlinepayments.com:4430/','https://gw2.cardsaveonlinepayments.com:4430/','https://gw3.cardsaveonlinepayments.com:4430/']      
+      
+      self.money_format = :cents
+      self.default_currency = 'GBP'
+      self.supported_cardtypes = [ :visa, :switch, :maestro, :master, :solo, :american_express, :jcb ]
+      self.supported_countries = [ 'GB' ]
+      self.homepage_url = 'http://www.cardsave.net/'
+      self.display_name = 'CardSave'
+      
+      def initialize(options={})
+        super
+        @test_url = 'https://gw1.cardsaveonlinepayments.com:4430/'
+        @live_url = 'https://gw1.cardsaveonlinepayments.com:4430/'
+      end
+      
+    end
+  end
+end
+

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

@@ -0,0 +1,238 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CardStreamGateway < Gateway
+      self.test_url = self.live_url = 'https://gateway.cardstream.com/direct/'
+      self.money_format = :cents
+      self.default_currency = 'GBP'
+      self.supported_countries = ['GB', 'US', 'CH', 'SE', 'SG', 'NO', 'JP', 'IS', 'HK', 'NL', 'CZ', 'CA', 'AU']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro, :solo, :switch]
+      self.homepage_url = 'http://www.cardstream.com/'
+      self.display_name = 'CardStream'
+
+      CURRENCY_CODES = {
+        "AUD" => '036',
+        "CAD" => '124',
+        "CZK" => '203',
+        "DKK" => '208',
+        "HKD" => '344',
+        "ICK" => '352',
+        "JPY" => '392',
+        "NOK" => '578',
+        "SGD" => '702',
+        "SEK" => '752',
+        "CHF" => '756',
+        "GBP" => '826',
+        "USD" => '840',
+        "EUR" => '978'
+      }
+
+      CVV_CODE = {
+        '0' => 'U',
+        '1' => 'P',
+        '2' => 'M',
+        '4' => 'N'
+      }
+
+      # 0 - No additional information available.
+      # 1 - Postcode not checked.
+      # 2 - Postcode matched.
+      # 4 - Postcode not matched.
+      # 8 - Postcode partially matched.
+      AVS_POSTAL_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+
+      # 0 - No additional information available.
+      # 1 - Address numeric not checked.
+      # 2 - Address numeric matched.
+      # 4 - Address numeric not matched.
+      # 8 - Address numeric partially matched.
+      AVS_STREET_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :shared_secret)
+        if (options[:threeDSRequired])
+          @threeDSRequired = options[:threeDSRequired]
+        else
+          @threeDSRequired = 'N'
+        end
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_invoice(post, creditcard, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        commit('PREAUTH', post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_invoice(post, creditcard, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        commit('SALE', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_amount(post, money, options)
+        commit('SALE', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        add_amount(post, money, options)
+        commit('REFUND', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_pair(post, :xref, authorization)
+        commit('REFUND', post)
+      end
+
+      def verify(creditcard, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, creditcard, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((cardNumber=)\d+), '\1[FILTERED]').
+          gsub(%r((CVV=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        add_pair(post, :amount, amount(money), :required => true)
+        add_pair(post, :currencyCode, currency_code(options[:currency] || currency(money)) || currency_code(self.default_currency))
+      end
+
+      def add_customer_data(post, options)
+        address = options[:billing_address] || options[:address]
+        add_pair(post, :customerPostCode, address[:zip])
+        add_pair(post, :customerEmail, options[:email])
+        add_pair(post, :customerPhone, options[:phone])
+      end
+
+      def add_address(post, creditcard, options)
+        address = options[:billing_address] || options[:address]
+
+        return if address.nil?
+
+        add_pair(post, :customerAddress, address[:address1] + " " + (address[:address2].nil? ? "" : address[:address2]))
+        add_pair(post, :customerPostCode, address[:zip])
+      end
+
+      def add_invoice(post, credit_card, money, options)
+        add_pair(post, :transactionUnique, options[:order_id], :required => true)
+        add_pair(post, :orderRef, options[:description] || options[:order_id], :required => true)
+        if ['american_express', 'diners_club'].include?(card_brand(credit_card).to_s)
+          add_pair(post, :item1Quantity, 1)
+          add_pair(post, :item1Description, (options[:description] || options[:order_id]).slice(0, 15))
+          add_pair(post, :item1GrossValue, amount(money))
+        end
+      end
+
+      def add_creditcard(post, credit_card)
+        add_pair(post, :customerName, credit_card.name, :required => true)
+        add_pair(post, :cardNumber, credit_card.number, :required => true)
+
+        add_pair(post, :cardExpiryMonth, format(credit_card.month, :two_digits), :required => true)
+        add_pair(post, :cardExpiryYear, format(credit_card.year, :two_digits), :required => true)
+
+        if requires_start_date_or_issue_number?(credit_card)
+          add_pair(post, :cardStartMonth, format(credit_card.start_month, :two_digits))
+          add_pair(post, :cardStartYear, format(credit_card.start_year, :two_digits))
+
+          add_pair(post, :cardIssueNumber, credit_card.issue_number)
+        end
+
+        add_pair(post, :cardCVV, credit_card.verification_value)
+      end
+
+      def add_hmac(post)
+        result = post.sort.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        result = Digest::SHA512.hexdigest("#{result}#{@options[:shared_secret]}")
+
+        add_pair(post, :signature, result)
+      end
+
+      def parse(body)
+        result = {}
+        pairs = body.split("&")
+        pairs.each do |pair|
+          a = pair.split("=")
+          # because some values pairs dont have a value
+          result[a[0].to_sym] = a[1] == nil ? '' : CGI.unescape(a[1])
+        end
+        result
+      end
+
+      def commit(action, parameters)
+
+        parameters.update(
+          :merchantID => @options[:login],
+          :action => action,
+          :type => '1', #Ecommerce
+          :countryCode => self.supported_countries[0],
+          :threeDSRequired => @threeDSRequired #Disable 3d secure by default
+        )
+        # adds a signature to the post hash/array
+        add_hmac(parameters)
+
+        response = parse(ssl_post(self.live_url, post_data(action, parameters)))
+
+        Response.new(response[:responseCode] == "0",
+                     response[:responseCode] == "0" ? "APPROVED" : response[:responseMessage],
+                     response,
+                     :test => test?,
+                     :authorization => response[:xref],
+                     :cvv_result => CVV_CODE[response[:avscv2ResponseCode].to_s[0, 1]],
+                     :avs_result => {
+                       :postal_match => AVS_POSTAL_MATCH[response[:avscv2ResponseCode].to_s[1, 1]],
+                       :street_match => AVS_STREET_MATCH[response[:avscv2ResponseCode].to_s[2, 1]]
+                     }
+        )
+      end
+
+      def currency_code(currency)
+        CURRENCY_CODES[currency]
+      end
+
+      def post_data(action, parameters = {})
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+    end
+  end
+end