Class: Spree::Variant

Inherits:
Object
  • Object
show all
Includes:
PgSearch::Model, DefaultPrice, MemoizedData, Metadata, Metafields, Webhooks
Defined in:
app/models/spree/variant.rb,
app/models/spree/variant/webhooks.rb

Defined Under Namespace

Modules: Webhooks

Constant Summary collapse

MEMOIZED_METHODS = 
%w(purchasable in_stock on_sale backorderable tax_category options_text compare_at_price)
DIMENSION_UNITS = 
%w[mm cm in ft]
WEIGHT_UNITS = 
%w[g kg lb oz]
LOCALIZED_NUMBERS =

FIXME: cost price should be represented with DisplayMoney class

%w(cost_price weight depth width height)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.product_name_or_sku_cont(query) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'app/models/spree/variant.rb', line 193

def self.product_name_or_sku_cont(query)
  sanitized_query = ActiveRecord::Base.sanitize_sql_like(query.to_s.downcase.strip)
  query_pattern = "%#{sanitized_query}%"
  sku_condition = arel_table[:sku].lower.matches(query_pattern)

  if Spree.use_translations?
    translation_arel_table = Product::Translation.arel_table.alias(Product.translation_table_alias)[:name]
    product_name_condition = translation_arel_table.lower.matches(query_pattern)

    joins(:product).
      join_translation_table(Product).
      where(product_name_condition.or(sku_condition))
  else
    product_name_condition = Product.arel_table[:name].lower.matches(query_pattern)
    joins(:product).where(product_name_condition.or(sku_condition))
  end
end

.search_by_product_name_or_sku(query) ⇒ Object 



211
212
213
 
# File 'app/models/spree/variant.rb', line 211

def self.search_by_product_name_or_sku(query)
  product_name_or_sku_cont(query)
end

Instance Method Details

#additional_images ⇒ Array<Spree::Image>

Returns all images except the default image, combining variant and product images.

Returns:



316
317
318
 
# File 'app/models/spree/variant.rb', line 316

def additional_images
  @additional_images ||= (images + product.images).uniq.reject { |image| image.id == default_image&.id }
end

#amount_in(currency) ⇒ BigDecimal

Returns the amount for the given currency.

Parameters:

  • currency (String) —

    the currency to get the amount for

Returns:

  • (BigDecimal) —

    the amount for the given currency



437
438
439
 
# File 'app/models/spree/variant.rb', line 437

def amount_in(currency)
  price_in(currency).try(:amount)
end

#available? ⇒ Boolean

Returns true if the variant is available.

Returns:

  • (Boolean) —

    true if the variant is available



227
228
229
 
# File 'app/models/spree/variant.rb', line 227

def available?
  !discontinued? && product.available?
end

#backorderable? ⇒ Boolean Also known as: is_backorderable?

Returns true if the variant is backorderable.

Returns:

  • (Boolean) —

    true if the variant is backorderable



549
550
551
552
553
 
# File 'app/models/spree/variant.rb', line 549

def backorderable?
  @backorderable ||= Rails.cache.fetch(['variant-backorderable', cache_key_with_version]) do
    quantifier.backorderable?
  end
end

#backordered? ⇒ Boolean

Returns:



595
596
597
 
# File 'app/models/spree/variant.rb', line 595

def backordered?
  @backordered ||= !in_stock? && stock_items.exists?(backorderable: true)
end

#clear_in_stock_cache ⇒ Object 



610
611
612
 
# File 'app/models/spree/variant.rb', line 610

def clear_in_stock_cache
  Rails.cache.delete(in_stock_cache_key)
end

#compare_at_amount_in(currency) ⇒ BigDecimal

Returns the compare at amount for the given currency.

Parameters:

  • currency (String) —

    the currency to get the compare at amount for

Returns:

  • (BigDecimal) —

    the compare at amount for the given currency



444
445
446
 
# File 'app/models/spree/variant.rb', line 444

def compare_at_amount_in(currency)
  price_in(currency).try(:compare_at_amount)
end

#compare_at_price ⇒ BigDecimal

Returns the compare at price of the variant.

Returns:

  • (BigDecimal) —

    the compare at price of the variant



519
520
521
 
# File 'app/models/spree/variant.rb', line 519

def compare_at_price
  @compare_at_price ||= price_in(cost_currency).try(:compare_at_amount)
end

#default_image ⇒ Spree::Image?

Returns default Image for Variant, falling back to product’s default image.

Returns:



298
299
300
 
# File 'app/models/spree/variant.rb', line 298

def default_image
  @default_image ||= has_images? ? images.first : product.default_image
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) —

    true if the variant is deleted.



283
284
285
 
