solidus_core 1.0.0.pre

data/app/models/spree/taxon.rb

@@ -0,0 +1,103 @@
+module Spree
+  class Taxon < Spree::Base
+    acts_as_nested_set dependent: :destroy
+
+    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
+    has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
+    has_many :products, through: :classifications
+
+    has_and_belongs_to_many :prototypes, join_table: :spree_taxons_prototypes
+
+    before_create :set_permalink
+
+    validates :name, presence: true
+    validates :meta_keywords, length: { maximum: 255 }
+    validates :meta_description, length: { maximum: 255 }
+    validates :meta_title, length: { maximum: 255 }
+
+    after_save :touch_ancestors_and_taxonomy
+    after_touch :touch_ancestors_and_taxonomy
+
+    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'
+
+    validates_attachment :icon,
+      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png", "image/gif"] }
+
+    # @note This method is meant to be overridden on a store by store basis.
+    # @return [Array] filters that should be used for a taxon
+    def applicable_filters
+      fs = []
+      # fs << ProductFilters.taxons_below(self)
+      ## unless it's a root taxon? left open for demo purposes
+
+      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
+      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
+      fs
+    end
+
+    # @return [String] meta_title if set otherwise a string containing the
+    #   root name and taxon name
+    def seo_title
+      unless meta_title.blank?
+        meta_title
+      else
+        root? ? name : "#{root.name} - #{name}"
+      end
+    end
+
+    # Sets this taxons permalink to a valid url encoded string based on its
+    # name and its parents permalink (if present.)
+    def set_permalink
+      if parent.present?
+        self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
+      else
+        self.permalink = name.to_url if permalink.blank?
+      end
+    end
+
+    # @return [String] this taxon's permalink
+    def to_param
+      permalink
+    end
+
+    # @return [ActiveRecord::Relation<Spree::Product>] the active products the
+    #   belong to this taxon
+    def active_products
+      products.active
+    end
+
+    # @return [String] this taxon's ancestors names followed by its own name,
+    #   separated by arrows
+    def pretty_name
+      ancestor_chain = self.ancestors.inject("") do |name, ancestor|
+        name += "#{ancestor.name} -> "
+      end
+      ancestor_chain + "#{name}"
+    end
+
+    # @see https://github.com/spree/spree/issues/3390
+    def child_index=(idx)
+      # awesome_nested_set sorts by :lft and :rgt. This call re-inserts the
+      # child node so that its resulting position matches the observable
+      # 0-indexed position.
+      #
+      # NOTE: no :position column needed - awesom_nested_set doesn't handle the
+      # reordering if you bring your own :order_column.
+      move_to_child_with_index(parent, idx.to_i) unless self.new_record?
+    end
+
+    private
+
+    def touch_ancestors_and_taxonomy
+      # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
+      self.class.where(id: ancestors.pluck(:id)).update_all(updated_at: Time.now)
+      # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
+      taxonomy.try!(:touch)
+    end
+  end
+end

data/app/models/spree/taxonomy.rb

@@ -0,0 +1,27 @@
+module Spree
+  class Taxonomy < Spree::Base
+    acts_as_list
+
+    validates :name, presence: true
+
+    has_many :taxons, inverse_of: :taxonomy
+    has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
+
+    after_save :set_name
+
+    default_scope -> { order("#{self.table_name}.position") }
+
+    private
+      def set_name
+        if root
+          root.update_columns(
+            name: name,
+            updated_at: Time.now,
+          )
+        else
+          self.root = Taxon.create!(taxonomy_id: id, name: name)
+        end
+      end
+
+  end
+end

data/app/models/spree/tracker.rb

@@ -0,0 +1,8 @@
+module Spree
+  class Tracker < Spree::Base
+    def self.current
+      tracker = where(active: true, environment: Rails.env).first
+      tracker.analytics_id.present? ? tracker : nil if tracker
+    end
+  end
+end

