tlconnor-activemerchant 1.20.4 → 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/migs.rb

@@ -0,0 +1,259 @@
+require File.dirname(__FILE__) + '/migs/migs_codes'
+
+require 'digest/md5' # Used in add_secure_hash
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MigsGateway < Gateway
+      include MigsCodes
+
+      API_VERSION = 1
+
+      SERVER_HOSTED_URL = 'https://migs.mastercard.com.au/vpcpay'
+      MERCHANT_HOSTED_URL = 'https://migs.mastercard.com.au/vpcdps'
+
+      # MiGS is supported throughout Asia Pacific, Middle East and Africa
+      # MiGS is used in Australia (AU) by ANZ (eGate), CBA (CommWeb) and more
+      # Source of Country List: http://www.scribd.com/doc/17811923
+      self.supported_countries = %w(AU AE BD BN EG HK ID IN JO KW LB LK MU MV MY NZ OM PH QA SA SG TT VN)
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.money_format = :cents
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://mastercard.com/mastercardsps'
+
+      # The name of the gateway
+      self.display_name = 'MasterCard Internet Gateway Service (MiGS)'
+
+      # Creates a new MigsGateway
+      # The advanced_login/advanced_password fields are needed for
+      # advanced methods such as the capture, refund and status methods
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The MiGS Merchant ID (REQUIRED)
+      # * <tt>:password</tt> -- The MiGS Access Code (REQUIRED)
+      # * <tt>:secure_hash</tt> -- The MiGS Secure Hash
+      # (Required for Server Hosted payments)
+      # * <tt>:advanced_login</tt> -- The MiGS AMA User
+      # * <tt>:advanced_password</tt> -- The MiGS AMA User's password
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @test = options[:login].start_with?('TEST')
+        @options = options
+        super
+      end
+
+      # ==== Options
+      #
+      # * <tt>:order_id</tt> -- A reference for tracking the order (REQUIRED)
+      # * <tt>:unique_id</tt> -- A unique id for this request (Max 40 chars).
+      # If not supplied one will be generated.
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:Amount] = amount(money)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_standard_parameters('pay', post, options[:unique_id])
+
+        commit(post)
+      end
+
+      # MiGS works by merchants being either purchase only or authorize/capture
+      # So authorize is the same as purchase when in authorize mode
+      alias_method :authorize, :purchase
+
+      # ==== Options
+      #
+      # * <tt>:unique_id</tt> -- A unique id for this request (Max 40 chars).
+      # If not supplied one will be generated.
+      def capture(money, authorization, options = {})
+        requires!(@options, :advanced_login, :advanced_password)
+
+        post = options.merge(:TransNo => authorization)
+        post[:Amount] = amount(money)
+        add_advanced_user(post)
+        add_standard_parameters('capture', post, options[:unique_id])
+
+        commit(post)
+      end
+
+      # ==== Options
+      #
+      # * <tt>:unique_id</tt> -- A unique id for this request (Max 40 chars).
+      # If not supplied one will be generated.
+      def refund(money, authorization, options = {})
+        requires!(@options, :advanced_login, :advanced_password)
+
+        post = options.merge(:TransNo => authorization)
+        post[:Amount] = amount(money)
+        add_advanced_user(post)
+        add_standard_parameters('refund', post, options[:unique_id])
+
+        commit(post)
+      end
+
+      def credit(money, authorization, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
+      end
+
+      # Checks the status of a previous transaction
+      # This can be useful when a response is not received due to network issues
+      #
+      # ==== Parameters
+      #
+      # * <tt>unique_id</tt> -- Unique id of transaction to find.
+      #   This is the value of the option supplied in other methods or
+      #   if not supplied is returned with key :MerchTxnRef
+      def status(unique_id)
+        requires!(@options, :advanced_login, :advanced_password)
+
+        post = {}
+        add_advanced_user(post)
+        add_standard_parameters('queryDR', post, unique_id)
+
+        commit(post)
+      end
+
+      # Generates a URL to redirect user to MiGS to process payment
+      # Once user is finished MiGS will redirect back to specified URL
+      # With a response hash which can be turned into a Response object
+      # with purchase_offsite_response
+      #
+      # ==== Options
+      #
+      # * <tt>:order_id</tt> -- A reference for tracking the order (REQUIRED)
+      # * <tt>:locale</tt> -- Change the language of the redirected page
+      #   Values are 2 digit locale, e.g. en, es
+      # * <tt>:return_url</tt> -- the URL to return to once the payment is complete
+      # * <tt>:card_type</tt> -- Providing this skips the card type step.
+      #   Values are ActiveMerchant formats: e.g. master, visa, american_express, diners_club
+      # * <tt>:unique_id</tt> -- Unique id of transaction to find.
+      #   If not supplied one will be generated.
+      def purchase_offsite_url(money, options = {})
+        requires!(options, :order_id, :return_url)
+        requires!(@options, :secure_hash)
+
+        post = {}
+        post[:Amount] = amount(money)
+        add_invoice(post, options)
+        add_creditcard_type(post, options[:card_type]) if options[:card_type]
+
+        post.merge!(
+          :Locale => options[:locale] || 'en',
+          :ReturnURL => options[:return_url]
+        )
+
+        add_standard_parameters('pay', post, options[:unique_id])
+
+        add_secure_hash(post)
+
+        SERVER_HOSTED_URL + '?' + post_data(post)
+      end
+
+      # Parses a response from purchase_offsite_url once user is redirected back
+      #
+      # ==== Parameters
+      #
+      # * <tt>data</tt> -- All params when offsite payment returns
+      # e.g. returns to http://company.com/return?a=1&b=2, then input "a=1&b=2"
+      def purchase_offsite_response(data)
+        requires!(@options, :secure_hash)
+
+        response_hash = parse(data)
+
+        expected_secure_hash = calculate_secure_hash(response_hash.reject{|k, v| k == :SecureHash}, @options[:secure_hash])
+        unless response_hash[:SecureHash] == expected_secure_hash
+          raise SecurityError, "Secure Hash mismatch, response may be tampered with"
+        end
+
+        response_object(response_hash)
+      end
+
+      private
+
+      def add_advanced_user(post)
+        post[:User] = @options[:advanced_login]
+        post[:Password] = @options[:advanced_password]
+      end
+
+      def add_invoice(post, options)
+        post[:OrderInfo] = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:CardNum] = creditcard.number
+        post[:CardSecurityCode] = creditcard.verification_value if creditcard.verification_value?
+        post[:CardExp] = format(creditcard.year, :two_digits) + format(creditcard.month, :two_digits)
+      end
+
+      def add_creditcard_type(post, card_type)
+        post[:Gateway]  = 'ssl'
+        post[:card] = CARD_TYPES.detect{|ct| ct.am_code == card_type}.migs_long_code
+      end
+
+      def parse(body)
+        params = CGI::parse(body)
+        hash = {}
+        params.each do |key, value|
+          hash[key.gsub('vpc_', '').to_sym] = value[0]
+        end
+        hash
+      end
+
+      def commit(post)
+        data = ssl_post MERCHANT_HOSTED_URL, post_data(post)
+        response_hash = parse(data)
+        response_object(response_hash)
+      end
+
+      def response_object(response)
+        Response.new(success?(response), response[:Message], response,
+          :test => @test,
+          :authorization => response[:TransactionNo],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response[:AVSResultCode] },
+          :cvv_result => response[:CSCResultCode]
+        )
+      end
+
+      def success?(response)
+        response[:TxnResponseCode] == '0'
+      end
+
+      def fraud_review?(response)
+        ISSUER_RESPONSE_CODES[response[:AcqResponseCode]] == 'Suspected Fraud'
+      end
+
+      def add_standard_parameters(action, post, unique_id = nil)
+        post.merge!(
+          :Version     => API_VERSION,
+          :Merchant    => @options[:login],
+          :AccessCode  => @options[:password],
+          :Command     => action,
+          :MerchTxnRef => unique_id || generate_unique_id.slice(0, 40)
+        )
+      end
+
+      def post_data(post)
+        post.collect { |key, value| "vpc_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_secure_hash(post)
+        post[:SecureHash] = calculate_secure_hash(post, @options[:secure_hash])
+      end
+
+      def calculate_secure_hash(post, secure_hash)
+        sorted_values = post.sort_by(&:to_s).map(&:last)
+        input = secure_hash + sorted_values.join
+        Digest::MD5.hexdigest(input).upcase
+      end
+    end
+  end
+end