spree_mollie_gateway 0.1.1 → 1.0.0.pre.beta3

data/Rakefile

@@ -1,6 +1,21 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-RSpec::Core::RakeTask.new(:spec)
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
 
-task :default => :spec
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir['spec/dummy'].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir('../../')
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_mollie_gateway'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/controllers/spree/api/v1/mollie_controller.rb

@@ -0,0 +1,16 @@
+module Spree
+  module Api
+    module V1
+      class MollieController < BaseController
+        def methods
+          mollie = Spree::PaymentMethod.find_by_type 'Spree::Gateway::MollieGateway'
+          payment_methods = mollie.available_payment_methods
+
+          puts payment_methods
+
+          render json: payment_methods
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -1,12 +1,15 @@
 module Spree
   module CheckoutWithMollie
+    # If we're currently in the checkout
     def update
       if payment_params_valid? && paying_with_mollie?
         if @order.update_from_params(params, permitted_checkout_attributes, request.headers.env)
           payment = @order.payments.last
-          payment.create_transaction!
+          payment.process!
           mollie_payment_url = payment.payment_source.payment_url
 
+          MollieLogger.debug("For order #{@order.number} redirect user to payment URL: #{mollie_payment_url}")
+
           redirect_to mollie_payment_url
         else
           render :edit
@@ -27,15 +30,11 @@ module Spree
 
     def paying_with_mollie?
       payment_method = PaymentMethod.find(payment_method_id_param)
-      mollie_payment_method?(payment_method)
+      payment_method.is_a? Gateway::MollieGateway
     end
 
     def payment_params_valid?
       (params[:state] === 'payment') && params[:order][:payments_attributes]
     end
-
-    def mollie_payment_method?(payment_method)
-      payment_method.is_a?(Gateway::MollieGateway)
-    end
   end
 end

data/app/controllers/spree/mollie_controller.rb

@@ -5,10 +5,13 @@ module Spree
     # When the user is redirected from Mollie back to the shop, we can check the
     # mollie transaction status and set the Spree order state accordingly.
     def validate_payment
-      order = Spree::Order.find_by_number(params[:order_number])
-      payment = order.payments.last
-      mollie = Spree::PaymentMethod.find_by_type('Spree::Gateway::MollieGateway')
-      mollie.update_payment_status(payment)
+      order_number, payment_number = split_payment_identifier params[:order_number]
+      payment = Spree::Payment.find_by_number payment_number
+      order = Spree::Order.find_by_number order_number
+      mollie = Spree::PaymentMethod.find_by_type 'Spree::Gateway::MollieGateway'
+      mollie.update_payment_status payment
+
+      MollieLogger.debug("Redirect URL visited for order #{params[:order_number]}")
 
       redirect_to order.reload.paid? ? order_path(order) : checkout_state_path(:payment)
     end
@@ -16,11 +19,20 @@ module Spree
     # Mollie might send us information about a transaction through the webhook.
     # We should update the payment state accordingly.
     def update_payment_status
-      payment = Spree::Payment.find_by_response_code(params[:id])
-      mollie = Spree::PaymentMethod.find_by_type('Spree::Gateway::MollieGateway')
-      mollie.update_payment_status(payment)
+      MollieLogger.debug("Webhook called for payment #{params[:id]}")
+
+      payment = Spree::MolliePaymentSource.find_by_payment_id(params[:id]).payments.first
+      mollie = Spree::PaymentMethod.find_by_type 'Spree::Gateway::MollieGateway'
+      mollie.update_payment_status payment
+
+      head :ok
+    end
+
+    private
 
-      render json: 'OK'
+    # Payment identifier is a combination of order_number and payment_id.
+    def split_payment_identifier(payment_identifier)
+      payment_identifier.split '-'
     end
   end
 end

data/app/models/mollie/client_decorator.rb

@@ -0,0 +1,13 @@
+Mollie::Client.class_eval do
+  attr_accessor :version_strings
+
+  def initialize(api_key = nil)
+    @api_endpoint = Mollie::Client::API_ENDPOINT
+    @api_key = api_key
+    @version_strings = []
+
+    add_version_string 'MollieSpreeCommerce/' << SpreeMollieGateway::VERSION
+    add_version_string 'Ruby/' << RUBY_VERSION
+    add_version_string OpenSSL::OPENSSL_VERSION.split(' ').slice(0, 2).join '/'
+  end
+end

data/app/models/spree/gateway/mollie_gateway.rb

@@ -3,16 +3,26 @@ module Spree
     preference :api_key, :string
     preference :hostname, :string
 
-    has_many :spree_mollie_transactions, class_name: 'Spree::MollieTransaction'
+    has_many :spree_mollie_payment_sources, class_name: 'Spree::MolliePaymentSource'
+
+    # Only enable one-click payments if spree_auth_devise is installed
+    def self.allow_one_click_payments?
+      Gem.loaded_specs.has_key?('spree_auth_devise')
+    end
 
     def payment_source_class
