update products when sales is disabled

.gitignore

@@ -9,3 +9,4 @@ nbproject
 *.swp
 spec/dummy
 .rvmrc
+Gemfile.lock

README.md

@@ -21,7 +21,7 @@ In your Gemfile add the following for the latest released version:
 
 _OR_ to work from master:
 
-    gem 'spree_sale_pricing', :git => 'git://github.com/jpstokes/spree-sale-pricing.git'
+    gem 'spree_sale_pricing', :git => 'git://github.com/deseretbook/spree_sale_pricing.git'
 
 Install the Gem:
 

app/controllers/spree/admin/sale_prices_controller.rb

@@ -1,19 +1,19 @@
 module Spree
   module Admin
     class SalePricesController < BaseController
-
-      before_filter :load_product
-
+      before_filter :load_product_and_variant
+      after_filter :update_product, only: [:create, :destroy]
       respond_to :js, :html
 
-      # Show all sale prices for a product
       def index
-        @sale_prices = @product.sale_prices
+        @sale_price = Spree::SalePrice.new
+        @sale_prices = @variant.sale_prices
       end
 
       # Create a new sale price
       def create
-        @sale_price = @product.put_on_sale params[:sale_price][:value], sale_price_params
+        @sale_price = @variant.put_on_sale(sale_price_params[:value], sale_price_params[:start_at], sale_price_params[:end_at])
+        logger.debug @sale_price.inspect
         respond_with(@sale_price)
       end
 
@@ -27,22 +27,21 @@ def destroy
 
       private
 
-        # Load the product as a before filter. Redirect to the referer if no product is found
-        def load_product
-          @product = Spree::Product.find_by(slug: params[:product_id])
-          redirect_to request.referer unless @product.present?
-        end
-
-        # Sale price params
-        def sale_price_params
-          params.require(:sale_price).permit(
-            :id,
-            :value,
-            :start_at,
-            :end_at,
-            :enabled
-          )
-        end
+      # Load the variant as a before filter. Redirect to the referer if no product is found
+      def load_product_and_variant
+        @product = Spree::Product.find_by(slug: params[:product_id])
+        @variant = @product.variants_including_master.find(params[:variant_id])
+        redirect_to request.referer unless @variant
+      end
+
+      # Sale price params
+      def sale_price_params
+        params.require(:sale_price).permit(:id, :value, :start_at, :end_at, :enabled)
+      end
+
+      def update_product
+        @product.touch
+      end
 
     end
   end

app/helpers/spree/products_helper_decorator.rb

@@ -1,5 +1,11 @@
 def discount_percentage(product)
-  if product.master.msrp.present?
-    "#{((1 - product.price.to_f / product.master.msrp.to_f) * 100).round}%"
+  if product.master.msrp.present? && (product.master.msrp.to_f > product.price.to_f)
+    "#{((1 - product.price.to_f / product.master.msrp.to_f) * 100).round}"
+  else
+    '0'
   end
 end
+
+def discount_percentage_variant(variant)
+  variant.display_discount
+end

app/models/spree/calculator/percent_on_line_item_msrp.rb

@@ -0,0 +1,26 @@
+module Spree
+  class Calculator
+    class PercentOnLineItemMsrp < Calculator
+      preference :percent, :decimal, default: 0
+
+      def self.description
+        Spree.t(:percent_per_item_msrp)
+      end
+
+      def compute(object)
+        variant = object.variant
+        sale_percent = 0
+
+        if variant.msrp.present? && (variant.msrp.to_f > 0)
+          sale_percent = ((1 - ((variant.price.instance_of?(BigDecimal) || variant.price.instance_of?(Float)) ? variant.price.to_f : variant.price.amount.to_f) / variant.msrp.to_f) * 100).round
+        end
+
+        if preferred_percent < sale_percent
+          return 0
+        end
+
+        ((variant.msrp * object.quantity) * (preferred_percent - sale_percent)) / 100
+      end
+    end
+  end
+end

app/models/spree/order_updater_decorator.rb

@@ -0,0 +1,8 @@
+Spree::OrderUpdater.class_eval do
+
+  def update_item_total
+    order.item_total = line_items.sum('price * quantity')
+    update_order_total
+  end
+
+end

app/models/spree/price_decorator.rb

@@ -1,37 +1,34 @@
 Spree::Price.class_eval do
-
   has_many :sale_prices
-
-  def put_on_sale value, params={}
-    new_sale(value, params).save
-  end
 