# File 'app/models/spree/variant.rb', line 283

def deleted?
  !!deleted_at
end

#descriptive_name ⇒ String

Returns the descriptive name of the variant.

Returns:

  • (String) —

    the descriptive name of the variant



275
276
277
 
# File 'app/models/spree/variant.rb', line 275

def descriptive_name
  is_master? ? name + ' - Master' : name + ' - ' + options_text
end

#digital? ⇒ Boolean

Is this variant purely digital? (no physical product)

Returns:



602
603
604
 
# File 'app/models/spree/variant.rb', line 602

def digital?
  product.digital?
end

#dimension ⇒ Object 



577
578
579
 
# File 'app/models/spree/variant.rb', line 577

def dimension
  (width || 0) + (height || 0) + (depth || 0)
end

#discontinue! ⇒ Object 



587
588
589
 
# File 'app/models/spree/variant.rb', line 587

def discontinue!
  update_attribute(:discontinue_on, Time.current)
end

#discontinued? ⇒ Boolean

Returns:



591
592
593
 
# File 'app/models/spree/variant.rb', line 591

def discontinued?
  !!discontinue_on && discontinue_on <= Time.current
end

#exchange_name ⇒ String

Returns the exchange name of the variant.

Returns:

  • (String) —

    the exchange name of the variant



269
270
271
 
# File 'app/models/spree/variant.rb', line 269

def exchange_name
  is_master? ? name : options_text
end

#find_option_value(opt_name) ⇒ Spree::OptionValue

Returns the option value for the given option name.

Parameters:

  • opt_name (String) —

    the option name to get the option value for

Returns:



391
392
393
 
# File 'app/models/spree/variant.rb', line 391

def find_option_value(opt_name)
  option_values.includes(:option_type).detect { |o| o.option_type.name.parameterize == opt_name.parameterize }
end

#has_images? ⇒ Boolean

Returns true if the variant has images. Uses loaded association when available, otherwise falls back to counter cache.

Returns:



290
291
292
293
294
 
# File 'app/models/spree/variant.rb', line 290

def has_images?
  return images.any? if images.loaded?

  image_count.positive?
end

#human_name ⇒ String

Returns the human name of the variant.

Returns:

  • (String) —

    the human name of the variant



217
218
219
220
221
222
223
 
# File 'app/models/spree/variant.rb', line 217

def human_name
  @human_name ||= option_values.
                  joins(option_type: :product_option_types).
                  merge(product.product_option_types).
                  reorder('spree_product_option_types.position').
                  pluck(:presentation).join('/')
end

#in_stock? ⇒ Boolean

Returns true if the variant is in stock.

Returns:

  • (Boolean) —

    true if the variant is in stock



537
538
539
540
541
542
543
544
545
 
# File 'app/models/spree/variant.rb', line 537

def in_stock?
  @in_stock ||= if association(:stock_items).loaded? && association(:stock_locations).loaded?
                  total_on_hand.positive?
                else
                  Rails.cache.fetch(in_stock_cache_key, version: cache_version) do
                    total_on_hand.positive?
                  end
                end
end

#in_stock_or_backorderable? ⇒ Boolean

Returns true if the variant is in stock or backorderable.

Returns:

  • (Boolean) —

    true if the variant is in stock or backorderable



233
234
235
 
# File 'app/models/spree/variant.rb', line 233

def in_stock_or_backorderable?
  self.class.in_stock_or_backorderable.exists?(id: id)
end

#name_and_sku ⇒ String

Returns the name and sku of the variant.

Returns:

  • (String) —

    the name and sku of the variant



525
526
527
 
# File 'app/models/spree/variant.rb', line 525

def name_and_sku
  "#{name} - #{sku}"
end

#on_sale?(currency) ⇒ Boolean

Returns:



555
556
557
 
# File 'app/models/spree/variant.rb', line 555

def on_sale?(currency)
  @on_sale ||= price_in(currency)&.discounted?
end

#option_value(option_type) ⇒ String

Returns the presentation of the option value for the given option type.

Parameters:

Returns:

  • (String) —

    the presentation of the option value for the given option type



398
399
400
401
402
403
404
 
# File 'app/models/spree/variant.rb', line 398

def option_value(option_type)
  if option_type.is_a?(Spree::OptionType)
    option_values.detect { |o| o.option_type_id == option_type.id }.try(:presentation)
  else
    find_option_value(option_type).try(:presentation)
  end
end

#options ⇒ Array<Hash>

Returns an array of hashes with the option type name, value and presentation

Returns:

  • (Array<Hash>) 


322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'app/models/spree/variant.rb', line 322