-      Spree::MollieTransaction
+      Spree::MolliePaymentSource
+    end
+
+    def actions
+      %w{credit}
     end
 
     def provider_class
-      ::Mollie::Provider
+      ::Mollie::Client
     end
 
+    # Always create a source which references to the selected Mollie payment method.
     def source_required?
       true
     end
@@ -21,41 +31,59 @@ module Spree
       true
     end
 
-    # Create a new transaction
-    def create_transaction(money, source, gateway_options)
-      payment = payments.last
-      transaction = ::Mollie::Payment.create(
-          prepare_transaction_params(payment.order, source)
-      )
-
-      invalidate_prev_transactions(payment.id)
-
-      payment.response_code = transaction.id
-      payment.save!
-
-      source.payment_id = transaction.id
-      source.payment_url = transaction.payment_url
-      source.save!
+    def auto_capture?
+      true
+    end
 
-      ActiveMerchant::Billing::Response.new(true, 'Transaction created')
+    # Create a new Mollie payment.
+    def create_transaction(money_in_cents, source, gateway_options)
+      MollieLogger.debug("About to create payment for order #{gateway_options[:order_id]}")
+
+      begin
+        mollie_payment = ::Mollie::Payment.create(
+            prepare_payment_params(money_in_cents, source, gateway_options)
+        )
+        MollieLogger.debug("Payment #{mollie_payment.id} created for order #{gateway_options[:order_id]}")
+
+        source.status = mollie_payment.status
+        source.payment_id = mollie_payment.id
+        source.payment_url = mollie_payment.payment_url
+        source.save!
+        ActiveMerchant::Billing::Response.new(true, 'Payment created')
+      rescue Mollie::Exception => e
+        MollieLogger.debug("Could not create payment for order #{gateway_options[:order_id]}: #{e.message}")
+        ActiveMerchant::Billing::Response.new(false, "Payment could not be created: #{e.message}")
+      end
     end
 
+    # Create a Mollie customer which can be passed with a payment.
+    # Required for one-click Mollie payments.
     def create_customer(user)
