spree 0.9.4 → 0.10.0.beta

data/app/models/product_scope.rb

@@ -0,0 +1,56 @@
+# *ProductScope* is model for storing named scopes with their arguments,
+# to be used with ProductGroups.
+#
+# Each product Scope can be applied to Product (or product scope) with #apply_on method
+# which returns new combined named scope
+#
+class ProductScope < ActiveRecord::Base
+  # name
+  # arguments
+  belongs_to :product_group
+  serialize :arguments
+
+  extend ::Scopes::Dynamic
+
+  # Get all products with this scope
+  def products
+    if Product.condition?(self.name)
+      Product.send(self.name, *self.arguments)
+    end
+  end
+
+  # Applies product scope on Product model or another named scope
+  def apply_on(another_scope)
+    another_scope.send(self.name, *self.arguments)
+  end
+
+  def before_validation_on_create
+    # Add default empty arguments so scope validates and errors aren't caused when previewing it
+    if args = Scopes::Product.arguments_for_scope_name(name)
+      self.arguments ||= ['']*args.length
+    end
+  end
+  
+  # checks validity of the named scope (if its safe and can be applied on Product)
+  def validate
+    errors.add(:name, "is not a valid scope name") unless Product.condition?(self.name)
+    apply_on(Product).limit(0) != nil
+  rescue Exception
+    errors.add(:arguments, "are incorrect")
+  end
+
+  # test ordering scope by looking for name pattern or :order clause
+  def is_ordering?
+    name =~ /^(ascend_by|descend_by)/ || apply_on(Product).scope(:find)[:order].present?
+  end
+
+  def to_sentence
+    result = I18n.t(:sentence, :scope => [:product_scopes, :scopes, self.name], :default => "")
+    result = I18n.t(:name, :scope => [:product_scopes, :scopes, self.name]) if result.blank?
+    result % [*self.arguments]
+  end
+
+  def to_s
+    to_sentence
+  end
+end

data/app/models/return_authorization.rb

@@ -0,0 +1,70 @@
+class ReturnAuthorization < ActiveRecord::Base
+  belongs_to :order
+  has_many :inventory_units
+  before_save :generate_number
+
+  validates_presence_of :order
+  validates_numericality_of :amount
+  validate :must_have_shipped_units
+
+  state_machine :initial => 'authorized' do
+    after_transition :to => 'received', :do => :add_credit
+
+    event :receive do
+      transition :to => 'received', :from => 'authorized', :if => :allow_receive?
+    end
+    event :cancel do
+      transition :to => 'cancelled', :from => 'authorized'
+    end
+  end
+
+  def add_variant(variant_id, quantity)
+    order_units = self.order.inventory_units.group_by(&:variant_id)
+    returned_units = self.inventory_units.group_by(&:variant_id)
+
+    count = 0
+
+    if returned_units[variant_id].nil? || returned_units[variant_id].size < quantity
+      count = returned_units[variant_id].nil? ? 0 : returned_units[variant_id].size
+
+      order_units[variant_id].each do |inventory_unit|
+        next unless inventory_unit.return_authorization.nil? && count < quantity
+
+        inventory_unit.return_authorization = self
+        inventory_unit.save!
+
+        count += 1
+      end
+    elsif returned_units[variant_id].size > quantity
+      (returned_units[variant_id].size - quantity).times do |i|
+        returned_units[variant_id][i].return_authorization_id = nil
+        returned_units[variant_id][i].save!
+      end
+    end
+
+    self.order.return_authorized! if self.inventory_units.reload.size > 0 && !self.order.awaiting_return?
+  end
+
+  private
+  def must_have_shipped_units
+    errors.add(:order, I18n.t("has_no_shipped_units")) if order.nil? || order.shipped_units.nil?
+  end
+
+  def generate_number
+    record = true
+    while record
+      random = "RMA#{Array.new(9){rand(9)}.join}"
+      record = ReturnAuthorization.find(:first, :conditions => ["number = ?", random])
+    end
+    self.number = random
+  end
+
+  def add_credit
+    credit = ReturnAuthorizationCredit.create(:adjustment_source => self, :order_id => self.order.id, :amount => self.amount, :description => "RMA Credit")
+    self.order.update_totals!
+  end
+
+  def allow_receive?
+    !inventory_units.empty?
+  end
+end

data/app/models/return_authorization_credit.rb

@@ -0,0 +1,3 @@
+class ReturnAuthorizationCredit < Credit
+
+end

data/app/models/shipment.rb

@@ -1,20 +1,21 @@
-class Shipment < ActiveRecord::Base        
+require 'ostruct'
+class Shipment < ActiveRecord::Base
   belongs_to :order
   belongs_to :shipping_method
   belongs_to :address
-  has_one    :charge,   :as => :adjustment_source
-
+  has_one    :shipping_charge,   :as => :adjustment_source
+  alias charge shipping_charge
+  has_many :state_events, :as => :stateful
+  has_many :inventory_units
   before_create :generate_shipment_number
