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



160
161
162
 
# File 'app/models/product.rb', line 160

def prototype_id
  @prototype_id
end

Class Method Details

.like_any(fields, values) ⇒ Object 



219
220
221
222
223
 
# File 'app/models/product.rb', line 219

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 



165
166
167
168
169
170
171
172
 
# File 'app/models/product.rb', line 165

def add_properties_and_option_types_from_prototype
  if prototype_id && 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” -> […]



214
215
216
217
 
# File 'app/models/product.rb', line 214

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) 


208
209
210
 
# File 'app/models/product.rb', line 208

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



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'app/models/product.rb', line 176

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) 


147
148
149
 
# File 'app/models/product.rb', line 147

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) 


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

def has_variants?
  !variants.empty?
end

#master_price ⇒ Object

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



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

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 



106
107
108
109
 
# File 'app/models/product.rb', line 106

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



136
137
138
 
# File 'app/models/product.rb', line 136

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



141
142
143
144
 
# File 'app/models/product.rb', line 141

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 



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

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



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

def to_param
  return permalink if permalink.present?
  name.to_url
end

#variant ⇒ Object 



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

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

#variants? ⇒ Boolean

Returns:

  • (Boolean) 


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

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