ba_spree_loyalty_points 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d41af755522c53281c393fab438993ccb713ab81216ad88f6db168fbbc26f97
+  data.tar.gz: 7ef5c5a668852db2f6e06bbf2fb02bf965116d3f076399ba013b8f7de4b644f1
+SHA512:
+  metadata.gz: 4422b91ac2aecc54fda2d4cc27dc9ac3f8a03f625b70821ec6891871b48031c0af407f0ab6c2c027df5a7c7d7980409ceeb163cdb10de78e338d271040fd10f7
+  data.tar.gz: 8eec429bba7907c9d2955e5351cecbf97e578a3d5e71051a3d0c5a76200a91d055839931dbd488078a002be12cb5b2591f352d33bfc8813f44d63f423056babb

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014 vinsol.com
+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 Spree 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,77 @@
+# ba_spree_loyalty_points
+
+This is a fork of [spree_loyalty_points](https://github.com/vinsol-spree-contrib/spree-loyalty-points) with additional features and improvements.
+
+Loyalty Points extension allows customers to earn loyalty points on the basis of their purchases. Admin can also reward Loyalty Points to it's customers manually. Customer can use these loyalty points to pay for their future orders.
+
+This extension allows admin to create a new payment method "Loyalty Points" in the system. Once this payment method is created and active, it would appear on checkout screen and customers can use this payment method for payments.
+
+This extension also automates the awarding of loyalty points to customers based on the configuration done by admin and updating loyalty points based on the transactions on Spree Commerce platform.
+
+This extension allows only Loyalty Points payment method for making a purchase and does not allow the payment through other payment modes like cash, check, credit card etc.
+
+## Features
+
+* Supports Ruby 3.1
+* Supports Rails 7.1
+* Supports Spree 4.10
+* Japanese translations included
+* Actively maintained with contributions back to the original project
+
+## Installation
+
+In your `Gemfile`, add:
+
+```ruby
+gem 'ba_spree_loyalty_points', github: 'your-github-username/ba_spree_loyalty_points'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bundle exec rails g ba_spree_loyalty_points:install
+```
+
+## How it works
+
+* To add loyalty point feature, Spree admin needs to create "Loyalty Points" payment method
+
+    Configuration -> Payment Methods -> New payment Method
+
+    You need to select "Spree::PaymentMethod::LoyaltyPoints" as a Provider
+
+* Spree admin need to make following settings on Configuration page:
+
+   - **Set minimum amount of an order that should be spent by the customer to earn loyalty points** - On the basis of this, it will be decided by the system whether loyalty points should be awarded for the order or not, based on the order value.
+
+  - **Set number of loyalty points to be awarded per unit amount spent** - On the basis of this configuration, number of loyalty points to be awarded are calculated based on the order value and per unit value defined. The loyalty points get added to the customer's account which he can use in future purchases.
+
+    Ex. Suppose Admin set this value this value to 1, it means, Customer will receive 1 Loyalty Point on spending every $1 on this site.
+
+       In order to receive loyalty points the payment should be done through some other
+     mode like Credit card, Debit card, Cash, Check etc.
+
+     No loyalty points are awarded for purchase done through existing Loyalty point
+    balance
+
+  - **Set minimum loyalty points balance required for redeeming** - On the basis of this, Customer will be permitted to make a payment with Loyalty Points only if he/she has Loyalty Points balance more than the minimum loyalty points set by the Admin.
+
+  - **Set Loyalty Point to Amount conversion rate** - This conversion rate converts the loyalty points into amount. This amount is displayed on the checkout screen with Loyalty Points balance.
+
+  - **Set Time to award Loyalty Points after payment** - Loyalty Points will be credited to the Customer's account on the basis of this set time period. This time period will be considered only after Customer makes the payment and Admin marks this payment "Capture".
+
+    **This field is provided to curb the misuse of the Loyalty Points by the customers. So, we suggest to set this time on the basis of the merchant's "Return Policy".**
+
+[Rest of the content remains the same until the Credits section...]
+
+## License
+
+This extension is available as open source under the terms of either:
+* [GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)](https://www.gnu.org/licenses/agpl-3.0.en.html)
+* [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)
+
+## Credits
+
+Originally created by Vinsol.
+Fork maintained by [be agile Co., Ltd.](https://be-agile.jp/).

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

@@ -0,0 +1,81 @@
+function SelectOptionChange(selectBoxId, containerId, heading) {
+    var that = this;
+    this.selectBoxId = selectBoxId;
+    this.containerId = containerId;
+    $('#' + this.selectBoxId).on('change', function(event) {
+        var appendPath = event.target.value;
+        $.ajax({
+            url: $(this).attr('data-transactions-link') + "/order_transactions/" + appendPath,
+            dataType: "json",
+            success: function(responseData, returnStatus, xhr) {
+                var $mainContainer = $('#' + containerId);
+                // Remove table for last order transactions
+                $mainContainer.html("");
+                // Add heading
+                $mainContainer.append($('<h5>' + heading + '</h5>'));
+                // Parse response data from ajax
+                that.displayData(responseData, $mainContainer);
+            }
+        });
+    });
+}
+$(document).ready(function() {
+    var orderSelection = new SelectOptionChange('loyalty_points_transaction_source_id', 'loyalty-points-order-transactions', 'Loyalty Point Transactions')
+    orderSelection.displayData = function(responseData, container) {
+        var $table = this.appendTable(container);
+        this.appendHeaderRow($table);
+        var $tableBody = this.appendTableBody($table);
+
+        $.each(responseData, function(index, transaction) {
+            var $transactionRow = this.appendTableRow($tableBody);
+            transaction_date = new Date(transaction['updated_at']).toLocaleString();
+            this.appendTableRowData(transaction_date, $transactionRow);
+            this.appendSourceReference(transaction['source_type'], transaction['source']['number'], $transactionRow);
+            this.appendTableRowData(transaction['comment'], $transactionRow);
+            this.appendTableRowData(transaction['transaction_type'], $transactionRow);
+            this.appendTableRowData(transaction['loyalty_points'], $transactionRow);
+            this.appendTableRowData(transaction['balance'], $transactionRow);
+        }.bind(this));
+    }
+    orderSelection.appendTable = function(container) {
+        return $('<table></table>').addClass("table").appendTo(container);
+    }
+    orderSelection.appendHeaderRow = function(container) {
+        $tableHead = this.appendTableHeader(container);
+        $tableHeadRow = this.appendTableRow($tableHead);
+        this.appendHeadData('Date', $tableHeadRow);
+        this.appendHeadData('Source', $tableHeadRow);
+        this.appendHeadData('Source Reference', $tableHeadRow);
+        this.appendHeadData('Comment', $tableHeadRow);
+        this.appendHeadData('Transaction Type', $tableHeadRow);
+        this.appendHeadData('Loyalty Points', $tableHeadRow);
+        this.appendHeadData('Updated Balance', $tableHeadRow);
+    }
+    orderSelection.appendTableBody = function(container) {
+        return $('<tbody></tbody>').appendTo(container);
+    }
+    orderSelection.appendTableHeader = function(container) {
+        return $('<thead></thead>').appendTo(container);
+    }
+    orderSelection.appendTableRow = function(container) {
+        return $('<tr></tr>').appendTo(container);
+    }
+    orderSelection.appendTableRowData = function(content, container) {
+        if (!content) {
+          content = "";
+        }
+        return $('<td>' + content + '</td>').appendTo(container);
+    }
+    orderSelection.appendHeadData = function(content, container) {
+        return $('<th>' + content + '</th>').appendTo(container);
+    }
+    orderSelection.appendSourceReference = function(source_type, source_reference, container) {
+        this.appendTableRowData(source_type.replace('Spree::', ''), container);
+        if (source_type == "Spree::Order") {
+            $("<td><a href='/admin/orders/" + source_reference + "/edit'>" + source_reference + "</a></td>").appendTo(container);
+        }
+        else {
+            this.appendTableRowData(source_reference, container);
+        }
+    }
+});

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

@@ -0,0 +1,10 @@
+
+#loyalty-points-info {
+  border: 1px solid #D9D9DB;
+  margin-bottom: 15px;
+  padding: 10px;
+}
+
+#loyalty-points-info dd {
+    margin-left: 0;
+}