-  def new_sale value, params={}
-    calculator_type = params[:calculator_type] || Spree::Calculator::DollarAmountSalePriceCalculator.new
-    start_at = params[:start_at] || Time.now
-    end_at = params[:end_at] || nil
-    enabled = params[:enabled] || true
+  # TODO also accept a class reference for calculator type instead of only a string
+  def put_on_sale(value, calculator_type = "Spree::Calculator::DollarAmountSalePriceCalculator", start_at = Time.now, end_at = nil, enabled = true)
+    new_sale(value, calculator_type, start_at, end_at, enabled).save
+  end
+  alias :create_sale :put_on_sale
 
-    sale_price = sale_prices.new({ value: value, start_at: start_at, end_at: end_at, enabled: enabled, calculator: calculator_type })
+  def new_sale(value, calculator_type = "Spree::Calculator::DollarAmountSalePriceCalculator", start_at = Time.now, end_at = nil, enabled = true)
+    sale_price = sale_prices.new({ value: value, start_at: start_at, end_at: end_at, enabled: enabled })
+    sale_price.calculator_type = calculator_type
     sale_price
   end
-  
+
   # TODO make update_sale method
 
   def active_sale
-    on_sale? ? first_sale(sale_prices.active) : nil
+    on_sale? ? lowest_sale(sale_prices.active) : nil
   end
   alias :current_sale :active_sale
 
   def next_active_sale
-    sale_prices.present? ? first_sale(sale_prices) : nil
+    sale_prices.present? ? lowest_sale(sale_prices) : nil
   end
   alias :next_current_sale :next_active_sale
 
   def sale_price
     on_sale? ? active_sale.price : nil
   end
-  
+
   def sale_price=(value)
     on_sale? ? active_sale.update_attribute(:value, value) : put_on_sale(value)
   end
@@ -41,25 +38,35 @@ def discount_percent
   end
 
   def on_sale?
-    sale_prices.active.present? && first_sale(sale_prices.active).value != original_price
+    sale_prices.active.present? && lowest_sale(sale_prices.active).value != original_price
   end
 
   def original_price
     self[:amount]
   end
-  
+
   def original_price=(value)
     self.price = value
   end
-  
+
   def price
     on_sale? ? sale_price : original_price
   end
-  
+
   def amount
     price
   end
 
+
+
+  def display_original_price
+    Spree::Money.new(self[:amount] || 0, { currency: currency })
+  end
+  def display_sale_price
+    Spree::Money.new(amount || 0, { currency: currency })
+  end
+
+
   def enable_sale
     return nil unless next_active_sale.present?
     next_active_sale.enable
@@ -79,10 +86,10 @@ def stop_sale
     return nil unless active_sale.present?
     active_sale.stop
   end
-  
-  private 
-  
-  def first_sale(scope)
-    scope.order("created_at DESC").first
+
+  private
+
+  def lowest_sale(scope)
+    scope.order("value ASC").first
   end
 end

app/models/spree/product_decorator.rb

@@ -1,21 +1,15 @@
 Spree::Product.class_eval do
-
-  has_many :sale_prices, through: :prices
-
   # Essentially all read values here are delegated to reading the value on the Master variant
   # All write values will write to all variants (including the Master) unless that method's all_variants parameter is set to false, in which case it will only write to the Master variant
 
   delegate_belongs_to :master, :active_sale_in, :current_sale_in, :next_active_sale_in, :next_current_sale_in,
                       :sale_price_in, :on_sale_in?, :original_price_in, :discount_percent_in, :sale_price,
-                      :original_price, :on_sale?
-
+                      :original_price, :on_sale?, :display_original_price, :display_sale_price
 
 
   # TODO also accept a class reference for calculator type instead of only a string
-  def put_on_sale value, params={}
-    all_variants = params[:all_variants] || true
-
-    run_on_variants(all_variants) { |v| v.put_on_sale(value, params) }
+  def put_on_sale(value, calculator_type = "Spree::Calculator::DollarAmountSalePriceCalculator", all_variants = true, start_at = Time.now, end_at = nil, enabled = true)
+    run_on_variants(all_variants) { |v| v.put_on_sale(value, calculator_type, true, start_at, end_at, enabled) }
   end
   alias :create_sale :put_on_sale
 

app/models/spree/sale_price.rb

@@ -1,15 +1,18 @@
 module Spree
   class SalePrice < ActiveRecord::Base
