Class: Spree::Promotion

Inherits:
Object
  • Object
show all
Includes:
Metadata, Metafields, Security::Promotions, StoreScopedResource
Defined in:
app/models/spree/promotion.rb,
app/models/spree/promotion/rules/user.rb,
app/models/spree/promotion/rules/taxon.rb,
app/models/spree/promotion/rules/country.rb,
app/models/spree/promotion/rules/product.rb,
app/models/spree/promotion/rules/currency.rb,
app/models/spree/promotion/rules/item_total.rb,
app/models/spree/promotion/rules/first_order.rb,
app/models/spree/promotion/rules/option_value.rb,
app/models/spree/promotion/rules/customer_group.rb,
app/models/spree/promotion/rules/user_logged_in.rb,
app/models/spree/promotion/actions/free_shipping.rb,
app/models/spree/promotion/rules/one_use_per_user.rb,
app/models/spree/promotion/actions/create_adjustment.rb,
app/models/spree/promotion/actions/create_line_items.rb,
app/models/spree/promotion/actions/create_item_adjustments.rb

Defined Under Namespace

Modules: Actions, Rules

Constant Summary collapse

MATCH_POLICIES = 
%w(all any)
UNACTIVATABLE_ORDER_STATES = 
['complete', 'awaiting_return', 'returned']

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Metadata

#metadata, #metadata=, #public_metadata=

Instance Attribute Details

#eligibility_errors ⇒ Object (readonly)

Returns the value of attribute eligibility_errors.



17
18
19
 
# File 'app/models/spree/promotion.rb', line 17

def eligibility_errors
  @eligibility_errors
end

#generate_code ⇒ Object

Returns the value of attribute generate_code.



17
18
19
 
# File 'app/models/spree/promotion.rb', line 17

def generate_code
  @generate_code
end

Class Method Details

.active ⇒ Object 



103
104
105
106
 
# File 'app/models/spree/promotion.rb', line 103

def self.active
  where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.current).
    where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
end

.order_activatable?(order) ⇒ Boolean

Returns:



108
109
110
 
# File 'app/models/spree/promotion.rb', line 108

def self.order_activatable?(order)
  order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
end

.with_coupon_code(coupon_code) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
 
# File 'app/models/spree/promotion.rb', line 91

def self.with_coupon_code(coupon_code)
  return nil unless coupon_code.present?

  coupon_code = coupon_code.strip.downcase

  coupons.includes(:promotion_actions).
    where.not(spree_promotion_actions: { id: nil }).
    where(code: coupon_code).or(
      where(id: Spree::CouponCode.where(code: coupon_code).select(:promotion_id))
    ).last
end

Instance Method Details

#activate(payload) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'app/models/spree/promotion.rb', line 134

def activate(payload)
  order = payload[:order]
  return unless self.class.order_activatable?(order)

  payload[:promotion] = self

  # Track results from actions to see if any action has been taken.
  # Actions should return nil/false if no action has been taken.
  # If an action returns true, then an action has been taken.
  results = actions.map do |action|
    action.perform(payload)
  end
  # If an action has been taken, report back to whatever activated this promotion.
  action_taken = results.include?(true)

  if action_taken
    # connect to the order
    # create the join_table entry.
    order.promotions << self unless order.promotions.include?(self)
    order.save
  end

  action_taken
end

#active? ⇒ Boolean

Returns:



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

def active?
  starts_at.present? && starts_at < Time.current && (expires_at.blank? || !expired?)
end

#adjusted_credits_count(promotable) ⇒ Object 



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

def adjusted_credits_count(promotable)
  adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
  credits_count - adjustments.eligible.promotion.where(source_id: actions.pluck(:id)).select(:order_id).distinct.count
end

#all_codes_used? ⇒ Boolean

Returns:



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

def all_codes_used?
  coupon_codes.used.count == coupon_codes.count
end

#code_for_order(order) ⇒ Object 



276
277
278
279
280
281
282
 
# File 'app/models/spree/promotion.rb', line 276

def code_for_order(order)
  if multi_codes?
    coupon_codes.find_by(order: order)&.code
  else
    code
  end
end

#credits ⇒ Object 



