solidus_mollie 0.1.0 → 0.9.2

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

@@ -1,2 +0,0 @@
-// 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

@@ -1,4 +0,0 @@
-/*
-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

@@ -1,4 +0,0 @@
-/*
-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

@@ -1,31 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,155 +0,0 @@
-# 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

data/app/models/spree/mollie/order_serializer.rb

@@ -1,169 +0,0 @@
-module Spree
-   module Mollie
-     class OrderSerializer
-      #  include ::Spree::Mollie::MoneyFormatter
-  
-        def self.serialize(gateway_options)
-          new(gateway_options).serialize
-        end
-  
-        def initialize(gateway_options)
-          @gateway_options = gateway_options
-          @source = @gateway_options[:originator].source
-          @order = Spree::Order.find(@gateway_options[:originator].order_id)
-        end
- 
-        def serialize
-          spree_routes = ::Spree::Core::Engine.routes.url_helpers
-          payment_identifier = @gateway_options[:order_id]
-  
-          order_params = {
-            amount: price(@order.total),
-            metadata: {
-              order_number: @order.number,
-              payment_identifier: payment_identifier
-            },
-            orderNumber: payment_identifier,
-            redirectUrl: spree_routes.mollie_validate_payment_mollie_url(
-              order_number: payment_identifier,
-              host: Spree::Store.default.url
-            ),
-            webhookUrl: spree_routes.mollie_update_payment_status_mollie_url(
-              payment_identifier: payment_identifier,
-              host: Spree::Store.default.url
-            ),
-            locale: 'en_US',
-          }
- 
-          if @gateway_options[:billing_address].present?
-            order_params.merge! ({
-              billingAddress: serialize_address(@gateway_options[:billing_address])
-            })
-          end
-  
-          if @gateway_options[:shipping_address].present?
-            order_params.merge! ({
-              shippingAddress: serialize_address(@gateway_options[:shipping_address])
-            })
-          end
-  
-          order_params.merge! ({
-            lines: prepare_line_items
-          })
-  
-          # User has already selected a payment method
-          if @source.try(:payment_method_name).present?
-            order_params.merge! ({
-              method: @source.payment_method_name
-            })
-          end
-  
-          # User has selected an issuer (available for iDEAL payments)
-          if @source.try(:issuer).present?
-            order_params.merge! ({
-              payment: {
-                issuer: @source.issuer
-              }
-            })
-          end
-  
-          order_params
-        end
- 
-        private
- 
-        def prepare_line_items
-          order_lines = []
-          @order.line_items.each do |line|
-            order_lines << serialize_line_item(line)
-          end
-  
-          order_lines << serialize_discounts if @order.adjustments.any?
-  
-          order_lines << serialize_shipping_costs
-  
-          # if @order.shipping_discount.positive?
-          #   order_lines << serialize_shipping_discounts
-          # end
-  
-          order_lines
-        end
-  
-        def serialize_address(address)
-          {
-            streetAndNumber: [address[:address1], address[:address2]].join(" "),
-            city: address[:city],
-            postalCode: address[:zip],
-            country: address[:country],
-            region: address[:state],
-            givenName: address[:name],
-            familyName: address[:name],
-            email: @order.email
-          }
-        end
-  
-        def serialize_shipping_costs
-          {
-            type: 'shipping_fee',
-            name: 'Shipping',
-            quantity: 1, # Considering shipment as one line item per order and not per item or package
-            unitPrice: price(@order.shipments.map(&:cost).inject(0, &:+).to_f + @order.shipments.map(&:adjustment_total).inject(0, &:+).to_f),
-            totalAmount: price(@order.shipments.map(&:cost).inject(0, &:+).to_f + @order.shipments.map(&:adjustment_total).inject(0, &:+).to_f),
-            vatAmount: price(format_money(@order.shipments.map(&:included_tax_total).inject(0, &:+).to_f)), #TODO: Extract to its own method
-            vatRate: @order.shipments.first.tax_category.tax_rates.first.amount.to_f * 100 #TODO: Mollie allows only one tax rate, extract to method
-          }
-        end
-  
-        def serialize_discounts
-          binding.pry #TODO: Not implemented
-          {
-            type: 'discount',
-            name: 'Order discount',
-            quantity: 1,
-            unitPrice: price(@order.display_order_adjustment_total),
-            totalAmount: price(@order.display_order_adjustment_total),
-            vatAmount: price(0),
-            vatRate: '0'
-          }
-        end
-  
-        def serialize_shipping_discounts
-          binding.pry #TODO: Not implemented
-          {
-            type: 'discount',
-            name: 'Shipping discount', 
-            quantity: 1,
-            unitPrice: price(@order.display_shipping_discount),
-            totalAmount: price(@order.display_shipping_discount),
-            vatAmount: price(0),
-            vatRate: '0'
-          }
-        end
- 
-        def serialize_line_item(line_item)
-          {
-            type: 'physical',
-            name: line_item.name,
-            quantity: line_item.quantity,
-            unitPrice: price(line_item.price),
-            discountAmount: price(line_item.promo_total),
-            totalAmount: price(line_item.total),
-            vatAmount: price(line_item.included_tax_total),
-            vatRate: line_item.tax_rate.to_f * 100, # TODO: Might need to verify this rates just one tax_rate
-            sku: line_item.sku
-          }
-        end
-
-        def price(amount)
-          {
-            value: format_money(amount),
-            currency: @order.currency
-          }
-        end
-
-        def format_money(money)
-          Spree::Money.new(money, { symbol: nil, thousands_separator: nil, decimal_mark: '.' }).format
-        end
-     end
-   end
- end

data/app/models/spree/mollie/payment_state_updater.rb

@@ -1,62 +0,0 @@
-module Spree
-   module Mollie
-     class PaymentStateUpdater
-
-      attr_reader :payment
-      attr_reader :mollie_order
-
-       def initialize(mollie_order, payment)
-         @mollie_order = mollie_order
-         @payment = payment
-       end
- 
-       def call
-         case mollie_order.status
-
-         when 'created'
-            transition_to_created!
-         when 'expired'
-            transition_to_failed!
-         when 'authorized'
-            transition_to_pending!
-         when 'paid', 'completed'
-            transition_to_complete!
-         when 'canceled'
-            transition_to_void!
-         when 'shipping'
-            transition_to_shipping!
-         else
-           MollieLogger.debug("Unhandled Mollie payment state received: #{mollie_order.status}. Therefore we did not update the payment state.")
-         end
-
-       end
- 
-       private
-
-       def transition_to_created!
-         true
-       end
-
-       def transition_to_failed!
-         payment.failure! unless @spree_payment.failed?
-       end
-
-       def transition_to_pending!
-         payment.pend! unless @spree_payment.pending?
-       end
-
-       def transition_to_complete!
-         payment.complete! unless @payment.completed?
-       end
-
-       def transition_to_void!
-         payment.void! unless @payment.void?
-       end
- 
-       def transition_to_shipping!
-         true
-       end
-
-     end
-   end
- end

data/app/models/spree/mollie_logger.rb

@@ -1,16 +0,0 @@
-module Spree
-  class MollieLogger
-    def self.debug(message = nil)
-      return unless message.present?
- 
-      @logger ||= Logger.new(File.join(Rails.root, 'log', 'solidus_mollie.log'))
-
-      #  .datetime_format = "%Y-%m-%d %H:%M:%S"
-      @logger.debug(message)
-    end
- 
-    class << self
-      attr_writer :logger
-    end
-  end
-end

data/app/models/spree/mollie_payment_source.rb

@@ -1,57 +0,0 @@
-module Spree
-  class MolliePaymentSource < Spree::PaymentSource
-
-    self.table_name = "solidus_mollie_payment_sources"
- 
-    def transaction_id 
-      payment_id
-    end
- 
-    def method_type
-      'mollie_payment_source'
-    end
-
-    def name
-      case payment_method_name
-      when ::Mollie::Method::IDEAL then
-        'iDEAL'
-      when ::Mollie::Method::CREDITCARD then
-        'Credit card'
-      when ::Mollie::Method::BANCONTACT then
-        'Bancontact'
-      when ::Mollie::Method::SOFORT then
-        'SOFORT Banking'
-      when ::Mollie::Method::BANKTRANSFER then
-        'Bank transfer'
-      when ::Mollie::Method::PAYPAL then
-        'PayPal'
-      when ::Mollie::Method::KBC then
-        'KBC/CBC Payment Button'
-      when ::Mollie::Method::BELFIUS then
-        'Belfius Pay Button'
-      when ::Mollie::Method::PAYSAFECARD then
-        'paysafecard'
-      when ::Mollie::Method::GIFTCARD then
-        'Giftcard'
-      when ::Mollie::Method::INGHOMEPAY then
-        'ING Home\'Pay'
-      when ::Mollie::Method::EPS then
-        'EPS'
-      when ::Mollie::Method::GIROPAY then
-        'Giropay'
-      when ::Mollie::Method::DIRECTDEBIT then
-        'SEPA Direct debit'
-      when ::Mollie::Method::KLARNASLICEIT then
-        'Klarna Slice it'
-      when ::Mollie::Method::KLARNAPAYLATER then
-        'Klarna Pay Later'
-      when ::Mollie::Method::PRZELEWY24 then
-        'Przelewy24'
-      when ::Mollie::Method::APPLEPAY then
-        'Apple Pay'
-      else
-        'Mollie (Unknown method)'
-      end
-    end
-  end
-end

data/app/models/spree/payment_method/mollie.rb

@@ -1,26 +0,0 @@
-
-# frozen_string_literal: true
-
-module Spree
-  class PaymentMethod::Mollie < Spree::PaymentMethod
-    preference :api_key, :string
-
-    def payment_source_class
-      MolliePaymentSource
-    end
-
-    def partial_name
-      "mollie"
-    end
-
-    def auto_capture
-      false
-    end
-
-    protected
-
-    def gateway_class
-      Spree::Gateway::MollieGateway
-    end
-  end
-end

data/app/views/spree/admin/payments/source_forms/_mollie.html.erb

@@ -1,8 +0,0 @@
-<fieldset class="no-border-bottom js-edit-credit-card">
-  <legend><%= payment_method.name %></legend>
-
-  <div id="card_form<%= payment_method.id %>" data-hook class="js-new-credit-card-form">
-    <% param_prefix = "payment_source[#{payment_method.id}]" %>
-    
-  </div>
-</fieldset>

data/app/views/spree/admin/payments/source_views/_mollie.html.erb

@@ -1,27 +0,0 @@
-<fieldset data-hook="credit_card">
-  <legend align="center"><%= Spree::MolliePaymentSource.model_name.human %></legend>
-
-  <div class="row">
-    <div class="col-12">
-      <dl>
-        <dt><%= t('spree.payment_method') %>:</dt>
-        <dd><%= payment.source.payment_method_name %></dd>
-
-         <dt><%= t('spree.transaction_id') %>:</dt>
-         <dd><%= payment.source.payment_id %></dd>
-
-         <dt><%= t('spree.Payment Link') %>:</dt>
-         <dd><a href="<%= payment.source.payment_url %>"><%= payment.source.payment_url %></a></dd>
-
-        <% if payment.source.issuer %>
-          <dt><%= t('spree.issuer') %>:</dt>
-          <dd><%= payment.source.issuer %></dd>
-        <% end %>
-
-         <dt><%= t('spree.payment_status') %>:</dt>
-         <dd><%= payment.source.status %></dd>
-      </dl>
-
-    </div>
-  </div>
-</fieldset>

data/app/views/spree/api/payments/show.json.jbuilder

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-json.(@payment, *payment_attributes)
-json.(@payment.source, :payment_url)
-#FIXME: This works, but I think there is a better way than overwriting this template

data/app/views/spree/api/payments/source_views/_mollie.json.jbuilder

@@ -1,2 +0,0 @@
-attrs = [:id, :payment_url]
-json.(payment_source, *attrs)