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



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

def prototype_id
  @prototype_id
end

Class Method Details

.like_any(fields, values) ⇒ Object 



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

def self.like_any(fields, values)
  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 



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

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” -> […]



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

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) 


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

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



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
204
 
# File 'app/models/product.rb', line 177

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) 


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

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) 


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

def has_variants?
  !variants.empty?
end

#master_price ⇒ Object

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



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

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 



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

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



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

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



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

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 



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

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



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

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

#variant ⇒ Object 



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

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

#variants? ⇒ Boolean

Returns:

  • (Boolean) 


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

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