tanga_activemerchant 1.37.0

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

@@ -0,0 +1,272 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SmartPs < Gateway #:nodoc:
+
+      ##
+      # This is the base gateway for processors who use the smartPS processing system
+
+      self.abstract_class = true
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Pass :store => true in the options to store the
+      # payment info at the gateway and get a generated
+      # customer_vault_id in the response.
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id the gateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard,options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_taxes(post, options)
+        add_processor(post, options)
+        commit('auth', money, post)
+      end
+
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_taxes(post, options)
+        add_processor(post, options)
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('capture', money, post)
+      end
+
+      def void(authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('void', nil, post)
+      end
+
+      def credit(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        add_sku(post,options)
+        add_currency(post, money, options)
+        add_processor(post, options)
+        commit('credit', money, post)
+      end
+
+      def refund(money, auth, options = {})
+        post = {}
+        add_transaction(post, auth)
+        commit('refund', money, post)
+      end
+
+
+      # Update the values (such as CC expiration) stored at
+      # the gateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, creditcard, options = {})
+        post = {}
+        post[:customer_vault] = "update_customer"
+        add_customer_vault_id(post, vault_id)
+        add_creditcard(post, creditcard, options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+
+        commit(nil, nil, post)
+      end
+
+      # Amend an existing transaction
+      def amend(auth, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_transaction(post, auth)
+        commit('update', nil, post)
+      end
+
+
+      def delete(vault_id)
+        post = {}
+        post[:customer_vault] = "delete_customer"
+        add_customer_vault_id(post, vault_id)
+        commit(nil, nil, post)
+      end
+
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(payment_source, options = {})
+        post = {}
+        billing_id = options.delete(:billing_id).to_s || true
+        add_payment_source(post, payment_source, :store => billing_id)
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        commit(nil, nil, post)
+      end
+
+      alias_method :unstore, :delete
+
+      private
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+        end
+
+        if options.has_key? :ip
+          post[:ipaddress] = options[:ip]
+        end
+      end
+
+      def add_address(post, address,prefix="")
+        prefix +="_" unless prefix.blank?
+        unless address.blank? or address.values.blank?
+          post[prefix+"address1"]    = address[:address1].to_s
+          post[prefix+"address2"]    = address[:address2].to_s unless address[:address2].blank?
+          post[prefix+"company"]    = address[:company].to_s
+          post[prefix+"phone"]      = address[:phone].to_s
+          post[prefix+"zip"]        = address[:zip].to_s
+          post[prefix+"city"]       = address[:city].to_s
+          post[prefix+"country"]    = address[:country].to_s
+          post[prefix+"state"]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def add_currency(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_taxes(post, options)
+        post[:tax] = amount(options[:tax])
+      end
+
+      def add_processor(post, options)
+        post[:processor] = options[:processor] unless options[:processor].nil?
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+      end
+
+      def add_payment_source(params, source, options={})
+        case determine_funding_source(source)
+        when :vault       then add_customer_vault_id(params, source)
+        when :credit_card then add_creditcard(params, source, options)
+        when :check       then add_check(params, source, options)
+        end
+      end
+
+      def add_customer_vault_id(params, vault_id)
+        params[:customer_vault_id] = vault_id
+      end
+
+      def add_creditcard(post, creditcard, options)
+        if options[:store]
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        post[:ccnumber]  = creditcard.number
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp]  = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name
+      end
+
+      def add_check(post, check, options)
+        if options[:store]
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+
+        post[:payment] = 'check' # Set transaction to ACH
+        post[:checkname] = check.name # The name on the customer's Checking Account
+        post[:checkaba] = check.routing_number # The customer's bank routing number
+        post[:checkaccount] = check.account_number # The customer's account number
+        post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
+        post[:account_type] = check.account_type # The customer's type of ACH account
+      end
+
+      def add_sku(post,options)
+        post["product_sku_#"] = options[:sku] || options["product_sku_#"]
+      end
+
+      def add_transaction(post, auth)
+        post[:transactionid] = auth
+      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)
+        parameters[:amount]  = amount(money) if money
+        response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
+        Response.new(response["response"] == "1", message_from(response), response,
+          :authorization => (response["transactionid"] || response["customer_vault_id"]),
+          :test => test?,
+          :cvv_result => response["cvvresponse"],
+          :avs_result => { :code => response["avsresponse"] }
+        )
+
+      end
+
+      def expdate(creditcard)
+        year  = sprintf("%.04i", creditcard.year.to_i)
+        month = sprintf("%.02i", creditcard.month.to_i)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+
+      def message_from(response)
+        case response["responsetext"]
+        when "SUCCESS", "Approved", nil # This is dubious, but responses from UPDATE are nil.
+          "This transaction has been approved"
+        when "DECLINE"
+          "This transaction has been declined"
+        else
+          response["responsetext"]
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:username]      = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = action if action
+
+        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request
+      end
+
+      def determine_funding_source(source)
+        case
+        when source.is_a?(String) then :vault
+        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when card_brand(source) == 'check' then :check
+        else raise ArgumentError, "Unsupported funding source provided"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,233 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Public: This gateway allows you to interact with any gateway you've
+    # created in Spreedly (https://spreedly.com).  It's an adapter which can be
+    # particularly useful if you already have code interacting with
+    # ActiveMerchant and want to easily take advantage of Spreedly's vault.
+    class SpreedlyCoreGateway < Gateway
+      self.live_url = 'https://core.spreedly.com/v1'
+
+      self.supported_countries = %w(AD AE AT AU BD BE BG BN CA CH CY CZ DE DK EE EG ES FI FR GB
+                                    GI GR HK HU ID IE IL IM IN IS IT JO KW LB LI LK LT LU LV MC
+                                    MT MU MV MX MY NL NO NZ OM PH PL PT QA RO SA SE SG SI SK SM
+                                    TR TT UM US VA VN ZA)
+
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://spreedly.com'
+      self.display_name = 'Spreedly'
+      self.money_format = :cents
+      self.default_currency = 'USD'
+
+      # Public: Create a new Spreedly gateway.
+      #
+      # options - A hash of options:
+      #           :login         - The environment key.
+      #           :password      - The access secret.
+      #           :gateway_token - The token of the gateway you've created in
+      #                            Spreedly.
+      def initialize(options = {})
+        requires!(options, :login, :password, :gateway_token)
+        super
+      end
+
+      # Public: Run a purchase transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly payment method token.
+      # options        - A standard ActiveMerchant options hash
+      def purchase(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          purchase_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { purchase_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      # Public: Run an authorize transaction.
+      #
+      # money          - The monetary amount of the transaction in cents.
+      # payment_method - The CreditCard or the Spreedly payment method token.
+      # options        - A standard ActiveMerchant options hash
+      def authorize(money, payment_method, options = {})
+        if payment_method.is_a?(String)
+          authorize_with_token(money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(false, payment_method, options) }
+            r.process { authorize_with_token(money, r.authorization, options) }
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/capture.xml", request)
+      end
+
+      def refund(money, authorization, options={})
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+        end
+
+        commit("transactions/#{authorization}/credit.xml", request)
+      end
+
+      def void(authorization, options={})
+        commit("transactions/#{authorization}/void.xml", '')
+      end
+
+      # Public: Store a credit card in the Spreedly vault and retain it.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def store(credit_card, options={})
+        save_card(true, credit_card, options)
+      end
+
+      # Public: Redact the CreditCard in Spreedly. This wipes the sensitive
+      #         payment information from the card.
+      #
+      # credit_card    - The CreditCard to store
+      # options        - A standard ActiveMerchant options hash
+      def unstore(authorization, options={})
+        commit("payment_methods/#{authorization}/redact.xml", '', :put)
+      end
+
+      private
+      def save_card(retain, credit_card, options)
+        request = build_xml_request('payment_method') do |doc|
+          add_credit_card(doc, credit_card, options)
+          add_data(doc, options)
+          doc.retained(true) if retain
+        end
+
+        commit("payment_methods.xml", request, :post, :payment_method_token)
+      end
+
+      def purchase_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/purchase.xml", request)
+      end
+
+      def authorize_with_token(money, payment_method_token, options)
+        request = auth_purchase_request(money, payment_method_token, options)
+        commit("gateways/#{@options[:gateway_token]}/authorize.xml", request)
+      end
+
+      def auth_purchase_request(money, payment_method_token, options)
+        build_xml_request('transaction') do |doc|
+          add_invoice(doc, money, options)
+          doc.payment_method_token(payment_method_token)
+        end
+      end
+
+      def add_invoice(doc, money, options)
+        doc.amount amount(money)
+        doc.currency_code(options[:currency] || currency(money) || default_currency)
+      end
+
+      def add_credit_card(doc, credit_card, options)
+        doc.credit_card do
+          doc.number(credit_card.number)
+          doc.first_name(credit_card.first_name)
+          doc.last_name(credit_card.last_name)
+          doc.month(credit_card.month)
+          doc.year(credit_card.year)
+          doc.email(options[:email])
+          doc.address1(options[:billing_address].try(:[], :address1))
+          doc.address2(options[:billing_address].try(:[], :address2))
+          doc.city(options[:billing_address].try(:[], :city))
+          doc.state(options[:billing_address].try(:[], :state))
+          doc.zip(options[:billing_address].try(:[], :zip))
+        end
+      end
+
+      def add_data(doc, options)
+        doc.data do
+          data_to_doc(doc, options[:data])
+        end
+      end
+
+      def data_to_doc(doc, value)
+        return doc.text value unless value.kind_of? Hash
+        value.each do |k, v|
+          doc.send(k) do
+            data_to_doc(doc, v)
+          end
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath('*').each do |node|
+          if (node.elements.empty?)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              childnode_to_response(response, node, childnode)
+            end
+          end
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, node, childnode)
+        name = "#{node.name.downcase}_#{childnode.name.downcase}"
+        if name == 'payment_method_data' && !childnode.elements.empty?
+          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        else
+          response[name.to_sym] = childnode.text
+        end
+      end
+
+      def build_xml_request(root)
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__(root) do |doc|
+          yield(doc)
+        end
+        builder.to_xml
+      end
+
+      def commit(relative_url, request, method = :post, authorization_field = :token)
+        begin
+          raw_response = ssl_request(method, "#{live_url}/#{relative_url}", request, headers)
+        rescue ResponseError => e
+          raw_response = e.response.body
+        end
+
+        response_from(raw_response, authorization_field)
+      end
+
+      def response_from(raw_response, authorization_field)
+        parsed = parse(raw_response)
+        options = {
+          :authorization => parsed[authorization_field],
+          :test => (parsed[:on_test_gateway] == 'true'),
+          :avs_result => { :code => parsed[:response_avs_code] },
+          :cvv_result => parsed[:response_cvv_code]
+        }
+
+        Response.new(parsed[:succeeded] == 'true', parsed[:message] || parsed[:error], parsed, options)
+      end
+
+      def headers
+        {
+          'Authorization' => ('Basic ' + Base64.strict_encode64("#{@options[:login]}:#{@options[:password]}").chomp),
+          'Content-Type' => 'text/xml'
+        }
+      end
+    end
+  end
+end
+