spree 0.6.0 → 0.7.0

data/app/controllers/products_controller.rb

@@ -26,14 +26,19 @@ class ProductsController < Spree::BaseController
   def collection
     if params[:taxon]
       @taxon = Taxon.find(params[:taxon])
-
-      @collection ||= Product.active.find(
-        :all, 
-        :conditions => ["products.id in (select product_id from products_taxons where taxon_id in (" +  @taxon.descendents.inject( @taxon.id.to_s) { |clause, t| clause += ', ' + t.id.to_s} + "))" ], 
-        :page => {:start => 1, :size => Spree::Config[:products_per_page], :current => params[:p]}, 
-        :include => :images)
+      
+      @search = Product.active.scoped(:conditions =>
+                                        ["products.id in (select product_id from products_taxons where taxon_id in (" +
+                                          @taxon.descendents.inject( @taxon.id.to_s) { |clause, t| clause += ', ' + t.id.to_s} + "))"
+                                        ]).new_search(params[:search])
     else
-      @collection ||= Product.active.find(:all, :page => {:start => 1, :size => Spree::Config[:products_per_page], :current => params[:p]}, :include => :images)
+      @search = Product.active.new_search(params[:search])
     end
+
+    @search.per_page = Spree::Config[:products_per_page]
+    @search.include = :images
+
+    @product_cols = 3
+    @products ||= @search.all
   end
 end

data/app/controllers/spree/base_controller.rb

@@ -1,6 +1,6 @@
 class Spree::BaseController < ApplicationController
 
-  filter_parameter_logging "password"
+  filter_parameter_logging :password, :creditcard_number, :creditcard_verification_value
 
   # retrieve the order_id from the session and then load from the database (or return a new order if no 
   # such id exists in the session)

data/app/controllers/states_controller.rb

@@ -1,10 +1,22 @@
 class StatesController < Spree::BaseController
   resource_controller
+
+  ssl_allowed :index
   
   index.response do |wants|
     wants.html
     wants.js do
-      @states = end_of_association_chain.find(:all, :conditions => ['lower(name) LIKE ?', "%#{params[:q].downcase}%"], :order => :name)
+      # @states = end_of_association_chain.find(:all, :conditions => ['lower(name) LIKE ?', "%#{params[:q].downcase}%"], :order => :name)
+     
+      # table of {country.id => { state.id => state.name }}
+      # blank added elsewhere, if needed
+      usa = {}
+      State.find(:all, :conditions => "country_id = 214", 
+                       :select => "id, name"
+                       ).each do |s|
+        usa[s.name] = s.id
+      end
+      @state_info = { "214" => usa }	# to be generalised...
     end
   end
-end
+end

data/app/controllers/taxons_controller.rb

@@ -12,12 +12,16 @@ class TaxonsController < Spree::BaseController
   
   private
   def load_data
-    @products ||= object.products.active.find(:all, :page => {:start => 1, :size => Spree::Config[:products_per_page], :current => params[:p]}, :include => :images)
+    @search = object.products.active.new_search(params[:search])
+    @search.per_page = Spree::Config[:products_per_page]
+    @search.include = :images
+
     @product_cols = 3
+    @products ||= @search.all
   end
   
   def object
-    objects ||= end_of_association_chain.find_by_permalink(params[:id].join("/") + "/")
+    @object ||= end_of_association_chain.find_by_permalink(params[:id].join("/") + "/")
   end
  
 end

data/app/controllers/users_controller.rb

@@ -9,13 +9,16 @@ class UsersController < Spree::BaseController
   show.before do
     @orders = Order.checkout_completed(true).find_all_by_user_id(current_user.id)
   end
-
-  create.after do   
-    self.current_user = @user       
-  end
-
-  create.response do |wants|  
+                 
+  create do
+    flash nil
     wants.html { redirect_back_or_default(products_path) }         
   end
   
+  create.after do
+    @user.roles << Role.find_by_name("user")
+    @user.save   
+    self.current_user = @user       
+  end
+  
 end

data/app/helpers/application_helper.rb

@@ -30,15 +30,5 @@ module ApplicationHelper
   def flag_image(code)
     "#{code.to_s.split("-").last.downcase}.png"
   end                      