data/app/controllers/spree/admin/loyalty_points_transactions_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Admin
+    class LoyaltyPointsTransactionsController < ResourceController
+      belongs_to Spree.user_class.to_s.underscore
+      before_action :set_user, only: :order_transactions
+      before_action :set_ordered_transactions, only: :index
+
+      def order_transactions
+        order = Spree::Order.find_by(id: params[:order_id])
+        @loyalty_points_transactions = @user.loyalty_points_transactions.for_order(order).includes(:source).order(updated_at: :desc)
+        respond_with @loyalty_points_transactions
+      end
+
+      def create
+        invoke_callbacks(:create, :before)
+        @object.attributes = loyalty_points_transaction_params
+        if @object.save
+          invoke_callbacks(:create, :after)
+          respond_with(@object) do |format|
+            format.html { redirect_to location_after_save, success: flash_message_for(@object, :successfully_created) }
+            format.js   { render layout: false }
+          end
+        else
+          invoke_callbacks(:create, :fails)
+          respond_with(@object) do |format|
+            format.html { render action: :new }
+          end
+        end
+      end
+
+      protected
+
+        def set_user
+          unless @user = Spree.user_class.find_by(id: params[:user_id])
+            redirect_to spree.admin_users_path, notice: flash_message_for(Spree.user_class.new, :not_found)
+          end
+        end
+
+        def loyalty_points_transaction_params
+          params.require(:loyalty_points_transaction).permit(:loyalty_points, :type, :comment, :source_id, :source_type)
+        end
+
+        def build_resource
+          if params[:loyalty_points_transaction].present? && params[:loyalty_points_transaction][:type].present?
+            parent.send(association_name(params[:loyalty_points_transaction][:type])).build
+          else
+            parent.send(controller_name).build
+          end
+        end
+
+        def association_name(klass)
+          klass.gsub('Spree::', '').pluralize.underscore
+        end
+
+        def collection_url
+          if (parent_data.present? && @parent.nil?) || parent_data.blank?
+            spree.admin_users_url
+          else
+            spree.admin_user_loyalty_points_url(parent)
+          end
+        end
+
+        def set_ordered_transactions
+          @loyalty_points_transactions = @loyalty_points_transactions.order(updated_at: :desc).
+                                           page(params[:page]).
+                                           per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
+        end
+    end
+  end
+end

