activemerchant 1.49.0 → 1.50.0

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

@@ -0,0 +1,245 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantPartnersGateway < Gateway
+      self.display_name = "Merchant Partners"
+      self.homepage_url = "http://www.merchantpartners.com/"
+
+      self.live_url = "https://trans.merchantpartners.com/cgi-bin/ProcessXML.cgi"
+
+      self.supported_countries = ["US"]
+      self.default_currency = "USD"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      def initialize(options={})
+        requires!(options, :account_id, :merchant_pin)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit(payment_method.is_a?(String) ? :stored_purchase : :purchase, post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit(:void, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit(:refund, post)
+      end
+
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+
+        commit(payment_method.is_a?(String) ? :stored_credit : :credit, post)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(payment_method, options = {})
+        post = {}
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        post[:profileactiontype] = options[:profileactiontype] || STORE_TX_TYPES[:store_only]
+
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<ccnum>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<cvv2>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<merchantpin>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      def test?
+        @options[:account_id].eql?('TEST0')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:merchantordernumber] = options[:order_id]
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_payment_method(post, payment_method)
+        if(payment_method.is_a?(String))
+          user_profile_id, last_4 = split_authorization(payment_method)
+          post[:userprofileid] = user_profile_id
+          post[:last4digits] = last_4
+        else
+          post[:ccname] = payment_method.name
+          post[:ccnum] = payment_method.number
+          post[:cvv2] = payment_method.verification_value
+          post[:expmon] = format(payment_method.month, :two_digits)
+          post[:expyear] = format(payment_method.year, :four_digits)
+          post[:swipedata] = payment_method.track_data if payment_method.track_data
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options[:email]
+        post[:ipaddress] = options[:ip] if options[:ip]
+        if(billing_address = options[:billing_address])
+          post[:billaddr1] = billing_address[:address1]
+          post[:billaddr2] = billing_address[:address2]
+          post[:billcity] = billing_address[:city]
+          post[:billstate] = billing_address[:state]
+          post[:billcountry] = billing_address[:country]
+          post[:bilzip]    = billing_address[:zip]
+          post[:phone] = billing_address[:phone]
+        end
+      end
+
+      def add_reference(post, authorization)
+        post[:historykeyid] = authorization
+      end
+
+      ACTIONS = {
+        purchase: "2",
+        authorize: "1",
+        capture: "3",
+        void: "5",
+        refund: "4",
+        credit: "6",
+        store: "7",
+        stored_purchase: "8",
+        stored_credit: "13"
+      }
+
+      STORE_TX_TYPES = {
+        store_only: "3"
+      }
+
+      def commit(action, post)
+        post[:acctid] = @options[:account_id]
+        post[:merchantpin] = @options[:merchant_pin]
+        post[:service] = ACTIONS[action] if ACTIONS[action]
+
+        data = build_request(post)
+        response_data = parse(ssl_post(live_url, data, headers))
+        succeeded = success_from(response_data)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response_data),
+          response_data,
+          authorization: authorization_from(post, response_data),
+          :avs_result => AVSResult.new(code: response_data["avs_response"]),
+          :cvv_result => CVVResult.new(response_data["cvv2_response"]),
+          test: test?
+        )
+      end
+
+      def headers
+        {
+          "Content-Type"  => "application/xml"
+        }
+      end
+
+      def build_request(post)
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.interface_driver {
+            xml.trans_catalog {
+              xml.transaction(name: "creditcard") {
+                xml.inputs {
+                  post.each do |field, value|
+                    xml.send(field, value)
+                  end
+                }
+              }
+            }
+          }
+        end.to_xml
+      end
+
+      def parse(body)
+        response = {}
+        Nokogiri::XML(CGI.unescapeHTML(body)).xpath("//trans_catalog/transaction/outputs").children.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.elements.size == 0
+          response[node.name.downcase.underscore.to_sym] = node.text
+        else
+          node.elements.each{|element| parse_element(response, element) }
+        end
+      end
+
+      def success_from(response)
+        response[:status] == "Approved"
+      end
+
+      def message_from(succeeded, response)
+        succeeded ? "Succeeded" : error_message_from(response)
+      end
+
+      def authorization_from(request, response)
+        request[:service] == ACTIONS[:store] ?
+          "#{response[:userprofileid]}|#{response[:last4digits]}" :
+          response[:historyid]
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def error_message_from(response)
+        if(response[:status] == "Declined")
+          match = response[:result].match(/DECLINED:\d{10}:(.+):/)
+          match[1] if match
+        end
+      end
+    end
+  end
+end

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

@@ -31,6 +31,7 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'NETbilling'
       self.homepage_url = 'http://www.netbilling.com'
       self.supported_countries = ['US']