data/app/models/spree/transfer_item.rb

@@ -0,0 +1,58 @@
+module Spree
+  class TransferItem < ActiveRecord::Base
+    acts_as_paranoid
+    belongs_to :stock_transfer, inverse_of: :transfer_items
+    belongs_to :variant
+
+    validate :stock_availability, if: :check_stock?
+    validates_presence_of :stock_transfer, :variant
+    validates_uniqueness_of :variant_id, scope: :stock_transfer_id
+    validates :expected_quantity, numericality: { greater_than: 0 }
+    validates :received_quantity, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: :expected_quantity }
+
+    scope :received, -> { where('received_quantity > 0') }
+    scope :fully_received, -> { where('expected_quantity = received_quantity') }
+    scope :partially_received, -> { received.where('expected_quantity > received_quantity') }
+
+    before_destroy :ensure_stock_transfer_not_finalized
+    before_validation :ensure_stock_transfer_not_closed
+    before_update :prevent_expected_quantity_update_stock_transfer_finalized
+
+    private
+
+    def ensure_stock_transfer_not_closed
+      if stock_transfer_closed?
+        errors.add(:base, Spree.t('errors.messages.cannot_modify_transfer_item_closed_stock_transfer'))
+      end
+    end
+
+    def ensure_stock_transfer_not_finalized
+      unless stock_transfer.finalizable?
+        errors.add(:base, Spree.t('errors.messages.cannot_delete_transfer_item_with_finalized_stock_transfer'))
+        return false
+      end
+    end
+
+    def prevent_expected_quantity_update_stock_transfer_finalized
+      if expected_quantity_changed? && stock_transfer.finalized?
+        errors.add(:base, Spree.t('errors.messages.cannot_update_expected_transfer_item_with_finalized_stock_transfer'))
+        return false
+      end
+    end
+
+    def stock_availability
+      stock_item = variant.stock_items.find_by(stock_location: stock_transfer.source_location)
+      if stock_item.nil? || stock_item.count_on_hand < expected_quantity
+        errors.add(:base, Spree.t('errors.messages.transfer_item_insufficient_stock'))
+      end
+    end
+
+    def stock_transfer_closed?
+      stock_transfer.closed?
+    end
+
+    def check_stock?
+      !stock_transfer_closed? && stock_transfer.source_location.check_stock_on_transfer?
+    end
+  end
+end

data/app/models/spree/unit_cancel.rb

@@ -0,0 +1,32 @@
+# This represents an inventory unit that has been canceled from an order after it has already been completed
+# The reason specifies why it was canceled.
+# This class should encapsulate logic related to canceling inventory after order complete
+class Spree::UnitCancel < ActiveRecord::Base
+  SHORT_SHIP = 'Short Ship'
+  belongs_to :inventory_unit
+  has_one :adjustment, as: :source, dependent: :destroy
+
+  validates :inventory_unit, presence: true
+
+  # Creates necessary cancel adjustments for the line item.
+  def adjust!
+    raise "Adjustment is already created" if adjustment
+
+    amount = compute_amount(inventory_unit.line_item)
+
+    create_adjustment!(
+      adjustable: inventory_unit.line_item,
+      amount: amount,
+      order: inventory_unit.order,
+      label: "#{Spree.t(:cancellation)} - #{reason}",
+      eligible: true,
+      state: 'closed',
+    )
+  end
+
+  # This method is used by Adjustment#update to recalculate the cost.
+  def compute_amount(line_item)
+    raise "Adjustable does not match line item" unless line_item == inventory_unit.line_item
+    -(line_item.total.to_d / line_item.inventory_units.not_canceled.reject(&:original_return_item ).size)
+  end
+end

data/app/models/spree/user_stock_location.rb

@@ -0,0 +1,6 @@
+module Spree
+  class UserStockLocation < ActiveRecord::Base
+    belongs_to :user, class_name: Spree.user_class.to_s, inverse_of: :user_stock_locations
+    belongs_to :stock_location, class_name: "Spree::StockLocation", inverse_of: :user_stock_locations
+  end
+end

