Class: Product

Inherits:
ActiveRecord::Base
  • Object
show all
Includes:
Scopes::Product
Defined in:
app/models/product.rb

Overview

PRODUCTS Products represent an entity for sale in a store. Products can have variations, called variants Products properties include description, permalink, availability,

shipping category, etc. that do not change by variant.

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. Price, SKU, size, weight, etc. are all delegated to the master variant. 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.

Constant Summary

Constants included from Scopes::Product

Scopes::Product::ATTRIBUTE_HELPER_METHODS, Scopes::Product::ORDERING, Scopes::Product::SCOPES

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Scopes::Product

arguments_for_scope_name, get_taxons, prepare_taxon_conditions, prepare_words

Instance Attribute Details

#prototype_id ⇒ Object

Adding properties and option types on creation based on a chosen prototype



145
146
147
 
# File 'app/models/product.rb', line 145

def prototype_id
  @prototype_id
end

Class Method Details

.like_any(fields, values) ⇒ Object 



204
205
206
207
208
 
# File 'app/models/product.rb', line 204

def self.like_any(fields, values)
  like = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE'
  where_str = fields.map{|field| Array.new(values.size, "products.#{field} #{like} ?").join(' OR ') }.join(' OR ')
  self.where([where_str, values.map{|value| "%#{value}%"} * fields.size].flatten)
end

Instance Method Details

#add_properties_and_option_types_from_prototype ⇒ Object 



150
151
152
153
154
155
156
157
 
# File 'app/models/product.rb', line 150

def add_properties_and_option_types_from_prototype
  if prototype_id and prototype = Prototype.find_by_id(prototype_id)
    prototype.properties.each do |property|
      product_properties.create(:property => property)
    end
    self.option_types = prototype.option_types
  end
end

#categorise_variants_from_option(opt_type) ⇒ Object

split variants list into hash which shows mapping of opt value onto matching variants eg categorise_variants_from_option(color) => -> […], “blue” -> […]



199
200
201
202
 
# File 'app/models/product.rb', line 199

def categorise_variants_from_option(opt_type)
  return {} unless option_types.include?(opt_type)
  variants.active.group_by {|v| v.option_values.detect {|o| o.option_type == opt_type} }
end

#deleted? ⇒ Boolean

use deleted? rather than checking the attribute directly. this allows extensions to override deleted? if they want to provide their own definition.

Returns:

  • (Boolean) 


193
194
195
 
# File 'app/models/product.rb', line 193

def deleted?
  !!deleted_at
end

#duplicate ⇒ Object

for adding products which are closely related to existing ones define “duplicate_extra” for site-specific actions, eg for additional fields



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'app/models/product.rb', line 161

def duplicate
  p = self.clone
  p.name = 'COPY OF ' + self.name
  p.deleted_at = nil
  p.created_at = p.updated_at = nil
  p.taxons = self.taxons

  p.product_properties = self.product_properties.map {|q| r = q.clone; r.created_at = r.updated_at = nil; r}

  image_clone = lambda {|i| j = i.clone; j.attachment = i.attachment.clone; j}
  p.images = self.images.map {|i| image_clone.call i}

  variant = self.master.clone
  variant.sku = 'COPY OF ' + self.master.sku
  variant.deleted_at = nil
  variant.images = self.master.images.map {|i| image_clone.call i}
  p.master = variant

  if self.has_variants?
    # don't clone the actual variants, just the characterising types
    p.option_types = self.option_types
  else
  end
  # allow site to do some customization
  p.send(:duplicate_extra) if p.respond_to?(:duplicate_extra)
  p.save!
  p
end

#has_stock? ⇒ Boolean

Returns true if there are inventory units (any variant) with “on_hand” state for this product

Returns:

  • (Boolean) 


132
133
134
 
# File 'app/models/product.rb', line 132

def has_stock?
  master.in_stock? || !!variants.detect{|v| v.in_stock?}
end

#has_variants? ⇒ Boolean

returns true if the product has any variants (the master variant is not a member of the variants array)

Returns:

  • (Boolean) 


116
117
118
 
# File 'app/models/product.rb', line 116

def has_variants?
  !variants.empty?
end

#master_price ⇒ Object

The following methods are deprecated and will be removed in a future version of Spree



86
87
88
89
 
# File 'app/models/product.rb', line 86

def master_price
  warn "[DEPRECATION] `Product.master_price` is deprecated.  Please use `Product.price` instead. (called from #{caller[0]})"
  self.price
end

#master_price=(value) ⇒ Object 



91
92
93
94
 
# File 'app/models/product.rb', line 91

def master_price=(value)
  warn "[DEPRECATION] `Product.master_price=` is deprecated.  Please use `Product.price=` instead. (called from #{caller[0]})"
  self.price = value
end

#on_hand ⇒ Object

returns the number of inventory units “on_hand” for this product



121
122
123
 
# File 'app/models/product.rb', line 121

def on_hand
  has_variants? ? variants.inject(0){|sum, v| sum + v.on_hand} : master.on_hand
end

#on_hand=(new_level) ⇒ Object

adjusts the “on_hand” inventory level for the product up or down to match the given new_level



126
127
128
129
 
# File 'app/models/product.rb', line 126

def on_hand=(new_level)
  raise "cannot set on_hand of product with variants" if has_variants? && Spree::Config[:track_inventory_levels]
  master.on_hand = new_level
end

#tax_category ⇒ Object 



136
137
138
139
140
141
142
 
# File 'app/models/product.rb', line 136

def tax_category
  if self[:tax_category_id].nil?
    TaxCategory.first(:conditions => {:is_default => true})
  else
    TaxCategory.find(self[:tax_category_id])
  end
end

#to_param ⇒ Object

end deprecation region



110
111
112
113
 
# File 'app/models/product.rb', line 110

def to_param
  return permalink unless permalink.blank?
  name.to_url
end

#variant ⇒ Object 



101
102
103
104
 
# File 'app/models/product.rb', line 101

def variant
  warn "[DEPRECATION] `Product.variant` is deprecated.  Please use `Product.master` instead. (called from #{caller[0]})"
  self.master
end

#variants? ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
99
 
# File 'app/models/product.rb', line 96

def variants?
  warn "[DEPRECATION] `Product.variants?` is deprecated.  Please use `Product.has_variants?` instead. (called from #{caller[0]})"
  self.has_variants?
end