swiss-crm-activemerchant-v2 1.0.22 → 1.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10b566d3f08b9618f3d388ca8a9cc3c65b9f33284cc2f3b33ffc78594e36e5a1
-  data.tar.gz: 19593bf9c7e4be5d20337ffeeba40e0dc4be4d5e43373f30a360e57ccc1b7013
+  metadata.gz: af3a2d531e5ddb1183fdad238a7087a6d77c68e0a3882ccf72c755143c29ca32
+  data.tar.gz: d923b080a1268a0e8143bfb5e81b927e651fdfd2d131db3559348adba04b4ae0
 SHA512:
-  metadata.gz: a2192ddf6220e465fb44881042a0aa91a56d6b194680ed93147672777ee8f1a7701aa0d3f9d0b0d975a2b497ff85bcd756d0d67cb66f4603b85605fc2c696b48
-  data.tar.gz: d8ec8c557433f4d9b0acf5f7e6de78c278c06953e0cc8ba7841aafb40723fed4581c58534dfcd3373303b5021418a958dc9eac7a7a15b56321ac8b59bcb4d231
+  metadata.gz: 3c2629ceac79372e2722b599a8ba02e3f0670d8eebd1c4405e703284d5db4d2cca654d78e89ea1c1b199366d6ddb5ea6cbd44792b83d66f0e6e51cad41bc4f1e
+  data.tar.gz: 74311b6b4d445056f69e18e965bb6cdb337c63ff61c3230d36c45bc419b744646b4167947c326a1f648b85b9b7cfb4667b57bab84eb3cb0ca4f63444b90ecf7c

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

@@ -1,87 +1,312 @@
-# lib/swiss/gateways/mollie_gateway.rb
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MollieGateway < Gateway
+      include Empty
 
-require 'mollie'
+      SOFT_DECLINE_REASONS = %w[
+        insufficient_funds
+        card_expired
+        card_declined
+        temporary_failure
+        verification_required
+      ].freeze
 
-module ActiveMerchant
-  module Billing
-    class MollieGateway < Gateway
-      self.supported_countries = %w[NL DE BE FR AT FI UK US]
-      self.supported_cardtypes = %i[visa master american_express]
+      AUTHORIZATION_PREFIX = 'Bearer '.freeze
+      CONTENT_TYPE         = 'application/json'.freeze
+
+      self.test_url = 'https://api.mollie.com/v2'
+      self.live_url = 'https://api.mollie.com/v2'
+      self.supported_countries = %w[NL BE DE FR CH US GB]
       self.default_currency = 'EUR'
+      self.supported_cardtypes = %i[visa master american_express]
       self.money_format = :cents
+      self.homepage_url = 'https://www.mollie.com'
       self.display_name = 'Mollie'
 
       def initialize(options = {})
         requires!(options, :api_key)
         super
-        Mollie::Client.configure do |config|
-          config.api_key = options[:api_key]
-        end
+        @api_key = options[:api_key]
       end
 
-      def purchase(amount, _payment_source, options = {})
-        payload = build_payment_payload(amount, options)
-        mollie_payment = Mollie::Payment.create(payload)
+      def purchase(amount, payment_method, options = {})
+        return recurring(amount, payment_method, options) if recurring_payment?(payment_method, options)
 
-        Response.new(
-          true,
-          mollie_payment.status,
-          mollie_payment.to_h,
-          test: test?,
-          authorization: mollie_payment.id,
-          redirect_url: mollie_payment.checkout_url,
-          params: {
-            mollie_checkout_url: mollie_payment.checkout_url,
-            payment_method: mollie_payment.method,
-            status: mollie_payment.status
-          }
-        )
-      rescue Mollie::Exception => e
-        Response.new(false, e.message, {}, test: test?)
+        result = add_customer_to_payment(payment_method, options)
+        return result if result.is_a?(Response) && !result.success?
+
+        post = {}
+        add_purchase_data(post, amount, payment_method, options)
+        add_customer_data(post, result, options)
+        add_payment_token(post, payment_method, options)
+        add_addresses(post, options)
+
+        commit('payments', post, options)
+      end
+
+      def recurring(amount, payment_method, options = {})
+        post = {}
+        add_recurring_data(post, amount, payment_method, options)
+
+        commit('payments', post, options)
       end
 
       def refund(amount, authorization, options = {})
