activemerchant 1.22.0 → 1.23.0

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

@@ -0,0 +1,275 @@
+require 'rubygems'
+require 'LitleOnline'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class LitleGateway < Gateway
+      # Specific to Litle options:
+      # * <tt>:merchant_id</tt> - Merchant Id assigned by Litle
+      # * <tt>:user</tt> - Username assigned by Litle
+      # * <tt>:password</tt> - Password assigned by Litle
+      # * <tt>:version</tt> - The version of the api you are using (eg, '8.10')
+      # * <tt>:proxy_addr</tt> - Proxy address - nil if not needed
+      # * <tt>:proxy_port</tt> - Proxy port - nil if not needed
+      # * <tt>:url</tt> - URL assigned by Litle (for testing, use the sandbox)
+      #
+      # Standard Active Merchant options
+      # * <tt>:order_id</tt> - The order number
+      # * <tt>:ip</tt> - The IP address of the customer making the purchase
+      # * <tt>:customer</tt> - The name, customer number, or other information that identifies the customer
+      # * <tt>:invoice</tt> - The invoice number
+      # * <tt>:merchant</tt> - The name or description of the merchant offering the product
+      # * <tt>:description</tt> - A description of the transaction
+      # * <tt>:email</tt> - The email address of the customer
+      # * <tt>:currency</tt> - The currency of the transaction.  Only important when you are using a currency that is not the default with a gateway that supports multiple currencies.
+      # * <tt>:billing_address</tt> - A hash containing the billing address of the customer.
+      # * <tt>:shipping_address</tt> - A hash containing the shipping address of the customer.
+      #
+      # The <tt>:billing_address</tt>, and <tt>:shipping_address</tt> hashes can have the following keys:
+      #
+      # * <tt>:name</tt> - The full name of the customer.
+      # * <tt>:company</tt> - The company name of the customer.
+      # * <tt>:address1</tt> - The primary street address of the customer.
+      # * <tt>:address2</tt> - Additional line of address information.
+      # * <tt>:city</tt> - The city of the customer.
+      # * <tt>:state</tt> - The state of the customer.  The 2 digit code for US and Canadian addresses. The full name of the state or province for foreign addresses.
+      # * <tt>:country</tt> - The [ISO 3166-1-alpha-2 code](http://www.iso.org/iso/country_codes/iso_3166_code_lists/english_country_names_and_code_elements.htm) for the customer.
+      # * <tt>:zip</tt> - The zip or postal code of the customer.
+      # * <tt>:phone</tt> - The phone number of the customer.
+
+      TEST_URL = 'https://www.testlitle.com/sandbox/communicator/online'
+      LIVE_URL = 'https://payments.litle.com/vap/communicator/online'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.litle.com/'
+
+      # The name of the gateway
+      self.display_name = 'Litle & Co.'
+
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        @litle = LitleOnline::LitleOnlineRequest.new
+        requires!(options, :merchant_id, :user, :password, :version, :url)
+        @options = options
+      end
+
+      def authorize(money, creditcard, options = {})
+        to_pass = create_credit_card_hash(money, creditcard, options)
+        build_response(:authorization, @litle.authorization(to_pass))
+      end
+
+      def purchase(money, creditcard, options = {})
+        to_pass = create_credit_card_hash(money, creditcard, options)
+        build_response(:sale, @litle.sale(to_pass))
+      end
+
+      def capture(money, authorization, options = {})
+        to_pass = create_capture_hash(money, authorization, options)
+        build_response(:capture, @litle.capture(to_pass))
+      end
+
+      def void(identification, options = {})
+        to_pass = create_void_hash(identification, options)
+        build_response(:void, @litle.void(to_pass))
+      end
+
+      def credit(money, identification, options = {})
+        to_pass = create_credit_hash(money, identification, options)
+        build_response(:credit, @litle.credit(to_pass))
+      end
+
+      def store(creditcard, options = {})
+        to_pass = create_token_hash(creditcard, options)
+        build_response(:registerToken, @litle.register_token_request(to_pass), %w(801 802))
+      end
+
+      private
+
+      CARD_TYPE = {
+        'visa' => 'VI',
+        'master' => 'MC',
+        'american_express' => 'AX',
+        'discover' => 'DI',
+        'jcb' => 'DI',
+        'diners_club' => 'DI'
+      }
+
+      AVS_RESPONSE_CODE = {
+        '00' => 'Y',
+        '01' => 'X',
+        '02' => 'D',
+        '10' => 'Z',
+        '11' => 'W',
+        '12' => 'A',
+        '13' => 'A',
+        '14' => 'P',
+        '20' => 'N',
+        '30' => 'S',
+        '31' => 'R',
+        '32' => 'U',
+        '33' => 'R',
+        '34' => 'I',
+        '40' => 'E'
+      }
+
+      def build_response(kind, litle_response, valid_responses=%w(000))
+        if litle_response.response == "0"
+          detail = litle_response.send("#{kind}Response")
+          Response.new(
+            (valid_responses.include?(detail.response)),
+            detail.message,
+            {:litleOnlineResponse => litle_response},
+            :authorization => detail.litleTxnId,
+            :avs_result => {:code => fraud_result(detail)['avs']},
+            :cvv_result => fraud_result(detail)['cvv']
+          )
+        else
+          Response.new(false, litle_response.message, :litleOnlineResponse => litle_response)
+        end
+      end
+
+      def create_credit_card_hash(money, creditcard, options)
+        cc_type = CARD_TYPE[creditcard.type]
+
+        exp_date_yr = creditcard.year.to_s()[2..3]
+
+        if( creditcard.month.to_s().length == 1 )
+          exp_date_mo = '0' + creditcard.month.to_s()
+        else
+          exp_date_mo = creditcard.month.to_s()
+        end
+
+        exp_date = exp_date_mo + exp_date_yr
+
+        card_info = {
+          'type' => cc_type,
+          'number' => creditcard.number,
+          'expDate' => exp_date,
+          'cardValidationNum' => creditcard.verification_value
+        }
+
+        hash = create_hash(money, options)
+        hash['card'] = card_info
+        hash
+      end
+
+      def create_capture_hash(money, authorization, options)
+        hash = create_hash(money, options)
+        hash['litleTxnId'] = authorization
+        hash
+      end
+
+      def create_credit_hash(money, identification, options)
+        hash = create_hash(money, options)
+        hash['litleTxnId'] = identification
+        hash['orderSource'] = nil
+        hash['orderId'] = nil
+        hash
+      end
+
+      def create_token_hash(creditcard, options)
+        hash = create_hash(0, options)
+        hash['accountNumber'] = creditcard.number
+        hash
+      end
+
+      def create_void_hash(identification, options)
+        hash = create_hash(nil, options)
+        hash['litleTxnId'] = identification
+        hash
+      end
+
+      def create_hash(money, options)
+        fraud_check_type = {}
+        if options[:ip]
+          fraud_check_type['customerIpAddress'] = options[:ip]
+        end
+
+        enhanced_data = {}
+        if options[:invoice]
+          enhanced_data['invoiceReferenceNumber'] = options[:invoice]
+        end
+
+        if options[:description]
+          enhanced_data['customerReference'] = options[:description]
+        end
+
+        if options[:billing_address]
+          bill_to_address = {
+            'name' => options[:billing_address][:name],
+            'companyName' => options[:billing_address][:company],
+            'addressLine1' => options[:billing_address][:address1],
+            'addressLine2' => options[:billing_address][:address2],
+            'city' => options[:billing_address][:city],
+            'state' => options[:billing_address][:state],
+            'zip' => options[:billing_address][:zip],
+            'country' => options[:billing_address][:country],
+            'email' => options[:email],
+            'phone' => options[:billing_address][:phone]
+          }
+        end
+        if options[:shipping_address]
+          ship_to_address = {
+            'name' => options[:shipping_address][:name],
+            'companyName' => options[:shipping_address][:company],
+            'addressLine1' => options[:shipping_address][:address1],
+            'addressLine2' => options[:shipping_address][:address2],
+            'city' => options[:shipping_address][:city],
+            'state' => options[:shipping_address][:state],
+            'zip' => options[:shipping_address][:zip],
+            'country' => options[:shipping_address][:country],
+            'email' => options[:email],
+            'phone' => options[:shipping_address][:phone]
+          }
+        end
+
+        hash = {
+          'billToAddress' => bill_to_address,
+          'shipToAddress' => ship_to_address,
+          'orderId' => (options[:order_id] or @options[:order_id]),
+          'customerId' => options[:customer],
+          'reportGroup' => (options[:merchant] or @options[:merchant]),
+          'merchantId' => (options[:merchant_id] or @options[:merchant_id]),
+          'orderSource' => 'ecommerce',
+          'enhancedData' => enhanced_data,
+          'fraudCheckType' => fraud_check_type,
+          'user' => (options[:user] or @options[:user]),
+          'password' => (options[:password] or @options[:password]),
+          'version' => (options[:version] or @options[:version]),
+          'url' => (options[:url] or @options[:url]),
+          'proxy_addr' => (options[:proxy_addr] or @options[:proxy_addr]),
+          'proxy_port' => (options[:proxy_port] or @options[:proxy_port]),
+          'id' => (options[:id] or options[:order_id] or @options[:order_id])
+        }
+
+        if( !money.nil? && money.to_s.length > 0 )
+          hash.merge!({'amount' => money})
+        end
+        hash
+      end
+
+      def fraud_result(authorization_response)
+        if authorization_response.respond_to?('fraudResult')
+          fraud_result = authorization_response.fraudResult
+          if fraud_result.respond_to?('cardValidationResult')
+            cvv_to_pass = fraud_result.cardValidationResult
+            if(cvv_to_pass == "")
+              cvv_to_pass = "P"
+            end
+          end
+          if fraud_result.respond_to?('avsResult')
+            avs_to_pass = AVS_RESPONSE_CODE[fraud_result.avsResult]
+          end
+        end
+        {'cvv'=>cvv_to_pass, 'avs'=>avs_to_pass}
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, credit_card_or_stored_id, options = {})
-        if credit_card_or_stored_id.is_a?(ActiveMerchant::Billing::CreditCard)
+        if credit_card_or_stored_id.respond_to?(:number)
           #Credit card for instant payment
           commit :purchase, build_purchase_request(money, credit_card_or_stored_id, options)
         else

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

