swiss-crm-activemerchant-v2 1.0.25 → 1.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8c97a821e37c5f68735206a29b4f9633048aa884cad771c148236924215092
-  data.tar.gz: 8f2a182c09ef9168c09ba8e792338a1ccbee01fbabedd53ac9f0eaff41d6f806
+  metadata.gz: 52a3a0245542e5d05468d5564d9bb9f25c2c8de6e480e312049ee3296a39fa0b
+  data.tar.gz: 61b9cc3da8c809c990d3e4fe591fe36ec654833a3a1b28a4629946c25b160600
 SHA512:
-  metadata.gz: 9cecc2fd882615b8797c67265d2ce9af85a7a9b7ddea35c16411cb53c68c3852eca2471fd44a4cfb92ba8419640be79f1dd71713eb30bdd858f806748c2bf8f6
-  data.tar.gz: dad2742d5a273f85b5e2d8c8313cd588b25567b86a7ed36cb52805ae064258759c49456890f4ea1ce1944fb671a91de9ef71f5d9eef44cffc558a3c354868b2f
+  metadata.gz: 3778575a3d6c5da62bbbbd46b3971da766e9207d05d126dbff9df650656297da9ff84d79b5a2b5288c73e41ac9a9c15fa4070bf8dcbb71c69261000497a6e464
+  data.tar.gz: 23809570d3c7203e57e31957ef7c6867c65ac81d81a29c3495c29da1435cce3098d75897033b90f2b453b292029fe396d1636e376cc75362054c6634352f082a

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

@@ -355,3 +355,4 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
+

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