-  after_save :transition_order
   after_save :create_shipping_charge
-  
-  attr_accessor :special_instructions 
+
+  attr_accessor :special_instructions
   accepts_nested_attributes_for :address
-     
-  def shipped?
-    self.shipped_at
-  end
-  
+  accepts_nested_attributes_for :inventory_units
+
+  validates_presence_of :inventory_units, :if => Proc.new { |unit| !unit.order.in_progress? }
+
   def shipped=(value)
     return unless value == "1" && shipped_at.nil?
     self.shipped_at = Time.now
@@ -22,18 +23,68 @@ class Shipment < ActiveRecord::Base
 
   def create_shipping_charge
     if shipping_method
-      self.charge ||= Charge.create({
+      self.shipping_charge ||= ShippingCharge.create({
           :order => order,
-          :secondary_type => "ShippingCharge",
-          :description => "#{I18n.t(:shipping)} (#{shipping_method.name})",
+          :description => description_for_shipping_charge,
           :adjustment_source => self,
         })
+
+      self.shipping_charge.update_attribute(:description, description_for_shipping_charge) unless self.shipping_charge.description == description_for_shipping_charge
+    end
+  end
+
+  def cost
+    shipping_charge.amount if shipping_charge
+  end
+
+  # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'pending' do
+    event :ready do
+      transition :from => 'pending', :to => 'ready_to_ship'
+    end
+    event :pend do
+      transition :from => 'ready_to_ship', :to => 'pending'
+    end
+    event :ship do
+      transition :from => 'ready_to_ship', :to => 'shipped'
+    end
+
+    after_transition :to => 'shipped', :do => :transition_order
+  end
+
+  def editable_by?(user)
+    !shipped?
+  end
+
+  def manifest
+    inventory_units.group_by(&:variant).map do |i|
+      OpenStruct.new(:variant => i.first, :quantity => i.last.length)
+    end
+  end
+
+  def line_items
+    if order.checkout_complete
+      order.line_items.select {|li| inventory_units.map(&:variant_id).include?(li.variant_id)}
+    else
+      order.line_items
     end
   end
 
+  def recalculate_needed?
+    changed? or !address.same_as?(Address.find(address.id))
+  end
+
+  def recalculate_order
+    shipping_charge.update_attribute(:description, description_for_shipping_charge)
+    order.update_adjustments
+    order.update_totals!
+    order.save
+  end
+
   private
 
   def generate_shipment_number
+    return self.number unless self.number.blank?
     record = true
     while record
       random = Array.new(11){rand(9)}.join
@@ -41,13 +92,21 @@ class Shipment < ActiveRecord::Base
     end
     self.number = random
   end
-  
+
+  def description_for_shipping_charge
+    "#{I18n.t(:shipping)} (#{shipping_method.name})"
+  end
+
   def transition_order
+    update_attribute(:shipped_at, Time.now)
     # transition order to shipped if all shipments have been shipped
-    return unless shipped_at_changed?
-    order.shipments.each do |shipment|
-      return unless shipment.shipped?
+    order.ship! if order.shipments.all?(&:shipped?)
+  end
+
+  def validate
+    unless shipping_method.nil?
+      errors.add :shipping_method, I18n.t("is_not_available_to_shipment_address") unless shipping_method.zone.include?(address)
     end
-    order.ship!
   end
-end
+
+end

data/app/models/shipping_charge.rb

@@ -0,0 +1,23 @@
+class ShippingCharge < Charge
+  def calculate_adjustment
+    adjustment_source && calculate_shipping_charge
+  end
+
+  # Calculates shipping cost using calculators from shipping_rates and shipping_method
+  # shipping_method calculator is used when there's no corresponding shipping_rate calculator
+  #
+  # shipping costs are calculated for each shipping_category - so if order have items
+  # from 3 shipping categories, shipping cost will triple.
+  # You can alter this behaviour by overwriting this method in your site extension
+  def calculate_shipping_charge
+    return unless shipping_method = adjustment_source.shipping_method
+    shipping_method.calculate_cost(adjustment_source)
+  end
+
+  # Checks if charge is applicable for the order.
+  # if it's tax or shipping charge we always preserve it (even if it's 0)
+  # otherwise we fall back to default adjustment behaviour.
+  def applicable?
+    true
+  end
+end

data/app/models/shipping_method.rb

@@ -1,27 +1,36 @@
 class ShippingMethod < ActiveRecord::Base
   belongs_to :zone
   has_many :shipping_rates
+  has_many :shipments
 
   has_calculator
-   
+
   def calculate_cost(shipment)
     rate_calculators = {}
     shipping_rates.each do |sr|
       rate_calculators[sr.shipping_category_id] = sr.calculator
     end
- 
-    calculated_costs = shipment.order.line_items.group_by{|li|
+
+    calculated_costs = shipment.line_items.group_by{|li|
       li.product.shipping_category_id
     }.map{ |shipping_category_id, line_items|
       calc = rate_calculators[shipping_category_id] || self.calculator
       calc.compute(line_items)
     }.sum
- 
+
     return(calculated_costs)
-  end   
-  
+  end
+
   def available?(order)
-    zone.include?(order.shipment.address) &&
-      calculator
+    calculator.available?(order)
   end
+
+  def available_to_order?(order)
+    available?(order) && zone && zone.include?(order.ship_address)
+  end
+
+  def self.all_available(order)
+    all.select { |method| method.available_to_order?(order)}
+  end
+
 end

data/app/models/state_event.rb

@@ -1,6 +1,6 @@
 class StateEvent < ActiveRecord::Base
   belongs_to :user
-  belongs_to :order
+  belongs_to :stateful, :polymorphic => true
   
   def <=>(other)
     created_at <=> other.created_at

data/app/models/state_monitor.rb

@@ -0,0 +1,25 @@
+class StateMonitor < ActiveRecord::Observer
+  observe :order, :shipment
+
+  # Generic transition callback *after* the transition is performed
+  def after_transition(object, transition)
+
+    current_user_session = UserSession.activated? ? UserSession.find : nil
+
+    if current_user_session
+      author = current_user_session.user
+    elsif object.respond_to?(:user)
+      author = object.user
+    end
+
+    to_state = transition.attributes[:to_name]
+    object.state_events.create({
+      :previous_state => transition.attributes[:from],
+      :name           => transition.attributes[:event].to_s,
+      :user_id        => author && author.id 
+      })
+
+    ActiveRecord::Base.logger.info("#{object.class}##{object.id}: #{transition.attributes[:from]} => #{transition.attributes[:to]}")
+  end
+
+end

data/app/models/tax_charge.rb

@@ -0,0 +1,23 @@
+class TaxCharge < Charge
+  def calculate_adjustment
+    adjustment_source && calculate_tax_charge
+  end
+
+  # Calculates taxation amountbased on Calculator::Vat or Calculator::SalesTax
+  def calculate_tax_charge
+    return unless order.shipment
+    return Calculator::Vat.calculate_tax(order) if order.shipment.address.blank? and Spree::Config[:show_price_inc_vat]
+    return unless order.shipment.address
+    zones = Zone.match(order.shipment.address)
+    tax_rates = zones.map{|zone| zone.tax_rates}.flatten.uniq
+    calculated_taxes = tax_rates.map{|tax_rate| tax_rate.calculate_tax(order)}
+    return(calculated_taxes.sum)
+  end
+
+  # Checks if charge is applicable for the order.
+  # if it's tax or shipping charge we always preserve it (even if it's 0)
+  # otherwise we fall back to default adjustment behaviour.
+  def applicable?
+    true
+  end
+end

data/app/models/taxon.rb

@@ -1,34 +1,42 @@
 class Taxon < ActiveRecord::Base
-  acts_as_adjacency_list :foreign_key => 'parent_id', :order => 'position'
+  acts_as_nested_set :dependent => :destroy
+
   belongs_to :taxonomy
   has_and_belongs_to_many :products
-  before_save :set_permalink  
-    
+  before_create :set_permalink
+  before_save :ensure_trailing_slash
 
   # indicate which filters should be used for a taxon
   # this method should be customized to your own site
-  include ProductFilters  # for detailed defs of filters
+  include ::ProductFilters  # for detailed defs of filters
   def applicable_filters
     fs  = []
     fs << ProductFilters.taxons_below(self)
-                          ## unless it's a root taxon? left open for demo purposes
-    fs += [ 
-            ProductFilters.price_filter,
-            ProductFilters.brand_filter,
-            ProductFilters.selective_brand_filter(self) ]
+    ## unless it's a root taxon? left open for demo purposes
+    fs += [
+      ProductFilters.price_filter,
+      ProductFilters.brand_filter,
+      ProductFilters.selective_brand_filter(self) ]
   end
 
-  private
-
   # Creates permalink based on .to_url method provided by stringx gem
   def set_permalink
-    self.permalink = (ancestors.reverse + [self]).collect { |taxon| 
-      taxon.name.to_url 
-    }.join("/") + "/"
+    if parent_id.nil?
+      self.permalink = name.to_url + "/" if self.permalink.blank?
+    else
+      parent_taxon = Taxon.find(parent_id)
+      self.permalink = parent_taxon.permalink + (self.permalink.blank? ? name.to_url : self.permalink.split("/").last) + "/"
+    end
   end
-  
-  # obsolete, kept for backwards compat 
+
+  private
+  # obsolete, kept for backwards compat
   def escape(str)
     str.blank? ? "" : str.to_url
   end
+
+  def ensure_trailing_slash
+    set_permalink if self.permalink.blank?
+    self.permalink += "/" unless self.permalink[-1..-1] == "/"
+  end
 end