def options
  @options ||= option_values.
               includes(option_type: :product_option_types).
               merge(product.product_option_types).
               reorder('spree_product_option_types.position').
               map do |option_value|
                 {
                   name: option_value.option_type.name,
                   value: option_value.name,
                   presentation: option_value.presentation
                 }
               end
end

#options=(options = {}) ⇒ void

This method returns an undefined value.

Sets the option values for the variant

Parameters:

  • options (Array<Hash>) (defaults to: {}) —

    the options to set



339
340
341
342
343
344
345
 
# File 'app/models/spree/variant.rb', line 339

def options=(options = {})
  options.each do |option|
    next if option[:name].blank? || option[:value].blank?

    set_option_value(option[:name], option[:value], option[:position])
  end
end

#options_text ⇒ String

Returns the options text of the variant.

Returns:

  • (String) —

    the options text of the variant



259
260
261
262
263
264
265
 
# File 'app/models/spree/variant.rb', line 259

def options_text
  @options_text ||= if option_values.loaded?
                      option_values.sort_by { |ov| ov.option_type.position }.map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence(words_connector: ', ', two_words_connector: ', ')
                    else
                      option_values.includes(:option_type).joins(:option_type).order("#{Spree::OptionType.table_name}.position").map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence(words_connector: ', ', two_words_connector: ', ')
                    end
end

#price_for(context_or_options) ⇒ Spree::Price

Returns the price for the given context or options.

Parameters:

Returns:

  • (Spree::Price) —

    the price for the given context or options



463
464
465
466
467
468
469
470
471
472
473
 
# File 'app/models/spree/variant.rb', line 463

def price_for(context_or_options)
  context = if context_or_options.is_a?(Spree::Pricing::Context)
              context_or_options
            elsif context_or_options.is_a?(Hash)
              Spree::Pricing::Context.new(**context_or_options.merge(variant: self))
            else
              raise ArgumentError, 'Must provide a Pricing::Context or options hash'
            end

  Spree::Pricing::Resolver.new(context).resolve
end

#price_in(currency) ⇒ Spree::Price

Returns the base price (global price, not from a price list) for the given currency. Use price_for(context) when you need to resolve prices including price lists.

Parameters:

  • currency (String) —

    the currency to get the price for

Returns:



410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'app/models/spree/variant.rb', line 410

def price_in(currency)
  currency = currency&.upcase

  price = if prices.loaded? && prices.any?
            prices.detect { |p| p.currency == currency && p.price_list_id.nil? }
          else
            prices.base_prices.find_by(currency: currency)
          end

  if price.nil?
    return Spree::Price.new(
      currency: currency,
      variant_id: id
    )
  end

  price
rescue TypeError
  Spree::Price.new(
    currency: currency,
    variant_id: id
  )
end

#price_modifier_amount(options = {}) ⇒ BigDecimal

Returns the price modifier amount of the variant.

Parameters:

  • options (Hash) (defaults to: {}) —

    the options to get the price modifier amount for

Returns:

  • (BigDecimal) —

    the price modifier amount of the variant



504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'app/models/spree/variant.rb', line 504

def price_modifier_amount(options = {})
  return 0 unless options.present?

  options.keys.map do |key|
    m = "#{key}_price_modifier_amount".to_sym
    if respond_to? m
      send(m, options[key])
    else
      0
    end
  end.sum
end

#price_modifier_amount_in(currency, options = {}) ⇒ Object 



488
489
490
491
492
493
494
495
496
497
498
499
 
# File 'app/models/spree/variant.rb', line 488

def price_modifier_amount_in(currency, options = {})
  return 0 unless options.present?

  options.keys.map do |key|
    m = "#{key}_price_modifier_amount_in".to_sym
    if respond_to? m
      send(m, currency, options[key])
    else
      0
    end
  end.sum
end

#primary_image ⇒ Spree::Image?

Returns first Image for Variant.

Returns:



304
305
306
 
# File 'app/models/spree/variant.rb', line 304

def primary_image
  images.first
end

#purchasable? ⇒ Boolean

Returns:



563
564
565
 
# File 'app/models/spree/variant.rb', line 563

def purchasable?
  @purchasable ||= in_stock? || backorderable?
end

#secondary_image ⇒ Spree::Image?

Returns second Image for Variant (for hover effects).

Returns:



310
311
312
 
# File 'app/models/spree/variant.rb', line 310

def secondary_image
  images.second
end

#set_option_value(opt_name, opt_value, opt_type_position = nil) ⇒ void

This method returns an undefined value.

Sets the option value for the given option name.

Parameters:

  • opt_name (String) —

    the option name to set the option value for

  • opt_value (String) —

    the option value to set

  • opt_type_position (Integer) (defaults to: nil) —

    the position of the option type



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'app/models/spree/variant.rb', line 352

