tlconnor-activemerchant 1.20.4

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

@@ -0,0 +1,308 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BarclaysEpdqGateway < Gateway
+      TEST_URL = 'https://secure2.mde.epdq.co.uk:11500'
+      LIVE_URL = 'https://secure2.epdq.co.uk:11500'
+
+      self.supported_countries = ['UK']
+      self.default_currency = 'GBP'
+      self.supported_cardtypes = [:visa, :master, :maestro, :switch ]
+      self.money_format = :cents
+      self.homepage_url = 'http://www.barclaycard.co.uk/business/accepting-payments/epdq-mpi/'
+      self.display_name = 'Barclays ePDQ'
+      
+      def initialize(options = {})
+        requires!(options, :login, :password, :client_id)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, creditcard, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(options[:order_id]) do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:PreAuth, money)
+          end
+        end
+
+        commit(document)
+      end
+      
+      def purchase(money, creditcard, options = {})
+        # disable fraud checks if this is a repeat order:
+        if options[:payment_number] && (options[:payment_number] > 1)
+          no_fraud = true
+        else
+          no_fraud = options[:no_fraud]
+        end
+        document = Document.new(self, @options, :no_fraud => no_fraud) do
+          add_order_form(options[:order_id], options[:group_id]) do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:Auth, money, options)
+          end
+        end
+        commit(document)
+      end                       
+    
+      # authorization is your unique order ID, not the authorization 
+      # code returned by ePDQ
+      def capture(money, authorization, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(authorization) do
+            add_transaction(:PostAuth, money)
+          end
+        end
+
+        commit(document)
+      end
+
+      # authorization is your unique order ID, not the authorization 
+      # code returned by ePDQ
+      def credit(money, creditcard_or_authorization, options = {})
+        if creditcard_or_authorization.is_a?(String)
+          deprecated CREDIT_DEPRECATION_MESSAGE
+          refund(money, creditcard_or_authorization, options)
+        else
+          credit_new_order(money, creditcard_or_authorization, options)
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        credit_existing_order(money, authorization, options)
+      end
+
+      def void(authorization, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(authorization) do
+            add_transaction(:Void)
+          end
+        end
+
+        commit(document)
+      end
+
+      private                       
+      def credit_new_order(money, creditcard, options)
+        document = Document.new(self, @options) do
+          add_order_form do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:Credit, money)
+          end
+        end
+
+        commit(document)
+      end
+
+      def credit_existing_order(money, authorization, options)
+        order_id, _ = authorization.split(":")
+        document = Document.new(self, @options) do
+          add_order_form(order_id) do
+            add_transaction(:Credit, money)
+          end
+        end
+        
+        commit(document)
+      end
+      
+      def parse(body)
+        parser = Parser.new(body)
+        response = parser.parse
+        Response.new(response[:success], response[:message], response,
+          :test => test?,
+          :authorization => response[:authorization],
+          :avs_result => response[:avsresponse],
+          :cvv_result => response[:cvv_result],
+          :order_id => response[:order_id],
+          :raw_response => response[:raw_response]
+        )
+      end     
+      
+      def commit(document)
+        url = (test? ? TEST_URL : LIVE_URL)
+        data = ssl_post(url, document.to_xml)
+        parse(data)
+      end
+
+      class Parser
+        def initialize(response)
+          @response = response
+        end
+
+        def parse
+          doc = REXML::Document.new(@response)
+          auth_type = find(doc, "//Transaction/Type").to_s
+
+          message = find(doc, "//Message/Text")
+          if message.blank?
+            message = find(doc, "//Transaction/CardProcResp/CcReturnMsg")
+          end
+
+          case auth_type
+          when 'Credit', 'Void'
+            success = find(doc, "//CcReturnMsg") == "Approved."
+          else
+            success = find(doc, "//Transaction/AuthCode").present?
+          end
+
+          {       
+            :success => success,
+            :message => message,
+            :authorization => find(doc, "//Transaction/Id"),
+            :avs_result => find(doc, "//Transaction/AvsRespCode"),
+            :cvv_result => find(doc, "//Transaction/Cvv2Resp"),
+            :order_id => find(doc, "//OrderFormDoc/Transaction/Id"),
+            :raw_response => @response
+          }
+        end
+
+        def find(doc, xpath)
+          REXML::XPath.first(doc, xpath).try(:text)
+        end
+      end
+
+      class Document
+        attr_reader :type, :xml
+
+        PAYMENT_INTERVALS = { 
+          :days => 'D',
+          :months => 'M'
+        }
+
+        EPDQ_CARD_TYPES = {
+          :visa => 1,
+          :master => 2,
+          :switch => 9,
+          :maestro => 10,
+        }
+      
+        def initialize(gateway, options = {}, document_options = {}, &block)
+          @gateway = gateway
+          @options = options
+          @document_options = document_options
+          @xml = Builder::XmlMarkup.new(:indent => 2)
+          build(&block)
+        end
+
+        def to_xml
+          @xml.target!
+        end
+
+        def build(&block)
+          xml.instruct!(:xml, :version => '1.0')
+          xml.EngineDocList do
+            xml.DocVersion "1.0"
+            xml.EngineDoc do
+              xml.ContentType "OrderFormDoc"
+              xml.User do
+                xml.Name(@options[:login])
+                xml.Password(@options[:password])
+                xml.ClientId({ :DataType => "S32" }, @options[:client_id])
+              end
+              xml.Instructions do
+                if @document_options[:no_fraud]
+                  xml.Pipeline "PaymentNoFraud" 
+                else
+                  xml.Pipeline "Payment"
+                end
+              end
+              instance_eval(&block)
+            end
+          end
+        end
+
+        def add_order_form(order_id=nil, group_id=nil, &block)
+          xml.OrderFormDoc do
+            xml.Mode 'P'
+            xml.Id(order_id) if order_id
+            xml.GroupId(group_id) if group_id
+            instance_eval(&block)
+          end
+        end
+
+        def add_consumer(options=nil, &block)
+          xml.Consumer do
+            if options
+              xml.Email(options[:email]) if options[:email]
+              billing_address = options[:billing_address] || options[:address]
+              if billing_address
+                xml.BillTo do
+                  xml.Location do
+                    xml.Address do
+                      xml.Street1 billing_address[:address1]
+                      xml.Street2 billing_address[:address2]
+                      xml.City billing_address[:city]
+                      xml.StateProv billing_address[:state]
+                      xml.PostalCode billing_address[:zip]
+                      xml.Country billing_address[:country_code]
+                    end
+                  end
+                end
+              end
+            end
+            instance_eval(&block)
+          end
+        end
+
+        def add_creditcard(creditcard)
+          xml.PaymentMech do
+            xml.CreditCard do
+              xml.Type({ :DataType => 'S32' }, EPDQ_CARD_TYPES[creditcard.brand.to_sym])
+              xml.Number creditcard.number
+              xml.Expires({ :DataType => 'ExpirationDate', :Locale => 826 }, format_expiry_date(creditcard))
+              if creditcard.verification_value.present?
+                xml.Cvv2Indicator 1
+                xml.Cvv2Val creditcard.verification_value
+              else
+                xml.Cvv2Indicator 5
+              end
+              xml.IssueNum(creditcard.issue_number) if creditcard.issue_number.present?
+            end
+          end
+        end
+
+        def add_transaction(auth_type, amount = nil, options = {})
+          @auth_type = auth_type
+          xml.Transaction do
+            xml.Type @auth_type.to_s
+            if options[:payment_number] && options[:payment_number] > 1
+              xml.CardholderPresentCode({ :DataType => 'S32' }, 8)
+            else
+              xml.CardholderPresentCode({ :DataType => 'S32' }, 7)
+            end
+            if options[:payment_number]
+              xml.PaymentNumber({ :DataType => 'S32' }, options[:payment_number])
+            end
+            if options[:total_payments]
+              xml.TotalNumberPayments({ :DataType => 'S32' }, options[:total_payments])
+            end
+            if amount
+              xml.CurrentTotals do
+                xml.Totals do
+                  xml.Total({ :DataType => 'Money', :Currency => 826 }, amount)
+                end
+              end
+            end
+          end
+        end
+
+        # date must be formatted MM/YY
+        def format_expiry_date(creditcard)
+          month_str = "%02d" % creditcard.month
+          if match = creditcard.year.to_s.match(/^\d{2}(\d{2})$/) 
+            year_str = "%02d" % match[1].to_i
+          else 
+            year_str = "%02d" % creditcard.year
+          end
+          "#{month_str}/#{year_str}"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,167 @@
+require File.dirname(__FILE__) + '/beanstream/beanstream_core'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # This class implements the Canadian {Beanstream}[http://www.beanstream.com] payment gateway.
+    # It is also named TD Canada Trust Online Mart payment gateway.
+    # To learn more about the specification of Beanstream gateway, please read the OM_Direct_Interface_API.pdf,
+    # which you can get from your Beanstream account or get from me by email.
+    #  
+    # == Supported transaction types by Beanstream:
+    # * +P+ - Purchase
+    # * +PA+ - Pre Authorization
+    # * +PAC+ - Pre Authorization Completion
+    #  
+    # == Secure Payment Profiles:
+    # BeanStream supports payment profiles (vaults). This allows you to store cc information with BeanStream and process subsequent transactions with a customer id.
+    # Secure Payment Profiles must be enabled on your account (must be done over the phone).
+    # Your API Access Passcode must be set in Administration => account settings => order settings.
+    # To learn more about storing credit cards with the Beanstream gateway, please read the BEAN_Payment_Profiles.pdf (I had to phone BeanStream to request it.)
+    # 
+    # == Notes 
+    # * Adding of order products information is not implemented.
+    # * Ensure that country and province data is provided as a code such as "CA", "US", "QC".
+    # * login is the Beanstream merchant ID, username and password should be enabled in your Beanstream account and passed in using the <tt>:user</tt> and <tt>:password</tt> options.
+    # * Test your app with your true merchant id and test credit card information provided in the api pdf document.
+    # * Beanstream does not allow Payment Profiles to be deleted with their API. The accounts are 'closed', but have to be deleted manually.  
+    #  
+    #  Example authorization (Beanstream PA transaction type):
+    #  
+    #   twenty = 2000
+    #   gateway = BeanstreamGateway.new(
+    #     :login => '100200000',
+    #     :user => 'xiaobozz',
+    #     :password => 'password'
+    #   )
+    #   
+    #   credit_card = CreditCard.new(
+    #     :number => '4030000010001234',
+    #     :month => 8,
+    #     :year => 2011,
+    #     :first_name => 'xiaobo',
+    #     :last_name => 'zzz',
+    #     :verification_value => 137
+    #   )
+    #   response = gateway.authorize(twenty, credit_card,
+    #     :order_id => '1234',
+    #     :billing_address => {
+    #       :name => 'xiaobo zzz',
+    #       :phone => '555-555-5555',
+    #       :address1 => '1234 Levesque St.',
+    #       :address2 => 'Apt B',
+    #       :city => 'Montreal',
+    #       :state => 'QC',
+    #       :country => 'CA',
+    #       :zip => 'H2C1X8'
+    #     },
+    #     :email => 'xiaobozzz@example.com',
+    #     :subtotal => 800,
+    #     :shipping => 100,
+    #     :tax1 => 100,
+    #     :tax2 => 100,
+    #     :custom => 'reference one'
+    #   )
+    class BeanstreamGateway < Gateway
+      include BeanstreamCore
+      
+      def authorize(money, source, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_source(post, source)        
+        add_address(post, options)
+        add_transaction_type(post, :authorization)
+        commit(post)
+      end
+      
+      def purchase(money, source, options = {})
+        post = {}
+        add_amount(post, money) 
+        add_invoice(post, options)
+        add_source(post, source)
+        add_address(post, options)
+        add_transaction_type(post, purchase_action(source))
+        commit(post)
+      end                       
+          
+      def void(authorization, options = {})
+        reference, amount, type = split_auth(authorization)
+        
+        post = {}
+        add_reference(post, reference)
+        add_original_amount(post, amount)
+        add_transaction_type(post, void_action(type))
+        commit(post)
+      end
+      
+      def recurring(money, source, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, source)
+        add_address(post, options)
+        add_transaction_type(post, purchase_action(source))
+        add_recurring_type(post, options)
+        commit(post)
+      end
+      
+      def update_recurring(amount, source, options = {})
+        post = {}
+        add_recurring_amount(post, amount)
+        add_recurring_invoice(post, options)
+        add_credit_card(post, source)
+        add_address(post, options)
+        add_recurring_operation_type(post, :update)
+        add_recurring_service(post, options)
+        recurring_commit(post)
+      end
+      
+      def cancel_recurring(options = {})
+        post = {}
+        add_recurring_operation_type(post, :cancel)
+        add_recurring_service(post, options)
+        recurring_commit(post)
+      end
+
+      def interac
+        @interac ||= BeanstreamInteracGateway.new(@options)
+      end
+      
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(credit_card, options = {})
+        post = {}        
+        add_address(post, options)
+        add_credit_card(post, credit_card)      
+        add_secure_profile_variables(post,options)
+        commit(post, true)
+      end
+      
+      #can't actually delete a secure profile with the supplicaed API. This function sets the status of the profile to closed (C).
+      #Closed profiles will have to removed manually.
+      def delete(vault_id)
+        update(vault_id, false, {:status => "C"})
+      end
+      
+      alias_method :unstore, :delete
+      
+      # Update the values (such as CC expiration) stored at
+      # the gateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, credit_card, options = {})
+        post = {}
+        add_address(post, options)
+        add_credit_card(post, credit_card)
+        options.merge!({:vault_id => vault_id, :operation => secure_profile_action(:modify)})
+        add_secure_profile_variables(post,options)
+        commit(post, true)
+      end
+
+      private
+      def build_response(*args)
+        Response.new(*args)
+      end
+    end
+  end
+end
+