+      self.ssl_version = :TLSv1
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
 
       def initialize(options = {})

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

@@ -0,0 +1,319 @@
+require 'active_merchant/billing/rails'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class OmiseGateway < Gateway
+      API_VERSION = '1.0'
+      API_URL     = 'https://api.omise.co/'
+      VAULT_URL   = 'https://vault.omise.co/'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        'invalid_security_code' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'failed_capture'        => STANDARD_ERROR_CODE[:card_declined]
+      }
+
+      self.live_url = self.test_url = API_URL
+
+      # Currency supported by Omise
+      # * Thai Baht with Satang, ie. 9000 => 90 THB
+      self.default_currency = 'THB'
+      self.money_format     = :cents
+
+      #Country supported by Omise
+      # * Thailand
+      self.supported_countries = %w( TH )
+
+      # Credit cards supported by Omise
+      # * VISA
+      # * MasterCard
+      self.supported_cardtypes = [:visa, :master]
+
+      # Omise main page
+      self.homepage_url = 'https://www.omise.co/'
+      self.display_name = 'Omise'
+
+      # Creates a new OmiseGateway.
+      #
+      # Omise requires public_key for token creation.
+      # And it requires secret_key for other transactions.
+      # These keys can be found in https://dashboard.omise.co/test/api-keys
+      #
+      # ==== Options
+      #
+      # * <tt>:public_key</tt> -- Omise's public key (REQUIRED).
+      # * <tt>:secret_key</tt> -- Omise's secret key (REQUIRED).
+
+      def initialize(options={})
+        requires!(options, :public_key, :secret_key)
+        @public_key = options[:public_key]
+        @secret_key = options[:secret_key]
+        super
+      end
+
+      # Perform a purchase (with auto capture)
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt>          -- The purchasing amount in Thai Baht Satang
+      # * <tt>payment_method</tt> -- The CreditCard object
+      # * <tt>options</tt>        -- An optional parameters, such as token from Omise.js
+      #
+      # ==== Options
+      # * <tt>token_id</tt> -- token id, use Omise.js library to retrieve a token id
+      # if this is passed as an option, it will ignore tokenizing via Omisevaultgateway object
+      #
+      # === Example
+      #  To create a charge on a card
+      #
+      #   purchase(money, Creditcard_object)
+      #
+      #  To create a charge on a token
+      #
+      #   purchase(money, nil, { :token_id => token_id, ... })
+      #
+      #  To create a charge on a customer
+      #
+      #   purchase(money, nil, { :customer_id => customer_id })
+
+      def purchase(money, payment_method, options={})
+        create_charge(money, payment_method, options)
+      end
+
+      # Authorize a charge.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt>          -- The purchasing amount in Thai Baht Satang
+      # * <tt>payment_method</tt> -- The CreditCard object
+      # * <tt>options</tt>        -- An optional parameters, such as token or capture
+
+      def authorize(money, payment_method, options={})
+        options[:capture] = 'false'
+        create_charge(money, payment_method, options)
+      end
+
+      # Capture an authorized charge.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt>     -- An amount in Thai Baht Satang
+      # * <tt>charge_id</tt> -- The CreditCard object
+      # * <tt>options</tt>   -- An optional parameters, such as token or capture
+
+      def capture(money, charge_id, options={})
+        post = {}
+        add_amount(post, money, options)
+        commit(:post, "charges/#{CGI.escape(charge_id)}/capture", post, options)
+      end
+
+      # Refund a charge.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt>     -- An amount of money to charge in Satang.
+      # * <tt>charge_id</tt> -- The CreditCard object
+      # * <tt>options</tt>   -- An optional parameters, such as token or capture
+
+      def refund(money, charge_id, options={})
+        options[:amount] = money if money
+        commit(:post, "charges/#{CGI.escape(charge_id)}/refunds", options)
+      end
+
+      # Store a card details as customer
+      #
+      # ==== Parameters
+      #
+      # * <tt>payment_method</tt> -- The CreditCard.
+      # * <tt>options</tt>        -- Optional Customer information:
+      #     'email'       (A customer email)
+      #     'description' (A customer description)
+
+      def store(payment_method, options={})
+        post, card_params = {}, {}
+        add_customer_data(post, options)
+        add_token(card_params, payment_method, options)
+        commit(:post, 'customers', post.merge(card_params), options)
+      end
+
+      # Delete a customer and all associated credit cards.
+      #
+      # ==== Parameters
+      #
+      # * <tt>customer_id</tt> -- The Customer identifier (REQUIRED).
+
+      def unstore(customer_id, options={})
+        commit(:delete, "customers/#{CGI.escape(customer_id)}")
+      end
+
+      # Enable scrubbling sensitive information
+      def supports_scrubbing?
+        true
+      end
+
+      # Scrub sensitive information out of HTTP transcripts
+      #
+      # ==== Parameters
+      #
+      # * <tt>transcript</tt> -- The HTTP transcripts
+
+      def scrub(transcript)
+        transcript.
+          gsub(/(Authorization: Basic )\w+/i, '\1[FILTERED]').
+          gsub(/(\\"number\\":)\\"\d+\\"/, '\1[FILTERED]').
+          gsub(/(\\"security_code\\":)\\"\d+\\"/,'\1[FILTERED]')
+      end
+
+      private
+
+      def create_charge(money, payment_method, options)
+        post = {}
+        add_token(post, payment_method, options)
+        add_amount(post, money, options)
+        add_customer(post, options)
+        post[:capture] = options[:capture] if options[:capture]
+        commit(:post, 'charges', post, options)
+      end
+
+      def headers(options={})
+        key = options[:key] || @secret_key
+        {
+          'Content-Type'    => 'application/json;utf-8',
+          'User-Agent'      => "Omise/v#{API_VERSION} ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'Authorization'   => 'Basic ' + Base64.encode64(key.to_s + ':').strip,
+          'Accept-Encoding' => 'utf-8'
+        }
+      end
+
+      def url_for(endpoint)
+        (endpoint == 'tokens' ? VAULT_URL : API_URL) + endpoint
+      end
+
+      def post_data(parameters)
+        parameters.present? ? parameters.to_json : nil
+      end
+
+      def https_request(method, endpoint, parameters=nil, options={})
+        raw_response = response = nil
+        begin
+          raw_response = ssl_request(method, url_for(endpoint), post_data(parameters), headers(options))
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+        response
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def json_error(raw_response)
+        msg  = "Invalid response received from Omise API. Please contact support@omise.co if you continue to receive this message."
+        msg += "The raw response returned by the API was #{raw_response.inspect})"
+        { message: msg }
+      end
+
+      def commit(method, endpoint, params=nil, options={})
+        response = https_request(method, endpoint, params, options)
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
+          {
+            authorization: authorization_from(response),
+            test: test?,
+            error_code: successful?(response) ? nil : standard_error_code_mapping(response)
+          }
+        )
+      end
+
+      def standard_error_code_mapping(response)
+        STANDARD_ERROR_CODE_MAPPING[error_code_from(response)] || message_to_standard_error_code_from(response)
+      end
+
+      def error_code_from(response)
+        error?(response) ? response['code'] : response['failure_code']
+      end
+
+      def message_to_standard_error_code_from(response)
+        message = response['message'] if response['code'] == 'invalid_card'
+        case message
+          when /brand not supported/
+            STANDARD_ERROR_CODE[:invalid_number]
+          when /number is invalid/
+            STANDARD_ERROR_CODE[:incorrect_number]
+          when /expiration date cannot be in the past/
+            STANDARD_ERROR_CODE[:expired_card]
+          when /expiration \w+ is invalid/
+            STANDARD_ERROR_CODE[:invalid_expiry_date]
+          else
+            STANDARD_ERROR_CODE[:processing_error]
+        end
+      end
+
+      def message_from(response)
+        if successful?(response)
+          'Success'
+        else
+          (response['message'] ? response['message'] : response['failure_message'])
+        end
+      end
+
+      def authorization_from(response)
+        response['id'] if successful?(response)
+      end
+
+      def successful?(response)
+        !error?(response) && response['failure_code'].nil?
+      end
+
+      def error?(response)
+        response.key?('object') && (response['object'] == 'error')
+      end
+
+      def get_token(post, credit_card)
+        add_creditcard(post, credit_card) if credit_card
+        commit(:post, 'tokens', post, { key: @public_key })
+      end
+
+      def add_token(post, credit_card, options={})
+        if options[:token_id].present?
+          post[:card] = options[:token_id]
+        else
+          response = get_token(post, credit_card)
+          response.authorization ? (post[:card] = response.authorization) : response
+        end
+      end
+
+      def add_creditcard(post, payment_method)
+        card = {
+          number:           payment_method.number,
+          name:             payment_method.name,
+          security_code:    payment_method.verification_value,
+          expiration_month: payment_method.month,
+          expiration_year:  payment_method.year
+        }
+        post[:card] = card
+      end
+
+      def add_customer(post, options={})
+        post[:customer] = options[:customer_id] if options[:customer_id]
+      end
+
+      def add_customer_data(post, options={})
+        post[:description] = options[:description] if options[:description]
+        post[:email]       = options[:email] if options[:email]
+      end
+
+      def add_amount(post, money, options)
+        post[:amount]      = amount(money)
+        post[:currency]    = (options[:currency] || currency(money))
+        post[:description] = options[:description] if options.key?(:description)
+      end
+
+    end
+  end
+end