spree_core 0.70.7 → 1.0.0.rc1

data/app/models/spree/role.rb

@@ -0,0 +1,5 @@
+module Spree
+  class Role < ActiveRecord::Base
+    has_and_belongs_to_many :users, :join_table => 'spree_roles_users'
+  end
+end

data/app/models/spree/shipment.rb

@@ -0,0 +1,153 @@
+require 'ostruct'
+
+module Spree
+  class Shipment < ActiveRecord::Base
+    belongs_to :order
+    belongs_to :shipping_method
+    belongs_to :address
+    has_many :state_events, :as => :stateful
+    has_many :inventory_units, :dependent => :nullify
+    has_one :adjustment, :as => :source
+
+    before_create :generate_shipment_number
+    after_save :ensure_correct_adjustment, :update_order
+
+    attr_accessor :special_instructions
+    accepts_nested_attributes_for :address
+    accepts_nested_attributes_for :inventory_units
+
+    validates :inventory_units, :presence => true, :if => :require_inventory
+    validates :shipping_method, :presence => true
+
+    make_permalink :field => :number
+
+    scope :shipped, where(:state => 'shipped')
+    scope :ready, where(:state => 'ready')
+    scope :pending, where(:state => 'pending')
+
+    def to_param
+      self.number if self.number
+      generate_shipment_number unless self.number
+      self.number.to_s.to_url.upcase
+    end
+
+    def shipped=(value)
+      return unless value == '1' && shipped_at.nil?
+      self.shipped_at = Time.now
+    end
+
+    # The adjustment amount associated with this shipment (if any.)  Returns only the first adjustment to match
+    # the shipment but there should never really be more than one.
+    def cost
+      adjustment ? adjustment.amount : 0
+    end
+
+    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+    state_machine :initial => 'pending', :use_transactions => false do
+      event :ready do
+        transition :from => 'pending', :to => 'ready'
+      end
+      event :pend do
+        transition :from => 'ready', :to => 'pending'
+      end
+      event :ship do
+        transition :from => 'ready', :to => 'shipped'
+      end
+
+      after_transition :to => 'shipped', :do => :after_ship
+    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.complete? and Spree::Config[:track_inventory_levels]
+        order.line_items.select { |li| inventory_units.map(&:variant_id).include?(li.variant_id) }
+      else
+        order.line_items
+      end
+    end
+
+    # Updates various aspects of the Shipment while bypassing any callbacks.  Note that this method takes an explicit reference to the
+    # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
+    # yield the correct results.
+    def update!(order)
+      old_state = self.state
+      new_state = determine_state(order)
+      update_attribute_without_callbacks 'state', determine_state(order)
+      after_ship if new_state == 'shipped' and old_state != 'shipped'
+    end
+
+    private
+      def generate_shipment_number
+        return self.number unless self.number.blank?
+        record = true
+        while record
+          random = "H#{Array.new(11){rand(9)}.join}"
+          record = self.class.where(:number => random).first
+        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
+      #   order.ship! if order.shipments.all?(&:shipped?)
+      # end
+
+      def validate_shipping_method
+        unless shipping_method.nil?
+          errors.add :shipping_method, I18n.t(:is_not_available_to_shipment_address) unless shipping_method.zone.include?(address)
+        end
+      end
+
+      # Determines the appropriate +state+ according to the following logic:
+      #
+      # pending    unless +order.payment_state+ is +paid+
+      # shipped    if already shipped (ie. does not change the state)
+      # ready      all other cases
+      def determine_state(order)
+        return 'pending' if self.inventory_units.any? { |unit| unit.backordered? }
+        return 'shipped' if state == 'shipped'
+        order.payment_state == 'balance_due' ? 'pending' : 'ready'
+      end
+
+      # Determines whether or not inventory units should be associated with the shipment.  This is always +false+ when
+      # +Spree::Config[:track_inventory_levels]+ is set to +false.+  Otherwise its +true+ whenever the order is completed
+      # (and not canceled.)
+      def require_inventory
+        return false unless Spree::Config[:track_inventory_levels]
+        order.completed? && !order.canceled?
+      end
+
+      def after_ship
+        inventory_units.each &:ship!
+        ShipmentMailer.shipped_email(self).deliver
+      end
+
+      def ensure_correct_adjustment
+        if adjustment
+          adjustment.originator = shipping_method
+          adjustment.save
+        else
+          shipping_method.create_adjustment(I18n.t(:shipping), order, self, true)
+          reload #ensure adjustment is present on later saves
+        end
+      end
+
+      def update_order
+        order.update!
+      end
+  end
+end

