start_activemerchant 1.50.0

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

@@ -0,0 +1,181 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AxcessmsGateway < Gateway
+      self.test_url = "https://test.ctpe.io/payment/ctpe"
+      self.live_url = "https://ctpe.io/payment/ctpe"
+
+      self.supported_countries = %w(AD AT BE BG BR CA CH CY CZ DE DK EE ES FI FO FR GB
+                                    GI GR HR HU IE IL IM IS IT LI LT LU LV MC MT MX NL
+                                    NO PL PT RO RU SE SI SK TR US VA)
+
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :solo]
+
+      self.homepage_url = "http://www.axcessms.com/"
+      self.display_name = "Axcess MS"
+      self.money_format = :dollars
+      self.default_currency = "GBP"
+
+      API_VERSION = "1.0"
+      PAYMENT_CODE_PREAUTHORIZATION = "CC.PA"
+      PAYMENT_CODE_DEBIT = "CC.DB"
+      PAYMENT_CODE_CAPTURE = "CC.CP"
+      PAYMENT_CODE_REVERSAL = "CC.RV"
+      PAYMENT_CODE_REFUND = "CC.RF"
+      PAYMENT_CODE_REBILL = "CC.RB"
+
+      def initialize(options={})
+        requires!(options, :sender, :login, :password, :channel)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        payment_code = payment.respond_to?(:number) ? PAYMENT_CODE_DEBIT : PAYMENT_CODE_REBILL
+        commit(payment_code, money, payment, options)
+      end
+
+      def authorize(money, authorization, options={})
+        commit(PAYMENT_CODE_PREAUTHORIZATION, money, authorization, options)
+      end
+
+      def capture(money, authorization, options={})
+        commit(PAYMENT_CODE_CAPTURE, money, authorization, options)
+      end
+
+      def refund(money, authorization, options={})
+        commit(PAYMENT_CODE_REFUND, money, authorization, options)
+      end
+
+      def void(authorization, options={})
+        commit(PAYMENT_CODE_REVERSAL, nil, authorization, options)
+      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
+
+      private
+
+      def commit(paymentcode, money, payment, options)
+        options[:mode] ||= (test? ? "INTEGRATOR_TEST" : "LIVE")
+        request = build_request(paymentcode, money, payment, options)
+
+        headers = {
+          "Content-Type" => "application/x-www-form-urlencoded;charset=UTF-8"
+        }
+
+        response = parse(ssl_post((test? ? test_url : live_url), "load=#{CGI.escape(request)}", headers))
+        success = (response[:result] == "ACK")
+        message = "#{response[:reason]} - #{response[:return]}"
+        authorization = response[:unique_id]
+
+        Response.new(success, message, response,
+          :authorization => authorization,
+          :test => (response[:mode] != "LIVE")
+        )
+      end
+
+      def parse(body)
+        return {} if body.blank?
+
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+
+        response[:mode] = REXML::XPath.first(xml, "//Transaction").attributes["mode"]
+
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_attributes?
+          node.attributes.each{|name, value| response["#{node.name}_#{name}".underscore.to_sym] = value }
+        end
+
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+
+      def build_request(payment_code, money, payment, options)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! "Request", "version" => API_VERSION do
+          xml.tag! "Header" do
+            xml.tag! "Security", "sender" => @options[:sender]
+          end
+          xml.tag! "Transaction", "mode" => options[:mode], "channel" => @options[:channel], "response" => "SYNC" do
+            xml.tag! "User", "login" => @options[:login], "pwd" => @options[:password]
+            xml.tag! "Identification" do
+              xml.tag! "TransactionID", options[:order_id] || generate_unique_id
+              xml.tag! "ReferenceID", payment unless payment.respond_to?(:number)
+            end
+
+            xml.tag! "Payment", "code" => payment_code do
+              xml.tag! "Memo", options[:memo] unless options[:memo].blank?
+              xml.tag! "Presentation" do
+                xml.tag! "Amount", amount(money)
+                xml.tag! "Currency", (options[:currency] || currency(money))
+                xml.tag! "Usage", options[:description]
+              end
+            end
+
+            if payment.respond_to?(:number)
+              add_payment(xml, payment)
+
+              xml.tag! "Customer" do
+                add_customer_name(xml, payment)
+                add_address(xml, options[:billing_address] || options[:address])
+                add_contact(xml, options)
+              end
+            end
+          end
+        end
+
+        xml.target!
+      end
+
+      def add_contact(xml, options)
+        xml.tag! "Contact" do
+          xml.tag! "Email", (options[:email] || "unknown@example.com")
+          xml.tag! "Ip", (options[:ip] || "127.0.0.1")
+        end
+      end
+
+      def add_customer_name(xml, payment)
+        xml.tag! "Name" do
+          xml.tag! "Given", payment.first_name
+          xml.tag! "Family", payment.last_name
+        end
+      end
+
+      def add_payment(xml, payment)
+        xml.tag! "Account" do
+          xml.tag! "Number", payment.number
+          xml.tag! "Holder", payment.name
+          xml.tag! "Brand", payment.brand
+          xml.tag! "Expiry", "month" => payment.month, "year" => payment.year
+          xml.tag! "Verification", payment.verification_value
+        end
+      end
+
+      def add_address(xml, address)
+        raise ArgumentError.new("Address is required") unless address
+        xml.tag! "Address" do
+          xml.tag! "Street", "#{address[:address1]} #{address[:address2]}".strip
+          xml.tag! "City", address[:city]
+          xml.tag! "State", address[:state]
+          xml.tag! "Zip", address[:zip]
+          xml.tag! "Country", address[:country]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information on Balanced visit https://www.balancedpayments.com
+    # or visit #balanced on irc.freenode.net
+    #
+    # Instantiate a instance of BalancedGateway by passing through your
+    # Balanced API key secret.
+    #
+    # ==== To obtain an API key of your own
+    #
+    # 1. Visit https://www.balancedpayments.com
+    # 2. Click "Get started"
+    # 3. The next screen will give you a test API key of your own
+    # 4. When you're ready to generate a production API key click the "Go
+    #    live" button on the Balanced dashboard and fill in your marketplace
+    #    details.
+    class BalancedGateway < Gateway
+      VERSION = "2.0.0"
+
+      self.live_url = 'https://api.balancedpayments.com'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://www.balancedpayments.com/'
+      self.display_name = 'Balanced'
+      self.money_format = :cents
+
+      # Creates a new BalancedGateway
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Balanced API Secret (REQUIRED)
+      def initialize(options = {})
+        requires!(options, :login)
+        super
+      end
+
+      def purchase(money, payment_method, options = {})
+        post = {}
+        add_amount(post, money)
+        post[:description] = options[:description]
+        add_common_params(post, options)
+
+        MultiResponse.run do |r|
+          identifier = if(payment_method.respond_to?(:number))
+            r.process{store(payment_method, options)}
+            r.authorization
+          else
+            payment_method
+          end
+          r.process{commit("debits", "cards/#{card_identifier_from(identifier)}/debits", post)}
+        end
+      end
+
+      def authorize(money, payment_method, options = {})
+        post = {}
+        add_amount(post, money)
+        post[:description] = options[:description]
+        add_common_params(post, options)
+
+        MultiResponse.run do |r|
+          identifier = if(payment_method.respond_to?(:number))
+            r.process{store(payment_method, options)}
+            r.authorization
+          else
+            payment_method
+          end
+          r.process{commit("card_holds", "cards/#{card_identifier_from(identifier)}/card_holds", post)}
+        end
+      end
+
+      def capture(money, identifier, options = {})
+        post = {}
+        add_amount(post, money)
+        post[:description] = options[:description] if options[:description]
+        add_common_params(post, options)
+
+        commit("debits", "card_holds/#{reference_identifier_from(identifier)}/debits", post)
+      end
+
+      def void(identifier, options = {})
+        post = {}
+        post[:is_void] = true
+        add_common_params(post, options)
+
+        commit("card_holds", "card_holds/#{reference_identifier_from(identifier)}", post, :put)
+      end
+
+      def refund(money, identifier, options = {})
+        post = {}
+        add_amount(post, money)
+        post[:description] = options[:description]
+        add_common_params(post, options)
+
+        commit("refunds", "debits/#{reference_identifier_from(identifier)}/refunds", post)
+      end
+
+      def store(credit_card, options={})
+        post = {}
+
+        post[:number] = credit_card.number
+        post[:expiration_month] = credit_card.month
+        post[:expiration_year] = credit_card.year
+        post[:cvv] = credit_card.verification_value if credit_card.verification_value?
+        post[:name] = credit_card.name if credit_card.name
+
+        add_address(post, options)
+
+        commit("cards", "cards", post)
+      end
+
+      private
+
+      def reference_identifier_from(identifier)
+        case identifier
+        when %r{\|}
+          uri = identifier.
+            split("|").
+            detect{|part| part.size > 0}
+          uri.split("/")[2]
+        when %r{\/}
+          identifier.split("/")[5]
+        else
+          identifier
+        end
+      end
+
+      def card_identifier_from(identifier)
+        identifier.split("/").last
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money) if money
+      end
+
+      def add_address(post, options)
+        address = (options[:billing_address] || options[:address])
+        if(address && address[:zip].present?)
+          post[:address] = {}
+          post[:address][:line1] = address[:address1] if address[:address1]
+          post[:address][:line2] = address[:address2] if address[:address2]
+          post[:address][:city] = address[:city] if address[:city]
+          post[:address][:state] = address[:state] if address[:state]
+          post[:address][:postal_code] = address[:zip] if address[:zip]
+          post[:address][:country_code] = address[:country] if address[:country]
+        end
+      end
+
+      def add_common_params(post, options)
+        post[:appears_on_statement_as] = options[:appears_on_statement_as]
+        post[:on_behalf_of_uri] = options[:on_behalf_of_uri]
+        post[:meta] = options[:meta]
+      end
+
+      def commit(entity_name, path, post, method=:post)
+        raw_response = begin
+          parse(ssl_request(
+            method,
+            live_url + "/#{path}",
+            post_data(post),
+            headers
+          ))
+        rescue ResponseError => e
+          raise unless(e.response.code.to_s =~ /4\d\d/)
+          parse(e.response.body)
+        end
+
+        Response.new(
+          success_from(entity_name, raw_response),
+          message_from(raw_response),
+          raw_response,
+          authorization: authorization_from(entity_name, raw_response),
+          test: test?,
+        )
+      end
+
+      def success_from(entity_name, raw_response)
+        entity = (raw_response[entity_name] || []).first
+        if(!entity)
+          false
+        elsif((entity_name == "refunds") && entity.include?("status"))
+          %w(succeeded pending).include?(entity["status"])
+        elsif(entity.include?("status"))
+          (entity["status"] == "succeeded")
+        elsif(entity_name == "cards")
+          !!entity["id"]
+        else
+          false
+        end
+      end
+
+      def message_from(raw_response)
+        if(raw_response["errors"])
+          error = raw_response["errors"].first
+          (error["additional"] || error["message"] || error["description"])
+        else
+          "Success"
+        end
+      end
+
+      def authorization_from(entity_name, raw_response)
+        entity = (raw_response[entity_name] || []).first
+        (entity && entity["id"])
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        message = 'Invalid response received from the Balanced API. Please contact support@balancedpayments.com if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "errors" => [{
+            "message" => message
+          }]
+        }
+      end
+
+      def post_data(params)
+        return nil unless params
+
+        params.map do |key, value|
+          next if value.blank?
+          if value.is_a?(Hash)
+            h = {}
+            value.each do |k, v|
+              h["#{key}[#{k}]"] = v unless v.blank?
+            end
+            post_data(h)
+          else
+            "#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end.compact.join("&")
+      end
+
+      def headers
+        @@ua ||= JSON.dump(
+           bindings_version: ActiveMerchant::VERSION,
+           lang: 'ruby',
+           lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+           lib_version: BalancedGateway::VERSION,
+           platform: RUBY_PLATFORM,
+           publisher: 'active_merchant'
+        )
+
+        {
+            "Authorization" => "Basic " + Base64.encode64(@options[:login].to_s + ":").strip,
+            "User-Agent" => "Balanced/v1.1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+            "Accept" => "application/vnd.api+json;revision=1.1",
+            "X-Balanced-User-Agent" => @@ua,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information visit {Bank Frick Acquiring Services}[http://www.bankfrickacquiring.com/merchantsolutions_en.html]
+    #
+    # Written by Piers Chambers (Varyonic.com)
+    class BankFrickGateway < Gateway
+      self.test_url = 'https://test.ctpe.io/payment/ctpe'
+      self.live_url = 'https://ctpe.io/payment/ctpe'
+
+      self.supported_countries = ['LI','US']
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.bankfrickacquiring.com/'
+      self.display_name = 'Bank Frick'
+
+      # The set of supported transactions for this gateway.
+      # More operations are supported by the gateway itself, but
+      # are not supported in this library.
+      SUPPORTED_TRANSACTIONS = {
+        'sale'      => 'CC.DB',
+        'authonly'  => 'CC.PA',
+        'capture'   => 'CC.CP',
+        'refund'    => 'CC.RF',
+        'void'      => 'CC.RV',
+      }
+
+      def initialize(options={})
+        requires!(options, :sender, :channel, :userid, :userpwd)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('authonly', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+        add_invoice(post, money, options)
+
+        commit('capture', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+        add_invoice(post, money, options)
+
+        commit('refund', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        post[:authorization] = authorization
+
+        commit('void', 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
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] || 'noone@example.com'
+        post[:ip] = options[:ip] || '0.0.0.0'
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address] = address[:address1].to_s
+          post[:company] = address[:company].to_s
+          post[:phone]   = address[:phone].to_s.gsub(/[^0-9]/, '') || "0000000"
+          post[:zip]     = address[:zip].to_s
+          post[:city]    = address[:city].to_s
+          post[:country] = address[:country].to_s
+          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:order_id]    = options[:order_id] if post.has_key? :order_id
+        post[:amount]      = amount(money)
+        post[:currency]    = (options[:currency] || currency(money))
+        post[:description] = options[:description]
+      end
+
+      def add_payment(post, payment)
+        post[:first_name] = payment.first_name
+        post[:last_name]  = payment.last_name
+        post[:brand]      = payment.brand
+        post[:card_num]   = payment.number
+        post[:card_code]  = payment.verification_value if payment.verification_value?
+        post[:exp_year]   = payment.year
+        post[:exp_month]  = payment.month
+      end
+
+      def parse(body)
+        results  = {}
+        xml = Nokogiri::XML(body)
+        resp = xml.xpath("//Response/Transaction/Identification")
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        resp = xml.xpath("//Response/Transaction/Processing")
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        results
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        headers = {
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=UTF-8'
+        }
+        response = parse(ssl_post(url, post_data(action, parameters), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        response[:result] == 'ACK'
+      end
+
+      def message_from(response)
+        response[:return]
+      end
+
+      def authorization_from(response)
+        response[:uniqueid]
+      end
+
+      def post_data(action, parameters = {})
+        xml = build_xml_request(action, parameters)
+        "load=#{CGI.escape(xml)}"
+      end
+
+      def build_xml_request(action, data)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.Request(version: '1.0') do
+          xml.Header do
+            xml.Security(sender: @options[:sender], type: 'MERCHANT')
+          end
+          xml.Transaction(response: 'SYNC', channel: @options[:channel], mode: 'LIVE') do
+            xml.User(pwd: @options[:userpwd], login: @options[:userid])
+            xml.Identification do
+              xml.TransactionID data[:order_id] if data.has_key? :order_id
+              xml.ReferenceID   data[:authorization] if data.has_key? :authorization
+            end
+            xml.Account do
+              xml.Holder        "#{data[:first_name]} #{data[:last_name]}"
+              xml.Brand         data[:brand]
+              xml.Number        data[:card_num]
+              xml.Bank          data[:bankname]
+              xml.Country       data[:country]
+              xml.Authorization data[:authorization]
+              xml.Verification  data[:card_code]
+              xml.Year          data[:exp_year]
+              xml.Month         data[:exp_month]
+            end if data.has_key? :card_num
+            xml.Payment(code: SUPPORTED_TRANSACTIONS[action]) do
+              xml.Presentation do
+                xml.Amount     data[:amount]
+                xml.Currency   data[:currency]
+                xml.Usage      data[:description]
+              end
+            end
+            xml.Customer do
+              xml.Contact do
+                xml.Email      data[:email]
+                xml.Mobile     data[:mobile]
+                xml.Ip         data[:ip]
+                xml.Phone      data[:phone]
+              end
+              xml.Address do
+                xml.Street     data[:address]
+                xml.Zip        data[:zip]
+                xml.City       data[:city]
+                xml.State      data[:state]
+                xml.Country    data[:country]
+              end
+              xml.Name do
+                xml.Salutation data[:salutation]
+                xml.Title      data[:title]
+                xml.Given      data[:first_name]
+                xml.Family     data[:last_name]
+                xml.Company    data[:company]
+              end
+            end if data.has_key? :last_name
+          end
+        end
+      end
+    end
+  end
+end