swiss-crm-activemerchant 1.0.12

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

@@ -0,0 +1,274 @@
+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)
+        add_eci(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
+
+      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
+
+      # 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 unstore delete
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options.has_key? :email
+
+        post[:ipaddress] = options[:ip] if options.has_key? :ip
+      end
+
+      def add_address(post, address, prefix = '')
+        prefix += '_' unless prefix.blank?
+        unless address.blank? || 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 add_eci(post, options)
+        post[:billing_method] = options[:eci] if options[:eci]
+      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] = localized_amount(money, parameters[:currency] || default_currency) 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)
+        month = sprintf('%.02i', creditcard.month)
+
+        "#{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.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/so_easy_pay.rb

@@ -0,0 +1,194 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SoEasyPayGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.soeasypay.com/gateway.asmx'
+      self.money_format = :cents
+
+      self.supported_countries = %w[
+        US CA AT BE BG HR CY CZ DK EE
+        FI FR DE GR HU IE IT LV LT LU
+        MT NL PL PT RO SK SI ES SE GB
+        IS NO CH
+      ]
+      self.supported_cardtypes = %i[visa master american_express discover maestro jcb diners_club]
+      self.homepage_url = 'http://www.soeasypay.com/'
+      self.display_name = 'SoEasyPay'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('AuthorizeTransaction', do_authorization(money, payment_source, options), options)
+        else
+          commit('ReauthorizeTransaction', do_reauthorization(money, payment_source, options), options)
+        end
+      end
+
+      def purchase(money, payment_source, options = {})
+        if payment_source.respond_to?(:number)
+          commit('SaleTransaction', do_sale(money, payment_source, options), options)
+        else
+          commit('RebillTransaction', do_rebill(money, payment_source, options), options)
+        end
+      end
+
+      def capture(money, authorization, options = {})
+        commit('CaptureTransaction', do_capture(money, authorization, options), options)
+      end
+
+      def refund(money, authorization, options = {})
+        commit('RefundTransaction', do_refund(money, authorization, options), options)
+      end
+
+      def void(authorization, options = {})
+        commit('CancelTransaction', do_void(authorization, options), options)
+      end
+
+      private
+
+      def do_authorization(money, card, options)
+        build_soap('AuthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_sale(money, card, options)
+        build_soap('SaleTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_cardholder(soap, card, options)
+          fill_card(soap, card)
+        end
+      end
+
+      def do_reauthorization(money, authorization, options)
+        build_soap('ReauthorizeTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_rebill(money, authorization, options)
+        build_soap('RebillTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_capture(money, authorization, options)
+        build_soap('CaptureTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_refund(money, authorization, options)
+        build_soap('RefundTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_order_info(soap, money, options, :no_currency)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def do_void(authorization, options)
+        build_soap('CancelTransaction') do |soap|
+          fill_credentials(soap, options)
+          fill_transaction_id(soap, authorization)
+        end
+      end
+
+      def fill_credentials(soap, options)
+        soap.tag!('websiteID', @options[:login].to_s)
+        soap.tag!('password', @options[:password].to_s)
+      end
+
+      def fill_cardholder(soap, card, options)
+        ch_info = options[:billing_address] || options[:address]
+
+        soap.tag!('customerIP', options[:ip].to_s)
+        name = card.name || ch_info[:name]
+        soap.tag!('cardHolderName', name.to_s)
+        address = ch_info[:address1] || ''
+        address << ch_info[:address2] if ch_info[:address2]
+        soap.tag!('cardHolderAddress', address.to_s)
+        soap.tag!('cardHolderZipcode', ch_info[:zip].to_s)
+        soap.tag!('cardHolderCity', ch_info[:city].to_s)
+        soap.tag!('cardHolderState', ch_info[:state].to_s)
+        soap.tag!('cardHolderCountryCode', ch_info[:country].to_s)
+        soap.tag!('cardHolderPhone', ch_info[:phone].to_s)
+        soap.tag!('cardHolderEmail', options[:email].to_s)
+      end
+
+      def fill_transaction_id(soap, transaction_id)
+        soap.tag!('transactionID', transaction_id.to_s)
+      end
+
+      def fill_card(soap, card)
+        soap.tag!('cardNumber', card.number.to_s)
+        soap.tag!('cardSecurityCode', card.verification_value.to_s)
+        soap.tag!('cardExpireMonth', card.month.to_s.rjust(2, '0'))
+        soap.tag!('cardExpireYear', card.year.to_s)
+      end
+
+      def fill_order_info(soap, money, options, skip_currency = false)
+        soap.tag!('orderID', options[:order_id].to_s)
+        soap.tag!('orderDescription', "Order #{options[:order_id]}")
+        soap.tag!('amount', amount(money).to_s)
+        soap.tag!('currency', (options[:currency] || currency(money)).to_s) unless skip_currency
+      end
+
+      def parse(response, action)
+        result = {}
+        document = REXML::Document.new(response)
+        response_element = document.root.get_elements("//*[@xsi:type='tns:#{action}Response']").first
+        response_element.elements.each do |element|
+          result[element.name.underscore] = element.text
+        end
+        result
+      end
+
+      def commit(soap_action, soap, options)
+        headers = { 'SOAPAction' => "\"urn:Interface##{soap_action}\"",
+                   'Content-Type' => 'text/xml; charset=utf-8' }
+        response_string = ssl_post(test? ? self.test_url : self.live_url, soap, headers)
+        response = parse(response_string, soap_action)
+        return Response.new(response['errorcode'] == '000',
+          response['errormessage'],
+          response,
+          test: test?,
+          authorization: response['transaction_id'])
+      end
+
+      def build_soap(request)
+        retval = Builder::XmlMarkup.new(indent: 2)
+        retval.instruct!(:xml, version: '1.0', encoding: 'utf-8')
+        retval.tag!('soap:Envelope', {
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:soapenc' => 'http://schemas.xmlsoap.org/soap/encoding/',
+          'xmlns:tns' => 'urn:Interface',
+          'xmlns:types' => 'urn:Interface/encodedTypes',
+          'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/'
+        }) do
+          retval.tag!('soap:Body', { 'soap:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/' }) do
+            retval.tag!("tns:#{request}") do
+              retval.tag!("#{request}Request", { 'xsi:type' => "tns:#{request}Request" }) do
+                yield retval
+              end
+            end
+          end
+        end
+        retval.target!
+      end
+    end
+  end
+end