-        payment = Mollie::Payment.get(authorization)
-        refund = payment.refunds.create(
-          amount: {
-            value: sprintf('%.2f', amount / 100.0),
-            currency: payment.amount['currency']
-          }
-        )
+        post = {}
+        add_refund_data(post, amount, authorization, options)
 
-        Response.new(true, 'Refund initiated', refund.to_h, test: test?, authorization: refund.id)
-      rescue Mollie::Exception => e
-        Response.new(false, e.message, {}, test: test?)
+        commit("payments/#{authorization}/refunds", post, options)
       end
 
-      def fetch_payment_status(authorization)
-        payment = Mollie::Payment.get(authorization)
-        Response.new(payment.paid?, payment.status, payment.to_h, test: test?)
-      rescue Mollie::Exception => e
-        Response.new(false, e.message, {}, test: test?)
+      def void(authorization, options = {})
+        commit("payments/#{authorization}/cancel", {}, options)
       end
 
       private
 
-      def build_payment_payload(amount, options)
+      def recurring_payment?(payment_method, options)
+        options[:mollie_customer_id].present? && payment_method.mollie_mandate_id.present?
+      end
+
+      def add_customer_to_payment(payment_method, options)
+        return options[:mollie_customer_id] if existing_customer?(options)
+
+        customer_response = create_customer(options)
+        return customer_response unless customer_response.success?
+
+        customer_response.params['id']
+      end
+
+      def existing_customer?(options)
+        options[:mollie_customer_id].present?
+      end
+
+      def create_customer(options)
+        post = {}
+        add_customer_creation_data(post, options)
+
+        commit('customers', post, options)
+      end
+
+      def add_customer_creation_data(post, options)
+        billing = options[:billing_address] || {}
+
+        post[:name]   = billing[:name]
+        post[:email]  = options[:email]
+        post[:locale] = options[:locale]
+      end
+
+      def add_purchase_data(post, amount, payment_method, options)
+        post[:amount]       = format_amount(amount, options[:currency])
+        post[:description]  = "Order ##{options[:order_id]}"
+        post[:method]       = payment_method.mollie_payment_method
+        post[:sequenceType] = 'first'
+        post[:locale]       = options[:locale]
+
+        add_urls(post, options)
+      end
+
+      def add_recurring_data(post, amount, payment_method, options)
+        post[:amount]       = format_amount(amount, options[:currency])
+        post[:description]  = "Order ##{options[:order_id]}"
+        post[:sequenceType] = 'recurring'
+        post[:customerId]   = options[:mollie_customer_id]
+        post[:mandateId]    = payment_method.mollie_mandate_id
+
+        add_urls(post, options)
+      end
+
+      def add_refund_data(post, amount, authorization, options)
+        post[:amount] = format_amount(amount, options[:currency])
+        post[:description] = "Order ##{options[:order_id]} Refund at #{Time.current.to_i}"
+
+        post[:metadata] = {
+          refund_reference: "refund-#{options[:order_id]}-#{SecureRandom.hex(4)}"
+        }
+      end
+
+      def add_customer_data(post, customer_result, options)
+        customer_id = customer_result.is_a?(String) ? customer_result : customer_result.params['id']
+        post[:customerId] = customer_id
+      end
+
+      def add_urls(post, options)
+        post[:redirectUrl] = options.dig(:redirect_links, :success_url)
+        post[:webhookUrl]  = options[:mollie_webhook_url]
+        post[:cancelUrl]   = options.dig(:redirect_links, :failure_url)
+      end
+
+      def add_payment_token(post, payment_method, options)
+        method = post[:method].to_s.downcase
+
+        return unless %w[creditcard applepay googlepay].include?(method)
+
+        token = payment_method.mollie_payment_token
+        return unless token
+
+        case method
+        when 'creditcard'
+          post[:cardToken] = token
+        when 'applepay'
+          post[:applePayPaymentToken] = token
+        when 'googlepay'
+          post[:googlePayPaymentToken] = token
+        end
+      end
+
+      def add_addresses(post, options)
+        post[:billingAddress]  = build_address(options[:billing_address])
+        post[:shippingAddress] = build_address(options[:shipping_address])
+      end
+
+      def build_address(data)
+        return if data.blank?
+
+        first_name, last_name = split_names(data[:name])
+
+        {
+          title: data[:title],
+          givenName: first_name,
+          familyName: last_name,
+          organizationName: data[:company],
+          streetAndNumber: data[:address1],
+          streetAdditional: data[:address2],
+          postalCode: data[:zip],
+          city: data[:city],
+          region: data[:state],
+          country: data[:country],
+          phone: data[:phone]
+        }.compact
+      end
+
+      def split_names(name)
+        return [nil, nil] if name.blank?
+
+        parts = name.split
+        [parts.first, parts[1..].join(' ')].compact
+      end
+
+      def format_amount(amount, currency = nil)
+        {
+          currency: currency || default_currency,
+          value: sprintf('%.2f', amount.to_f / 100)
+        }
+      end
+
+      def commit(endpoint, post = {}, _options = {})
+        request_url = build_request_url(endpoint)
+        payload = build_payload(post)
+
+        begin
+          raw_response = perform_request(:post, request_url, payload)
+          response = parse(raw_response)
+          succeeded = success_from(response)
+
+          Response.new(
+            succeeded,
+            message_from(succeeded, response),
+            response,
+            authorization: authorization_from(response),
+            test: test_from(response),
+            error_code: error_code_from(succeeded, response),
+            response_type: response_type_from(response),
+            response_http_code: @response_http_code,
+            request_endpoint: request_url,
+            request_method: :post,
+            request_body: payload
+          )
+        rescue ResponseError => e
+          handle_error_response(e)
+        end
+      end
+
+      def build_request_url(endpoint)
+        "#{url}/#{endpoint}"
+      end
+
+      def build_payload(post)
+        post.compact
+      end
+
+      def perform_request(method, url, payload)
+        ssl_post(url, payload.to_json, headers)
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def headers
         {
-          amount: {
-            value: sprintf('%.2f', amount.to_f / 100),
-            currency: options[:currency] || default_currency
-          },
-          method: options[:payment_method],
-          description: options[:description] || "Order ##{options[:order_id]}",
-          redirect_url: options[:redirect_url],
-          webhook_url: options[:webhook_url],
-          metadata: {
-            order_id: options[:order_id],
-            customer_id: options[:customer_id]
-          }.compact
+          'Authorization' => "#{AUTHORIZATION_PREFIX}#{@api_key}",
+          'Content-Type' => CONTENT_TYPE
         }
       end
 
