spree_enhanced_option_types 0.30.0

data/.gitignore

@@ -0,0 +1,9 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+tmp
+nbproject
+*.swp

data/LICENSE

@@ -0,0 +1,23 @@
+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 of the Rails Dog LLC 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.markdown

@@ -0,0 +1,126 @@
+# Enchanced Option Types
+
+Now supporting Spree 0.30.x !
+
+## Description
+
+This extension enchances spree functionality when handling products with
+numerous and complex variants.
+
+Following enchancements are provided:
+
+* Admin side:
+  * Selecting order of option types for prototype with drag & drop
+  * Optional "modifiers" for option values that can modify price of variant
+  * Option to generate set of variants from prototype with option types.
+    When option is selected during product creation, variants are created for
+    each combination of option values (eg. Sizes: [S,M,L], Colors: [Red, Blue]
+    will generate 6 variants), with prices calculated from sum of product base price
+    and amount of option_value modifiers.
+  * Option to regenerate variants when needed.
+  * Option to calculate variant price when creating new variant based on product
+    price and sum of modifiers from option values.
+* Client side variant selection:
+  * using x select boxes (1 for each option_type)
+  * using x sets of radio boxes grouped in fieldsets (one fieldset for each option type)
+  * using 2d table of radio boxes (only when there are only 2 option types!)
+* Javascript helpers:
+  * Instant updating of price based on variant selected using above methods
+  * Instand updating of number of on_hand units
+  * enabling/disabling options that don't have corresponding variant.
+  * products.js override (edge spree only) for working with variant images
+
+Some of the functionality might not work without javascript, but much work was put
+to make JS as unintrusive as possible, so It should be fairly easy excercise
+to make it completelly JS independent.
+
+## Credits
+
+Created by Marcin Raczkowski (marcin.raczkowski@gmail.com)
+
+2d table was inspired by Stephanie Powell [post](
+http://blog.endpoint.com/2009/12/rails-ecommerce-product-optioning-in.html)
+You can(and should!) read it.
+
+## Examples
+
+![Radiobox sets](/swistak/spree-enchanced-option-types/raw/master/doc/sets.jpg)
+![selects sets](/swistak/spree-enchanced-option-types/raw/master/doc/selects.jpg)
+![table](/swistak/spree-enchanced-option-types/raw/master/doc/2d.jpg)
+
+On first example you can see sets of radio boxes and modifiers in action,
+also notable is separation of base price and current(variant) price, only second one is updatable.
+
+Second one shows selects - it's much more compact then previous example,
+ but doesn't instantly show all options.
+
+Thrid shows the 2d table for variant choosing.
+
+## Instalation
+
+Add the following to your Gemfile:
+<code>gem 'spree_enhanced_option_types', :git => 'git://github.com/swistak/spree-enhanced-option-types.git'</code>
+
+Run:
+<code>bundle install</code>
+
+and:
+<code>rake spree_enhance_option_types:install</code>
+
+and finally:
+<code>rake db:migrate</code>
+
+## Customization
+
+User interface change is limited only to _cart_form partial from original spree.
+it was separated into several subfiles to make customization and embeding in custom layouts easier.
+
+There are no inline styles (except for 2d table, that absolutelly requires
+some wire frame styles to look sane), you can either use provided _cart_form
+partial as a replacement for generic spree partial, or you can roll your own and
+only include one of variant choosing partials.
+
+There are some special css classes you might be interested in:
+.price.update - price field that should be updated with new price value if variant changes.
+span.
+
+Source is extensivelly documented and I recomend reading it.
+
+## Limitations
+
+- currently there's no way to change order of option types AFTER product is created
+
+## TODO
+
+- gracefull handling non-js users.
+- test under other browsers then FF
+
+## License
+
+Copyright (c) 2009, Marcin Raczkowski
+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 of the Marcin Raczkowski 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,13 @@
+EnhancedOptionTypes
+===================
+
+Introduction goes here.
+
+
+Example
+=======
+
+Example goes here.
+
+
+Copyright (c) 2010 [name of extension creator], released under the New BSD License

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+spec = eval(File.read('enhanced_option_types.gemspec'))
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+desc "Release to gemcutter"
+task :release => :package do
+  require 'rake/gemcutter'
+  Rake::Gemcutter::Tasks.new(spec).define
+  Rake::Task['gem:push'].invoke
+end
+
+desc "Default Task"
+task :default => [ :spec ]
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format pretty}
+end