@@ -20,7 +20,7 @@ module ActiveMerchant #:nodoc:
       
       self.homepage_url = 'http://www.paymentexpress.com/'
       self.display_name = 'PaymentExpress'
-      
+
       URL = 'https://sec.paymentexpress.com/pxpost.aspx'
       
       APPROVED = '1'
@@ -34,8 +34,13 @@ module ActiveMerchant #:nodoc:
       }
       
       # We require the DPS gateway username and password when the object is created.
+      #
+      # The PaymentExpress gateway also supports a :use_custom_payment_token boolean option.
+      # If set to true the gateway will use BillingId for the Token type.  If set to false,
+      # then the token will be sent as the DPS specified "DpsBillingId".  This is per the documentation at
+      # http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Tokenbilling
       def initialize(options = {})
-        # A DPS username and password must exist 
+        # A DPS username and password must exist
         requires!(options, :login, :password)
         # Make the options an instance variable
         @options = options
@@ -43,6 +48,12 @@ module ActiveMerchant #:nodoc:
       end
       
       # Funds are transferred immediately.
+      #
+      # `payment_source` can be a usual ActiveMerchant credit_card object, or can also
+      # be a string of the `DpsBillingId` or `BillingId` which can be gotten through the 
+      # store method.  If you are using a `BillingId` instead of `DpsBillingId` you must
+      # also set the instance method `#use_billing_id_for_token` to true, see the `#store`
+      # method for an example of how to do this.
       def purchase(money, payment_source, options = {})
         request = build_purchase_or_authorization_request(money, payment_source, options)
         commit(:purchase, request)      