data/app/controllers/spree/admin/resource_controller_decorator.rb

@@ -0,0 +1,25 @@
+module Spree
+  module Admin
+    module ResourceControllerDecorator
+      protected
+
+      def parent
+        if parent_data.is_a?(Hash) && parent_data[:model_class].present?
+          @parent ||= parent_data[:model_class].send("find_by_#{parent_data[:find_by]}", params["#{resource.model_name}_id"])
+          raise ActiveRecord::RecordNotFound unless @parent
+          instance_variable_set("@#{resource.model_name}", @parent)
+        else
+          nil
+        end
+      end
+
+      def resource_not_found
+        flash[:error] = flash_message_for(model_class.new, :not_found)
+        flash[:error] = flash_message_for(parent_data[:model_class].new, :not_found) if parent_data.present? && @parent.nil?
+        redirect_to collection_url
+      end
+    end
+  end
+end
+
+Spree::Admin::ResourceController.prepend(Spree::Admin::ResourceControllerDecorator)

data/app/controllers/spree/admin/return_authorizations_controller_decorator.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Admin
+    module ReturnAuthorizationsControllerDecorator
+      def self.prepended(base)
+        base.before_action :set_loyalty_points_transactions, only: [:new, :edit, :create, :update]
+      end
+
+      private
+
+      def set_loyalty_points_transactions
+        @loyalty_points_transactions = @return_authorization.order.loyalty_points_transactions.
+          page(params[:page]).
+          per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
+      end
+    end
+  end
+end
+
+Spree::Admin::ReturnAuthorizationsController.prepend(Spree::Admin::ReturnAuthorizationsControllerDecorator)

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,21 @@
+module Spree
+  module CheckoutControllerDecorator
+    def self.prepended(base)
+      base.before_action :sufficient_loyalty_points, only: [:update], if: -> { params[:state] == 'payment' }
+    end
+
+    private
+
+    def sufficient_loyalty_points
+      payment_method_ids = params[:order][:payments_attributes].collect do |payment|
+        payment["payment_method_id"]
+      end
+      if Spree::PaymentMethod.loyalty_points_id_included?(payment_method_ids) && !@order.user.has_sufficient_loyalty_points?(@order)
+        flash[:error] = Spree.t(:insufficient_loyalty_points)
+        redirect_to spree.checkout_state_path(@order.state)
+      end
+    end
+  end
+end
+
+Spree::CheckoutController.prepend Spree::CheckoutControllerDecorator if Spree::CheckoutController.included_modules.exclude?(Spree::CheckoutControllerDecorator)