data/app/controllers/admin/prototypes_controller_decorator.rb

@@ -0,0 +1,21 @@
+Admin::PrototypesController.class_eval do
+  skip_after_filter :set_habtm_associations
+
+  reorder_option_types = lambda do
+    set_habtm_associations
+    @prototype.option_types_prototypes.each do |otp|
+      new_position = params[:option_type][:id].index(otp.option_type_id.to_s)
+      # Rails get crazy when table doesn't have PrimaryID,
+      # updates don't work, so we have to do them using update_all
+      OptionTypesPrototype.update_all({ # SET
+          :position => new_position
+        }, { #WHERE
+          :prototype_id => otp.prototype_id,
+          :option_type_id => otp.option_type_id
+        })
+    end
+  end
+  
+  update.after(&reorder_option_types)
+  create.after(&reorder_option_types)
+end

data/app/controllers/admin/variants_controller_decorator.rb

@@ -0,0 +1,8 @@
+Admin::VariantsController.class_eval do
+  def regenerate
+    product = Product.find_by_permalink(params[:product_id])
+    product.variants.delete_all
+    product.do_create_variants(:recreate)
+    redirect_to :action => :index, :product_id => params[:product_id]
+  end
+end

data/app/controllers/orders_controller_decorator.rb

@@ -0,0 +1,58 @@
+OrdersController.class_eval do
+
+  def populate
+    @order = current_order(true)
+
+    params[:products].each do |product_id,variant_id|
+      if !params[:quantity].is_a?(Hash)
+        quantity = params[:quantity].to_i
+      else
+        quantity = params[:quantity][variant_id].to_i
+      end
+      @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+    end if params[:products]
+
+    params[:variants].each do |variant_id, quantity|
+      quantity = quantity.to_i
+      @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+    end if params[:variants]
+
+    params[:option_values].each_pair do |product_id, otov|
+      if !params[:quantity].is_a?(Array)
+        quantity = params[:quantity].to_i
+      else
+        quantity = params[:quantity][variant_id].to_i
+      end
+      option_value_ids = otov.map{|option_type_id, option_value_id| option_value_id}
+      variant = Variant.by_option_value_ids(option_value_ids, product_id).first
+      @order.add_variant(variant, quantity) if quantity > 0
+    end if params[:option_values]
+
+    redirect_to cart_path
+
+    #    if quantity > 0 && variant
+    #      if quantity > variant.on_hand
+    #        flash[:error] = t(:stock_to_small) % [variant.on_hand]
+    #      else
+    #        @order.add_variant(variant, quantity)
+    #        if @order.save
+    #          # store order token in the session
+    #          session[:order_token] = @order.token
+    #        else
+    #          flash[:error] = t(:out_of_stock)
+    #        end
+    #      end
+    #    elsif quantity > 0
+    #      flash[:error] = t(:wrong_combination)
+    #    else
+    #      flash[:error] = t(:wrong_quantity)
+    #    end
+    #    if flash[:error].blank?
+    #      # redirect_to edit_order_url(@order)
+    #      redirect_to cart_path
+    #    else
+    #      redirect_to :back
+    #    end
+  end
+
+end

data/app/helpers/variant_selection.rb

@@ -0,0 +1,47 @@
+module VariantSelection
+  # Returns array of arrays of ids of option values,
+  # that represent all possible combinations of option _values
+  # sorted by option type position in that product.
+  def options_values_combinations(product)
+    product.variants.map{|v| # we get all variants from product
+      # then we take all option_values
+      v.option_values.sort_by{|ov|
+        # then sort them by position of option value in product
+        ProductOptionType.find(:first, :conditions => {
+            :option_type_id => ov.option_type_id,
+            :product_id => product.id
+          }).position
+      }.map(&:id) # and get the id
+    }
+  end
+
+  # Returns hash that maps _array of ids of option values_ to _variant attributes_,
+  #
+  # eg.
+  #
+  # { [1,2,3,4] => <Variant#1> }
+  #
+  def ov_to_variant_map(product)
+    result = {}
+    product.variants.map{|v|
+      # we get all variants from product
+      # then we take all option_values
+      key = v.option_values.sort_by{|ov|
+        # then sort them by position of option value in product
+        ProductOptionType.find(:first, :conditions => { :option_type_id => ov.option_type_id, :product_id => product.id }).position
+      }.map(&:id)
+      result[key] = v
+    }
+    return(result)
+  end
+
+  # checks if there's a possible combination
+  #
+  # WARNING! This helper has equivalent on javascript side.
+  # If you plan to change it, make sure they both behave in the same way
+  def possible_combination?(all_combinations, values)
+    all_combinations.any?{|combination|
+      values.enum_for(:each_with_index).all?{|v, i| combination[i] == v}
+    }
+  end
+end