data/app/models/spree/validations/db_maximum_length_validator.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Validations
+    ##
+    # Validates a field based on the maximum length of the underlying DB field, if there is one.
+    class DbMaximumLengthValidator < ActiveModel::Validator
+
+      def initialize(options)
+        super
+        @field = options[:field].to_s
+        raise ArgumentError.new("a field must be specified to the validator") if @field.blank?
+      end
+
+      def validate(record)
+        limit = record.class.columns_hash[@field].limit
+        value = record[@field.to_sym]
+        if value && limit && value.to_s.length > limit
+          record.errors.add(@field.to_sym, :too_long, count: limit)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/variant.rb

@@ -0,0 +1,356 @@
+module Spree
+  # == Master Variant
+  #
+  # Every product has one master variant, which stores master price and SKU,
+  # size and weight, etc. The master variant does not have option values
+  # associated with it. Contains on_hand inventory levels only when there are
+  # no variants for the product.
+  #
+  # == Variants
+  #
+  # All variants can access the product properties directly (via reverse
+  # delegation). Inventory units are tied to Variant.  The master variant can
+  # have inventory units, but not option values. All other variants have
+  # option values and may have inventory units. Sum of on_hand each variant's
+  # inventory level determine "on_hand" level for the product.
+  class Variant < Spree::Base
+    acts_as_paranoid
+
+    include Spree::DefaultPrice
+
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :variants
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+
+    delegate_belongs_to :product, :name, :description, :slug, :available_on,
+                        :shipping_category_id, :meta_description, :meta_keywords,
+                        :shipping_category
+
+    has_many :inventory_units, inverse_of: :variant
+    has_many :line_items, inverse_of: :variant
+    has_many :orders, through: :line_items
+
+    has_many :stock_items, dependent: :destroy, inverse_of: :variant
+    has_many :stock_locations, through: :stock_items
+    has_many :stock_movements, through: :stock_items
+
+    has_many :option_values_variants, dependent: :destroy
+    has_many :option_values, through: :option_values_variants
+
+    has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: "Spree::Image"
+
+    has_one :default_price,
+      -> { where(currency: Spree::Config[:currency], is_default: true) },
+      class_name: 'Spree::Price',
+      dependent: :destroy
+
+    delegate_belongs_to :default_price, :display_price, :display_amount, :price, :price=, :currency
+
+    has_many :prices,
+      class_name: 'Spree::Price',
+      dependent: :destroy,
+      inverse_of: :variant
+
+    before_validation :set_cost_currency
+
+    validate :check_price
+
+    validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates_uniqueness_of :sku, allow_blank: true, conditions: -> { where(deleted_at: nil) }
+
+    after_create :create_stock_items
+    after_create :set_position
+    after_create :set_master_out_of_stock, unless: :is_master?
+
+    after_touch :clear_in_stock_cache
+
+    scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
+
+    # Returns variants that are not deleted and have a price in the given
+    # currency.
+    #
+    # @param currency [String] the currency to filter by; defaults to Spree's default
+    # @return [ActiveRecord::Relation]
+    def self.active(currency = nil)
+      joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
+    end
+
+    # @return [Spree::TaxCategory] the variant's tax category
+    def tax_category
+      if self[:tax_category_id].nil?
+        product.tax_category
+      else
+        TaxCategory.find(self[:tax_category_id])
+      end
+    end
+
+    # Sets the cost_price for the variant.
+    #
+    # @param price [Any] the price to set
+    # @return [Bignum]
+    def cost_price=(price)
+      self[:cost_price] = Spree::LocalizedNumber.parse(price) if price.present?
+    end
+
+    # Sets the weight for the variant.
+    #
+    # @param weight [Any] the weight to set
+    # @return [Bignum]
+    def weight=(weight)
+      self[:weight] = Spree::LocalizedNumber.parse(weight) if weight.present?
+    end
+
+    # Counts the number of units currently on backorder for this variant.
+    #
+    # @return [Fixnum]
+    def on_backorder
+      inventory_units.with_state('backordered').size
+    end
+
+    # @return [Boolean] true if this variant can be backordered
+    def is_backorderable?
+      Spree::Stock::Quantifier.new(self).backorderable?
+    end
+
+    # Creates a sentence out of the variant's (sorted) option values.
+    #
+    # @return [String] a sentence-ified string of option values.
+    def options_text
+      values = self.option_values.sort do |a, b|
+        a.option_type.position <=> b.option_type.position
+      end
+
+      values.to_a.map! do |ov|
+        "#{ov.option_type.presentation}: #{ov.presentation}"
+      end
+
+      values.to_sentence({ words_connector: ", ", two_words_connector: ", " })
+    end
+
+    # Determines the name of an Exchange variant.
+    #
+    # @return [String] the master variant name, if it is a master; or a comma-separated list of all option values.
+    def exchange_name
+      is_master? ? name : options_text
+    end
+
+    # Generates a verbose name for the variant, appending 'Master' if it is a
+    # master variant, otherwise a list of its option values.
+    #
+    # @return [String] the generated name
+    def descriptive_name
+      is_master? ? name + ' - Master' : name + ' - ' + options_text
+    end
+
+    # Returns whether this variant has been deleted. Provided as a method of
+    # overriding the logic for determining if a variant is deleted.
+    #
+    # @return [Boolean] true if this variant has been deleted
+    def deleted?
+      !!deleted_at
+    end
+
+    # Override ActiveRecord finder to function even if the product has been
+    # deleted.
+    #
+    # @return [Spree::Product]
+    def product
+      Spree::Product.unscoped { super }
+    end
+
+    # Assign given options hash to option values.
+    #
+    # @param options [Array] array of hashes with a name and value.
+    def options=(options = {})
+      options.each do |option|
+        set_option_value(option[:name], option[:value])
+      end
+    end
+
+    # Sets an option type and value for the given name and value.
+    #
+    # @param opt_name [String] the name of the option
+    # @param opt_value [String] the value to set to the option
+    def set_option_value(opt_name, opt_value)
+      # no option values on master
+      return if self.is_master
+
+      option_type = Spree::OptionType.where(name: opt_name).first_or_initialize do |o|
+        o.presentation = opt_name
+        o.save!
+      end
+
+      current_value = self.option_values.detect { |o| o.option_type.name == opt_name }
+
+      unless current_value.nil?
+        return if current_value.name == opt_value
+        self.option_values.delete(current_value)
+      else
+        # then we have to check to make sure that the product has the option type
+        unless self.product.option_types.include? option_type
+          self.product.option_types << option_type
+        end
+      end
+
+      option_value = Spree::OptionValue.where(option_type_id: option_type.id, name: opt_value).first_or_initialize do |o|
+        o.presentation = opt_value
+        o.save!
+      end
+
+      self.option_values << option_value
+      self.save
+    end
+
+    # Fetches the option value for the given option name.
+    #
+    # @param opt_name [String] the name of the option whose value you want
+    # @return [String] the option value
+    def option_value(opt_name)
+      self.option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+    end
+
+    # Converts the variant's price to the given currency.
+    #
+    # @param currency [String] the desired currency
+    # @return [Spree::Price] the price in the desired currency
+    def price_in(currency)
+      prices.detect{ |price| price.currency == currency && price.is_default } || Spree::Price.new(variant_id: self.id, currency: currency)
+    end
+
+    # Fetches the price amount in the specified currency.
+    #
+    # @param currency (see #price)
+    # @return [Float] the amount in the specified currency.
+    def amount_in(currency)
+      price_in(currency).try(:amount)
+    end
+
+    # Calculates the sum of the specified price modifiers in the specified
+    # currency.
+    #
+    # @param currency [String] (see #price)
+    # @param options (see #price_modifier_amount)
+    # @return (see #price_modifier_amount)
+    def price_modifier_amount_in(currency, options = {})
+      return 0 unless options.present?
+
+      options.keys.map { |key|
+        m = "#{key}_price_modifier_amount_in".to_sym
+        if self.respond_to? m
+          self.send(m, currency, options[key])
+        else
+          0
+        end
+      }.sum
+    end
+
+    # Calculates the sum of the specified price modifiers.
+    #
+    # @param options [Hash] for specifying keys, eg: `{keys: ['key_1', 'key_2']}`
+    # @return [Fixnum] the sum
+    def price_modifier_amount(options = {})
+      return 0 unless options.present?
+
+      options.keys.map { |key|
+        m = "#{options[key]}_price_modifier_amount".to_sym
+        if self.respond_to? m
+          self.send(m, options[key])
+        else
+          0
+        end
+      }.sum
+    end
+
+    # Generates a friendly name and sku string.
+    #
+    # @return [String]
+    def name_and_sku
+      "#{name} - #{sku}"
+    end
+
+    # Generates a string of the SKU and a list of all the option values.
+    #
+    # @return [String]
+    def sku_and_options_text
+      "#{sku} #{options_text}".strip
+    end
+
+    # @return [Boolean] true if there is stock on-hand for the variant.
+    def in_stock?
+      Rails.cache.fetch(in_stock_cache_key) do
+        total_on_hand > 0
+      end
+    end
+
+    # @param quantity [Fixnum] how many are desired
+    # @return [Boolean] true if the desired quantity can be supplied
+    def can_supply?(quantity=1)
+      Spree::Stock::Quantifier.new(self).can_supply?(quantity)
+    end
+
+    # Fetches the on-hand quantity of the variant.
+    #
+    # @return [Fixnum] the number currently on-hand
+    def total_on_hand
+      Spree::Stock::Quantifier.new(self).total_on_hand
+    end
+
+    # Shortcut method to determine if inventory tracking is enabled for this
+    # variant. This considers both variant tracking flag and site-wide inventory
+    # tracking settings.
+    #
+    # @return [Boolean] true if inventory tracking is enabled
+    def should_track_inventory?
+      self.track_inventory? && Spree::Config.track_inventory_levels
+    end
+
+    def display_image
+      images.first || Spree::Image.new
+    end
+
+    private
+
+      def set_master_out_of_stock
+        if product.master && product.master.in_stock?
+          product.master.stock_items.update_all(:backorderable => false)
+          product.master.stock_items.each { |item| item.reduce_count_on_hand_to_zero }
+        end
+      end
+
+      # Ensures a new variant takes the product master price when price is not supplied
+      def check_price
+        if price.nil? && Spree::Config[:require_master_price]
+          raise 'No master variant found to infer price' unless (product && product.master)
+          raise 'Must supply price for variant or master.price for product.' if self == product.master
+          self.price = product.master.price
+        end
+        if currency.nil?
+          self.currency = Spree::Config[:currency]
+        end
+      end
+
+      def set_cost_currency
+        self.cost_currency = Spree::Config[:currency] if cost_currency.nil? || cost_currency.empty?
+      end
+
+      def create_stock_items
+        StockLocation.where(propagate_all_variants: true).each do |stock_location|
+          stock_location.propagate_variant(self)
+        end
+      end
+
+      def set_position
+        self.update_column(:position, product.variants.maximum(:position).to_i + 1)
+      end
+
+      def in_stock_cache_key
+        "variant-#{id}-in_stock"
+      end
+
+      def clear_in_stock_cache
+        Rails.cache.delete(in_stock_cache_key)
+      end
+  end
+end
+
+require_dependency 'spree/variant/scopes'