@@ -51,6 +62,8 @@ module ActiveMerchant #:nodoc:
       # NOTE: Perhaps in options we allow a transaction note to be inserted
       # Verifies that funds are available for the requested card and amount and reserves the specified amount.
       # See: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Authcomplete
+      #
+      # `payment_source` can be a usual ActiveMerchant credit_card object or a token, see #purchased method
       def authorize(money, payment_source, options = {})
         request = build_purchase_or_authorization_request(money, payment_source, options)
         commit(:authorization, request)
@@ -76,18 +89,47 @@ module ActiveMerchant #:nodoc:
         refund(money, identification, options)
       end
       
-      # token based billing
-      
-      # initiates a "Validate" transcation to store card data on payment express servers
-      # returns a "token" that can be used to rebill this card
+      # Token Based Billing
+      # 
+      # Instead of storing the credit card details locally, you can store them inside the
+      # Payment Express system and instead bill future transactions against a token.
+      #
+      # This token can either be specified by your code or autogenerated by the PaymentExpress
+      # system.  The default is to let PaymentExpress generate the token for you and so use
+      # the `DpsBillingId`.  If you do not pass in any option of the `billing_id`, then the store
+      # method will ask PaymentExpress to create a token for you.  Additionally, if you are
+      # using the default `DpsBillingId`, you do not have to do anything extra in the
+      # initialization of your gateway object.
+      #
+      # To specify and use your own token, you need to do two things.
+      # 
+      # Firstly, pass in a `:billing_id` as an option in the hash of this store method.  No
+      # validation is done on this BillingId by PaymentExpress so you must ensure that it is unique.
+      #
+      #     gateway.store(credit_card, {:billing_id => 'YourUniqueBillingId'})
+      #
+      # Secondly, you will need to pass in the option `{:use_custom_payment_token => true}` when
+      # initializing your gateway instance, like so:
+      #
+      #     gateway = ActiveMerchant::Billing::PaymentExpressGateway.new(
+      #       :login    => 'USERNAME',
+      #       :password => 'PASSWORD',
+      #       :use_custom_payment_token => true
+      #     )
+      #
       # see: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Tokenbilling
