solidus_mollie 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b93ec5f4b4a21514882eb71bbe99ba37826ad0cbbd83421b3661b2251cc2e589
+  data.tar.gz: af024b49050bbeaf8e186b0b4b338e8e8893fe507087d369a417e152aaa052b2
+SHA512:
+  metadata.gz: f3ad564dcc8d5ea425b5cfe5c9887a74deb903acba47bcc4f30cc40600243dc42d8a433350a1533875bf180f3adc14c723582f495592ed747a28ab76876ebc6e
+  data.tar.gz: 89a485930ff1261aa2d49bb24061305a45eb7f5ea6a00116d6c00aa82759c175385017ff5bbf0a193176b208650960e20ab088b9b8f1f891449dce5df5a8ae74

data/.circleci/config.yml

@@ -0,0 +1,41 @@
+version: 2.1
+
+orbs:
+  # Always take the latest version of the orb, this allows us to
+  # run specs against Solidus supported versions only without the need
+  # to change this configuration every time a Solidus version is released
+  # or goes EOL.
+  solidusio_extensions: solidusio/extensions@volatile
+
+jobs:
+  run-specs-with-postgres:
+    executor: solidusio_extensions/postgres
+    steps:
+      - solidusio_extensions/run-tests
+  run-specs-with-mysql:
+    executor: solidusio_extensions/mysql
+    steps:
+      - solidusio_extensions/run-tests
+  lint-code:
+    executor: solidusio_extensions/sqlite-memory
+    steps:
+      - solidusio_extensions/lint-code
+
+workflows:
+  "Run specs on supported Solidus versions":
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql
+      - lint-code
+
+  "Weekly run specs against master":
+    triggers:
+      - schedule:
+          cron: "0 0 * * 4" # every Thursday
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql

data/.gem_release.yml

@@ -0,0 +1,5 @@
+bump:
+  recurse: false
+  file: 'lib/solidus_mollie/version.rb'
+  message: Bump SolidusMollie to %{version}
+  tag: true

data/.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: false
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It might be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

data/.github_changelog_generator

@@ -0,0 +1,2 @@
+issues=false
+exclude-labels=infrastructure

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy
+spec/examples.txt
+/sandbox
+.rvmrc
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,5 @@
+require:
+  - solidus_dev_support/rubocop
+
+AllCops:
+  NewCops: disable

data/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

