aktivemerchant 2.0.0

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

@@ -0,0 +1,197 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MaxipagoGateway < Gateway
+      API_VERSION = '3.1.1.15'
+
+      self.live_url = 'https://api.maxipago.net/UniversalAPI/postXML'
+      self.test_url = 'https://testapi.maxipago.net/UniversalAPI/postXML'
+
+      self.supported_countries = ['BR']
+      self.default_currency = 'BRL'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club]
+      self.homepage_url = 'http://www.maxipago.com/'
+      self.display_name = 'maxiPago!'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_aux_data(post, options)
+        add_amount(post, money)
+        add_creditcard(post, creditcard)
+        add_name(post, creditcard)
+        add_address(post, options)
+
+        commit(build_sale_request(post))
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_aux_data(post, options)
+        add_amount(post, money)
+        add_creditcard(post, creditcard)
+        add_name(post, creditcard)
+        add_address(post, options)
+
+        commit(build_sale_request(post, "auth"))
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money)
+        add_aux_data(post, options)
+        commit(build_capture_request(authorization, post))
+      end
+
+      private
+
+      def commit(request)
+        url = (test? ? self.test_url : self.live_url)
+        response = parse(ssl_post(url, request, 'Content-Type' => 'text/xml'))
+        Response.new(
+          success?(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: response[:order_id]
+        )
+      end
+
+      def success?(response)
+        (response[:response_code] == '0')
+      end
+
+      def message_from(response)
+        return response[:error_message] if response[:error_message].present?
+        return response[:processor_message] if response[:processor_message].present?
+        return response[:response_message] if response[:response_message].present?
+        return (success?(response) ? 'success' : 'error')
+      end
+
+      def add_aux_data(post, options)
+        post[:processorID] = (test? ? 1 : 4) # test: 1, redecard: 2, cielo: 4
+        post[:referenceNum] = options[:order_id]
+        post[:installments] = options[:installments] if options.has_key?(:installments) && options[:installments] > 1 # only send installments if it is a deferred payment
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_number] = creditcard.number
+        post[:card_exp_month] = creditcard.month
+        post[:card_exp_year] = creditcard.year
+        post[:card_cvv] = creditcard.verification_value
+      end
+
+      def add_name(post, creditcard)
+        post[:billing_name] = creditcard.name
+      end
+
+      def add_address(post, options)
+        if(address = (options[:address] || options[:billing_address]))
+          post[:billing_address] = address[:address1]
+          post[:billing_address2] = address[:address2]
+          post[:billing_city] = address[:city]
+          post[:billing_state] = address[:state]
+          post[:billing_postalcode] = address[:zip]
+          post[:billing_country] = address[:country]
+          post[:billing_phone] = address[:phone]
+        end
+      end
+
+      def build_capture_request(authorization, params)
+        build_request(params) do |xml|
+          xml.capture! {
+            xml.orderID authorization
+            xml.referenceNum params[:referenceNum]
+            xml.payment {
+              xml.chargeTotal params[:amount]
+            }
+          }
+        end
+      end
+
+      def build_sale_request(params, action="sale")
+        build_request(params) do |xml|
+          xml.send(action) {
+            xml.processorID params[:processorID]
+            xml.fraudCheck 'N'
+            xml.referenceNum params[:referenceNum] # spree_order
+            xml.transactionDetail {
+              xml.payType {
+                xml.creditCard {
+                  xml.number params[:card_number]
+                  xml.expMonth params[:card_exp_month]
+                  xml.expYear params[:card_exp_year]
+                  xml.cvvNumber params[:card_cvv]
+                }
+              }
+            }
+            xml.payment {
+              xml.chargeTotal params[:amount]
+              if params[:installments].present?
+                xml.creditInstallment {
+                  xml.numberOfInstallments params[:installments]
+                  xml.chargeInterest 'N'
+                }
+              end
+            }
+            xml.billing {
+              xml.name params[:billing_name]
+              xml.address params[:billing_address] if params[:billing_address].present?
+              xml.address2 params[:billing_address2] if params[:billing_address2].present?
+              xml.city params[:billing_city] if params[:billing_city].present?
+              xml.state params[:billing_state] if params[:billing_state].present?
+              xml.postalcode params[:billing_postalcode] if params[:billing_postalcode].present?
+              xml.country params[:billing_country] if params[:billing_country].present?
+              xml.phone params[:billing_phone] if params[:billing_phone].present?
+            }
+          }
+        end
+      end
+
+      def build_request(params)
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.send("transaction-request") {
+            xml.version API_VERSION
+            xml.verification {
+              xml.merchantId @options[:login]
+              xml.merchantKey @options[:password]
+            }
+            xml.order {
+              yield(xml)
+            }
+          }
+        end
+        builder.to_xml(indent: 2)
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,170 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantESolutionsGateway < Gateway
+      self.test_url = 'https://cert.merchante-solutions.com/mes-api/tridentApi'
+      self.live_url = 'https://api.merchante-solutions.com/mes-api/tridentApi'
+
+      # 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, :jcb]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.merchante-solutions.com/'
+
+      # The name of the gateway
+      self.display_name = 'Merchant e-Solutions'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        add_address(post, options)
+        commit('P', money, post)
+      end
+
+      def purchase(money, creditcard_or_card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:moto_ecommerce_ind] = options[:moto_ecommerce_ind] if options.has_key?(:moto_ecommerce_ind)
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        add_address(post, options)
+        commit('D', money, post)
+      end
+
+      def capture(money, transaction_id, options = {})
+        post ={}
+        post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        commit('S', money, post)
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_creditcard(post, creditcard, options)
+        commit('T', nil, post)
+      end
+
+      def unstore(card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        post[:card_id] = card_id
+        commit('X', nil, post)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+        post[:transaction_id] = identification
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('U', money, options.merge(post))
+      end
+
+      def credit(money, creditcard_or_card_id, options = {})
+        post = {}
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        add_invoice(post, options)
+        add_payment_source(post, creditcard_or_card_id, options)
+        commit('C', money, post)
+      end
+
+      def void(transaction_id, options = {})
+        post = {}
+        post[:transaction_id] = transaction_id
+        post[:client_reference_number] = options[:customer] if options.has_key?(:customer)
+        options.delete(:customer)
+        options.delete(:billing_address)
+        commit('V', nil, options.merge(post))
+      end
+
+      private
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:cardholder_street_address] = address[:address1].to_s.gsub(/[^\w.]/, '+')
+          post[:cardholder_zip] = address[:zip].to_s
+        end
+      end
+
+      def add_invoice(post, options)
+        if options.has_key? :order_id
+          post[:invoice_number] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+        end
+      end
+
+      def add_payment_source(post, creditcard_or_card_id, options)
+        if creditcard_or_card_id.is_a?(String)
+          # using stored card
+          post[:card_id] = creditcard_or_card_id
+          post[:card_exp_date] = options[:expiration_date] if options[:expiration_date]
+        else
+          # card info is provided
+          add_creditcard(post, creditcard_or_card_id, options)
+        end
+      end
+
+      def add_creditcard(post, creditcard, options)
+        post[:card_number]  = creditcard.number
+        post[:cvv2] = creditcard.verification_value if creditcard.verification_value?
+        post[:card_exp_date]  = expdate(creditcard)
+      end
+
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key] = val
+        end
+        results
+      end
+
+      def commit(action, money, parameters)
+        url = test? ? self.test_url : self.live_url
+        parameters[:transaction_amount]  = amount(money) if money unless action == 'V'
+
+
+        response = begin
+          parse( ssl_post(url, post_data(action,parameters)) )
+        rescue ActiveMerchant::ResponseError => e
+          { "error_code" => "404",  "auth_response_text" => e.to_s }
+        end
+
+        Response.new(response["error_code"] == "000", message_from(response), response,
+          :authorization => response["transaction_id"],
+          :test => test?,
+          :cvv_result => response["cvv2_result"],
+          :avs_result => { :code => response["avs_result"] }
+        )
+      end
+
+      def message_from(response)
+        if response["error_code"] == "000"
+          "This transaction has been approved"
+        else
+          response["auth_response_text"]
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:profile_id] = @options[:login]
+        post[:profile_key] = @options[:password]
+        post[:transaction_type] = action if action
+
+        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require "cgi"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MerchantOneGateway < Gateway
+
+      class MerchantOneSslConnection < ActiveMerchant::Connection
+        def configure_ssl(http)
+          super(http)
+          http.use_ssl = true
+        end
+      end
+
+      BASE_URL = 'https://secure.merchantonegateway.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://merchantone.com/'
+      self.display_name = 'Merchant One Gateway'
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_customer_data(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+        commit('auth', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_customer_data(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post.merge!(:transactionid => authorization)
+        add_amount(post, money, options)
+        commit('capture', money, post)
+      end
+
+      def new_connection(endpoint)
+        MerchantOneSslConnection.new(endpoint)
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post['firstname'] = options[:billing_address][:first_name]
+        post['lastname'] = options[:billing_address][:last_name]
+      end
+
+      def add_amount(post, money, options)
+        post['amount'] = amount(money)
+      end
+
+      def add_address(post, creditcard, options)
+        post['address1'] = options[:billing_address][:address1]
+        post['city'] = options[:billing_address][:city]
+        post['state'] = options[:billing_address][:state]
+        post['zip'] = options[:billing_address][:zip]
+        post['country'] = options[:billing_address][:country]
+      end
+
+      def add_creditcard(post, creditcard)
+       post['cvv'] = creditcard.verification_value
+       post['ccnumber'] = creditcard.number
+       post['ccexp'] =  "#{sprintf("%02d", creditcard.month)}#{"#{creditcard.year}"[-2, 2]}"
+      end
+
+      def commit(action, money, parameters={})
+        parameters['username'] = @options[:username]
+        parameters['password'] = @options[:password]
+        parse(ssl_post(BASE_URL,post_data(action, parameters)))
+      end
+
+      def post_data(action, parameters = {})
+        parameters.merge!({:type => action})
+        ret = ""
+        for key in parameters.keys
+          ret += "#{key}=#{CGI.escape(parameters[key].to_s)}"
+          if key != parameters.keys.last
+            ret += "&"
+          end
+        end
+        ret.to_s
+      end
+
+      def parse(data)
+        responses =  CGI.parse(data).inject({}){|h,(k, v)| h[k] = v.first; h}
+        Response.new(
+          (responses["response"].to_i == 1),
+          responses["responsetext"],
+          responses,
+          :test => test?,
+          :authorization => responses["transactionid"]
+        )
+      end
+    end
+  end
+end
+