@@ -0,0 +1,369 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FlexchargeGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://api-sandbox.flexfactor.io'
+      self.live_url = 'https://api.flexfactor.io'
+      self.homepage_url = 'https://www.flexcharge.com'
+      self.supported_countries = %w[US CA]
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.display_name = 'Flexcharge'
+
+      def initialize(options = {})
+        requires!(options, :api_key, :api_secret, :merchant_id, :token)
+        super
+        @api_key = options[:api_key]
+        @api_secret = options[:api_secret]
+        @mid = options[:merchant_id]
+        @tokenization_key = options[:token]
+        @site_id = options[:site_id]
+        @response_http_code = nil
+      end
+
+      def purchase(amount, payment_source, options = {})
+        token_response = get_access_token
+        return token_response unless token_response.success?
+
+        tokenize_response = tokenize_card(payment_source, options)
+        return tokenize_response unless tokenize_response.success?
+
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, tokenize_response.params['paymentMethod'])
+        add_customer_data(post, options)
+        add_billing_address(post, payment_source, options['billing_address'])
+        add_merchant_data(post, options)
+        add_idempotency_key(post, options)
+
+        evaluate_response = commit('evaluate', post, token_response.authorization, options)
+        handle_evaluate_response(evaluate_response, amount, options)
+      end
+
+      def capture(amount, authorization, options = {})
+        token_response = get_access_token
+        return token_response unless token_response.success?
+
+        post = {}
+        add_capture_data(post, amount, authorization, options)
+        add_idempotency_key(post, options)
+
+        commit('capture', post, token_response.authorization, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        token_response = get_access_token
+        return token_response unless token_response.success?
+
+        post = {}
+        add_refund_data(post, amount)
+
+        commit('refund', post, token_response.authorization, options.merge(order_id: authorization))
+      end
+
+      def verify_credentials
+        response = get_access_token
+        response.success?
+      end
+
+      private
+
+      def tokenize_card(payment_source, options)
+        uri = build_tokenization_uri
+        payload = build_tokenization_payload(payment_source, options)
+
+        begin
+          raw_response = ssl_post(uri, payload.to_json, tokenization_headers)
+          parsed = parse(raw_response)
+          process_tokenization_response(parsed, payment_source)
+        rescue ResponseError => e
+          handle_response_error(e)
+        end
+      end
+
+      def build_tokenization_uri
+        base_url = test? ? test_url : live_url
+        "#{base_url}/v1/tokenize?mid=#{@mid}&environment=#{@tokenization_key}"
+      end
+
+      def build_tokenization_payload(payment_source, options)
+        {
+          payment_method: {
+            email: options[:email],
+            credit_card: {
+              first_name: payment_source.first_name,
+              last_name: payment_source.last_name,
+              number: payment_source.number,
+              verification_value: payment_source.verification_value,
+              month: payment_source.month.to_s,
+              year: payment_source.year.to_s
+            }
+          }
+        }
+      end
+
+      def process_tokenization_response(parsed, payment_source)
+        token = parsed.dig("transaction", "payment_method", "token")
+        success = token.present?
+        payment_method = build_payment_method_data(payment_source, token)
+
+        Response.new(
+          success,
+          success ? 'Tokenization successful' : 'Tokenization failed',
+          parsed.merge('paymentMethod' => payment_method),
+          test: test?,
+          authorization: token
+        )
+      end
+
+      def build_payment_method_data(payment_source, token)
+        {
+          holderName: "#{payment_source.first_name} #{payment_source.last_name}",
+          cardType: "CREDIT",
+          expirationMonth: payment_source.month.to_i,
+          expirationYear: payment_source.year.to_i,
+          cardBinNumber: payment_source.bin_card,
+          cardLast4Digits: payment_source.last_digits,
+          cardNumber: token,
+          token: true
+        }
+      end
+
+      def handle_evaluate_response(evaluate_response, amount, options)
+        return evaluate_response unless evaluate_response.success?
+
+        status = evaluate_response.params['status']
+
+        case status
+        when 'CAPTUREREQUIRED'
+          process_capture_required(evaluate_response, amount, options)
+        else
+          evaluate_response
+        end
+      end
+
+      def process_capture_required(evaluate_response, amount, options)
+        capture_response = capture(amount, evaluate_response.authorization, options)
+        merged_params    = evaluate_response.params.merge('capture' => capture_response.params)
+
+        Response.new(
+          capture_response.success?,
+          capture_response.message,
+          merged_params,
+          test: test?,
+          authorization: capture_response.authorization
+        )
+      end
+
+      def add_invoice(post, amount, options)
+        post[:transaction] = {
+          amount: amount,
+          currency: options[:currency],
+          id: options[:order_id],
+          dynamicDescriptor: options[:descriptor],
+          transactionType: 'CAPTURE'
+        }
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:paymentMethod] = payment_method
+      end
+
+      def add_customer_data(post, options)
+        post[:payer] = {
+          email: options[:email]
+        }
+      end
+
+      def add_billing_address(post, payment_source, billing_address)
+        post[:billingInformation] = {
+          firstName: payment_source.first_name,
+          lastName: payment_source.last_name,
+          country: billing_address["country"],
+          countryCode: billing_address["country"],
+          addressLine1: billing_address["address1"],
+          city: billing_address["city"],
+          state: billing_address["state"],
+          zipcode: billing_address["zip"]
+        }.compact
+      end
+
+      def add_merchant_data(post, options)
+        post[:orderId]    = options[:order_id]
+        post[:mid]        = @mid
+        post[:isDeclined] = true
+        post[:siteId]     = @site_id
+      end
+
+      def add_capture_data(post, amount, authorization, options)
+        post[:idempotencyKey] = options[:idempotency_id]
+        post[:orderId]        = authorization
+        post[:amount]         = amount
+        post[:currency]       = options[:currency]
+      end
+
+      def add_refund_data(post, amount)
+        post[:amountToRefund] = amount.to_f / 100
+      end
+
+      def add_idempotency_key(post, options)
+        post[:idempotencyKey] = options[:idempotency_id]
+      end
+
+      def commit(action, params, access_token, options = {})
+        request_url  = build_request_url(action, options)
+        raw_response = ssl_post(request_url, params.to_json, headers(access_token))
+        response     = parse(raw_response)
+        succeeded    = success_from(action, response)
+
+        Response.new(
+          succeeded,
+          message_from(action, response),
+          response,
+          error_code: error_code_from(succeeded, response),
+          authorization: authorization_from(response),
+          test: test?,
+          request_method: :post,
+          request_endpoint: request_url,
+          request_body: params,
+          response_type: response_type(response['status']),
+          response_http_code: @response_http_code
+        )
+      rescue ResponseError => e
+        handle_response_error(e)
+      end
+
+      def build_request_url(action, options)
+        case action
+        when 'evaluate'
+          "#{url}/v1/evaluate"
+        when 'capture'
+          "#{url}/v1/capture"
+        when 'refund'
+          "#{url}/v1/orders/#{options[:order_id]}/refund"
+        end
+      end
+
+      def headers(access_token)
+        {
+          'Authorization' => "Bearer #{access_token}",
+          'accept' => 'application/json',
+          'content-type' => 'application/*+json'
+        }
+      end
+
+      def tokenization_headers
+        {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      def get_access_token
+        payload      = build_token_payload
+        raw_response = ssl_post("#{url}/v1/oauth2/token", payload.to_json, tokenization_headers)
+        process_token_response(raw_response)
+      rescue ResponseError => e
+        handle_response_error(e)
+      end
+
+      def build_token_payload
+        {
+          AppKey: @api_key,
+          AppSecret: @api_secret
+        }
+      end
+
+      def process_token_response(raw_response)
+        parsed  = parse(raw_response)
+        token   = parsed['accessToken']
+        success = token.present?
+
+        Response.new(
+          success,
+          success ? 'Token Retrieved' : 'Token Request Failed',
+          parsed,
+          authorization: token,
+          test: test?
+        )
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(action, response)
+        case action
+        when 'evaluate'
+          %w[APPROVED CAPTUREREQUIRED].include?(response['status'])
+        when 'capture'
+          response['status'] == 'SUCCESS'
+        when 'refund'
+          response['status'] == 'SUCCESS'
+        else
+          false
+        end
+      end
+
+      def message_from(action, response)
+        status = response['status']
+
+        case action
+        when 'evaluate'
+          return 'Pending' if %w[SUBMITTED CHALLENGE].include?(status)
+          status == 'APPROVED' ? 'Succeeded' : status
+        when 'capture'
+          status == 'SUCCESS' ? status : Array(response['errors']).join(', ').presence
+        when 'refund'
+          status == 'SUCCESS' ? status : response['responseMessage']
+        end
+      end
+
+      def authorization_from(response)
+        response['orderId'] || response['transactionId']
+      end
+
+      def handle_response_error(error)
+        @response_http_code = error.response&.code&.to_i
+        body = error.response.body
+        parsed = parse(body) rescue { 'error' => body }
+        Response.new(
+          false,
+          parsed['error'],
+          parsed,
+          test: test?,
+          response_http_code: @response_http_code
+        )
+      end
+
+      def error_code_from(succeeded, response)
+        return nil if succeeded
+
+        errors = response['errors']
+        return response['title'] if errors.blank?
+
+        errors.map { |_, messages| Array(messages).join(', ') }.join('; ')
+      end
+
+      def handle_response(response)
+        @response_http_code = response.code.to_i
+        response.body
+      end
+
+      def response_type(status)
+        case status
+        when 'APPROVED', 'SUCCESS'                       then 0
+        when 'CAPTUREREQUIRED', 'CHALLENGE', 'SUBMITTED' then 1
+        when 'FAILED'                                    then 2
+        else 1
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module ActiveMerchant #:nodoc:
     class MollieGateway < Gateway
       include Empty
 
-      SOFT_DECLINE_REASONS = %w[
+      SOFT_DECLINE_CODES = %w[
         insufficient_funds
         card_expired
         card_declined
@@ -195,7 +195,7 @@ module ActiveMerchant #:nodoc:
         post[:shippingAddress] = shipping_address
       end
 
-      def build_address(data, email)
+      def build_address(data, email = nil)
         return if data.blank?
 
         first_name, last_name = split_names(data[:name])

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.0.25'
+  VERSION = '1.0.27'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss-crm-activemerchant-v2
 version: !ruby/object:Gem::Version
-  version: 1.0.25
+  version: 1.0.27
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-25 00:00:00.000000000 Z
+date: 2025-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -289,6 +289,7 @@ files:
 - lib/active_merchant/billing/gateways/first_pay.rb
 - lib/active_merchant/billing/gateways/firstdata_e4.rb
 - lib/active_merchant/billing/gateways/firstdata_e4_v27.rb
+- lib/active_merchant/billing/gateways/flexcharge.rb
 - lib/active_merchant/billing/gateways/flo2cash.rb
 - lib/active_merchant/billing/gateways/flo2cash_simple.rb
 - lib/active_merchant/billing/gateways/fluidpay.rb