solidus_sale_pricing 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43f2552daf03ea9d96228ae50b12181d542a6ddc
+  data.tar.gz: d0507eccc04923af5cb7cc8c7b775d3feb8706ec
+SHA512:
+  metadata.gz: a011d0c4fb2e6d7294b15f475eb8e9a4760e55773c4e797bc75ee18d89b49e95b898e29094eafb77eb3160b55fc8ef472aea7ea38f1fc95766f2fa88f73f7cdc
+  data.tar.gz: a5a39ca9f034a2be81c354df766adf22ce0b66925d8f5fc99325a39536e3ab2485de83de53b958af80bbe64b557c9b7562fc64f366a1dbccd1c204c8eee054de

data/.gitignore

@@ -0,0 +1,14 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+
+branch = ENV.fetch('SOLIDUS_BRANCH', 'master')
+gem 'solidus', github: 'solidusio/solidus', branch: branch
+gem 'solidus_auth_devise'
+
+if branch == 'master' || branch >= 'v2.0'
+  gem 'rails-controller-testing', group: :test
+else
+  gem 'rails_test_params_backport', group: :test
+  gem 'rails', '~> 4.2.7'
+end
+
+gem 'pg'
+gem 'mysql2'
+
+group :development, :test do
+  gem 'pry-rails'
+  gem 'pry-byebug'
+  gem 'vcr'
+  gem 'webmock'
+  gem 'timecop'
+end
+
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016 [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 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,173 @@
+Solidus Sale Pricing
+=======================
+
+Based on https://github.com/jonathandean/spree-sale-pricing.
+
+New changes
+===========
+
+- Added backend interface
+- Added missing methods
+
+Solidus Sale Pricing
+==================
+
+A Solidus extension (Rails Engine) that lets you set sale prices on products, either by a fixed sale price or a
+percentage off of the original price. Sale prices have a start date, end date and enabled flag to allow you to schedule
+sales, have a historical record of sale prices and put sales on hold.
+
+Installing
+----------
+
+In your `Gemfile` add the following for the latest released version:
+```ruby
+gem 'solidus_sale_pricing'
+```
+
+_OR_ to work from master:
+```ruby
+gem 'solidus_sale_pricing', :git => 'git://github.com/jtapia/solidus_sale_pricing.git'
+```
+
+Install the Gem:
+```sh
+bundle install
+```
+
+Copy the migrations in your app:
+```sh
+bundle exec rake railties:install:migrations
+```
+
+Run database migrations in your app:
+```sh
+bundle exec rake db:migrate
+```
+
+Usage
+-----
+
+Simple example assuming you have a product in your database with the price of $20 and you want to put it on sale
+immediately for $10:
+```ruby
+product = Spree::Product.first
+
+puts product.price.to_f              # => 20.0
+puts product.on_sale?                # => false
+
+product.put_on_sale 10
+
+puts product.price.to_f              # => 10.0
+puts product.original_price.to_f     # => 20.0
+puts product.on_sale?                # => true
+```
+
+By default it uses the supplied Spree::Calculator::DollarAmountSalePriceCalculator which essentially just returns the
+value you give it as the sale price.
+
+You can also give a certain percentage off by specifying that you want to use Spree::Calculator::PercentOffSalePriceCalculator.
+Note that the percentage is given as a float between 0 and 1, not the integer amount from 0 to 100.
+```ruby
+product.put_on_sale 0.2, "Spree::Calculator::PercentOffSalePriceCalculator"
+puts product.price.to_f              # => 16.0
+```
+
+This extension gives you all of the below methods on both your Products and Variants. If accessed on the Product when reading values,
+it will return values from your Master variant. If accessed on the Product when writing values, it will by default update
+all variants including the master variants. If you change the all_variants parameter to false, it will only then write to
+the master variant and leave the other variants untouched.
+
+**price**                                             Returns the sale price if currently on sale, the original price if not
+
+**sale_price**                                        Returns the sale price if currently on sale, nil if not
+
+**original_price**                                    Always returns the original price
+
+**on_sale?**                                          Return a boolean indication if it is currently on sale (enabled is set to true and we are currently within the active date range)
+
+**put\_on\_sale(value[, ...])**                       Put this item on sale (see below sections for options and more information)
+
+**create_sale**                                       Alias of ```put_on_sale```
+
+**active_sale**                                       Returns the currently active sale (Spree::SalePrice object) that price and sale_price will use. If there is more than one potentially active sale, the one with the latest created_at timestamp is used. See the section on "Multiple active sales" for the reasoning behind that.
+
+**current_sale**                                      Alias of ```active_sale```
+
+**next_active_sale**                                  Currently returns the latest created Spree::SalePrice object (active or not.) The name is kind of misleading so it should probably be changed. We may also want to make this only return the latest created inactive sale, since that's kind of the original intention of it to be used inside of ```enable_sale``` and ```start_sale```. Needs more thought.
+
+**next_current_sale**                                 Alias of ```next_active_sale```
+
+**enable_sale(all_variants = true)**                  Enable the sale returned by ```next_active_sale``` by setting that Spree::SalePrice object's enabled flag to true. Does not change the start and end dates so it does not necessary mean that the sale will then become active. Therefore, you can enable a sale in this manner and still have it not take effect on the site. (Use ```start_sale``` for that) _Note:_ The all_variants flag is only available on Spree::Product (not on Spree::Variant)
+
+**disable_sale(all_variants = true)**                 Disable the sale returned by ```active_sale``` by setting that Spree::SalePrice object's enabled flag to false. This always makes the sale inactive, regardless of the date range. _Note:_ The all_variants flag is only available on Spree::Product (not on Spree::Variant)
+
+**start_sale(end_time = nil, all_variants = true)**   Start the sale returned by ```next_active_sale``` (and make it active) by setting that Spree::SalePrice object's enabled flag to true and ensuring that the current time is in between the start and end dates. _Note:_ The all_variants flag is only available on Spree::Product (not on Spree::Variant)
+
+**stop_sale(all_variants = true)**                    Stop the sale returned by ```active_sale``` by setting that Spree::SalePrice object's enabled flag to false and the end date to the current time. _Note:_ The all_variants flag is only available on Spree::Product (not on Spree::Variant)
+
+Since you have these methods available to both your products and variants, it is possible to put the product and all
+variants on sale or just particular variants. See the explanation of put\_on\_sale below for more information.
+
+
+Options for put\_on\_sale (create_sale)
+---------------------------------------
+```ruby
+put_on_sale(value, calculator_type = "Spree::Calculator::DollarAmountSalePriceCalculator", all_variants = true, start_at = Time.now, end_at = nil, enabled = true)
+```
+**value**           (_float_)
+
+This is either the sale price that you want to sell the product for (if using the default DollarAmountSalePriceCalculator)
+or the float representation of the percentage off of the original price (between 0 and 1)
+
+**calculator_type** (_string_)    - Default: **"Spree::Calculator::DollarAmountSalePriceCalculator"**
+
+Specify which calculator to use for determining the sale price. The default calculator will take the value as is and use it
+as the sale price. You can also pass in another calculator value to determine the sale price differently, such as the
+provided "Spree::Calculator::PercentOffSalePriceCalculator", which will take a given percentage off of the original
+price.
+
+**all_variants**    (_boolean_)   - Default: **true**
+
+_Only for Spree::Product_. By default it set all of variants (including the master variant) for the product on sale. If you change this value to false
+it will only put the master variant on sale. Only change this if you know the implications.
+
+**start_at**        (_DateTime or nil_)  - Default: **Time.now**
+
+Specify the date and time that the sale takes effect. By default it uses the current time. It can also be nil but it's not
+recommended because for future reporting reasons you will probably want to know exactly when the sale started.
+
+**end_at**          (_DateTime or nil_)  - Default: **nil**
+
+Specify the end date of the sale or nil to keep the sale running indefinitely. For future reporting reasons it's recommended
+to set this at the time you decide to deactivate the sale rather than just setting enabled to false.
+
+**enabled**         (_boolean_)   - Default: **true**
+
+Disable this sale temporarily by setting this to false (overrides the start_at and end_at range). It's not recommended to
+use this to stop the sale when you decide to end it because it could impact future reporting needs. It's mainly intended
+to keep the sale disabled while you are still working on it and it isn't quite ready, or if you need to disable temporarily
+for some reason in the middle of a sale.
+
+Multiple active sales
+---------------------
+
+Technically you can have more than one active sale at a time. However, because
+Solidus is going to use product.price or
+variant.price throughout (with no additional parameters or means to identify a particular sale), we have to consistently
+work with a single sale price so that the customer is always charged the same price as they see on the site. What we do then
+is always take the last created sale price. We do this so that if you want to temporarily make a new sale to override a
+currently running one, you just add a new active sale. Then when that new sale ends, the old sale will be in effect again
+(provided it's still active, of course.) So you can add more than one active sale but only one will actually be used at
+a given time.
+
+Testing
+-------
+
+Tests are in progress, so there aren't any yet. I know, TDD, blah blah blah.
+
+Be sure to bundle your dependencies and then create a dummy test app for the specs to run against.
+```sh
+$ bundle
+$ bundle exec rake test app
+$ bundle exec rspec spec
+```

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir["spec/dummy"].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir("../../")
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'solidus_sale_pricing'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/javascripts/spree/backend/solidus_sale_pricing.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_sale_pricing.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_sale_pricing.css

@@ -0,0 +1,13 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/
+
+table th .actions [class*='fa-'].stop:hover, td .actions [class*='fa-'].stop:hover {
+  background-color: #C60F13;
+  color: #FFFFFF;
+}
+
+table th .actions [class*='fa-'].stop:active, td .actions [class*='fa-'].stop:active {
+  color: #C60F13;
+}

data/app/assets/stylesheets/spree/frontend/solidus_sale_pricing.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/admin/product_controller_decorator.rb

@@ -0,0 +1,10 @@
+module Spree
+  module Admin
+    ProductsController.class_eval do
+      def create_sale
+        # if @product.create_sale()
+        # @relation_types = Spree::Product.relation_types
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Spree
+  module Admin
+    class SalePricesController < ResourceController
+      before_action :load_data
+      before_action :load_sale_price, only: [:update, :destroy]
+
+      def index
+        @sale_prices = @product.sale_prices
+      end
+
+      def create
+        begin
+          @product.create_sale(sale_price_params)
+          flash[:success] = Spree.t(:sale_price_successfully_created)
+          redirect_to admin_product_sale_prices_path(@product)
+        rescue => e
+          flash[:error] = Spree.t(:error_on_create)
+          render :new
+        end
+      end
+
+      def update
+        if @sale_price.update(sale_price_params)
+          flash.now[:success] = Spree.t(:sale_price_successfully_updated)
+        else
+          flash.now[:error] = Spree.t(:error_on_update)
+        end
+
+        render :edit
+      end
+
+      def stop
+        if @product.stop_sale
+          flash[:success] = Spree.t(:sale_price_stopped)
+
+          respond_with(@product) do |format|
+            format.html { redirect_to admin_product_sale_prices_path(@product) }
+            format.js { redirect_to admin_product_sale_prices_path(@product) }
+          end
+        end
+      end
+
+      def enable
+        if @product.enable_sale
+          flash[:success] = Spree.t(:sale_price_enabled)
+
+          respond_with(@product) do |format|
+            format.html { redirect_to admin_product_sale_prices_path(@product) }
+            format.js { redirect_to admin_product_sale_prices_path(@product) }
+          end
+        end
+      end
+
+      private
+
+      def sale_price_params
+        params.require(:sale_price).permit(permitted_sale_price_attributes)
+      end
+
+      def permitted_sale_price_attributes
+        [ :value, :start_at, :end_at, :caclulator_type ]
+      end
+
+      def load_data
+        @product ||= Spree::Product.friendly.find(params[:product_id])
+      end
+
+      def load_sale_price
+        @sale_price ||= Spree::SalePrice.find(params[:id])
+      end
+    end
+  end
+end

data/app/helpers/spree/base_helper_decorator.rb

@@ -0,0 +1,21 @@
+Spree::BaseHelper.class_eval do
+  def display_original_price(product_or_variant)
+    product_or_variant.original_price_in(current_currency).display_price.to_html
+  end
+
+  def display_discount_percent(product_or_variant, append_text = 'Off')
+    discount = product_or_variant.discount_percent_in current_currency
+
+    # number_to_percentage(discount, precision: 0).to_html
+
+    if discount > 0
+      return "#{number_to_percentage(discount, precision: 0).to_html} #{append_text}"
+    else
+      return ''
+    end
+  end
+
+  def format_date date
+    date.strftime('%Y-%m-%dT%H:%M:%S') if date
+  end
+end

data/app/models/spree/calculator/dollar_amount_sale_price_calculator.rb

@@ -0,0 +1,12 @@
+module Spree
+  class Calculator::DollarAmountSalePriceCalculator < Spree::Calculator
+    # TODO validate that the sale price is less than the original price
+    def self.description
+      'Calculates the sale price for a Variant by returning the provided fixed sale price'
+    end
+
+    def compute(sale_price)
+      sale_price.value
+    end
+  end
+end

data/app/models/spree/calculator/percent_off_sale_price_calculator.rb

@@ -0,0 +1,12 @@
+module Spree
+  class Calculator::PercentOffSalePriceCalculator < Spree::Calculator
+    # TODO validate that the sale price is between 0 and 1
+    def self.description
+      'Calculates the sale price for a Variant by taking off a percentage of the original price'
+    end
+
+    def compute(sale_price)
+      (1.0 - sale_price.value.to_f) * sale_price.variant.original_price.to_f
+    end
+  end
+end

data/app/models/spree/price_decorator.rb

@@ -0,0 +1,93 @@
+Spree::Price.class_eval do
+  has_many :sale_prices
+
+  # TODO also accept a class reference for calculator type instead of only a string
+  def put_on_sale(attrs={})
+    new_sale(attrs).save!
+  end
+  alias :create_sale :put_on_sale
+
+  def new_sale(attrs={})
+    sale_price = sale_prices.new({
+      value: attrs[:value],
+      start_at: attrs[:start_at] || Time.now,
+      end_at: attrs[:end_at],
+      enabled: attrs[:enabled] || true
+    })
+    sale_price.calculator_type = attrs[:calculator_type] || 'Spree::Calculator::DollarAmountSalePriceCalculator'
+    sale_price
+  end
+
+  def active_sale
+    on_sale? ? first_sale(sale_prices.active) : nil
+  end
+  alias :current_sale :active_sale
+
+  def next_active_sale
+    sale_prices.present? ? first_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
+
+  def discount_percent
+    on_sale? ? (1 - (sale_price / original_price)) * 100 : 0.0
+  end
+
+  def on_sale?
+    sale_prices.active.present? && first_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 enable_sale
+    return nil unless next_active_sale.present?
+    next_active_sale.enable
+  end
+
+  def disable_sale
+    return nil unless active_sale.present?
+    active_sale.disable
+  end
+
+  def start_sale(end_time = nil)
+    return nil unless next_active_sale.present?
+    next_active_sale.start(end_time)
+  end
+
+  def stop_sale
+    return nil unless active_sale.present?
+    active_sale.stop
+  end
+
+  def update_sale(attrs)
+    return nil unless active_sale.present?
+    active_sale.update(attrs)
+  end
+
+  private
+
+  def first_sale(scope)
+    scope.order("created_at DESC").first
+  end
+end