tanga_activemerchant 1.37.0

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

@@ -0,0 +1,316 @@
+require 'active_support/core_ext/hash/slice'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class StripeGateway < Gateway
+      self.live_url = 'https://api.stripe.com/v1/'
+
+      AVS_CODE_TRANSLATOR = {
+        'line1: pass, zip: pass' => 'Y',
+        'line1: pass, zip: fail' => 'A',
+        'line1: pass, zip: unchecked' => 'B',
+        'line1: fail, zip: pass' => 'Z',
+        'line1: fail, zip: fail' => 'N',
+        'line1: unchecked, zip: pass' => 'P',
+        'line1: unchecked, zip: unchecked' => 'I'
+      }
+
+      CVC_CODE_TRANSLATOR = {
+        'pass' => 'M',
+        'fail' => 'N',
+        'unchecked' => 'P'
+      }
+
+      self.supported_countries = ['US', 'CA']
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'https://stripe.com/'
+      self.display_name = 'Stripe'
+
+      def initialize(options = {})
+        requires!(options, :login)
+        @api_key = options[:login]
+        @fee_refund_api_key = options[:fee_refund_login]
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
+        post[:capture] = "false"
+
+        commit(:post, 'charges', post, generate_meta(options), creditcard)
+      end
+
+      # To create a charge on a card or a token, call
+      #
+      #   purchase(money, card_hash_or_token, { ... })
+      #
+      # To create a charge on a customer, call
+      #
+      #   purchase(money, nil, { :customer => id, ... })
+      def purchase(money, creditcard, options = {})
+        post = create_post_for_auth_or_purchase(money, creditcard, options)
+
+        commit(:post, 'charges', post, generate_meta(options), creditcard)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {:amount => amount(money)}
+        add_application_fee(post, nil, options)
+
+        commit(:post, "charges/#{CGI.escape(authorization)}/capture", post)
+      end
+
+      def void(identification, options = {})
+        commit(:post, "charges/#{CGI.escape(identification)}/refund", {})
+      end
+
+      def refund(money, identification, options = {})
+        post = {:amount => amount(money)}
+        commit_options = generate_meta(options)
+
+        MultiResponse.run do |r|
+          r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, commit_options) }
+
+          return r unless options[:refund_fee_amount]
+
+          r.process { fetch_application_fees(identification, commit_options) }
+          r.process { refund_application_fee(options[:refund_fee_amount], application_fee_from_response(r), commit_options) }
+        end
+      end
+
+      def application_fee_from_response(response)
+        return unless response.success?
+
+        application_fees = response.params["data"].select { |fee| fee["object"] == "application_fee" }
+        application_fees.first["id"] unless application_fees.empty?
+      end
+
+      def refund_application_fee(money, identification, options = {})
+        return Response.new(false, "Application fee id could not be found") unless identification
+
+        post = {:amount => amount(money)}
+        options.merge!(:key => @fee_refund_api_key)
+
+        commit(:post, "application_fees/#{CGI.escape(identification)}/refund", post, options)
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        post[:description] = options[:description]
+        post[:email] = options[:email]
+
+        path = if options[:customer]
+          "customers/#{CGI.escape(options[:customer])}"
+        else
+          'customers'
+        end
+
+        commit(:post, path, post, generate_meta(options))
+      end
+
+      def update(customer_id, creditcard, options = {})
+        options = options.merge(:customer => customer_id)
+        store(creditcard, options)
+      end
+
+      def unstore(customer_id, options = {})
+        commit(:delete, "customers/#{CGI.escape(customer_id)}", nil, generate_meta(options))
+      end
+
+      private
+
+      def create_post_for_auth_or_purchase(money, creditcard, options)
+        post = {}
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        add_customer(post, options)
+        add_customer_data(post,options)
+        post[:description] = options[:description] || options[:email]
+        add_flags(post, options)
+        add_application_fee(post, creditcard, options)
+        post
+      end
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money)).downcase
+      end
+
+      def add_application_fee(post, creditcard, options)
+        return unless options[:application_fee]
+        if use_card_not_present_fee?(creditcard, options)
+          post[:application_fee] = options[:card_not_present_fee]
+        else
+          post[:application_fee] = options[:application_fee]
+        end
+      end
+
+      def use_card_not_present_fee?(creditcard, options)
+        options[:card_not_present_fee].present? && !includes_track_data?(creditcard, options)
+      end
+
+      def includes_track_data?(creditcard, options)
+        if creditcard.respond_to?(:track_data)
+          creditcard.track_data.present?
+        else
+          options[:track_data].present?
+        end
+      end
+
+      def add_customer_data(post, options)
+        metadata_options = [:description,:browser_ip,:user_agent,:referrer]
+        post.update(options.slice(*metadata_options))
+
+        post[:external_id] = options[:order_id]
+        post[:payment_user_agent] = "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+      end
+
+      def add_address(post, options)
+        return unless post[:card] && post[:card].kind_of?(Hash)
+        if address = options[:billing_address] || options[:address]
+          post[:card][:address_line1] = address[:address1] if address[:address1]
+          post[:card][:address_line2] = address[:address2] if address[:address2]
+          post[:card][:address_country] = address[:country] if address[:country]
+          post[:card][:address_zip] = address[:zip] if address[:zip]
+          post[:card][:address_state] = address[:state] if address[:state]
+          post[:card][:address_city] = address[:city] if address[:city]
+        end
+      end
+
+      def add_creditcard(post, creditcard, options)
+        card = {}
+        if creditcard.respond_to?(:number)
+          if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
+            card[:swipe_data] = creditcard.track_data
+          else
+            card[:number] = creditcard.number
+            card[:exp_month] = creditcard.month
+            card[:exp_year] = creditcard.year
+            card[:cvc] = creditcard.verification_value if creditcard.verification_value?
+            card[:name] = creditcard.name if creditcard.name
+          end
+
+          post[:card] = card
+          add_address(post, options)
+        elsif creditcard.kind_of?(String)
+          if options[:track_data]
+            card[:swipe_data] = options[:track_data]
+          else
+            card[:number] = creditcard
+          end
+          post[:card] = card
+        end
+      end
+
+      def add_customer(post, options)
+        post[:customer] = options[:customer] if options[:customer] && !post[:card]
+      end
+
+      def add_flags(post, options)
+        post[:uncaptured] = true if options[:uncaptured]
+      end
+
+      def fetch_application_fees(identification, options = {})
+        options.merge!(:key => @fee_refund_api_key)
+
+        commit(:get, "application_fees?charge=#{identification}", nil, options)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      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 generate_meta(options)
+        {:meta => {:ip => options[:ip]}}
+      end
+
+      def headers(options = {})
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant',
+          :uname => (RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil)
+        })
+
+        key = options[:key] || @api_key
+
+        {
+          "Authorization" => "Basic " + Base64.encode64(key.to_s + ":").strip,
+          "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "X-Stripe-Client-User-Agent" => @@ua,
+          "X-Stripe-Client-User-Metadata" => options[:meta].to_json
+        }
+      end
+
+      def commit(method, url, parameters=nil, options = {}, creditcard = nil)
+        raw_response = response = nil
+        success = false
+        begin
+          raw_response = ssl_request(method, self.live_url + url, post_data(parameters), headers(options))
+          response = parse(raw_response)
+          success = !response.key?("error")
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        response[:card_present] = includes_track_data?(creditcard, options)
+
+        card = response["card"] || response["active_card"] || {}
+        avs_code = AVS_CODE_TRANSLATOR["line1: #{card["address_line1_check"]}, zip: #{card["address_zip_check"]}"]
+        cvc_code = CVC_CODE_TRANSLATOR[card["cvc_check"]]
+        Response.new(success,
+          success ? "Transaction approved" : response["error"]["message"],
+          response,
+          :test => response.has_key?("livemode") ? !response["livemode"] : false,
+          :authorization => response["id"],
+          :avs_result => { :code => avs_code },
+          :cvv_result => cvc_code
+        )
+      end
+
+      def response_error(raw_response)
+        begin
+          parse(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the Stripe API.  Please contact support@stripe.com if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "error" => {
+            "message" => msg
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransFirstGateway < Gateway
+      self.live_url = self.test_url = 'https://webservices.primerchants.com/creditcard.asmx/CCSale'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.transfirst.com/'
+      self.display_name = 'TransFirst'
+
+      UNUSED_FIELDS = %w(ECIValue UserId CAVVData TrackData POSInd EComInd MerchZIP MerchCustPNum MCC InstallmentNum InstallmentOf POSEntryMode POSConditionCode AuthCharInd CardCertData)
+
+      DECLINED = 'The transaction was declined'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        post = {}
+
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+        add_address(post, options)
+
+        commit(post)
+      end
+
+      private
+      def add_amount(post, money)
+        add_pair(post, :Amount, amount(money), :required => true)
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address] || options[:address]
+
+        if address
+          add_pair(post, :Address, address[:address1])
+          add_pair(post, :ZipCode, address[:zip])
+        end
+      end
+
+      def add_invoice(post, options)
+        add_pair(post, :RefID, options[:order_id], :required => true)
+        add_pair(post, :PONumber, options[:invoice], :required => true)
+        add_pair(post, :SaleTaxAmount, amount(options[:tax] || 0))
+        add_pair(post, :PaymentDesc, options[:description], :required => true)
+        add_pair(post, :TaxIndicator, 0)
+      end
+
+      def add_credit_card(post, credit_card)
+        add_pair(post, :CardHolderName, credit_card.name, :required => true)
+        add_pair(post, :CardNumber, credit_card.number, :required => true)
+
+        add_pair(post, :Expiration, expdate(credit_card), :required => true)
+        add_pair(post, :CVV2, credit_card.verification_value)
+      end
+
+      def add_unused_fields(post)
+        UNUSED_FIELDS.each do |f|
+          post[f] = ""
+        end
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+
+      def parse(data)
+        response = {}
+
+        xml = REXML::Document.new(data)
+        root = REXML::XPath.first(xml, "//CCSaleDebitResponse")
+
+        if root.nil?
+          response[:message] = data.to_s.strip
+        else
+          root.elements.to_a.each do |node|
+            response[node.name.underscore.to_sym] = node.text
+          end
+        end
+
+        response
+      end
+
+      def commit(params)
+        response = parse( ssl_post(self.live_url, post_data(params)) )
+
+        Response.new(response[:status] == "Authorized", message_from(response), response,
+          :test => test?,
+          :authorization => response[:trans_id],
+          :avs_result => { :code => response[:avs_code] },
+          :cvv_result => response[:cvv2_code]
+        )
+      end
+
+      def message_from(response)
+        case response[:message]
+        when 'Call Voice Center'
+          DECLINED
+        else
+          response[:message]
+        end
+      end
+
+      def post_data(params = {})
+        add_unused_fields(params)
+        params[:MerchantID] = @options[:login]
+        params[:RegKey] = @options[:password]
+
+        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__),'smart_ps.rb')
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransaxGateway < SmartPs
+      self.live_url = self.test_url = 'https://secure.nelixtransax.net/api/transact.php'
+      
+      # 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]
+      
+      # The homepage URL of the gateway
+      self.homepage_url = 'https://www.nelixtransax.com/'
+      
+      # The name of the gateway
+      self.display_name = 'NELiX TransaX'
+
+    end
+  end
+end
+

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

@@ -0,0 +1,239 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransnationalGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.tnbci.com/'
+      self.display_name = 'Transnational'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, option)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, options)
+        # unencrypted tracks
+        post[:track_1] = options[:track_1]
+        post[:track_2] = options[:track_2]
+        post[:track_3] = options[:track_3]
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, creditcard_or_check_or_vault_id, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, options)
+
+        # creditcard_or_check can be blank if using swipe data
+        if creditcard_or_check_or_vault_id.is_a?(CreditCard) # creditcard or check
+          creditcard = creditcard_or_check_or_vault_id
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        elsif creditcard_or_check_or_vault_id.is_a?(Check)
+          check = creditcard_or_check_or_vault_id
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        else
+          post[:customer_vault_id] = creditcard_or_check_or_vault_id
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(:customer_vault => action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => raw['avsresponse']},
+          :cvv_result => raw['cvvresponse']
+        )
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
+          authorization = response['customer_vault_id']
+        end
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end
+