Class: Spree::Variant

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/spree/variant.rb,
app/models/spree/variant/scopes.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.active(currency = nil) ⇒ Object 



45
46
47
 
# File 'app/models/spree/variant.rb', line 45

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

.has_option(option_type, *option_values) ⇒ Object Also known as: has_options

Returns variants that match a given option value

Example:

product.variants_including_master.has_option(OptionType.find_by(name: ‘shoe-size’), OptionValue.find_by(name: ‘8’))



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'app/models/spree/variant/scopes.rb', line 12

def has_option(option_type, *option_values)
  option_types = OptionType.table_name

  option_type_conditions = case option_type
  when OptionType then { "#{option_types}.name" => option_type.name }
  when String     then { "#{option_types}.name" => option_type }
  else                 { "#{option_types}.id"   => option_type }
  end

  relation = joins(:option_values => :option_type).where(option_type_conditions)

  option_values_conditions = option_values.each do |option_value|
    option_value_conditions = case option_value
    when OptionValue then { "#{OptionValue.table_name}.name" => option_value.name }
    when String      then { "#{OptionValue.table_name}.name" => option_value }
    else                  { "#{OptionValue.table_name}.id"   => option_value }
    end
    relation = relation.where(option_value_conditions)
  end

  relation
end

Instance Method Details

#amount_in(currency) ⇒ Object 



122
123
124
 
# File 'app/models/spree/variant.rb', line 122

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

#cost_price=(price) ⇒ Object 



49
50
51
 
# File 'app/models/spree/variant.rb', line 49

def cost_price=(price)
  self[:cost_price] = parse_price(price) if price.present?
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) 


75
76
77
 
# File 'app/models/spree/variant.rb', line 75

def deleted?
  deleted_at
end

#gross_profit ⇒ Object 



68
69
70
 
# File 'app/models/spree/variant.rb', line 68

def gross_profit
  cost_price.nil? ? 0 : (price - cost_price)
end

#has_default_price? ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
 
# File 'app/models/spree/variant.rb', line 114

def has_default_price?
  !self.default_price.nil?
end

#in_stock?(quantity = 1) ⇒ Boolean

Returns:

  • (Boolean) 


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

def in_stock?(quantity=1)
  Spree::Stock::Quantifier.new(self).can_supply?(quantity)
end

#name_and_sku ⇒ Object 



126
127
128
 
# File 'app/models/spree/variant.rb', line 126

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

#on_backorder ⇒ Object

returns number of units currently on backorder for this variant.



54
55
56
 
# File 'app/models/spree/variant.rb', line 54

def on_backorder
  inventory_units.with_state('backordered').size
end

#option_value(opt_name) ⇒ Object 



110
111
112
 
# File 'app/models/spree/variant.rb', line 110

def option_value(opt_name)
  self.option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
end

#options_text ⇒ Object 



58
59
60
61
62
63
64
65
66
 
# File 'app/models/spree/variant.rb', line 58

def options_text
  values = self.option_values.joins(:option_type).order("#{Spree::OptionType.table_name}.position asc")

  values.map! do |ov|
    "#{ov.option_type.presentation}: #{ov.presentation}"
  end

  values.to_sentence({ words_connector: ", ", two_words_connector: ", " })
end

#price_in(currency) ⇒ Object 



118
119
120
 
# File 'app/models/spree/variant.rb', line 118

def price_in(currency)
  prices.select{ |price| price.currency == currency }.first || Spree::Price.new(variant_id: self.id, currency: currency)
end

#product ⇒ Object

Product may be created with deleted_at already set, which would make AR’s default finder return nil. This is a stopgap for that little problem.



133
134
135
 
# File 'app/models/spree/variant.rb', line 133

def product
  Spree::Product.unscoped { super }
end

#set_option_value(opt_name, opt_value) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'app/models/spree/variant.rb', line 79

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
      self.product.save
    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

#total_on_hand ⇒ Object 



141
142
143
 
# File 'app/models/spree/variant.rb', line 141

def total_on_hand
  Spree::Stock::Quantifier.new(self).total_on_hand
end