def set_option_value(opt_name, opt_value, opt_type_position = nil)
  # no option values on master
  return if is_master

  option_type = Spree::OptionType.where(name: opt_name.parameterize).first_or_initialize do |o|
    o.name = o.presentation = opt_name
    o.save!
  end

  current_value = find_option_value(opt_name)

  if current_value.nil?
    # then we have to check to make sure that the product has the option type
    product_option_type = if (existing_prod_ot = product.product_option_types.find { |ot| ot.option_type_id == option_type.id })
                            existing_prod_ot
                          else
                            product_option_type = product.product_option_types.new
                            product_option_type.option_type = option_type
                          end
    product_option_type.position = opt_type_position if opt_type_position
    product_option_type.save! if product_option_type.new_record? || product_option_type.changed?
  else
    return if current_value.name.parameterize == opt_value.parameterize

    option_values.delete(current_value)
  end

  option_value = option_type.option_values.where(name: opt_value.parameterize).first_or_initialize do |o|
    o.name = o.presentation = opt_value
    o.save!
  end

  option_values << option_value
  save
end

#set_price(currency, amount, compare_at_amount = nil) ⇒ void

This method returns an undefined value.

Sets the base price (global price, not for a price list) for the given currency.

Parameters:

  • currency (String) —

    the currency to set the price for

  • amount (BigDecimal) —

    the amount to set

  • compare_at_amount (BigDecimal) (defaults to: nil) —

    the compare at amount to set



453
454
455
456
457
458
 
# File 'app/models/spree/variant.rb', line 453

def set_price(currency, amount, compare_at_amount = nil)
  price = prices.base_prices.find_or_initialize_by(currency: currency)
  price.amount = amount
  price.compare_at_amount = compare_at_amount if compare_at_amount.present?
  price.save!
end

#set_stock(count_on_hand, backorderable = nil, stock_location = nil) ⇒ void

This method returns an undefined value.

Sets the stock for the variant

Parameters:

  • count_on_hand (Integer) —

    the count on hand

  • backorderable (Boolean) (defaults to: nil) —

    the backorderable flag

  • stock_location (Spree::StockLocation) (defaults to: nil) —

    the stock location to set the stock for



480
481
482
483
484
485
486
 
# File 'app/models/spree/variant.rb', line 480

def set_stock(count_on_hand, backorderable = nil, stock_location = nil)
  stock_location ||= Spree::Store.current.default_stock_location
  stock_item = stock_items.find_or_initialize_by(stock_location: stock_location)
  stock_item.count_on_hand = count_on_hand
  stock_item.backorderable = backorderable if backorderable.present?
  stock_item.save!
end

#should_track_inventory? ⇒ Boolean

Shortcut method to determine if inventory tracking is enabled for this variant This considers both variant tracking flag and site-wide inventory tracking settings

Returns:



569
570
571
 
# File 'app/models/spree/variant.rb', line 569

def should_track_inventory?
  track_inventory? && Spree::Config.track_inventory_levels
end

#sku_and_options_text ⇒ String

Returns the sku and options text of the variant.

Returns:

  • (String) —

    the sku and options text of the variant



531
532
533
 
# File 'app/models/spree/variant.rb', line 531

def sku_and_options_text
  "#{sku} #{options_text}".strip
end

#tax_category ⇒ Spree::TaxCategory

Returns tax category for Variant

Returns:



239
240
241
242
243
244
245
 
# File 'app/models/spree/variant.rb', line 239

def tax_category
  @tax_category ||= if self[:tax_category_id].nil?
                      product.tax_category
                    else
                      Spree::TaxCategory.find_by(id: self[:tax_category_id]) || product.tax_category
                    end
end

#tax_category_id ⇒ Integer

Returns tax category ID for Variant

Returns:

  • (Integer) 


249
250
251
252
253
254
255
 
# File 'app/models/spree/variant.rb', line 249

def tax_category_id
  @tax_category_id ||= if self[:tax_category_id].nil?
                         product.tax_category_id
                       else
                         self[:tax_category_id]
                       end
end

#volume ⇒ Object 



573
574
575
 
# File 'app/models/spree/variant.rb', line 573

def volume
  (width || 0) * (height || 0) * (depth || 0)
end

#weight_unit ⇒ String

Returns the weight unit for the variant

Returns:

  • (String) 


583
584
585
 
# File 'app/models/spree/variant.rb', line 583

def weight_unit
  attributes['weight_unit'] || Spree::Store.default.preferred_weight_unit
end

#with_digital_assets? ⇒ Boolean

Returns:



606
607
608
 
# File 'app/models/spree/variant.rb', line 606

def with_digital_assets?
  digitals.any?
end