active_accountability_merchant 1.97.1

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

@@ -0,0 +1,233 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DecidirGateway < Gateway
+      self.test_url = 'https://developers.decidir.com/api/v2'
+      self.live_url = 'https://live.decidir.com/api/v2'
+
+      self.supported_countries = ['AR']
+      self.money_format = :cents
+      self.default_currency = 'ARS'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :naranja, :cabal]
+
+      self.homepage_url = 'http://www.decidir.com'
+      self.display_name = 'Decidir'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        1 => STANDARD_ERROR_CODE[:call_issuer],
+        2 => STANDARD_ERROR_CODE[:call_issuer],
+        3 => STANDARD_ERROR_CODE[:config_error],
+        4 => STANDARD_ERROR_CODE[:pickup_card],
+        5 => STANDARD_ERROR_CODE[:card_declined],
+        7 => STANDARD_ERROR_CODE[:pickup_card],
+        12 => STANDARD_ERROR_CODE[:processing_error],
+        14 => STANDARD_ERROR_CODE[:invalid_number],
+        28 => STANDARD_ERROR_CODE[:processing_error],
+        38 => STANDARD_ERROR_CODE[:incorrect_pin],
+        39 => STANDARD_ERROR_CODE[:invalid_number],
+        43 => STANDARD_ERROR_CODE[:pickup_card],
+        45 => STANDARD_ERROR_CODE[:card_declined],
+        46 => STANDARD_ERROR_CODE[:invalid_number],
+        47 => STANDARD_ERROR_CODE[:card_declined],
+        48 => STANDARD_ERROR_CODE[:card_declined],
+        49 => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        51 => STANDARD_ERROR_CODE[:card_declined],
+        53 => STANDARD_ERROR_CODE[:card_declined],
+        54 => STANDARD_ERROR_CODE[:expired_card],
+        55 => STANDARD_ERROR_CODE[:incorrect_pin],
+        56 => STANDARD_ERROR_CODE[:card_declined],
+        57 => STANDARD_ERROR_CODE[:card_declined],
+        76 => STANDARD_ERROR_CODE[:call_issuer],
+        96 => STANDARD_ERROR_CODE[:processing_error],
+        97 => STANDARD_ERROR_CODE[:processing_error],
+      }
+
+      def initialize(options={})
+        requires!(options, :api_key)
+        super
+        @options[:preauth_mode] ||= false
+      end
+
+      def purchase(money, payment, options={})
+        raise ArgumentError, 'Purchase is not supported on Decidir gateways configured with the preauth_mode option' if @options[:preauth_mode]
+
+        post = {}
+        add_auth_purchase_params(post, money, payment, options)
+        commit(:post, 'payments', post)
+      end
+
+      def authorize(money, payment, options={})
+        raise ArgumentError, 'Authorize is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        post = {}
+        add_auth_purchase_params(post, money, payment, options)
+        commit(:post, 'payments', post)
+      end
+
+      def capture(money, authorization, options={})
+        raise ArgumentError, 'Capture is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        post = {}
+        add_amount(post, money, options)
+        commit(:put, "payments/#{authorization}", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_amount(post, money, options)
+        commit(:post, "payments/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        commit(:post, "payments/#{authorization}/refunds", post)
+      end
+
+      def verify(credit_card, options={})
+        raise ArgumentError, 'Verify is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((apikey: )\w+)i, '\1[FILTERED]').
+          gsub(%r((\"card_number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"security_code\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"emv_issuer_data\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_auth_purchase_params(post, money, credit_card, options)
+        post[:payment_method_id] =  options[:payment_method_id] ? options[:payment_method_id].to_i : 1
+        post[:site_transaction_id] = options[:order_id]
+        post[:bin] = credit_card.number[0..5]
+        post[:payment_type] = options[:payment_type] || 'single'
+        post[:installments] = options[:installments] ? options[:installments].to_i : 1
+        post[:description] = options[:description] if options[:description]
+        post[:email] = options[:email] if options[:email]
+        post[:sub_payments] = []
+
+        add_invoice(post, money, options)
+        add_payment(post, credit_card, options)
+      end
+
+      def add_invoice(post, money, options)
+        add_amount(post, money, options)
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def add_amount(post, money, options)
+        currency = (options[:currency] || currency(money))
+        post[:amount] = localized_amount(money, currency).to_i
+      end
+
+      def add_payment(post, credit_card, options)
+        card_data = {}
+        card_data[:card_number] = credit_card.number
+        card_data[:card_expiration_month] = format(credit_card.month, :two_digits)
+        card_data[:card_expiration_year] = format(credit_card.year, :two_digits)
+        card_data[:security_code] = credit_card.verification_value if credit_card.verification_value?
+        card_data[:card_holder_name] = credit_card.name if credit_card.name
+
+        # additional data used for Visa transactions
+        card_data[:card_holder_door_number] = options[:card_holder_door_number].to_i if options[:card_holder_door_number]
+        card_data[:card_holder_birthday] = options[:card_holder_birthday] if options[:card_holder_birthday]
+
+        card_data[:card_holder_identification] = {}
+        card_data[:card_holder_identification][:type] = options[:card_holder_identification_type] if options[:card_holder_identification_type]
+        card_data[:card_holder_identification][:number] = options[:card_holder_identification_number] if options[:card_holder_identification_number]
+
+        post[:card_data] = card_data
+      end
+
+      def headers(options = {})
+        {
+          'apikey' => @options[:api_key],
+          'Content-type'  => 'application/json',
+          'Cache-Control' => 'no-cache'
+        }
+      end
+
+      def commit(method, endpoint, parameters, options={})
+        url = "#{(test? ? test_url : live_url)}/#{endpoint}"
+
+        begin
+          raw_response = ssl_request(method, url, post_data(parameters), headers(options))
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        end
+
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: success ? nil : error_code_from(response)
+        )
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        {
+          'message' => "A non-JSON response was received from Decidir where one was expected. The raw response was:\n\n#{body}"
+        }
+      end
+
+      def message_from(success, response)
+        return response['status'] if success
+        return response['message'] if response['message']
+
+        message = nil
+
+        if error = response.dig('status_details', 'error')
+          message = error.dig('reason', 'description')
+        elsif response['error_type']
+          if response['validation_errors']
+            message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ')
+          end
+          message ||= response['error_type']
+        end
+
+        message
+      end
+
+      def success_from(response)
+        response['status'] == 'approved' || response['status'] == 'pre_approved'
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def error_code_from(response)
+        error_code = nil
+        if error = response.dig('status_details', 'error')
+          code = error.dig('reason', 'id')
+          error_code = STANDARD_ERROR_CODE_MAPPING[code]
+          error_code ||= error['type']
+        elsif response['error_type']
+          error_code = response['error_type'] if response['validation_errors']
+        end
+
+        error_code || STANDARD_ERROR_CODE[:processing_error]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DibsGateway < Gateway
+      self.display_name = 'DIBS'
+      self.homepage_url = 'http://www.dibspayment.com/'
+
+      self.live_url = 'https://api.dibspayment.com/merchant/v1/JSON/Transaction/'
+
+      self.supported_countries = ['US', 'FI', 'NO', 'SE', 'GB']
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :secret_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run(false) do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_amount(post, amount)
+        add_invoice(post, amount, options)
+        if payment_method.respond_to?(:number)
+          add_payment_method(post, payment_method, options)
+          commit(:authorize, post)
+        else
+          add_ticket_id(post, payment_method)
+          commit(:authorize_ticket, post)
+        end
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit(:void, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:refund, 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
+
+      def store(payment_method, options = {})
+        post = {}
+
+        add_invoice(post, 0, options)
+        add_payment_method(post, payment_method, options)
+
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(("cardNumber\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvc\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
+      CURRENCY_CODES['USD'] = '840'
+      CURRENCY_CODES['DKK'] = '208'
+      CURRENCY_CODES['NOK'] = '578'
+      CURRENCY_CODES['SEK'] = '752'
+      CURRENCY_CODES['GBP'] = '826'
+      CURRENCY_CODES['EUR'] = '978'
+
+      def add_invoice(post, money, options)
+        post[:orderId] = options[:order_id] || generate_unique_id
+        post[:currency] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_ticket_id(post, payment_method)
+        post[:ticketId] = payment_method
+      end
+
+      def add_payment_method(post, payment_method, options)
+        post[:cardNumber] = payment_method.number
+        post[:cvc] = payment_method.verification_value if payment_method.verification_value
+        post[:expYear] = format(payment_method.year, :two_digits)
+        post[:expMonth] = payment_method.month
+        post[:clientIp] = options[:ip] || '127.0.0.1'
+        post[:test] = true if test?
+      end
+
+      def add_reference(post, authorization)
+        post[:transactionId] = authorization
+      end
+
+      def add_amount(post, amount)
+        post[:amount] = amount
+      end
+
+      ACTIONS = {
+        authorize: 'AuthorizeCard',
+        authorize_ticket: 'AuthorizeTicket',
+        capture: 'CaptureTransaction',
+        void: 'CancelTransaction',
+        refund: 'RefundTransaction',
+        store: 'CreateTicket'
+      }
+
+      def commit(action, post)
+        post[:merchantId] = @options[:merchant_id]
+
+        data = build_request(post)
+        raw = parse(ssl_post(url(action), "request=#{data}", headers))
+        succeeded = success_from(raw)
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          authorization: authorization_from(post, raw),
+          test: test?
+        )
+      rescue JSON::ParserError
+        unparsable_response(raw)
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        }
+      end
+
+      def build_request(post)
+        add_hmac(post)
+        post.to_json
+      end
+
+      def add_hmac(post)
+        data = post.sort.collect { |key, value| "#{key}=#{value}" }.join('&')
+        digest = OpenSSL::Digest.new('sha256')
+        key = [@options[:secret_key]].pack('H*')
+        post[:MAC] = OpenSSL::HMAC.hexdigest(digest, key, data)
+      end
+
+      def url(action)
+        live_url + ACTIONS[action]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(raw_response)
+        raw_response['status'] == 'ACCEPT'
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          response['status'] + ': ' + response['declineReason'] || 'Unable to read error message'
+        end
+      end
+
+      def authorization_from(request, response)
+        response['transactionId'] || response['ticketId'] || request[:transactionId]
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Invalid JSON response received from Dibs. Please contact Dibs if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DigitzsGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://beta.digitzsapi.com/sandbox'
+      self.live_url = 'https://beta.digitzsapi.com/v3'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.money_format = :cents
+
+      self.homepage_url = 'https://digitzs.com'
+      self.display_name = 'Digitzs'
+
+      def initialize(options={})
+        requires!(options, :app_key, :api_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        MultiResponse.run do |r|
+          r.process { commit('auth/token', app_token_request(options)) }
+          r.process { commit('payments', purchase_request(money, payment, options), options.merge({ app_token: app_token_from(r) })) }
+        end
+      end
+
+      def refund(money, authorization, options={})
+        MultiResponse.run do |r|
+          r.process { commit('auth/token', app_token_request(options)) }
+          r.process { commit('payments', refund_request(money, authorization, options), options.merge({ app_token: app_token_from(r) })) }
+        end
+      end
+
+      def store(payment, options = {})
+        MultiResponse.run do |r|
+          r.process { commit('auth/token', app_token_request(options)) }
+          options[:app_token] = app_token_from(r)
+
+          if options[:customer_id].present?
+            customer_id = check_customer_exists(options)
+
+            if customer_id
+              r.process { add_credit_card_to_customer(payment, options) }
+            else
+              r.process { add_customer_with_credit_card(payment, options) }
+            end
+          else
+            r.process { add_customer_with_credit_card(payment, options) }
+          end
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Bearer ).+), '\1[FILTERED]').
+          gsub(%r((X-Api-Key: )\w+), '\1[FILTERED]').
+          gsub(%r((\"id\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"appKey\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"appToken\\\":\\\").+), '\1[FILTERED]').
+          gsub(%r((\"code\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"number\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def new_post
+        {
+          data: {
+            attributes: {}
+          }
+        }
+      end
+
+      def add_split(post, options)
+        return unless options[:payment_type] == 'card_split' || options[:payment_type] == 'token_split'
+
+        post[:data][:attributes][:split] = {
+          merchantId: options[:split_merchant_id],
+          amount: amount(options[:split_amount])
+        }
+      end
+
+      def add_payment(post, payment, options)
+        if payment.is_a? String
+          customer_id, token = split_authorization(payment)
+          post[:data][:attributes][:token] = {
+            customerId: customer_id,
+            tokenId: token
+          }
+        else
+          post[:data][:attributes][:card] = {
+            type: payment.brand,
+            holder: payment.name,
+            number: payment.number,
+            expiry: expdate(payment),
+            code: payment.verification_value
+          }
+        end
+      end
+
+      def add_transaction(post, money, options)
+        post[:data][:attributes][:transaction] = {
+          amount: amount(money),
+          currency: (options[:currency] || currency(money)),
+          invoice: options[:order_id] || generate_unique_id
+        }
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:data][:attributes][:billingAddress] = {
+            line1: address[:address1] || '',
+            line2: address[:address2] || '',
+            city: address[:city] || '',
+            state: address[:state] || '',
+            zip: address[:zip] || '',
+            country: address['country'] || 'USA'
+          }
+        end
+      end
+
+      def app_token_request(options)
+        post = new_post
+        post[:data][:type] = 'auth'
+        post[:data][:attributes] = { appKey: @options[:app_key] }
+
+        post
+      end
+
+      def purchase_request(money, payment, options)
+        post = new_post
+        post[:data][:type] = 'payments'
+        post[:data][:attributes][:merchantId] = options[:merchant_id]
+        post[:data][:attributes][:paymentType] = determine_payment_type(payment, options)
+        add_split(post, options)
+        add_payment(post, payment, options)
+        add_transaction(post, money, options)
+        add_address(post, options)
+
+        post
+      end
+
+      def refund_request(money, authorization, options)
+        post = new_post
+        post[:data][:type] = 'payments'
+        post[:data][:attributes][:merchantId] = options[:merchant_id]
+        post[:data][:attributes][:paymentType] = 'cardRefund'
+        post[:data][:attributes][:originalTransaction] = {id: authorization}
+        add_transaction(post, money, options)
+
+        post
+      end
+
+      def create_customer_request(payment, options)
+        post = new_post
+        post[:data][:type] = 'customers'
+        post[:data][:attributes] = {
+          merchantId: options[:merchant_id],
+          name: payment.name,
+          externalId: SecureRandom.hex(16)
+        }
+
+        post
+      end
+
+      def create_token_request(payment, options)
+        post = new_post
+        post[:data][:type] = 'tokens'
+        post[:data][:attributes] = {
+          tokenType: 'card',
+          customerId: options[:customer_id],
+          label: 'Credit Card',
+        }
+        add_payment(post, payment, options)
+        add_address(post, options)
+
+        post
+      end
+
+      def check_customer_exists(options = {})
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_get(url + "/customers/#{options[:customer_id]}", headers(options)))
+
+        return response.try(:[], 'data').try(:[], 'customerId') if success_from(response)
+        return nil
+      end
+
+      def add_credit_card_to_customer(payment, options = {})
+        commit('tokens', create_token_request(payment, options), options)
+      end
+
+      def add_customer_with_credit_card(payment, options = {})
+        customer_response = commit('customers', create_customer_request(payment, options), options)
+        options[:customer_id] = customer_response.authorization
+        commit('tokens', create_token_request(payment, options), options)
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters, options={})
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url + "/#{action}", parameters.to_json, headers(options)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: avs_result_from(response)),
+          cvv_result: CVVResult.new(cvv_result_from(response)),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response['errors'].nil? && response['message'].nil?
+      end
+
+      def message_from(response)
+        return response['message'] if response['message']
+        return 'Success' if success_from(response)
+        response['errors'].map { |error_hash| error_hash['detail'] }.join(', ')
+      end
+
+      def authorization_from(response)
+        if customer_id = response.try(:[], 'data').try(:[], 'attributes').try(:[], 'customerId')
+          "#{customer_id}|#{response.try(:[], "data").try(:[], "id")}"
+        else
+          response.try(:[], 'data').try(:[], 'id')
+        end
+      end
+
+      def avs_result_from(response)
+        response.try(:[], 'data').try(:[], 'attributes').try(:[], 'transaction').try(:[], 'avsResult')
+      end
+
+      def cvv_result_from(response)
+        response.try(:[], 'data').try(:[], 'attributes').try(:[], 'transaction').try(:[], 'codeResult')
+      end
+
+      def app_token_from(response)
+        response.params.try(:[], 'data').try(:[], 'attributes').try(:[], 'appToken')
+      end
+
+      def headers(options)
+        headers = {
+          'Content-Type' => 'application/json',
+          'x-api-key' => @options[:api_key]
+        }
+
+        headers['Authorization'] = "Bearer #{options[:app_token]}" if options[:app_token]
+        headers
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response['errors'].nil? ? response['message'] : response['errors'].map { |error_hash| error_hash['code'] }.join(', ')
+        end
+      end
+
+      def split_authorization(authorization)
+        customer_id, token = authorization.split('|')
+        [customer_id, token]
+      end
+
+      def determine_payment_type(payment, options)
+        return 'cardSplit' if options[:payment_type] == 'card_split'
+        return 'tokenSplit' if options[:payment_type] == 'token_split'
+        return 'token' if payment.is_a? String
+        'card'
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200..499
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end