data/app/controllers/spree/loyalty_points_controller.rb

@@ -0,0 +1,11 @@
+module Spree
+  class LoyaltyPointsController < StoreController
+
+    def index
+      @loyalty_points_transactions = spree_current_user.loyalty_points_transactions.includes(:source).order(updated_at: :desc).
+                                       page(params[:page]).
+                                       per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
+    end
+
+  end
+end

data/app/models/concerns/spree/loyalty_points.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+
+module Spree
+  module LoyaltyPoints
+    extend ActiveSupport::Concern
+
+    def loyalty_points_for(amount, purpose = 'award')
+      loyalty_points = if purpose == 'award' && eligible_for_loyalty_points?(amount)
+        (amount * Spree::Store.default.loyalty_points_awarding_unit).floor
+      elsif purpose == 'redeem'
+        (amount / Spree::Store.default.loyalty_points_conversion_rate).ceil
+      else
+        0
+      end
+    end
+
+    def eligible_for_loyalty_points?(amount)
+      amount >= Spree::Store.default.min_amount_required_to_get_loyalty_points
+    end
+
+  end
+end

data/app/models/concerns/spree/order/loyalty_points.rb

@@ -0,0 +1,55 @@
+require 'active_support/concern'
+
+module Spree
+  class Order
+    module LoyaltyPoints
+      extend ActiveSupport::Concern
+
+      def loyalty_points_total
+        loyalty_points_credit_transactions.sum(:loyalty_points) - loyalty_points_debit_transactions.sum(:loyalty_points)
+      end
+
+      def award_loyalty_points
+        loyalty_points_earned = loyalty_points_for(item_total)
+        if !loyalty_points_used?
+          create_credit_transaction(loyalty_points_earned)
+        end
+      end
+
+      def loyalty_points_awarded?
+        loyalty_points_credit_transactions.count > 0
+      end
+
+      def loyalty_points_used?
+        payments.any_with_loyalty_points?
+      end
+
+      module ClassMethods
+
+        def credit_loyalty_points_to_user
+          points_award_period = Spree::Store.default.loyalty_points_award_period
+          uncredited_orders = Spree::Order.with_uncredited_loyalty_points(points_award_period)
+          uncredited_orders.each do |order|
+            order.award_loyalty_points
+          end
+        end
+
+      end
+
+      def create_credit_transaction(points)
+        user.loyalty_points_credit_transactions.create(source: self, loyalty_points: points)
+      end
+
+      def create_debit_transaction(points)
+        user.loyalty_points_debit_transactions.create(source: self, loyalty_points: points)
+      end
+
+      private
+
+        def complete_loyalty_points_payments
+          payments.by_loyalty_points.with_state('checkout').each { |payment| payment.complete! }
+        end
+
+    end
+  end
+end

data/app/models/concerns/spree/payment/loyalty_points.rb

