swiss-activemerchant 1.0.1

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

@@ -0,0 +1,243 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AxcessmsGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://eu-test.oppwa.com/'
+      self.live_url = 'https://eu-prod.oppwa.com/'
+
+      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 = %i[visa master american_express discover jcb maestro]
+
+      self.homepage_url = 'http://www.axcessms.com/'
+      self.display_name = 'Axcess MS'
+      self.money_format = :dollars
+      self.default_currency = 'GBP'
+
+      API_VERSION = 'v1'
+      PAYMENT_CODE_PREAUTHORIZATION = 'PA'
+      PAYMENT_CODE_DEBIT = 'DB'
+      PAYMENT_CODE_CAPTURE = 'CP'
+      PAYMENT_CODE_REVERSAL = 'RV'
+      PAYMENT_CODE_REFUND = 'RF'
+      PAYMENT_CODE_REBILL = 'RB'
+
+      SUCCESS_CODES = %w[000.000.100 000.000.100 000.100.110]
+      SOFT_DECLINE_CODES = %w{
+        800.100.201 800.100.203 800.100.204 100.150.204 000.100.204
+        000.100.205 800.100.205 000.100.221 000.100.223 000.100.225
+        000.100.226 300.100.100
+      }.freeze
+
+      def initialize(options = {})
+        requires!(options, :token, :entityId)
+        super
+        @response_http_code = nil
+      end
+
+      def authorize(amount, payment_method, options = {})
+        post = {}
+        add_payment_method(post, payment_method, options)
+        add_customer_details(post, options)
+        add_three_d_secure_data(post, amount, options) if options[:three_d_secure_data].present?
+        add_invoice_details(post, PAYMENT_CODE_PREAUTHORIZATION, amount, options)
+        add_recurring_details(post, options)
+        commit(:authorize, post)
+      end
+
+      def purchase(amount, payment_method, options = {})
+        post = {}
+        add_payment_method(post, payment_method, options)
+        add_customer_details(post, options)
+        add_three_d_secure_data(post, amount, options) if options[:three_d_secure_data].present?
+        add_invoice_details(post, PAYMENT_CODE_DEBIT, amount, options)
+        add_recurring_details(post, options)
+        commit(:purchase, post)
+      end
+
+      def registration_token_purchase(amount, payment_method, options)
+        post = {}
+        add_customer_details(post, options)
+        add_invoice_details(post, PAYMENT_CODE_DEBIT, amount, options)
+        add_repeated_recurring_details(post, options)
+        commit(:registration_token_purchase, post, :post, payment_method)
+      end
+
+      def rebill(amount, authorization, options = {})
+        post = {}
+        add_invoice_details(post, PAYMENT_CODE_REBILL, amount, options)
+        commit(:rebill, post, :post, authorization)
+      end
+
+      def capture(amount, authorization, options = {})
+        post = {}
+        add_invoice_details(post, PAYMENT_CODE_CAPTURE, amount, options)
+        commit(:capture, post, :post, authorization)
+      end
+
+      def refund(amount, authorization, options = {})
+        post = {}
+        add_invoice_details(post, PAYMENT_CODE_REFUND, amount, options)
+        commit(:refund, post, :post, authorization)
+      end
+
+      def void(amount, authorization, options = {})
+        post = {}
+        add_invoice_details(post, PAYMENT_CODE_REVERSAL, amount, options)
+        commit(:void, post, :post, authorization)
+      end
+
+      def confirm(authorization)
+        post = {}
+        commit(:confirm, post, :get, authorization)
+      end
+
+      private
+
+      def add_payment_method(post, payment_method, options)
+        post["createRegistration"] = true
+        post["card.number"] = payment_method.number
+        post["card.expiryMonth"] = format(payment_method.month, :two_digits)
+        post["card.expiryYear"] = format(payment_method.year, :four_digits)
+        post["card.cvv"] = payment_method.verification_value unless empty?(payment_method.verification_value)
+        post["card.holder"] = options[:billing_address][:name] if options[:billing_address].present?
+      end
+
+      def add_customer_details(post, options)
+        post["customer.email"] = options[:email]
+        post["customer.ip"] = options[:ip]
+        post["customer.browser.userAgent"] = options[:browser_details][:identity] if options[:browser_details].present?
+        post["shopperResultUrl"] = options[:redirect_links][:success_url] if options[:redirect_links].present?
+
+        if options[:billing_address].present?
+          post["billing.street1"] = options[:billing_address][:address1]
+          post["billing.street2"] = options[:billing_address][:address2]
+          post["billing.city"] = options[:billing_address][:city]
+          post["billing.postcode"] = options[:billing_address][:zip]
+          post["billing.state"] = options[:billing_address][:state]
+          post["billing.country"] = options[:billing_address][:country]
+          post['customer.phone'] = options[:billing_address][:phone]
+        end
+      end
+
+      def add_invoice_details(post, payment_code, amount, options)
+        post["amount"] = localized_amount(amount, options[:currency])
+        post["currency"] = options[:currency]
+        post["paymentType"] = payment_code
+      end
+
+      def add_three_d_secure_data(post, amount, options)
+        post["threeDSecure.challengeIndicator"]= options[:three_d_secure_data][:challengeIndicator]
+        post["threeDSecure.exemptionFlag"]= options[:three_d_secure_data][:exemptionFlag]
+        post["threeDSecure.verificationId"]= options[:three_d_secure_data][:verificationId]
+        post["threeDSecure.eci"]= options[:three_d_secure_data][:eci]
+        post["threeDSecure.xid"]= options[:three_d_secure_data][:xid]
+      end
+
+      def add_recurring_details(post, options)
+        post["standingInstruction.type"] = "RECURRING"
+        post["standingInstruction.mode"] = "INITIAL"
+        post["standingInstruction.source"] = "CIT"
+      end
+
+      def add_repeated_recurring_details(post, options)
+        post["standingInstruction.type"] = "RECURRING"
+        post["standingInstruction.mode"] = "REPEATED"
+        post["standingInstruction.source"] = "MIT"
+      end
+
+      def commit(action, params, method = :post, authorization=nil)
+        params = params.merge("entityId" => @options[:entityId])
+        request_body = post_data(action, params)
+        request_endpoint = url(action, authorization)
+        raw_response =  if method == :post
+                          ssl_post(request_endpoint, request_body, headers)
+                        else
+                          request_endpoint = request_endpoint + "?#{request_body}"
+                          ssl_get(request_endpoint, headers)
+                        end
+        response = JSON.parse(raw_response)
+
+        succeeded = success_from(response)
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response, params["paymentType"]),
+          response_type: response_type(response.dig('result', 'code')),
+          test: test?,
+          response_http_code: @response_http_code,
+          request_endpoint:,
+          request_method: method,
+          request_body: params
+        )
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def url(action, authorization)
+        case action
+        when :authorize, :purchase
+          "#{base_url}#{API_VERSION}/payments"
+        when :capture, :refund, :void, :rebill, :confirm
+          "#{base_url}#{API_VERSION}/payments/#{split_authorization(authorization)}"
+        when :registration_token_purchase
+           "#{base_url}#{API_VERSION}/registrations/#{authorization}/payments"
+        end
+      end
+
+      def headers
+        headers = { 'Authorization' => 'Bearer ' + @options[:token] }
+        headers
+      end
+
+      def post_data(action, params)
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def authorization_from(response, payment_type)
+        authorization = response["id"].present? ? response["id"] : "Failed"
+        [authorization, payment_type].join('#')
+      end
+
+      def split_authorization(authorization)
+        transaction_id, = authorization.split('#')
+        transaction_id
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          response.dig('result', 'description') == 'transaction pending' ? '3DS_REQUIRED' : response.dig('result', 'description')
+        end
+      end
+
+      def success_from(response)
+        code = response.dig('result', 'code')
+        SUCCESS_CODES.include?(code)
+      end
+
+
+      def response_type(code)
+        if SUCCESS_CODES.include?(code)
+          0
+        elsif SOFT_DECLINE_CODES.include?(code)
+          1
+        else
+          2
+        end
+      end
+
+      def handle_response(response)
+        @response_http_code = response.code.to_i
+        response.body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+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 = %i[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