238
239
240
 
# File 'app/models/spree/promotion.rb', line 238

def credits
  Adjustment.eligible.promotion.where(source_id: actions.map(&:id))
end

#credits_count ⇒ Object 



242
243
244
 
# File 'app/models/spree/promotion.rb', line 242

def credits_count
  credits.select(:order_id).distinct.count
end

#deactivate(payload) ⇒ Object

Called when a promotion is removed from the cart



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'app/models/spree/promotion.rb', line 160

def deactivate(payload)
  order = payload[:order]
  return unless self.class.order_activatable?(order)

  payload[:promotion] = self

  # Track results from actions to see if any action has been taken.
  # Actions should return nil/false if no action has been taken.
  # If an action returns true, then an action has been taken.
  results = actions.map do |action|
    action.revert(payload) if action.respond_to?(:revert)
  end

  # If an action has been taken, report back to whatever `d this promotion.
  action_taken = results.include?(true)

  if action_taken
    # connect to the order
    # create the join_table entry.
    order.promotions << self unless order.promotions.include?(self)
    order.save
  end

  action_taken
end

#eligible?(promotable, options = {}) ⇒ Boolean

called anytime order.update_with_updater! happens

Returns:



187
188
189
190
191
 
# File 'app/models/spree/promotion.rb', line 187

def eligible?(promotable, options = {})
  return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)

  !!eligible_rules(promotable, options)
end

#eligible_rules(promotable, options = {}) ⇒ Object

eligible_rules returns an array of promotion rules where eligible? is true for the promotable if there are no such rules, an empty array is returned if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)



196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'app/models/spree/promotion.rb', line 196

def eligible_rules(promotable, options = {})
  # Promotions without rules are eligible by default.
  return [] if rules.none?

  specific_rules = rules.select { |rule| rule.applicable?(promotable) }
  return [] if specific_rules.none?

  rule_eligibility = Hash[specific_rules.map do |rule|
    [rule, rule.eligible?(promotable, options)]
  end]

  if match_all?
    # If there are rules for this promotion, but no rules for this
    # particular promotable, then the promotion is ineligible by default.
    unless rule_eligibility.values.all?
      @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
      return nil
    end
    specific_rules
  else
    unless rule_eligibility.values.any?
      @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
      return nil
    end

    [rule_eligibility.detect { |_, eligibility| eligibility }.first]
  end
end

#expired? ⇒ Boolean

Returns:



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

def expired?
  !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
end

#inactive? ⇒ Boolean

Returns:



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

def inactive?
  !active?
end

#line_item_actionable?(order, line_item) ⇒ Boolean

Returns:



246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'app/models/spree/promotion.rb', line 246

def line_item_actionable?(order, line_item)
  if eligible? order
    rules = eligible_rules(order)
    if rules.blank?
      true
    else
      rules.send(match_all? ? :all? : :any?) do |rule|
        rule.actionable? line_item
      end
    end
  else
    false
  end
end

#name_for_order(order) ⇒ Object 



268
269
270
271
272
273
274
 
# File 'app/models/spree/promotion.rb', line 268

def name_for_order(order)
  if coupon_code?
    code_for_order(order)
  else
    name
  end.to_s.upcase
end

#products ⇒ Object 



225
226
227
 
# File 'app/models/spree/promotion.rb', line 225

def products
  rules.where(type: 'Spree::Promotion::Rules::Product').map(&:products).flatten.uniq
end

#usage_limit_exceeded?(promotable) ⇒ Boolean

Returns:



229
230
231
 
# File 'app/models/spree/promotion.rb', line 229

def usage_limit_exceeded?(promotable)
  usage_limit.present? && usage_limit > 0 && adjusted_credits_count(promotable) >= usage_limit
end

#used_by?(user, excluded_orders = []) ⇒ Boolean

Returns:



261
262
263
264
265
266
 
# File 'app/models/spree/promotion.rb', line 261

def used_by?(user, excluded_orders = [])
  user.orders.complete.joins(:promotions).joins(:all_adjustments).
    where.not(spree_orders: { id: excluded_orders.map(&:id) }).
    where(spree_promotions: { id: id }).
    where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
end