tanga_activemerchant 1.37.0

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

@@ -0,0 +1,313 @@
+require 'base64'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WirecardGateway < Gateway
+      # Test server location
+      self.test_url = 'https://c3-test.wirecard.com/secure/ssl-gateway'
+
+      # Live server location
+      self.live_url = 'https://c3.wirecard.com/secure/ssl-gateway'
+
+      # The Namespaces are not really needed, because it just tells the System, that there's actually no namespace used.
+      # It's just specified here for completeness.
+      ENVELOPE_NAMESPACES = {
+        'xmlns:xsi' => 'http://www.w3.org/1999/XMLSchema-instance',
+        'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
+      }
+
+      PERMITTED_TRANSACTIONS = %w[ PREAUTHORIZATION CAPTURE PURCHASE ]
+
+      RETURN_CODES = %w[ ACK NOK ]
+
+      # Wirecard only allows phone numbers with a format like this: +xxx(yyy)zzz-zzzz-ppp, where:
+      #   xxx = Country code
+      #   yyy = Area or city code
+      #   zzz-zzzz = Local number
+      #   ppp = PBX extension
+      # For example, a typical U.S. or Canadian number would be "+1(202)555-1234-739" indicating PBX extension 739 at phone
+      # number 5551234 within area code 202 (country code 1).
+      VALID_PHONE_FORMAT = /\+\d{1,3}(\(?\d{3}\)?)?\d{3}-\d{4}-\d{3}/
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['DE']
+
+      # Wirecard supports all major credit and debit cards:
+      # Visa, Mastercard, American Express, Diners Club,
+      # JCB, Switch, VISA Carte Bancaire, Visa Electron and UATP cards.
+      # They also support the latest anti-fraud systems such as Verified by Visa or Master Secure Code.
+      self.supported_cardtypes = [
+        :visa, :master, :american_express, :diners_club, :jcb, :switch
+      ]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.wirecard.com'
+
+      # The name of the gateway
+      self.display_name = 'Wirecard'
+
+      # The currency should normally be EUROs
+      self.default_currency = 'EUR'
+
+      # 100 is 1.00 Euro
+      self.money_format = :cents
+
+      def initialize(options = {})
+        # verify that username and password are supplied
+        requires!(options, :login, :password)
+        # unfortunately Wirecard also requires a BusinessCaseSignature in the XML request
+        requires!(options, :signature)
+        super
+      end
+
+      # Authorization
+      def authorize(money, creditcard, options = {})
+        options[:credit_card] = creditcard
+        commit(:preauthorization, money, options)
+      end
+
+      # Capture Authorization
+      def capture(money, authorization, options = {})
+        options[:preauthorization] = authorization
+        commit(:capture, money, options)
+      end
+
+      # Purchase
+      def purchase(money, creditcard, options = {})
+        options[:credit_card] = creditcard
+        commit(:purchase, money, options)
+      end
+
+      private
+
+      def prepare_options_hash(options)
+        result = @options.merge(options)
+        setup_address_hash!(result)
+        result
+      end
+
+      # Create all address hash key value pairs so that
+      # it still works if only provided with one or two of them
+      def setup_address_hash!(options)
+        options[:billing_address] = options[:billing_address] || options[:address] || {}
+        options[:shipping_address] = options[:shipping_address] || {}
+        # Include Email in address-hash from options-hash
+        options[:billing_address][:email] = options[:email] if options[:email]
+      end
+
+      # Contact WireCard, make the XML request, and parse the
+      # reply into a Response object
+      def commit(action, money, options)
+        request = build_request(action, money, options)
+
+        headers = { 'Content-Type' => 'text/xml',
+                    'Authorization' => encoded_credentials }
+
+        response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
+        # Pending Status also means Acknowledged (as stated in their specification)
+        success = response[:FunctionResult] == "ACK" || response[:FunctionResult] == "PENDING"
+        message = response[:Message]
+        authorization = response[:GuWID]
+
+        Response.new(success, message, response,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => response[:avsCode] },
+          :cvv_result => response[:cvCode]
+        )
+      rescue ResponseError => e
+        if e.response.code == "401"
+          return Response.new(false, "Invalid Login")
+        else
+          raise
+        end
+      end
+
+      # Generates the complete xml-message, that gets sent to the gateway
+      def build_request(action, money, options)
+        options = prepare_options_hash(options)
+        options[:action] = action
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! 'WIRECARD_BXML' do
+          xml.tag! 'W_REQUEST' do
+          xml.tag! 'W_JOB' do
+              xml.tag! 'JobID', ''
+              # UserID for this transaction
+              xml.tag! 'BusinessCaseSignature', options[:signature] || options[:login]
+              # Create the whole rest of the message
+              add_transaction_data(xml, money, options)
+            end
+          end
+        end
+        xml.target!
+      end
+
+      # Includes the whole transaction data (payment, creditcard, address)
+      def add_transaction_data(xml, money, options)
+        options[:order_id] ||= generate_unique_id
+
+        xml.tag! "FNC_CC_#{options[:action].to_s.upcase}" do
+          xml.tag! 'FunctionID', options[:description].to_s.slice(0,32)
+          xml.tag! 'CC_TRANSACTION' do
+            xml.tag! 'TransactionID', options[:order_id]
+            case options[:action]
+            when :preauthorization, :purchase
+              add_invoice(xml, money, options)
+              add_creditcard(xml, options[:credit_card])
+              add_address(xml, options[:billing_address])
+            when :capture
+              xml.tag! 'GuWID', options[:preauthorization]
+              add_amount(xml, money)
+            end
+          end
+        end
+      end
+
+      # Includes the payment (amount, currency, country) to the transaction-xml
+      def add_invoice(xml, money, options)
+        add_amount(xml, money)
+        xml.tag! 'Currency', options[:currency] || currency(money)
+        xml.tag! 'CountryCode', options[:billing_address][:country]
+        xml.tag! 'RECURRING_TRANSACTION' do
+          xml.tag! 'Type', options[:recurring] || 'Single'
+        end
+      end
+
+      # Include the amount in the transaction-xml
+      def add_amount(xml, money)
+        xml.tag! 'Amount', amount(money)
+      end
+
+      # Includes the credit-card data to the transaction-xml
+      def add_creditcard(xml, creditcard)
+        raise "Creditcard must be supplied!" if creditcard.nil?
+        xml.tag! 'CREDIT_CARD_DATA' do
+          xml.tag! 'CreditCardNumber', creditcard.number
+          xml.tag! 'CVC2', creditcard.verification_value
+          xml.tag! 'ExpirationYear', creditcard.year
+          xml.tag! 'ExpirationMonth', format(creditcard.month, :two_digits)
+          xml.tag! 'CardHolderName', [creditcard.first_name, creditcard.last_name].join(' ')
+        end
+      end
+
+      # Includes the IP address of the customer to the transaction-xml
+      def add_customer_data(xml, options)
+        return unless options[:ip]
+        xml.tag! 'CONTACT_DATA' do
+          xml.tag! 'IPAddress', options[:ip]
+        end
+      end
+
+      # Includes the address to the transaction-xml
+      def add_address(xml, address)
+        return if address.nil?
+        xml.tag! 'CORPTRUSTCENTER_DATA' do
+          xml.tag! 'ADDRESS' do
+            xml.tag! 'Address1', address[:address1]
+            xml.tag! 'Address2', address[:address2] if address[:address2]
+            xml.tag! 'City', address[:city]
+            xml.tag! 'ZipCode', address[:zip]
+
+            if address[:state] =~ /[A-Za-z]{2}/ && address[:country] =~ /^(us|ca)$/i
+              xml.tag! 'State', address[:state].upcase
+            end
+
+            xml.tag! 'Country', address[:country]
+            xml.tag! 'Phone', address[:phone] if address[:phone] =~ VALID_PHONE_FORMAT
+            xml.tag! 'Email', address[:email]
+          end
+        end
+      end
+
+      # Read the XML message from the gateway and check if it was successful,
+      # and also extract required return values from the response.
+      def parse(xml)
+        basepath = '/WIRECARD_BXML/W_RESPONSE'
+        response = {}
+
+        xml = REXML::Document.new(xml)
+        if root = REXML::XPath.first(xml, "#{basepath}/W_JOB")
+          parse_response(response, root)
+        elsif root = REXML::XPath.first(xml, "//ERROR")
+          parse_error(response, root)
+        else
+          response[:Message] = "No valid XML response message received. \
+                                Propably wrong credentials supplied with HTTP header."
+        end
+
+        response
+      end
+
+      # Parse the <ProcessingStatus> Element which containts all important information
+      def parse_response(response, root)
+        status = nil
+        # get the root element for this Transaction
+        root.elements.to_a.each do |node|
+          if node.name =~ /FNC_CC_/
+            status = REXML::XPath.first(node, "CC_TRANSACTION/PROCESSING_STATUS")
+          end
+        end
+        message = ""
+        if status
+          if info = status.elements['Info']
+            message << info.text
+          end
+          # Get basic response information
+          status.elements.to_a.each do |node|
+            response[node.name.to_sym] = (node.text || '').strip
+          end
+        end
+        parse_error(root, message)
+        response[:Message] = message
+      end
+
+      # Parse a generic error response from the gateway
+      def parse_error(root, message = "")
+        # Get errors if available and append them to the message
+        errors = errors_to_string(root)
+        unless errors.strip.blank?
+          message << ' - ' unless message.strip.blank?
+          message << errors
+        end
+        message
+      end
+
+      # Parses all <ERROR> elements in the response and converts the information
+      # to a single string
+      def errors_to_string(root)
+        # Get context error messages (can be 0..*)
+        errors = []
+        REXML::XPath.each(root, "//ERROR") do |error_elem|
+          error = {}
+          error[:Advice] = []
+          error[:Message] = error_elem.elements['Message'].text
+          error_elem.elements.each('Advice') do |advice|
+            error[:Advice] << advice.text
+          end
+          errors << error
+        end
+        # Convert all messages to a single string
+        string = ''
+        errors.each do |error|
+          string << error[:Message]
+          error[:Advice].each_with_index do |advice, index|
+            string << ' (' if index == 0
+            string << "#{index+1}. #{advice}"
+            string << ' and ' if index < error[:Advice].size - 1
+            string << ')' if index == error[:Advice].size - 1
+          end
+        end
+        string
+      end
+
+      # Encode login and password in Base64 to supply as HTTP header
+      # (for http basic authentication)
+      def encoded_credentials
+        credentials = [@options[:login], @options[:password]].join(':')
+        "Basic " << Base64.encode64(credentials).strip
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,303 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WorldpayGateway < Gateway
+      self.test_url = 'https://secure-test.worldpay.com/jsp/merchant/xml/paymentService.jsp'
+      self.live_url = 'https://secure.worldpay.com/jsp/merchant/xml/paymentService.jsp'
+
+      self.default_currency = 'GBP'
+      self.money_format = :cents
+      self.supported_countries = ['HK', 'US', 'GB', 'AU']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :laser]
+      self.homepage_url = 'http://www.worldpay.com/'
+      self.display_name = 'WorldPay'
+
+      CARD_CODES = {
+        'visa'             => 'VISA-SSL',
+        'master'           => 'ECMC-SSL',
+        'discover'         => 'DISCOVER-SSL',
+        'american_express' => 'AMEX-SSL',
+        'jcb'              => 'JCB-SSL',
+        'maestro'          => 'MAESTRO-SSL',
+        'laser'            => 'LASER-SSL',
+        'diners_club'      => 'DINERS-SSL'
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, payment_method, options = {})
+        MultiResponse.run do |r|
+          r.process{authorize(money, payment_method, options)}
+          r.process{capture(money, r.authorization, options.merge(:authorization_validated => true))}
+        end
+      end
+
+      def authorize(money, payment_method, options = {})
+        requires!(options, :order_id)
+        authorize_request(money, payment_method, options)
+      end
+
+      def capture(money, authorization, options = {})
+        MultiResponse.run do |r|
+          r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
+          if r.params
+            authorization_currency = r.params['amount_currency_code']
+            options = options.merge(:currency => authorization_currency) if authorization_currency.present?
+          end
+          r.process{capture_request(money, authorization, options)}
+        end
+      end
+
+      def void(authorization, options = {})
+        MultiResponse.run do |r|
+          r.process{inquire_request(authorization, options, "AUTHORISED")}
+          r.process{cancel_request(authorization, options)}
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        MultiResponse.run do |r|
+          r.process{inquire_request(authorization, options, "CAPTURED", "SETTLED")}
+          r.process{refund_request(money, authorization, options)}
+        end
+      end
+
+      private
+
+      def authorize_request(money, payment_method, options)
+        commit('authorize', build_authorization_request(money, payment_method, options), "AUTHORISED")
+      end
+
+      def capture_request(money, authorization, options)
+        commit('capture', build_capture_request(money, authorization, options), :ok)
+      end
+
+      def cancel_request(authorization, options)
+        commit('cancel', build_void_request(authorization, options), :ok)
+      end
+
+      def inquire_request(authorization, options, *success_criteria)
+        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria)
+      end
+
+      def refund_request(money, authorization, options)
+        commit('refund', build_refund_request(money, authorization, options), :ok)
+      end
+
+      def build_request
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct! :xml, :encoding => 'ISO-8859-1'
+        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.wp3.rbsworldpay.com/paymentService_v1.dtd"
+        xml.tag! 'paymentService', 'version' => "1.4", 'merchantCode' => @options[:login] do
+          yield xml
+        end
+        xml.target!
+      end
+
+      def build_order_modify_request(authorization)
+        build_request do |xml|
+          xml.tag! 'modify' do
+            xml.tag! 'orderModification', 'orderCode' => authorization do
+              yield xml
+            end
+          end
+        end
+      end
+
+      def build_order_inquiry_request(authorization, options)
+        build_request do |xml|
+          xml.tag! 'inquiry' do
+            xml.tag! 'orderInquiry', 'orderCode' => authorization
+          end
+        end
+      end
+
+      def build_authorization_request(money, payment_method, options)
+        build_request do |xml|
+          xml.tag! 'submit' do
+            xml.tag! 'order', {'orderCode' => options[:order_id], 'installationId' => @options[:inst_id]}.reject{|_,v| !v} do
+              xml.description(options[:description].blank? ? "Purchase" : options[:description])
+              add_amount(xml, money, options)
+              if options[:order_content]
+                xml.tag! 'orderContent' do
+                  xml.cdata! options[:order_content]
+                end
+              end
+              add_payment_method(xml, money, payment_method, options)
+            end
+          end
+        end
+      end
+
+      def build_capture_request(money, authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'capture' do
+            time = Time.now
+            xml.tag! 'date', 'dayOfMonth' => time.day, 'month' => time.month, 'year'=> time.year
+            add_amount(xml, money, options)
+          end
+        end
+      end
+
+      def build_void_request(authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'cancel'
+        end
+      end
+
+      def build_refund_request(money, authorization, options)
+        build_order_modify_request(authorization) do |xml|
+          xml.tag! 'refund' do
+            add_amount(xml, money, options.merge(:debit_credit_indicator => "credit"))
+          end
+        end
+      end
+
+      def add_amount(xml, money, options)
+        currency = options[:currency] || currency(money)
+        amount   = localized_amount(money, currency)
+
+        amount_hash = {
+          :value => amount,
+          'currencyCode' => currency,
+          'exponent' => 2
+        }
+
+        if options[:debit_credit_indicator]
+          amount_hash.merge!('debitCreditIndicator' => options[:debit_credit_indicator])
+        end
+
+        xml.tag! 'amount', amount_hash
+      end
+
+      def add_payment_method(xml, amount, payment_method, options)
+        if payment_method.is_a?(String)
+          xml.tag! 'payAsOrder', 'orderCode' => payment_method do
+            add_amount(xml, amount, options)
+          end
+        else
+          xml.tag! 'paymentDetails' do
+            xml.tag! CARD_CODES[card_brand(payment_method)] do
+              xml.tag! 'cardNumber', payment_method.number
+              xml.tag! 'expiryDate' do
+                xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+              end
+
+              xml.tag! 'cardHolderName', payment_method.name
+              xml.tag! 'cvc', payment_method.verification_value
+
+              add_address(xml, 'cardAddress', (options[:billing_address] || options[:address]))
+            end
+          end
+        end
+      end
+
+      def add_address(xml, element, address)
+        return if address.nil?
+
+        xml.tag! element do
+          xml.tag! 'address' do
+            if m = /^\s*([^\s]+)\s+(.+)$/.match(address[:name])
+              xml.tag! 'firstName', m[1]
+              xml.tag! 'lastName', m[2]
+            end
+            if m = /^\s*(\d+)\s+(.+)$/.match(address[:address1])
+              xml.tag! 'street', m[2]
+              house_number = m[1]
+            else
+              xml.tag! 'street', address[:address1]
+            end
+            xml.tag! 'houseName', address[:address2] if address[:address2]
+            xml.tag! 'houseNumber', house_number if house_number.present?
+            xml.tag! 'postalCode', (address[:zip].present? ? address[:zip] : "0000")
+            xml.tag! 'city', address[:city] if address[:city]
+            xml.tag! 'state', (address[:state].present? ? address[:state] : 'N/A')
+            xml.tag! 'countryCode', address[:country]
+            xml.tag! 'telephoneNumber', address[:phone] if address[:phone]
+          end
+        end
+      end
+
+      def parse(action, xml)
+        parse_element({:action => action}, REXML::Document.new(xml))
+      end
+
+      def parse_element(raw, node)
+        node.attributes.each do |k, v|
+          raw["#{node.name.underscore}_#{k.underscore}".to_sym] = v
+        end
+        if node.has_elements?
+          raw[node.name.underscore.to_sym] = true unless node.name.blank?
+          node.elements.each{|e| parse_element(raw, e) }
+        else
+          raw[node.name.underscore.to_sym] = node.text unless node.text.nil?
+        end
+        raw
+      end
+
+      def commit(action, request, *success_criteria)
+        xmr = ssl_post(url, request, 'Content-Type' => 'text/xml', 'Authorization' => encoded_credentials)
+        raw = parse(action, xmr)
+        success, message = success_and_message_from(raw, success_criteria)
+
+        Response.new(
+          success,
+          message,
+          raw,
+          :authorization => authorization_from(raw),
+          :test => test?)
+
+      rescue ActiveMerchant::ResponseError => e
+        if e.response.code.to_s == "401"
+          return Response.new(false, "Invalid credentials", {}, :test => test?)
+        else
+          raise e
+        end
+      end
+
+      def url
+        test? ? self.test_url : self.live_url
+      end
+
+      # success_criteria can be:
+      #   - a string or an array of strings (if one of many responses)
+      #   - An array of strings if one of many responses could be considered a
+      #     success.
+      def success_and_message_from(raw, success_criteria)
+        success = (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
+        if success
+          message = "SUCCESS"
+        else
+          message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
+        end
+
+        [ success, message ]
+      end
+
+      def required_status_message(raw, success_criteria)
+        if(!success_criteria.include?(raw[:last_event]))
+          "A transaction status of #{success_criteria.collect{|c| "'#{c}'"}.join(" or ")} is required."
+        end
+      end
+
+      def authorization_from(raw)
+        pair = raw.detect{|k,v| k.to_s =~ /_order_code$/}
+        (pair ? pair.last : nil)
+      end
+
+      def encoded_credentials
+        credentials = "#{@options[:login]}:#{@options[:password]}"
+        "Basic #{[credentials].pack('m').strip}"
+      end
+
+      def localized_amount(money, currency)
+        amount = amount(money)
+        return amount unless CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
+
+        amount.to_i / 100 * 100
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways.rb

@@ -0,0 +1,17 @@
+module ActiveMerchant
+  module Billing
+    autoload :Gateway, 'active_merchant/billing/gateway'
+
+    Dir[File.dirname(__FILE__) + '/gateways/**/*.rb'].each do |f|
+      # Get camelized class name
+      filename = File.basename(f, '.rb')
+      # Add _gateway suffix
+      gateway_name = filename + '_gateway'
+      # Camelize the string to get the class name
+      gateway_class = gateway_name.camelize
+
+      # Register for autoloading
+      autoload gateway_class, f
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/a1agregator/helper.rb

@@ -0,0 +1,31 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module A1agregator
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+
+          # public key
+          mapping :account, 'key'
+
+          mapping :amount, 'cost'
+
+          mapping :order, 'order_id'
+
+          mapping :customer, :email => 'email',
+                             :phone => 'phone_number'
+
+           # payment description
+          mapping :credential2, 'name'
+
+          mapping :credential3, 'comment'
+
+          # on error
+          # 1 - raise error
+          # 0 - redirect
+          mapping :credential4, 'verbose'
+
+        end
+      end
+    end
+  end
+end