data/app/models/option_types_prototype.rb

@@ -0,0 +1,2 @@
+class OptionTypesPrototype < ActiveRecord::Base
+end

data/app/models/option_value_decorator.rb

@@ -0,0 +1,9 @@
+OptionValue.class_eval do
+  validates_numericality_of :amount, :allow_nil => true
+  
+  after_update :adjust_variant_prices, :if => :amount_changed?
+
+  def adjust_variant_prices
+    variants.each{|v| v.update_attribute(:price, v.calculate_price)}
+  end
+end

data/app/models/product_decorator.rb

@@ -0,0 +1,40 @@
+Product.class_eval do
+  attr_accessor :create_variants
+  after_create :do_create_variants
+
+  has_many :option_types, :through => :product_option_types, :order => "product_option_types.position ASC"
+
+  def do_create_variants(force = false)
+    if (create_variants == "1" || force) && self.option_types.length > 0
+      generate_variant_combinations.each_with_index do |option_values, index|
+        sku = option_values.map(&:sku).reject(&:blank?).join("-")
+        sku = index+1 if sku.blank?
+
+        v = Variant.create({
+            :product => self,
+            :option_values => option_values,
+            :is_master => false,
+            :sku => self.sku.blank? ? "#{self.name.to_url[0..3]}-#{sku}" : "#{self.sku}-#{sku}"
+          })
+        v
+      end
+    end
+  end
+
+  def default_variant
+    variants.first
+  end
+
+  def generate_variant_combinations(option_values = nil)
+    option_values ||= self.option_types.map{|ot| ot.option_values}
+    if option_values.length == 1
+      option_values.first.map{|v| [v]}
+    else
+      result = []
+      option_values.first.each do |value|
+        result += generate_variant_combinations(option_values[1..-1]).map{|rv| rv.push(value) }
+      end
+      result
+    end
+  end
+end

data/app/models/prototype.rb

@@ -0,0 +1,6 @@
+class Prototype < ActiveRecord::Base
+  has_and_belongs_to_many :properties
+  has_and_belongs_to_many :option_types, :order => "option_types_prototypes.position ASC"
+  has_many :option_types_prototypes
+  validates_presence_of :name
+end

data/app/models/variant_decorator.rb

@@ -0,0 +1,41 @@
+Variant.class_eval do
+  after_update :adjust_variant_prices, :if => lambda{|r| r.price_changed? && r.is_master}
+
+  def self.by_option_value_ids(option_value_ids, product_id)
+    Variant.find_by_sql(['
+        SELECT
+          option_values_variants.variant_id as id
+        FROM
+          option_values_variants, variants
+        WHERE
+          option_values_variants.option_value_id IN (?) 
+            AND
+          option_values_variants.variant_id = variants.id
+            AND
+          variants.product_id = ?
+        GROUP BY
+          option_values_variants.variant_id
+        HAVING
+          COUNT(option_values_variants.variant_id) = ?',
+        option_value_ids, product_id, option_value_ids.length
+      ]).map(&:reload)
+  end
+
+  def calculate_price(master_price=nil)
+    price = (master_price || product.master.price).to_i
+    price+= self.option_values.map{|ov| ov.amount.to_i}.sum
+    price > 0 ? price : 0
+  end
+
+  # Ensures a new variant takes the product master price when price is not supplied
+  def check_price
+    if self.price.blank?
+      raise "Must supply price for variant or master.price for product." if self.is_master
+      self.price = calculate_price
+    end
+  end
+
+  def adjust_variant_prices
+    product.variants.each{|v| v.update_attribute(:price, v.calculate_price(self.price))}
+  end
+end