-      def test?
-        ENV['MOLLIE_ENV'] == 'test'
+      def parse(response)
+        @response_http_code = response.respond_to?(:code) ? response.code.to_i : nil
+        JSON.parse(response)
+      end
+
+      def success_from(response)
+        resource_type = response['resource']
+        status = response['status']
+
+        resource_type == 'customer' || %w[paid authorized].include?(status)
+      end
+
+      def message_from(succeeded, response)
+        resource_type = response['resource']
+        status = response['status']
+
+        return 'Customer created' if resource_type == 'customer'
+        return 'Pending' if status == 'open' || (resource_type == 'refund' && status == 'pending')
+        return 'Success' if %w[paid authorized].include?(status)
+
+        status || 'failed'
+      end
+
+      def error_code_from(succeeded, response)
+        return nil if succeeded
+
+        response['status'] || response['type']
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def test_from(response)
+        response['mode'] == 'test'
+      end
+
+      def response_type_from(response)
+        return 'success' if response['sequenceType'] == 'recurring' && response['status'] == 'paid'
+
+        nil
+      end
+
+      def handle_error_response(error)
+        parsed     = JSON.parse(error.response.body) rescue {}
+        error_code = error.response.code
+        detail     = parsed['detail']
+        field      = parsed['field']
+        message    = parsed['title'] || parsed['message'] || error.message
+
+        full_message = build_error_message(error_code, message, detail, field)
+
+        Response.new(
+          false,
+          full_message,
+          parsed,
+          error_code: error_code
+        )
+      end
+
+      def build_error_message(error_code, message, detail, field)
+        components = ["Failed with #{error_code}", message, detail]
+        components << "(field: #{field})" if field
+        components.compact.join(': ')
       end
     end
   end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.0.22'
+  VERSION = '1.0.23'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss-crm-activemerchant-v2
 version: !ruby/object:Gem::Version
-  version: 1.0.22
+  version: 1.0.23
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-08 00:00:00.000000000 Z
+date: 2025-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport