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 



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

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 



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

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

#cost_price=(price) ⇒ Object 



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

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) 


79
80
81
 
# File 'app/models/spree/variant.rb', line 79

def deleted?
  deleted_at
end

#gross_profit ⇒ Object 



72
73
74
 
# File 'app/models/spree/variant.rb', line 72

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

#has_default_price? ⇒ Boolean

Returns:

  • (Boolean) 


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

def has_default_price?
  !self.default_price.nil?
end

#in_stock?(quantity = 1) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#name_and_sku ⇒ Object 



130
131
132
 
# File 'app/models/spree/variant.rb', line 130

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

#on_backorder ⇒ Object

returns number of units currently on backorder for this variant.



58
59
60
 
# File 'app/models/spree/variant.rb', line 58

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

#option_value(opt_name) ⇒ Object 



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

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

#options_text ⇒ Object 



62
63
64
65
66
67
68
69
70
 
# File 'app/models/spree/variant.rb', line 62

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 



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

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.



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

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

#set_option_value(opt_name, opt_value) ⇒ Object 



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
109
110
111
112
 
# File 'app/models/spree/variant.rb', line 83

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 



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

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