spree_loyalty_points 1.0.0

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,68 @@
+Spree Loyalty Points
+====================
+
+This extension adds Loyalty Points for users.
+
+
+Installation
+------------
+
+Add spree_loyalty_points to your Gemfile:
+
+```ruby
+gem 'spree_loyalty_points', '~> 1.0.0'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bundle exec rails g spree_loyalty_points:install
+bundle exec rake db:migrate
+```
+
+Usage
+-----
+
+From Admin end, create a payment method of LoyaltyPoints type for payment with Loyalty Points.
+
+Go to the Admin end of the website and open the Configurations Tab. Set up the values for the following Loyalty Points Settings under General Settings:
+
+* Minimum Amount to be spent per Order(Item Total, excluding Shipping and any other Charges) to award Loyalty Points : This is the minimum amount the user has to spend on an order to receive Loyalty Points for that order
+* Number of Loyalty Points to be awarded per Unit Amount Spent : Loyalty Points to be awarded against Unit Amount spent on Order
+* Minimum Loyalty Points Balance Required for Redeeming : Minimum Loyalty Points Balance a user should have for spending Loyalty Points
+* Loyalty Point to Amount Conversion Rate : Conversion Rate for getting Amount equivalent value of Loyalty Points
+* Time(in hours) after payment to award Loyalty Points : Time period to wait from the time payment is received for the order to award Loyalty Points
+
+After an order's payment is received, Loyalty Points will be awarded (only after the Time period specified in the above setting) when you run the rake task.
+Add a Cron Job to run the following Rake Task to Award Loyalty Points to Users:
+
+```shell
+bundle exec rake spree:loyalty_points:award
+```
+
+Testing
+-------
+
+Be sure to bundle your dependencies and then create a dummy test app for the specs to run against.
+
+```shell
+bundle
+bundle exec rake test_app
+bundle exec rspec spec
+```
+
+When testing your applications integration with this extension you may use it's factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'spree_loyalty_points/factories'
+```
+
+
+Credits
+-------
+
+[![vinsol.com: Ruby on Rails, iOS and Android developers](http://vinsol.com/vin_logo.png "Ruby on Rails, iOS and Android developers")](http://vinsol.com)
+
+Copyright (c) 2014 [vinsol.com](http://vinsol.com "Ruby on Rails, iOS and Android developers"), released under the New MIT License

data/app/assets/javascripts/admin/spree_loyalty_points.js

@@ -0,0 +1,83 @@
+//= require admin/spree_backend
+
+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>').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/javascripts/store/spree_loyalty_points.js

@@ -0,0 +1 @@
+//= require store/spree_frontend

data/app/assets/stylesheets/admin/spree_loyalty_points.css

@@ -0,0 +1,3 @@
+/*
+ *= require admin/spree_backend
+*/

data/app/assets/stylesheets/store/spree_loyalty_points.css

@@ -0,0 +1,13 @@
+/*
+ *= require store/spree_frontend
+*/
+
+#loyalty-points-info {
+  border: 1px solid #D9D9DB;
+  margin-bottom: 15px;
+  padding: 10px;
+}
+
+#loyalty-points-info dd {
+    margin-left: 0;
+}

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

@@ -0,0 +1,17 @@
+Spree::Admin::GeneralSettingsController.class_eval do
+
+  before_action :set_loyalty_points_settings, only: [:edit]
+
+  private
+
+    def set_loyalty_points_settings
+      @preferences_loyalty_points = {
+        :min_amount_required_to_get_loyalty_points => [""],
+        :loyalty_points_awarding_unit => ["For example: Set this as 10 if we wish to award 10 points for $1 spent on the site."],
+        :loyalty_points_redeeming_balance => [""],
+        :loyalty_points_conversion_rate => ["For example: Set this value to 5 if we wish 1 loyalty point is equivalent to $5"],
+        :loyalty_points_award_period => [""]
+      }
+    end
+
+end

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

@@ -0,0 +1,80 @@
+class Spree::Admin::LoyaltyPointsTransactionsController < Spree::Admin::ResourceController
+  before_action :set_user, only: [:order_transactions]
+  belongs_to 'spree/user'
+  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_to do |format|
+      format.json do
+        render json: @loyalty_points_transactions.to_json(
+          :include => {
+            :source => {
+              :only => [:id, :number]
+            }
+          },
+          :only => [:source_type, :comment, :updated_at, :loyalty_points, :balance],
+          :methods => [:transaction_type]
+        )
+      end
+    end
+  end
+
+  def create
+    invoke_callbacks(:create, :before)
+    @object.attributes = loyalty_points_transaction_params
+    if @object.save
+      invoke_callbacks(:create, :after)
+      flash[:success] = flash_message_for(@object, :successfully_created)
+      respond_with(@object) do |format|
+        format.html { redirect_to location_after_save }
+        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.find_by(id: params[:user_id])
+        redirect_to admin_users_path, notice: 'User 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?
+        admin_users_url
+      else
+        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::Config[:orders_per_page])
+    end
+
+end

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

@@ -0,0 +1,21 @@
+Spree::Admin::ResourceController.class_eval do
+  
+  protected
+
+    def parent
+      if parent_data.present?
+        @parent ||= parent_data[:model_class].send("find_by_#{parent_data[:find_by]}", params["#{model_name}_id"])
+        raise ActiveRecord::RecordNotFound unless @parent
+        instance_variable_set("@#{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

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

@@ -0,0 +1,11 @@
+Spree::Admin::ReturnAuthorizationsController.class_eval do
+  before_action :set_loyalty_points_transactions, only: [:new, :edit, :create, :update]
+
+  private
+
+    def set_loyalty_points_transactions
+      @loyalty_points_transactions = @return_authorization.order.loyalty_points_transactions.
+        page(params[:page]).
+        per(params[:per_page] || Spree::Config[:orders_per_page])
+    end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,17 @@
+module Spree
+  CheckoutController.class_eval do
+    before_filter :sufficient_loyalty_points, only: [:update], if: -> { params[:state] == 'payment' }
+
+    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 checkout_state_path(@order.state)
+        end
+      end
+  end
+end

data/app/controllers/spree/loyalty_points_controller.rb

@@ -0,0 +1,9 @@
+class Spree::LoyaltyPointsController < Spree::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::Config[:orders_per_page])
+  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::Config.loyalty_points_awarding_unit).floor
+      elsif purpose == 'redeem'
+        (amount / Spree::Config.loyalty_points_conversion_rate).ceil
+      else
+        0
+      end
+    end
+
+    def eligible_for_loyalty_points?(amount)
+      amount >= Spree::Config.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 < ActiveRecord::Base
+    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::Config.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,39 @@
+require 'active_support/concern'
+
+module Spree
+  class Payment < ActiveRecord::Base
+    module LoyaltyPoints
+      extend ActiveSupport::Concern
+
+        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')
+          if by_loyalty_points? && redeemable_loyalty_points_balance?
+            order.create_debit_transaction(loyalty_points_redeemed)
+          end
+        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?
+          amount >= Spree::Config.loyalty_points_redeeming_balance
+        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/app_configuration_decorator.rb

@@ -0,0 +1,8 @@
+#TODO -> Rspecs for this model.
+Spree::AppConfiguration.class_eval do
+  preference :min_amount_required_to_get_loyalty_points, :decimal, :default => 20.0
+  preference :loyalty_points_awarding_unit, :decimal, :default => 0.0
+  preference :loyalty_points_redeeming_balance, :integer, :default => 50
+  preference :loyalty_points_conversion_rate, :decimal, :default => 5.0
+  preference :loyalty_points_award_period, :integer, :default => 1
+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,45 @@
+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
+    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? }
+
+    #TODO -> rspecs missing for this scope
+    scope :for_order, ->(order) { where(source: order) }
+
+    #TODO -> Rspecs missing for this callback.
+    before_create :generate_transaction_id
+
+    #TODO -> Rspecs missing for this method.
+    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,18 @@
+Spree::Order.class_eval do
+  include Spree::LoyaltyPoints
+  include Spree::Order::LoyaltyPoints
+
+  has_many :loyalty_points_transactions, as: :source
+  has_many :loyalty_points_credit_transactions, as: :source
+  has_many :loyalty_points_debit_transactions, as: :source
+
+  scope :loyalty_points_not_awarded, -> { includes(:loyalty_points_credit_transactions).where(:spree_loyalty_points_transactions => { :source_id => nil } ) }
+
+  scope :with_hours_since_payment, ->(num) { where('`spree_orders`.`paid_at` < ? ', num.hours.ago) }
+
+  scope :with_uncredited_loyalty_points, ->(num) { with_hours_since_payment(num).loyalty_points_not_awarded }
+
+  fsm = self.state_machines[:state]
+  fsm.before_transition :from => fsm.states.map(&:name) - [:complete], :to => [:complete], :do => :complete_loyalty_points_payments
+
+end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,34 @@
+Spree::Payment.class_eval do
+
+  include Spree::LoyaltyPoints
+  include Spree::Payment::LoyaltyPoints
+
+  validates :amount, numericality: { greater_than: 0 }, :if => :by_loyalty_points?
+  scope :state_not, ->(s) { where('state != ?', s) }
+  scope :by_loyalty_points, -> { joins(:payment_method).readonly(false).where(:spree_payment_methods => { type: 'Spree::PaymentMethod::LoyaltyPoints'}) }
+
+  fsm = self.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?
+
+  def invalidate_old_payments
+    order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+      payment.invalidate!
+    end unless by_loyalty_points?
+  end
+
+  private
+
+    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