-  
-  # Takes a filter and converts it into a hash of name/value pairs that can be used in query string
-  def generate_search_options(filter)
-    options = {}
-    filter.attributes.each do |key, value|
-      filter_key = "filter[#{key.to_s}]"
-      options[filter_key] = value
-    end
-    options
-  end
-  
+
 end

data/app/helpers/products_helper.rb

@@ -22,7 +22,9 @@ module ProductsHelper
     end
   end
   
-  def format_price(price)
+  def format_price(price)      
+    # Don't be fooled - default implementation uses number_to_currency but other extensions may patch into this.  It is
+    # suggested that you leave your format_price calls alone.
     number_to_currency(price)
   end
   

data/app/helpers/spree/base_helper.rb

@@ -4,33 +4,7 @@ module Spree::BaseHelper
     return new_order_url if session[:order_id].blank?
     return edit_order_url(Order.find_or_create_by_id(session[:order_id]))
   end
-  
-  def windowed_pagination_links(pagingEnum, options)
-    link_to_current_page = options[:link_to_current_page]
-    always_show_anchors = options[:always_show_anchors]
-    padding = options[:window_size]
-
-    current_page = pagingEnum.page
-    html = ''
-
-    #Calculate the window start and end pages 
-    padding = padding < 0 ? 0 : padding
-    first = pagingEnum.page_exists?(current_page  - padding) ? current_page - padding : 1
-    last = pagingEnum.page_exists?(current_page + padding) ? current_page + padding : pagingEnum.last_page
-
-    # Print start page if anchors are enabled
-    html << yield(1) if always_show_anchors and not first == 1
 
-  # Print window pages
-  first.upto(last) do |page|
-    (current_page == page && !link_to_current_page) ? html << page : html << yield(page)
-  end
-
-  # Print end page if anchors are enabled
-  html << yield(pagingEnum.last_page) if always_show_anchors and not last == pagingEnum.last_page
-  html
-  end 
-  
   def add_product_link(text, product) 
     link_to_remote text, {:url => {:controller => "cart", 
               :action => "add", :id => product}}, 

data/app/models/address.rb

@@ -12,12 +12,12 @@ class Address < ActiveRecord::Base
   validates_presence_of :zipcode
   validates_presence_of :country
   validates_presence_of :phone
-  
+
   def full_name
     self.firstname + " " + self.lastname
   end
-  
+
   def state_text
-    state.nil? ? state_name : (state.abbr=="" ? state.name : state.abbr)
+    state.nil? ? state_name : (state.abbr.blank? ? state.name : state.abbr)
   end
 end

data/app/models/app_configuration.rb

@@ -31,6 +31,7 @@ class AppConfiguration < Configuration
   preference :admin_interface_logo, :string, :default => "spree/spree.jpg"
   preference :allow_ssl_in_production, :boolean, :default => true
   preference :allow_ssl_in_development_and_test, :boolean, :default => false
+  preference :google_analytics_id, :string, :default => '12312312' # Replace with real Google Analytics Id
 
   validates_presence_of :name
   validates_uniqueness_of :name

data/app/models/country.rb

@@ -1,4 +1,8 @@
 class Country < ActiveRecord::Base
   has_many :states
   named_scope :order_by_name, :order => :name
+  
+  def <=>(other)
+    name <=> other.name
+  end
 end

data/app/models/creditcard.rb

@@ -66,7 +66,12 @@ class Creditcard < ActiveRecord::Base
   def last_digits
     self.class.last_digits(number)
   end
-  
+
+  # needed for some of the ActiveMerchant gateways (eg. Protx)
+  def brand
+    cc_type
+  end 
+
   def validate 
     validate_essential_attributes
     validate_card_type

data/app/models/creditcard_payment.rb

@@ -7,7 +7,7 @@ class CreditcardPayment < Payment
   def find_authorization
     #find the transaction associated with the original authorization/capture 
     txns.find(:first, 
-              :conditions => ["txn_type = ?", CreditcardTxn::TxnType::AUTHORIZE],
+              :conditions => ["txn_type = ? AND response_code IS NOT NULL", CreditcardTxn::TxnType::AUTHORIZE],
               :order => 'created_at DESC')
   end 
   

data/app/models/inventory_unit.rb