-
     # TODO validations
     belongs_to :price, :class_name => "Spree::Price"
     has_one :calculator, :class_name => "Spree::Calculator", :as => :calculable, :dependent => :destroy
-
     accepts_nested_attributes_for :calculator
-
     validates :calculator, :presence => true
 
-    scope :active, -> { where(enabled: true).where('(start_at <= ? OR start_at IS NULL) AND (end_at >= ? OR end_at IS NULL)', Time.now, Time.now) }
+    after_save :refresh_product_document
+
+    #attr_accessible :value, :start_at, :end_at, :enabled
+
+    scope :active, lambda {
+      where("enabled = 't' AND (start_at <= ? OR start_at IS NULL) AND (end_at >= ? OR end_at IS NULL)", Time.now, Time.now)
+    }
 
     # TODO make this work or remove it
     #def self.calculators
@@ -20,6 +23,11 @@ def calculator_type
       calculator.class.to_s if calculator
     end
 
+    def calculator_type=(calculator_type)
+      clazz = calculator_type.constantize if calculator_type
+      self.calculator = clazz.new if clazz and not self.calculator.is_a? clazz
+    end
+
     def price
       calculator.compute self
     end
@@ -43,9 +51,11 @@ def stop
       update_attributes({ end_at: Time.now, enabled: false })
     end
 
-    # Convenience method for displaying the price of a given sale_price in the table
-    def display_price
-      Spree::Money.new(value, {currency: Spree::Config[:currency]})
+
+    def refresh_product_document
+      _price = Spree::Price.where(id: self.price_id).first
+      _price.variant.product.save unless _price.nil?
     end
+
   end
 end

app/models/spree/variant_decorator.rb

@@ -2,11 +2,12 @@
 
   has_many :sale_prices, through: :prices
 
-  delegate_belongs_to :default_price, :sale_price, :original_price, :on_sale?
+  delegate_belongs_to :default_price, :sale_price, :original_price, :on_sale?,
+                      :display_original_price, :display_sale_price
 
-  def put_on_sale value, params={}
-    all_currencies = params[:all_variants] || true    
-    run_on_prices(all_currencies) { |p| p.put_on_sale value, params }
+  # TODO also accept a class reference for calculator type instead of only a string
+  def put_on_sale(value, start_at = Time.now, end_at = nil, enabled = true, all_currencies = true, calculator_type = "Spree::Calculator::DollarAmountSalePriceCalculator")
+    run_on_prices(all_currencies) { |p| p.put_on_sale value, calculator_type, start_at, end_at, enabled }
   end
   alias :create_sale :put_on_sale
 
@@ -25,11 +26,32 @@ def next_active_sale_in(currency)
   def sale_price_in(currency)
     Spree::Price.new variant_id: self.id, currency: currency, amount: price_in(currency).sale_price
   end
-
+
+  # Returns true if the product is discounted by an amount that rounds to at least 1%
+  def discounted?
+    begin
+      price = self.price.respond_to?(:to_f) ? self.price.to_f : self.price.amount.to_f
+      msrp = self.msrp.try(:to_f)
+
+      msrp && self.price && ((1 - price / msrp) * 100).round > 0
+    rescue
+      false
+    end
+  end
+
   def discount_percent_in(currency)
     price_in(currency).discount_percent
   end
-
+
+  # Returns a String with the discounted percentage between #price and #msrp.
+  def display_discount
+    if discounted?
+      "#{((1 - price / msrp) * 100).round}"
+    else
+      '0'
+    end
+  end
+
   def on_sale_in?(currency)
     price_in(currency).on_sale?
   end
@@ -53,14 +75,14 @@ def start_sale(end_time = nil, all_currencies = true)
   def stop_sale(all_currencies=true)
     run_on_prices(all_currencies) { |p| p.stop_sale }
   end
-  
+
   private
-   
+
   def run_on_prices(all_currencies, &block)
     if all_currencies && prices.present?
       prices.each { |p| block.call p }
     else
-      block.call default_price  
+      block.call default_price
     end
   end
-end
+end

app/overrides/add_original_price_to_orders_item_added.rb

@@ -0,0 +1,5 @@
+Deface::Override.new(virtual_path: "spree/orders/item_added",
+                     name: "add_original_price_to_orders_item_added",
+                     replace_contents: "p.listing-price",
+                     partial: "spree/shared/original_price_display_item_added",
+                     disabled: false)