-      # PaymentExpress does not support unstoring a stored card.
+      #
+      # Note, once stored, PaymentExpress does not support unstoring a stored card.
       def store(credit_card, options = {})
         request  = build_token_request(credit_card, options)
         commit(:validate, request)
       end
-      
+    
       private
+
+      def use_custom_payment_token?
+        @options[:use_custom_payment_token]
+      end
       
       def build_purchase_or_authorization_request(money, payment_source, options)
         result = new_transaction      
@@ -137,6 +179,7 @@ module ActiveMerchant #:nodoc:
         
         if credit_card.verification_value?
           xml.add_element("Cvc2").text = credit_card.verification_value
+          xml.add_element("Cvc2Presence").text = "1"
         end
         
         if requires_start_date_or_issue_number?(credit_card)
@@ -144,9 +187,13 @@ module ActiveMerchant #:nodoc:
           xml.add_element("IssueNumber").text = credit_card.issue_number unless credit_card.issue_number.blank?
         end
       end
-      
-      def add_billing_token(xml, token) 
-        xml.add_element("DpsBillingId").text = token
+
+      def add_billing_token(xml, token)
+        if use_custom_payment_token?
+          xml.add_element("BillingId").text = token
+        else
+          xml.add_element("DpsBillingId").text = token
+        end
       end
       
       def add_token_request(xml, options)
@@ -232,4 +279,4 @@ module ActiveMerchant #:nodoc:
       end
     end
   end
-end
+end

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

@@ -64,7 +64,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, credit_card_or_stored_id, options = {})
-        if credit_card_or_stored_id.is_a?(ActiveMerchant::Billing::CreditCard)
+        if credit_card_or_stored_id.respond_to?(:number)
           requires!(options, :order_id)
           commit :purchase, build_purchase_request(money, credit_card_or_stored_id, options)
         else
@@ -126,7 +126,8 @@ module ActiveMerchant #:nodoc:
       def build_reference_request(money, reference)
         xml = Builder::XmlMarkup.new
 
-        transaction_id, order_id, preauth_id, original_amount = reference.split("*")
+        transaction_id, order_id, preauth_id, original_amount = reference.split('*')
+
         xml.tag! 'amount', (money ? amount(money) : original_amount)
         xml.tag! 'currency', options[:currency] || currency(money)
         xml.tag! 'txnID', transaction_id

data/lib/active_merchant/billing/integrations/two_checkout.rb

@@ -7,7 +7,7 @@ module ActiveMerchant #:nodoc:
         autoload 'Notification', File.dirname(__FILE__) + '/two_checkout/notification'
        
         mattr_accessor :payment_routine