data/app/models/spree/shipping_category.rb

@@ -0,0 +1,5 @@
+module Spree
+  class ShippingCategory < ActiveRecord::Base
+    validates :name, :presence => true
+  end
+end

data/app/models/spree/shipping_method.rb

@@ -0,0 +1,26 @@
+module Spree
+  class ShippingMethod < ActiveRecord::Base
+    DISPLAY =  [:both, :front_end, :back_end]
+    belongs_to :zone
+    has_many :shipments
+    validates :name, :calculator, :zone, :presence => true
+
+    calculated_adjustments
+
+    def available?(order, display_on=nil)
+      display_check = (self.display_on == display_on.to_s || self.display_on.blank?)
+      calculator_check = calculator.available?(order)
+      display_check && calculator_check
+    end
+
+    def available_to_order?(order, display_on=nil)
+      availability_check = available?(order,display_on)
+      zone_check = zone && zone.include?(order.ship_address)
+      availability_check && zone_check
+    end
+
+    def self.all_available(order, display_on=nil)
+      all.select { |method| method.available_to_order?(order,display_on) }
+    end
+  end
+end

data/app/models/spree/state.rb

@@ -0,0 +1,22 @@
+module Spree
+  class State < ActiveRecord::Base
+    belongs_to :country
+
+    has_one :zone_member, :as => :zoneable
+    has_one :zone, :through => :zone_member
+
+    validates :country, :name, :presence => true
+
+    def self.find_all_by_name_or_abbr(name_or_abbr)
+      where("name = ? OR abbr = ?", name_or_abbr, name_or_abbr)
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/spree/state_event.rb

@@ -0,0 +1,18 @@
+module Spree
+  class StateEvent < ActiveRecord::Base
+    belongs_to :user
+    belongs_to :stateful, :polymorphic => true
+    before_create :assign_user
+
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+
+    def assign_user
+      # if Session.activated? && current_user_session = Session.find
+      #   self.user_id ||= current_user_session.user.id
+      # end
+      true   # don't stop the filters
+    end
+  end
+end

data/app/models/spree/tax_category.rb

@@ -0,0 +1,18 @@
+module Spree
+  class TaxCategory < ActiveRecord::Base
+    validates :name, :presence => true, :uniqueness => true
+
+    has_many :tax_rates, :dependent => :destroy
+
+    before_save :set_default_category
+
+    def set_default_category
+      #set existing default tax category to false if this one has been marked as default
+
+      if is_default && tax_category = self.class.where(:is_default => true).first
+        tax_category.update_attribute(:is_default, false)
+      end
+    end
+
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -0,0 +1,61 @@
+module Spree
+  class DefaultTaxZoneValidator < ActiveModel::Validator
+    def validate(record)
+      if record.included_in_price
+        record.errors.add(:included_in_price, I18n.t(:included_price_validation)) unless Zone.default_tax
+      end
+    end
+  end
+end
+
+module Spree
+  class TaxRate < ActiveRecord::Base
+    belongs_to :zone
+    belongs_to :tax_category
+
+    validates :amount, :presence => true, :numericality => true
+    validates :tax_category_id, :presence => true
+    validates_with DefaultTaxZoneValidator
+
+    calculated_adjustments
+    scope :by_zone, lambda { |zone| where(:zone_id => zone) }
+
+    # Gets the array of TaxRates appropriate for the specified order
+    def self.match(order)
+      return [] unless order.tax_zone
+      all.select { |rate| rate.zone == order.tax_zone || rate.zone.contains?(order.tax_zone) }
+    end
+
+    # For Vat the default rate is the rate that is configured for the default category
+    # It is needed for every price calculation (as all customer facing prices include vat )
+    # The function returns the actual amount, which may be 0 in case of wrong setup, but is never nil
+    def self.default
+      category = TaxCategory.includes(:tax_rates).where(:is_default => true).first
+      return 0 unless category
+
+      category.effective_amount || 0
+    end
+
+    # Creates necessary tax adjustments for the order.
+    def adjust(order)
+      label = "#{tax_category.name} #{amount * 100}%"
+      if self.included_in_price
+        if Zone.default_tax.contains? order.tax_zone
+          order.line_items.each { |line_item| create_adjustment(label, line_item, line_item) }
+        else
+          amount = -1 * calculator.compute(order)
+          label = I18n.t(:refund) + label
+          order.adjustments.create(:amount => amount,
+                                   :source => order,
+                                   :originator => self,
+                                   :locked => true,
+                                   :label => label)
+        end
+      else
+        create_adjustment(label, order, order)
+      end
+    end
+
+  end
+
+end