@@ -9,6 +9,9 @@ class InventoryUnit < ActiveRecord::Base
     event :sell do
       transition :to => 'sold', :from => 'on_hand'
     end
+    event :fill_backorder do
+      transition :to => 'sold', :from => 'backordered'
+    end
     event :ship do
       transition :to => 'shipped', :if => :allow_ship? #, :from => 'sold'
     end
@@ -61,7 +64,7 @@ class InventoryUnit < ActiveRecord::Base
   
   private
   def allow_ship?
-    state == 'sold' || Spree::Config[:allow_backorder_shipping]
+    state == 'ready_to_ship' || Spree::Config[:allow_backorder_shipping]
   end
   
 end

data/app/models/order.rb

@@ -1,5 +1,5 @@
 class Order < ActiveRecord::Base  
-  before_create :generate_order_number
+#  before_create :generate_order_number
   before_save :update_line_items
   
   has_many :line_items, :dependent => :destroy, :attributes => true do
@@ -7,13 +7,13 @@ class Order < ActiveRecord::Base
       find :first, :conditions => ['variant_id = ?', variant.id]
     end
   end
-  has_many :products, :through => :line_items
   has_many :inventory_units
   has_many :state_events
   has_many :payments
   has_many :creditcard_payments
   has_many :creditcards
   belongs_to :user
+  has_many :shipments, :dependent => :destroy
 
   validates_associated :line_items, :message => "are not valid"
   validates_numericality_of :tax_amount
@@ -31,6 +31,13 @@ class Order < ActiveRecord::Base
   # attr_accessible is a nightmare with attachment_fu, so use attr_protected instead.
   attr_protected :ship_amount, :tax_amount, :item_total, :total, :user, :number, :ip_address, :checkout_complete, :state
   
+  def to_param  
+    self.number if self.number
+    generate_order_number unless self.number
+    self.number.parameterize.to_s.upcase
+  end
+  make_permalink :field => :number
+  
   # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
   state_machine :initial => 'in_progress' do    
     after_transition :to => 'in_progress', :do => lambda {|order| order.update_attribute(:checkout_complete, false)}
@@ -38,15 +45,9 @@ class Order < ActiveRecord::Base
     after_transition :to => 'canceled', :do => :cancel_order
     after_transition :to => 'returned', :do => :restock_inventory
     after_transition :to => 'resumed', :do => :restore_state 
-
-    before_transition :to => 'paid', :do => :record_payment_event
-    
-    event :next do
-      transition :to => 'creditcard', :from => 'in_progress'
-      transition :to => 'new', :from => 'creditcard'
-    end
-    event :edit do
-      transition :to => 'in_progress', :from => %w{creditcard in_progress}
+     
+    event :complete do
+      transition :to => 'new', :from => 'in_progress'
     end
     event :cancel do
       transition :to => 'canceled', :if => :allow_cancel?
@@ -60,11 +61,9 @@ class Order < ActiveRecord::Base
     event :pay do
       transition :to => 'paid', :if => :allow_pay?
     end
-  end
-
-  def record_payment_event
-    # normally these types of transitions are recorded by controller
-    state_events.create(:name => I18n.t(:pay), :previous_state => state)
+    event :ship do
+      transition :to => 'shipped', :from  => 'paid'
+    end
   end
   
   def restore_state
@@ -74,7 +73,7 @@ class Order < ActiveRecord::Base
   end
 
   def allow_cancel?
-    self.checkout_complete && self.state != 'canceled'
+    self.state != 'canceled'
   end
   
   def allow_resume?
@@ -112,12 +111,12 @@ class Order < ActiveRecord::Base
     end
   end
 
-  def generate_order_number
+  def generate_order_number                
     record = true
     while record
-      random = Array.new(9){rand(9)}.join
+      random = "R#{Array.new(9){rand(9)}.join}"                                        
       record = Order.find(:first, :conditions => ["number = ?", random])
-    end
+    end          
     self.number = random
   end          
   
@@ -142,6 +141,18 @@ class Order < ActiveRecord::Base
     return nil if creditcards.empty?
     return creditcards.last.address
   end
+
+  # convenience method since many stores will not allow user to create multiple shipments
+  def shipment
+    shipments.last
+  end
+  
+  def ship_address
+    return nil if shipments.empty?
+    return shipment.address
+  end      
+ 
+  include Spree::ShippingCalculator
  
   private
   def complete_order