-        self.payment_routine = :multi_page
+        self.payment_routine = :single_page
         
         def self.service_url
           case self.payment_routine

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

@@ -6,67 +6,84 @@ module ActiveMerchant #:nodoc:
           def initialize(order, account, options = {})
             super
             add_field('fixed', 'Y')
-            
+
             if ActiveMerchant::Billing::Base.integration_mode == :test || options[:test]
               add_field('demo', 'Y')
-            end 
+            end
           end
-          
+
           # The 2checkout vendor account number
           mapping :account, 'sid'
-          
-          # he total amount to be billed, in decimal form, without a currency symbol. (8 characters, decimal, 2 characters: Example: 99999999.99)
+
+          # The total amount to be billed, in decimal form, without a currency symbol. (8 characters, decimal, 2 characters: Example: 99999999.99)
           mapping :amount, 'total'
-        
-          # a unique order id from your program. (128 characters max)
+
+          # Pass your order id if you are using Third Part Cart Parameters. (128 characters max)
           mapping :order, 'cart_order_id'
 
+          # Pass your order id if you are using the Pass Through Products Parameters.  (50 characters max)
+          mapping :invoice, 'merchant_order_id'
+
+          # Left here for backward compatibility, do not use. The line_item method will add automatically.
           mapping :mode, 'mode'
 
           mapping :customer, :email      => 'email',
-                             :phone      => 'phone'
+                  :phone      => 'phone'
 
           mapping :billing_address, :city     => 'city',
-                                    :address1 => 'street_address',
-                                    :address2 => 'street_address2',
-                                    :state    => 'state',
-                                    :zip      => 'zip',
-                                    :country  => 'country'
-          
+                  :address1 => 'street_address',
+                  :address2 => 'street_address2',
+                  :state    => 'state',
+                  :zip      => 'zip',
+                  :country  => 'country'
+
           mapping :shipping_address, :city     => 'ship_city',
-                                     :address1 => 'ship_street_address',
-                                     :state    => 'ship_state',
-                                     :zip      => 'ship_zip',
-                                     :country  => 'ship_country'
-          
-          mapping :invoice, 'merchant_order_id'
-          
+                  :address1 => 'ship_street_address',
+                  :state    => 'ship_state',
+                  :zip      => 'ship_zip',
+                  :country  => 'ship_country'
+
           # Does nothing, since we've disabled the Continue Shopping button by using the fixed = Y field
           mapping :return_url, 'return_url'
-          
-          #mapping :description, ''
-          #mapping :tax, ''
-          #mapping :shipping, ''
-          
+
+          # Approved URL path
+          mapping :notification_url, 'x_receipt_link_url'
+
           def customer(params = {})
             add_field(mappings[:customer][:email], params[:email])
             add_field(mappings[:customer][:phone], params[:phone])
             add_field('card_holder_name', "#{params[:first_name]} #{params[:last_name]}")
           end
-          
+
+          # Uses Pass Through Product Parameters to pass in lineitems.
+          # (must mark tanigble sales as shipped to settle the transaction)
           def line_item(params = {})
-            max_existing_line_item_id = form_fields.keys.map do |key| 
-              match = key.to_s.match(/li_(\d+)_/)
-              if match
-                match[1]
-              end
-            end.reject(&:nil?).max.to_i
-            
+            add_field('mode', '2CO')
+            (max_existing_line_item_id = form_fields.keys.map do |key|
+              i = key.to_s[/^li_(\d+)_/, 1]
+              (i && i.to_i)
+            end.compact.max || 0)
+
             line_item_id = max_existing_line_item_id + 1
             params.each do |key, value|
               add_field("li_#{line_item_id}_#{key}", value)
             end
           end
+
+          # Uses Third Party Cart parameter set to pass in lineitem details.
+          # (sales settle automatically)
+          def auto_settle(params = {})
+            add_field('id_type', '1')
+            (max_existing_line_item_id = form_fields.keys.map do |key|
+              i = key.to_s[/^c_prod_(\d+)/, 1]
+              (i && i.to_i)
+            end.compact.max || 0)
+
+            line_item_id = max_existing_line_item_id + 1
+            params.each do |key, value|
+              add_field("c_#{key}_#{line_item_id}", value)
+            end
+          end
         end
       end
     end