@@ -0,0 +1,48 @@
+require 'active_support/concern'
+
+module Spree
+  class Payment
+    module LoyaltyPoints
+      extend ActiveSupport::Concern
+
+      included do
+        scope :by_loyalty_points, -> { joins(:payment_method).readonly(false).where(spree_payment_methods: { type: 'Spree::PaymentMethod::LoyaltyPoints'}) }
+      end
+
+        module ClassMethods
+
+          def any_with_loyalty_points?
+            by_loyalty_points.size != 0
+          end
+        end
+
+      private
+
+        def redeem_loyalty_points
+          loyalty_points_redeemed = loyalty_points_for(amount, 'redeem')
+          order.create_debit_transaction(loyalty_points_redeemed)
+        end
+
+        def return_loyalty_points
+          loyalty_points_redeemed = loyalty_points_for(amount, 'redeem')
+          order.create_credit_transaction(loyalty_points_redeemed)
+        end
+
+        def by_loyalty_points?
+          payment_method.type == "Spree::PaymentMethod::LoyaltyPoints"
+        end
+
+        def redeemable_loyalty_points_balance?
+          order.user.loyalty_points_balance >= Spree::Store.default.loyalty_points_redeeming_balance
+        end
+
+        def redeemable_user_balance
+          unless redeemable_loyalty_points_balance?
+            min_balance = Spree::Store.default.loyalty_points_redeeming_balance
+            errors.add :loyalty_points_balance, "should be atleast #{ min_balance.to_s + " " + "point".pluralize(min_balance) } for redeeming Loyalty Points"
+          end
+        end
+
+    end
+  end
+end

data/app/models/concerns/spree/transactions_total_validation.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+
+module Spree
+  module TransactionsTotalValidation
+    extend ActiveSupport::Concern
+
+      def net_transactions_sum(trans_type, relation)
+        credit_transactions_total = relation.loyalty_points_credit_transactions.sum(:loyalty_points)
+        debit_transactions_total = relation.loyalty_points_debit_transactions.sum(:loyalty_points)
+        trans_type == "Debit" ? debit_transactions_total += loyalty_points : credit_transactions_total += loyalty_points
+        credit_transactions_total - debit_transactions_total
+      end
+
+      def validate_transactions_total_range(trans_type, relation)
+        net_transactions_total = net_transactions_sum(trans_type, relation)
+        first_transaction = relation.loyalty_points_transactions.first
+        if first_transaction.transaction_type == "Debit"
+          errors.add :base, "Loyalty Points Net Debit Total should be in the range [0, #{ first_transaction.loyalty_points }]" if net_transactions_total > 0 || net_transactions_total < -first_transaction.loyalty_points
+        else
+          errors.add :base, "Loyalty Points Net Credit Total should be in the range [0, #{ first_transaction.loyalty_points }]" if net_transactions_total < 0 || net_transactions_total > first_transaction.loyalty_points
+        end
+      end
+
+  end
+end

data/app/models/spree/loyalty_points_credit_transaction.rb

@@ -0,0 +1,18 @@
+module Spree
+  class LoyaltyPointsCreditTransaction < LoyaltyPointsTransaction
+    after_create :update_user_balance
+    before_create :update_balance
+
+    private
+
+      def update_user_balance
+        user.increment(:loyalty_points_balance, loyalty_points)
+        user.save!
+      end
+
+      def update_balance
+        self.balance = user.loyalty_points_balance + loyalty_points
+      end
+
+  end
+end

data/app/models/spree/loyalty_points_debit_transaction.rb

@@ -0,0 +1,18 @@
+module Spree
+  class LoyaltyPointsDebitTransaction < LoyaltyPointsTransaction
+    after_create :update_user_balance
+    before_create :update_balance
+
+    private
+
+      def update_user_balance
+        user.decrement(:loyalty_points_balance, loyalty_points)
+        user.save!
+      end
+
+      def update_balance
+        self.balance = user.loyalty_points_balance - loyalty_points
+      end
+
+  end
+end

data/app/models/spree/loyalty_points_transaction.rb