data/app/models/spree/taxon.rb

@@ -0,0 +1,53 @@
+module Spree
+  class Taxon < ActiveRecord::Base
+    acts_as_nested_set :dependent => :destroy
+
+    belongs_to :taxonomy
+    has_and_belongs_to_many :products, :join_table => 'spree_products_taxons'
+    before_create :set_permalink
+
+    validates :name, :presence => true
+    has_attached_file :icon,
+      :styles => { :mini => '32x32>', :normal => '128x128>' },
+      :default_style => :mini,
+      :url => '/spree/taxons/:id/:style/:basename.:extension',
+      :path => ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
+      :default_url => '/assets/default_taxon.png'
+
+    include ::Spree::ProductFilters  # for detailed defs of filters
+
+    # indicate which filters should be used for a taxon
+    # this method should be customized to your own site
+    def applicable_filters
+      fs = []
+      # fs << ProductFilters.taxons_below(self)
+      ## unless it's a root taxon? left open for demo purposes
+
+      fs << ProductFilters.price_filter if ProductFilters.respond_to?(:price_filter)
+      fs << ProductFilters.brand_filter if ProductFilters.respond_to?(:brand_filter)
+      fs
+    end
+
+    # Creates permalink based on Stringex's .to_url method
+    def set_permalink
+      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)].join('/')
+      end
+    end
+
+    def active_products
+      scope = self.products.active
+      scope = scope.on_hand unless Spree::Config[:show_zero_stock_products]
+      scope
+    end
+
+    private
+      # obsolete, kept for backwards compat
+      def escape(str)
+        str.blank? ? '' : str.to_url
+      end
+  end
+end

data/app/models/spree/taxonomy.rb

@@ -0,0 +1,24 @@
+module Spree
+  class Taxonomy < ActiveRecord::Base
+    validates :name, :presence => true
+
+    has_many :taxons
+    has_one :root, :conditions => { :parent_id => nil }, :class_name => 'Spree::Taxon'
+
+    after_save :set_name
+    after_destroy :destroy_root_taxon
+
+    private
+      def set_name
+        if self.root
+          self.root.update_attribute(:name, self.name)
+        else
+          self.root = Taxon.create!({ :taxonomy_id => self.id, :name => self.name })
+        end
+      end
+
+      def destroy_root_taxon
+        self.root.destroy
+      end
+  end
+end

data/app/models/spree/tracker.rb

@@ -0,0 +1,7 @@
+module Spree
+  class Tracker < ActiveRecord::Base
+    def self.current
+      first(:conditions => { :active => true, :environment => Rails.env })
+    end
+  end
+end

data/app/models/spree/user.rb

@@ -0,0 +1,23 @@
+# Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth)
+module Spree
+  class User < ActiveRecord::Base
+    has_many :orders
+
+    belongs_to :ship_address, :foreign_key => 'ship_address_id', :class_name => 'Spree::Address'
+    belongs_to :bill_address, :foreign_key => 'bill_address_id', :class_name => 'Spree::Address'
+
+    scope :registered
+
+    def anonymous?
+      false
+    end
+
+    # Creates an anonymous user
+    def self.anonymous!
+      create
+    end
+
+    attr_accessor :password
+    attr_accessor :password_confirmation
+  end
+end