@@ -149,7 +160,12 @@ class Order < ActiveRecord::Base
     InventoryUnit.sell_units(self)
     if user && user.email
       OrderMailer.deliver_confirm(self)
-    end
+    end   
+    # finalize order totals 
+    calculator = shipment.shipping_method.shipping_calculator.constantize.new
+    self.ship_amount = calculator.calculate_shipping(shipment) 
+    self.tax_amount = calculate_tax
+    save
   end
   
   def cancel_order

data/app/models/product.rb

@@ -15,19 +15,22 @@ class Product < ActiveRecord::Base
   validates_presence_of :name
   validates_presence_of :master_price
   validates_presence_of :description
-
-  make_permalink :with => :name, :field => :permalink
+  
+  make_permalink
 
   alias :options :product_option_types
 
   # default product scope only lists available and non-deleted products
   named_scope :active, lambda { |*args| { :conditions => ["products.available_on <= ? and products.deleted_at is null", (args.first || Time.zone.now)] } }
+  named_scope :not_deleted, lambda { |*args| { :conditions => ["products.deleted_at is null", (args.first || Time.zone.now)] } }
   
   named_scope :available, lambda { |*args| { :conditions => ["products.available_on <= ?", (args.first || Time.zone.now)] } }
-  named_scope :by_name, lambda {|name| {:conditions => ["products.name like ?", "%#{name}%"]}}
-  named_scope :by_sku, lambda {|sku| { :include => :variants, :conditions => ["variants.sku like ?", "%#{sku}%"]}}
-  named_scope :deleted, :conditions =>  "not products.deleted_at is null"
-
+                 
+  def to_param       
+    return permalink unless permalink.blank?
+    name.parameterize.to_s
+  end
+  
   # checks is there are any meaningful variants (ie. variants with at least one option value)
   def variants?
     self.variants.each do |v|
@@ -65,16 +68,24 @@ class Product < ActiveRecord::Base
   def has_stock?
     variants.inject(false){ |tf, v| tf ||= v.in_stock }
   end
-
+  
   private
 
-    def adjust_inventory    
+    def adjust_inventory
       return if self.new_record?
       return unless @quantity && @quantity.is_integer?    
       new_level = @quantity.to_i
       # don't allow negative on_hand inventory
       return if new_level < 0
       variant.save
+      variant.inventory_units.with_state("backordered").each{|iu|
+        if new_level > 0
+          iu.fill_backorder
+          new_level = new_level - 1
+        end
+        break if new_level < 1
+        }
+      
       adjustment = new_level - on_hand
       if adjustment > 0
         InventoryUnit.create_on_hand(variant, adjustment)

data/{vendor/extensions/shipping/app → app}/models/shipment.rb

@@ -1,17 +1,28 @@
-class Shipment < ActiveRecord::Base
-  before_create :generate_shipment_number
+class Shipment < ActiveRecord::Base      
+  include ActionView::Helpers::NumberHelper # Needed for JS usable rate information
+  
   belongs_to :order
   belongs_to :shipping_method
+  has_one :address, :as => :addressable, :dependent => :destroy
 
+  before_create :generate_shipment_number
+  after_save :recalculate_tax
   after_save :transition_order
-  has_one :address, :as => :addressable, :dependent => :destroy
     
   def shipped?
     self.shipped_at
   end
     
   def shipping_methods
-    ShippingMethod.all.select { |method| method.zone.include?(address) }
+    ShippingMethod.all.select { |method| method.zone.include?(address) && method.available?(order) }
+  end 
+  
+  def rates
+    quotes = []
+    shipping_methods.each do |method|
+      quotes << {:id => method.id, :name => method.name, :rate => number_to_currency(method.calculate_shipping(self)) }
+    end
+    quotes
   end
 
   private  
@@ -32,4 +43,9 @@ class Shipment < ActiveRecord::Base
     # transition order to shipped if all shipments have been shipped
     order.ship!
   end
+  
+  def recalculate_tax
+    return unless order && order.respond_to?(:calculate_tax)      
+    order.update_attribute("tax_amount", order.calculate_tax)
+  end
 end