swiss-crm-activemerchant-v2 1.0.26 → 1.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f047038c38a8e7697181cfacf67ed5e78d25d6183ad600b62847e9424c81c62c
-  data.tar.gz: f4c1fbfedadf6a59e131e3fcc15ba6db6eac232c2254c9644d8068edd5a68b0c
+  metadata.gz: 395642de699b76ea08960c76960c856dbc3c493e39c95a3755cb9503517ed980
+  data.tar.gz: 83f22a8df4ba195ecb8485fc857af605d6abae4505a5bdff13cd35806f83f38f
 SHA512:
-  metadata.gz: 5f03d59d1f9d3bd67b3844e6ed58cc63fd889b3008401e8cf2431b7ead8cf9805db4f4a0d0286b4cb7060b03eb0454d5a437bc00035a4c151ba3dea6f1ad64c0
-  data.tar.gz: e3b549c33adf95ecdb4db05dbdff4079672f6cdd721490840ce3026043169c523aff4c2c29902e8ebffb84a5db7f769b1299b6dc2ae88b917142e69f752e2df8
+  metadata.gz: 86734ccd901d11b2743de57dd7a7440ce4e716eb29528ec5388aeca631549293a1a796e8f4797649afb4f40ff31ffff6ebdd67b0c49f341b493efa701e3f2f74
+  data.tar.gz: 831f5049e863030c2e200d7fc03bb7fdf67d71c90ede532b5fa7a67b78667693660fddda1a62d12d54e1f687b3ff5b487bd066b9add0e4fc0fa825bbc9424390

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

@@ -0,0 +1,382 @@
+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)
+        add_subscription_data(post, amount, options) if options[:flex_merchant_initiated]
+
+        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_subscription_data(post, amount, options)
+        post[:isRecurring]   = true
+        post[:isMIT]         = true
+        post[:expiryDateUtc] = 2.hours.from_now.utc.iso8601
+        post[:subscription]  = {
+          subscriptionId: options['merchant_initiated_data']['subscriptionId'],
+          interval: "Monthly",
+          price: amount,
+          currency: options[:currency]
+        }
+      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', 'SUBMITTED'          then 0
+        when 'CAPTUREREQUIRED', 'CHALLENGE'              then 1
+        when 'FAILED'                                    then 2
+        else 1
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.0.26'
+  VERSION = '1.0.28'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss-crm-activemerchant-v2
 version: !ruby/object:Gem::Version
-  version: 1.0.26
+  version: 1.0.28
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-25 00:00:00.000000000 Z
+date: 2025-08-07 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