-      Mollie::Customer.create(
+      customer = Mollie::Customer.create(
           email: user.email,
           api_key: get_preference(:api_key),
           )
+      MollieLogger.debug("Created a Mollie Customer for Spree user with ID #{customer.id}")
+      customer
     end
 
-    def prepare_transaction_params(order, source)
+    def prepare_payment_params(money_in_cents, source, gateway_options)
       spree_routes = ::Spree::Core::Engine.routes.url_helpers
+      order_number = gateway_options[:order_id]
+      customer_id = gateway_options[:customer_id]
+      amount = money_in_cents / 100.0
 
-      order_number = order.number
       order_params = {
-          amount: order.total.to_f,
+          amount: amount,
           description: "Spree Order ID: #{order_number}",
-          redirectUrl: spree_routes.mollie_validate_payment_mollie_url(order_number: order_number, host: get_preference(:hostname)),
-          webhookUrl: spree_routes.mollie_update_payment_status_mollie_url(order_number: order_number, host: get_preference(:hostname)),
+          redirectUrl: spree_routes.mollie_validate_payment_mollie_url(
+              order_number: order_number,
+              host: get_preference(:hostname)
+          ),
+          webhookUrl: spree_routes.mollie_update_payment_status_mollie_url(
+              order_number: order_number,
+              host: get_preference(:hostname)
+          ),
           method: source.payment_method_name,
           metadata: {
               order_id: order_number
@@ -63,24 +91,54 @@ module Spree
           api_key: get_preference(:api_key),
       }
 
-      if order.user_id.present?
+      source.issuer.present?
+      order_params.merge! ({
+        issuer: source.issuer
+      })
+
+      if customer_id.present?
         if source.payment_method_name.match(Regexp.union([::Mollie::Method::BITCOIN, ::Mollie::Method::BANKTRANSFER, ::Mollie::Method::GIFTCARD]))
           order_params.merge! ({
-              billingEmail: order.user.email
+              billingEmail: gateway_options[:email]
           })
         end
 
-        # Allow single click payments by passing Mollie customer ID
-        if order.user.mollie_customer_id.present?
-          order_params.merge! ({
-              customerId: order.user.mollie_customer_id
-          })
+        if Spree::Gateway::MollieGateway.allow_one_click_payments?
+          mollie_customer_id = Spree.user_class.find(customer_id).try(:mollie_customer_id)
+
+          # Allow one-click payments by passing Mollie customer ID.
+          if mollie_customer_id.present?
+            order_params.merge! ({
+                customerId: customer_id
+            })
+          end
         end
       end
 
       order_params
     end
 
+    # Create a new Mollie refund
+    def credit(credit_cents, payment_id, options)
+      order_number = options[:originator].try(:payment).try(:order).try(:number)
+      MollieLogger.debug("Starting refund for order #{order_number}")
+
+      begin
+        amount = credit_cents / 100.0
+        Mollie::Payment::Refund.create(
+            payment_id: payment_id,
+            amount: amount,
+            description: "Refund Spree Order ID: #{order_number}",
+            api_key: get_preference(:api_key)
+        )
+        MollieLogger.debug("Successfully refunded #{amount} for order #{order_number}")
+        ActiveMerchant::Billing::Response.new(true, 'Refund successful')
+      rescue Mollie::Exception => e
+        MollieLogger.debug("Refund failed for order #{order_number}: #{e.message}")
+        ActiveMerchant::Billing::Response.new(false, 'Refund unsuccessful')
+      end
+    end
+
     def available_payment_methods
       ::Mollie::Method.all(
           api_key: get_preference(:api_key),
@@ -89,35 +147,32 @@ module Spree
     end
 
     def update_payment_status(payment)
-      mollie_transaction_id = payment.response_code
-      transaction = ::Mollie::Payment.get(
+      mollie_transaction_id = payment.source.payment_id
+      mollie_payment = ::Mollie::Payment.get(
           mollie_transaction_id,
           api_key: get_preference(:api_key)
       )
 
-      unless payment.completed?
-        case transaction.status
-          when 'paid'
-            payment.complete! unless payment.completed?
-            payment.order.finalize!
-            payment.order.update_attributes(:state => 'complete', :completed_at => Time.now)
-          when 'cancelled', 'expired', 'failed'
-            payment.failure! unless payment.failed?
-          else
-            logger.debug 'Unhandled Mollie payment state received. Therefore we did not update the payment state.'
-        end
-      end
+      MollieLogger.debug("Updating order state for payment. Payment has state #{mollie_payment.status}")
 
-      payment.source.update(status: payment.state)
+      update_by_mollie_status!(mollie_payment, payment)
     end
 
-    private
-    def invalidate_prev_transactions(current_payment_id)
-      # Cancel all previous payment which are pending or are still being processed
-      payments.with_state('processing').or(payments.with_state('pending')).where.not(id: current_payment_id).each do |payment|
-        # Set internal payment state to failed
-        payment.failure! unless payment.store_credit?
+    def update_by_mollie_status!(mollie_payment, payment)
+      case mollie_payment.status
+        when 'paid'
+          payment.complete! unless payment.completed?
+          payment.order.finalize!
+          payment.order.update_attributes(:state => 'complete', :completed_at => Time.now)
+        when 'cancelled', 'expired', 'failed'
+          payment.failure! unless payment.failed?
+        when 'refunded'
+          payment.void! unless payment.void?
+        else
+          MollieLogger.debug('Unhandled Mollie payment state received. Therefore we did not update the payment state.')
       end
+
+      payment.source.update(status: payment.state)
     end
   end
 end

data/app/models/spree/mollie_logger.rb

@@ -0,0 +1,9 @@
+module Spree
+  class MollieLogger
+    def self.debug(message = nil)
+      return unless message.present?
+      @logger ||= Logger.new(File.join(Rails.root, 'log', 'mollie.log'))
+      @logger.debug(message)
+    end
+  end
+end

data/app/models/spree/{mollie_transaction.rb → mollie_payment_source.rb}

@@ -1,14 +1,18 @@
 module Spree
-  class MollieTransaction < Spree::Base
+  class MolliePaymentSource < Spree::Base
     belongs_to :payment_method
-    has_many :payment, as: :source
+    has_many :payments, as: :source
 
     def actions
       []
     end
 
+    def transaction_id
+      payment_id
+    end
+
     def method_type
-      'mollie_transaction'
+      'mollie_payment_source'
     end
 
     def name

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,24 @@
+Spree::Order.class_eval do
+  # Make sure the order confirmation is delivered when the order has been paid for.
+  def finalize!
+    # lock all adjustments (coupon promotions, etc.)
+    all_adjustments.each(&:close)
+
+    # update payment and shipment(s) states, and save
+    updater.update_payment_state
+    shipments.each do |shipment|
+      shipment.update!(self)
+      shipment.finalize!
+    end
+
+    updater.update_shipment_state
+    save!
+    updater.run_hooks
+
+    touch :completed_at
+
+    deliver_order_confirmation_email unless confirmation_delivered? or !paid?
+
+    consider_risk
+  end
+end

data/app/models/spree/payment/processing_decorator.rb

@@ -1,6 +1,12 @@
 Spree::Payment::Processing.module_eval do
-  def create_transaction!
+  def process!(amount = nil)
+    amount ||= money.money.cents
     started_processing!
-    gateway_action(source, :create_transaction, :pend)
+    response = payment_method.create_transaction(
+        amount,
+        source,
+        gateway_options
+    )
+    handle_response(response, :pend, :failure)
   end
 end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,16 @@
+Spree::Payment.class_eval do
+  delegate :transaction_id, to: :source
+
+  def build_source
+    return unless new_record?
+    if source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
+      self.source = payment_method.payment_source_class.new(source_attributes)
+      source.payment_method_id = payment_method.id
+      source.user_id = order.user_id if order
+
+      # Spree will not process payments if order is completed.
+      # We should call process! for completed orders to create a new Mollie payment.
+      process! if order.completed?
+    end
+  end
+end