@@ -0,0 +1,42 @@
+module Spree
+  class LoyaltyPointsTransaction < ActiveRecord::Base
+    include Spree::TransactionsTotalValidation
+    TRANSACTION_TYPES = ['Spree::LoyaltyPointsCreditTransaction', 'Spree::LoyaltyPointsDebitTransaction']
+    CLASS_TO_TRANSACTION_TYPE = { 'Spree::LoyaltyPointsCreditTransaction' => 'Credit', 'Spree::LoyaltyPointsDebitTransaction' => 'Debit'}
+    belongs_to :user, class_name: "::#{Spree.user_class}"
+    belongs_to :source, polymorphic: true
+
+    validates :loyalty_points, numericality: { only_integer: true, message: Spree.t('validation.must_be_int'), greater_than: 0 }
+    validates :type, inclusion: { in: TRANSACTION_TYPES }
+    validates :balance, presence: true
+    validate :source_or_comment_present
+    validate :transactions_total_range, if: -> { source.present? && source.loyalty_points_transactions.present? }
+
+    scope :for_order, ->(order) { where(source: order) }
+
+    before_create :generate_transaction_id
+
+    def transaction_type
+      CLASS_TO_TRANSACTION_TYPE[type]
+    end
+
+    private
+
+      def source_or_comment_present
+        unless source.present? || comment.present?
+          errors.add :base, 'Source or Comment should be present'
+        end
+      end
+
+      def generate_transaction_id
+        begin
+          self.transaction_id = (Time.current.strftime("%s") + rand(999999).to_s).to(15)
+        end while Spree::LoyaltyPointsTransaction.where(transaction_id: transaction_id).present?
+      end
+
+      def transactions_total_range
+        validate_transactions_total_range(transaction_type, source)
+      end
+
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,33 @@
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.include Spree::LoyaltyPoints
+      base.include Spree::Order::LoyaltyPoints
+
+      base.has_many :loyalty_points_transactions, as: :source
+      base.has_many :loyalty_points_credit_transactions, as: :source
+      base.has_many :loyalty_points_debit_transactions, as: :source
+
+      base.scope :loyalty_points_not_awarded, -> {
+        includes(:loyalty_points_credit_transactions).where(spree_loyalty_points_transactions: { source_id: nil })
+      }
+
+      base.scope :with_hours_since_payment, ->(num) {
+        where('`spree_orders`.`paid_at` < ? ', num.hours.ago)
+      }
+
+      base.scope :with_uncredited_loyalty_points, ->(num) {
+        with_hours_since_payment(num).loyalty_points_not_awarded
+      }
+
+      # FSM transitions
+      base.state_machines[:state].after_transition(
+        from: base.state_machines[:state].states.map(&:name) - [:complete],
+        to: [:complete],
+        do: :complete_loyalty_points_payments
+      )
+    end
+  end
+end
+
+Spree::Order.prepend(Spree::OrderDecorator)

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,38 @@
+module Spree
+  module PaymentDecorator
+    def self.prepended(base)
+      base.include Spree::LoyaltyPoints
+      base.include Spree::Payment::LoyaltyPoints
+
+      base.validates :amount, numericality: { greater_than: 0 }, if: :by_loyalty_points?
+      base.validate :redeemable_user_balance, if: :by_loyalty_points?
+      base.scope :state_not, ->(s) { where('state != ?', s) }
+
+      fsm = base.state_machines[:state]
+      fsm.after_transition from: fsm.states.map(&:name) - [:completed], to: [:completed], do: :notify_paid_order
+      fsm.after_transition from: fsm.states.map(&:name) - [:completed], to: [:completed], do: :redeem_loyalty_points, if: :by_loyalty_points?
+      fsm.after_transition from: [:completed], to: fsm.states.map(&:name) - [:completed], do: :return_loyalty_points, if: :by_loyalty_points?
+    end
+
+    private
+
+    def invalidate_old_payments
+      return if store_credit? || by_loyalty_points?
+      order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+        payment.invalidate! unless payment.store_credit?
+      end
+    end
+
+    def notify_paid_order
+      if all_payments_completed?
+        order.touch :paid_at
+      end
+    end
+
+    def all_payments_completed?
+      order.payments.state_not('invalid').all? { |payment| payment.completed? }
+    end
+  end
+end
+
+Spree::Payment.prepend Spree::PaymentDecorator if Spree::Payment.included_modules.exclude?(Spree::PaymentDecorator)