data/app/models/spree/variant.rb

@@ -0,0 +1,107 @@
+module Spree
+  class Variant < ActiveRecord::Base
+    belongs_to :product
+    delegate_belongs_to :product, :name, :description, :permalink, :available_on, :tax_category_id, :shipping_category_id, :meta_description, :meta_keywords, :tax_category
+
+    has_many :inventory_units
+    has_many :line_items
+    has_and_belongs_to_many :option_values, :join_table => 'spree_option_values_variants'
+    has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
+
+    validate :check_price
+    validates :price, :numericality => { :greater_than_or_equal_to => 0 }, :presence => true
+    validates :cost_price, :numericality => { :greater_than_or_equal_to => 0, :allow_nil => true } if self.table_exists? && self.column_names.include?('cost_price')
+    validates :count_on_hand, :numericality => true
+
+    before_save :touch_product
+
+    # default variant scope only lists non-deleted variants
+    scope :active, where(:deleted_at => nil)
+    scope :deleted, where('deleted_at IS NOT NULL')
+
+    # default extra fields for shipping purposes
+    @fields = [{ :name => 'Weight', :only => [:variant], :format => '%.2f' },
+               { :name => 'Height', :only => [:variant], :format => '%.2f' },
+               { :name => 'Width',  :only => [:variant], :format => '%.2f' },
+               { :name => 'Depth',  :only => [:variant], :format => '%.2f' }]
+
+    # Returns number of inventory units for this variant (new records haven't been saved to database, yet)
+    def on_hand
+      Spree::Config[:track_inventory_levels] ? self.count_on_hand : nil
+    end
+
+    # Adjusts the inventory units to match the given new level.
+    def on_hand=(new_level)
+      if Spree::Config[:track_inventory_levels]
+        new_level = new_level.to_i
+
+        # increase Inventory when
+        if new_level > on_hand
+          # fill backordered orders before creating new units
+          inventory_units.with_state('backordered').slice(0, new_level).each do |iu|
+            iu.fill_backorder
+            new_level -= 1
+          end
+        end
+
+        self.count_on_hand = new_level
+      else
+        raise 'Cannot set on_hand value when Spree::Config[:track_inventory_levels] is false'
+      end
+    end
+
+    # returns number of units currently on backorder for this variant.
+    def on_backorder
+      inventory_units.with_state('backordered').size
+    end
+
+    # returns true if at least one inventory unit of this variant is "on_hand"
+    def in_stock?
+      Spree::Config[:track_inventory_levels] ? on_hand > 0 : true
+    end
+    alias in_stock in_stock?
+
+    def self.additional_fields
+      @fields
+    end
+
+    def self.additional_fields=(new_fields)
+      @fields = new_fields
+    end
+
+    # returns true if this variant is allowed to be placed on a new order
+    def available?
+      Spree::Config[:track_inventory_levels] ? (Spree::Config[:allow_backorders] || self.in_stock?) : true
+    end
+
+    def options_text
+      self.option_values.sort { |ov1, ov2| ov1.option_type.position <=> ov2.option_type.position }.map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence({ :words_connector => ", ", :two_words_connector => ", " })
+    end
+
+    def gross_profit
+      self.cost_price.nil? ? 0 : (self.price - self.cost_price)
+    end
+
+    # use deleted? rather than checking the attribute directly. this
+    # allows extensions to override deleted? if they want to provide
+    # their own definition.
+    def deleted?
+      deleted_at
+    end
+
+    private
+      # Ensures a new variant takes the product master price when price is not supplied
+      def check_price
+        if self.price.nil?
+          raise 'Must supply price for variant or master.price for product.' if self == product.master
+          self.price = product.master.price
+        end
+      end
+
+      def touch_product
+        product.touch unless is_master?
+      end
+  end
+end
+
+require_dependency 'spree/variant/scopes'