data/Gemfile

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+branch = ENV.fetch('SOLIDUS_BRANCH', 'master')
+gem 'solidus', github: 'solidusio/solidus', branch: branch
+
+# Needed to help Bundler figure out how to resolve dependencies,
+# otherwise it takes forever to resolve them.
+# See https://github.com/bundler/bundler/issues/6677
+gem 'rails', '>0.a'
+
+# Provides basic authentication functionality for testing parts of your engine
+gem 'solidus_auth_devise'
+
+case ENV['DB']
+when 'mysql'
+  gem 'mysql2'
+when 'postgresql'
+  gem 'pg'
+else
+  gem 'sqlite3'
+end
+
+gemspec
+
+# Use a local Gemfile to include development dependencies that might not be
+# relevant for the project or for other contributors, e.g. pry-byebug.
+#
+# We use `send` instead of calling `eval_gemfile` to work around an issue with
+# how Dependabot parses projects: https://github.com/dependabot/dependabot-core/issues/1658.
+send(:eval_gemfile, 'Gemfile-local') if File.exist? 'Gemfile-local'

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2021 [name of plugin creator]
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Solidus nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,91 @@
+# Solidus Mollie
+
+[![CircleCI](https://circleci.com/gh/solidusio-contrib/solidus_mollie.svg?style=shield)](https://circleci.com/gh/solidusio-contrib/solidus_mollie)
+[![codecov](https://codecov.io/gh/solidusio-contrib/solidus_mollie/branch/master/graph/badge.svg)](https://codecov.io/gh/solidusio-contrib/solidus_mollie)
+
+## Installation
+
+Add solidus\_mollie to your Gemfile:
+
+```ruby
+gem 'solidus_mollie'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bin/rails generate solidus_mollie:install
+```
+
+## Usage
+
+<!-- Explain how to use your extension once it's been installed. -->
+
+## Development
+
+### Testing the extension
+
+First bundle your dependencies, then run `bin/rake`. `bin/rake` will default to building the dummy
+app if it does not exist, then it will run specs. The dummy app can be regenerated by using
+`bin/rake extension:test_app`.
+
+```shell
+bin/rake
+```
+
+To run [Rubocop](https://github.com/bbatsov/rubocop) static code analysis run
+
+```shell
+bundle exec rubocop
+```
+
+When testing your application's integration with this extension you may use its factories.
+Simply add this require statement to your `spec/spec_helper.rb`:
+
+```ruby
+require 'solidus_mollie/testing_support/factories'
+```
+
+Or, if you are using `FactoryBot.definition_file_paths`, you can load Solidus core
+factories along with this extension's factories using this statement:
+
+```ruby
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusMollie::Engine)
+```
+
+### Running the sandbox
+
+To run this extension in a sandboxed Solidus application, you can run `bin/sandbox`. The path for
+the sandbox app is `./sandbox` and `bin/rails` will forward any Rails commands to
+`sandbox/bin/rails`.
+
+Here's an example:
+
+```
+$ bin/rails server
+=> Booting Puma
+=> Rails 6.0.2.1 application starting in development
+* Listening on tcp://127.0.0.1:3000
+Use Ctrl-C to stop
+```
+
+### Updating the changelog
+
+Before and after releases the changelog should be updated to reflect the up-to-date status of
+the project:
+
+```shell
+bin/rake changelog
+git add CHANGELOG.md
+git commit -m "Update the changelog"
+```
+
+### Releasing new versions
+
+Please refer to the dedicated [page](https://github.com/solidusio/solidus/wiki/How-to-release-extensions) on Solidus wiki.
+
+## License
+
+Copyright (c) 2021 Victor ter Hark.
+Copyright (c) 2026 Kalopa Robotics Limited.
+Released under the New BSD License.

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'solidus_dev_support/rake_tasks'
+SolidusDevSupport::RakeTasks.install
+
+task default: 'extension:specs'

data/app/assets/javascripts/spree/backend/solidus_mollie.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'

data/app/assets/javascripts/spree/frontend/solidus_mollie.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'

data/app/assets/stylesheets/spree/backend/solidus_mollie.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

data/app/assets/stylesheets/spree/frontend/solidus_mollie.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

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

@@ -0,0 +1,31 @@
+module Spree
+  module Api
+    class MollieController < Spree::Api::BaseController
+      def payment_methods
+        #FIXME: This is not safe. 
+        order = Spree::Order.find_by(number: params[:id])
+        method_params = payload(order)
+
+        payment_methods = Spree::PaymentMethod::Mollie.first.gateway.available_methods(method_params).map(&:attributes)
+
+        render json: payment_methods
+      end
+
+      def validate_payment
+      end
+
+      private
+
+        def payload(order)
+          {
+            amount: {
+              currency: order.currency,
+              value: Spree::Money.new(order.order_total_after_store_credit, { symbol: nil, thousands_separator: nil, decimal_mark: '.' }).format
+            },
+            resource: 'orders',
+            billingCountry: order.bill_address.country.iso
+          }
+        end
+      end
+   end
+ end

data/app/controllers/spree/mollie_controller.rb

@@ -0,0 +1,53 @@
+module Spree
+    class MollieController < BaseController
+      skip_before_action :verify_authenticity_token, only: [:update_payment_status]
+  
+      # We might need this if the Webhook is late
+      def validate_payment
+        payment_number = split_payment_identifier(params[:order_number])
+        payment = Spree::Payment.find_by(number: payment_number)
+        payment.payment_method.gateway.update_payment_status(payment)
+
+        order = payment.order
+        order.reload
+
+        binding.pry
+  
+        # Order is paid for or authorized (e.g. Klarna Pay Later)
+        if (order.paid? && (order.can_complete?))
+          order.complete
+
+          redirect_to "https://bitter-lizard-32.loca.lt/checkout/success/#{order.number}"
+          # redirect_to order_path(payment.order)
+        else payment.pending?
+          redirect_to "https://bitter-lizard-32.loca.ltcheckout/#{params[:order_number]}"
+          # redirect_to checkout_state_path(:payment)
+        end
+      end
+ 
+     # Mollie might send us information about a transaction through the webhook.
+     # We should update the payment state accordingly.
+     def update_payment_status
+       payment_number = split_payment_identifier(params[:payment_identifier])
+       payment = Spree::Payment.find_by(number: payment_number)
+       payment.payment_method.gateway.update_payment_status(payment)
+  
+       head :ok
+     end
+ 
+     private
+ 
+       # Payment identifier is a combination of order_number and payment_id.
+       def split_payment_identifier(payment_identifier)
+         payment_identifier.split('-')[1]
+       end
+
+       def payment_status_params
+         params.permit(:payment_identifier, :id)
+       end
+
+       def load_order
+         @order = ::Spree::Order.find_by!(number: params[:order_id])
+       end
+   end
+ end

data/app/decorators/models/line_item_decorator.rb

@@ -0,0 +1,21 @@
+module SolidusMollie
+   module LineItemDecorator
+   
+      def tax_rate
+         if adjustments.tax.any?
+           # Solidus allows line items to have multiple TaxRate adjustments.
+           # Mollie does not support this. Raise an error if there > 1 TaxRate adjustment.
+
+           if adjustments.tax.count > 1
+             raise 'Mollie does not support multiple TaxRate adjustments per line item'
+           end
+           
+           adjustments.tax.first.source.amount
+         else
+           0.00
+         end
+       end
+ 
+     ::Spree::LineItem.prepend self
+   end
+  end

data/app/decorators/models/payment_create_decorator.rb

@@ -0,0 +1,22 @@
+module SolidusMollie
+  module PaymentCreateDecorator
+  
+    def authorized?
+      if source.is_a? Spree::MolliePaymentSource
+        pending?
+      else
+        false
+      end
+    end
+  
+    def after_pay_method?
+      if source.is_a? Spree::MolliePaymentSource
+        return source.payment_method_name == ::Mollie::Method::KLARNAPAYLATER || source.payment_method_name == ::Mollie::Method::KLARNASLICEIT
+      else
+        false
+      end
+    end
+
+    ::Spree::PaymentCreate.prepend self
+  end
+ end

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

@@ -0,0 +1,155 @@
+# Credit
+
+# 1. Webhook Callbacks
+# 2. Payment Methods through API
+# 3. Create Mollie User
+# 4. Mollie shipments
+
+# X. Client wrapper like PayPal
+# X. Ugly functions in serializer
+# x. Nice helper for Payment ID
+# X. Check if we pass only variables needed
+
+module Spree 
+  class Gateway::MollieGateway 
+
+    def initialize(options)
+      ::Mollie::Client.configure do |config|
+        config.api_key  = options[:api_key]
+      end
+    end
+
+    def format_money(money)
+      Spree::Money.new(money, { symbol: nil, thousands_separator: nil, decimal_mark: '.' }).format
+    end
+
+    def authorize(_money, _source, gateway_options = {})
+      begin
+        payment = gateway_options[:originator]
+        invalidate_previous_orders(payment.order_id)
+
+        # Create a new Mollie order and update the payment source
+        mollie_order = create_mollie_order(gateway_options)
+        payment.source.update(status: mollie_order.status, payment_id: mollie_order.id, payment_url: mollie_order.checkout_url)
+
+        ActiveMerchant::Billing::Response.new(true, 'Order created')
+      rescue ::Mollie::Exception => e
+        ActiveMerchant::Billing::Response.new(false, "Order could not be created: #{e.message}")
+      end
+    end
+
+    def capture(_money, _response_code, gateway_options = {})
+      authorize(_money, nil, gateway_options)
+      # ActiveMerchant::Billing::Response.new(true, 'Mollie will automatically capture the amount.')
+    end
+
+    def purchase(money, source, gateway_options = {})
+      authorize(money, source, gateway_options = {})
+    end
+
+    def void(_respoonse_code, gateway_options = {})
+      begin
+        payment_id = gateway_options[:originator].source.payment_id
+
+        if cancel_mollie_order!(payment_id)
+          ActiveMerchant::Billing::Response.new(true, 'Mollie order has been cancelled.')
+        else
+          ActiveMerchant::Billing::Response.new(true, 'Spree order has been canceled, could not cancel Mollie order.')
+        end
+      rescue ::Mollie::Exception => e
+        ActiveMerchant::Billing::Response.new(false, 'Order cancellation unsuccessful.')
+      end
+    end
+
+    def credit(_money_cents, _transaction_id, options)
+      refund = options[:originator]
+
+      payment = refund.try(:payment)
+      order = payment.try(:order)
+      reimbursement = refund.try(:reimbursement)
+
+      # binding.pry
+      begin
+        if reimbursement
+          mollie_order = ::Mollie::Order.get(payment.source.payment_id)
+
+          mollie_order_refund_lines = reimbursement.return_items.map do |reimbursement|
+            line_item = mollie_order.lines.detect { |line|
+	      line_item.sku == reimbursement.inventory_unit.line_item.mollie_identifier
+	    }
+            { id: line_item.id, quantity: ri.inventory_unit.line_item.quantity } if line_item
+          end.compact
+
+          mollie_order.refund!({lines: mollie_order_refund_lines})
+        else
+          ::Mollie::Payment::Refund.create(
+            payment_id: payment_id,
+            amount: {
+              value: format_money(refund.amount),
+              currency: refund.currency
+            },
+            description: "Refund Order ID: #{order.number}",
+
+          )
+        end
+        ActiveMerchant::Billing::Response.new(true, "Successfully refunded #{order.display_total} for order #{order_number}")
+      rescue ::Mollie::Exception => e
+        ActiveMerchant::Billing::Response.new(false, e.message)
+      end
+    end
+
+    def available_methods(params = nil)
+      method_params = {
+        include: 'issuers',
+        resource: 'orders'
+      }
+   
+      method_params.merge! params if params.present?
+   
+      ::Mollie::Method.all(method_params)
+    end
+   
+    def available_methods_for_order(order)
+      params = {
+        amount: {
+          currency: order.currency,
+          value: format_money(order.total)
+        },
+        resource: 'orders',
+        billingCountry: order.billing_address.country.try(:iso)
+      }
+      available_methods(params)
+    end
+
+    def update_payment_status(payment)
+      mollie_order = ::Mollie::Order.get(payment.source.payment_id, embed: 'payments')
+   
+      Spree::Mollie::PaymentStateUpdater.new(mollie_order, payment).call
+    end
+
+    private
+      
+      def create_mollie_order(gateway_options)
+        order_params = Spree::Mollie::OrderSerializer.serialize(gateway_options)
+
+        ::Mollie::Order.create(order_params)
+      end
+
+      def cancel_mollie_order!(payment_id)
+        mollie_order = ::Mollie::Order.get(payment_id)
+        mollie_order.cancel if mollie_order.cancelable?
+      end
+   
+      def invalidate_previous_orders(order_id)
+        #TODO: Nice scope that checks for Payment Source
+        # Spree::Payment.by_mollie_and_order(order_id).each { cancel_mollie_order(paymnet) }
+
+        Spree::Payment.where(order_id: order_id).where("state = ? OR state = ?", 'pending', 'processing').each do |payment|
+          if payment.source_type == "Spree::MolliePaymentSource"
+            payment.void!
+            cancel_mollie_order!(payment.source.payment_id)
+          end
+        end
+      end
+  end
+end