Class: Spree::Order

Inherits:
Base
  • Object
show all
Extended by:
DisplayMoney
Includes:
Checkout, Payments
Defined in:
app/models/spree/order.rb,
app/models/spree/order/checkout.rb,
app/models/spree/order/payments.rb

Defined Under Namespace

Modules: Checkout, Payments Classes: CannotRebuildShipments, InsufficientStock

Constant Summary collapse

ORDER_NUMBER_LENGTH = 
9
ORDER_NUMBER_LETTERS = 
false
ORDER_NUMBER_PREFIX = 
'R'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DisplayMoney

money_methods

Methods included from Payments

#authorize_payments!, #capture_payments!, #process_payments!, #unprocessed_payments

Methods included from Checkout

included

Methods inherited from Base

display_includes, #initialize_preference_defaults, page, preference

Methods included from Preferences::Preferable

#default_preferences, #defined_preferences, #get_preference, #has_preference!, #has_preference?, #preference_default, #preference_type, #set_preference

Instance Attribute Details

#coupon_code ⇒ Object

Returns the value of attribute coupon_code.



32
33
34
 
# File 'app/models/spree/order.rb', line 32

def coupon_code
  @coupon_code
end

#temporary_address ⇒ Object

Returns the value of attribute temporary_address.



33
34
35
 
# File 'app/models/spree/order.rb', line 33

def temporary_address
  @temporary_address
end

#temporary_credit_card ⇒ Object

Returns the value of attribute temporary_credit_card.



33
34
35
 
# File 'app/models/spree/order.rb', line 33

def temporary_credit_card
  @temporary_credit_card
end

#use_billing ⇒ Object

Returns the value of attribute use_billing.



90
91
92
 
# File 'app/models/spree/order.rb', line 90

def use_billing
  @use_billing
end

Class Method Details

.by_customer(customer) ⇒ Object 



129
130
131
 
# File 'app/models/spree/order.rb', line 129

def self.by_customer(customer)
  joins(:user).where("#{Spree.user_class.table_name}.email" => customer)
end

.by_number(number) ⇒ Object 



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

def by_number(number)
  where(number: number)
end

.by_state(state) ⇒ Object 



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

def self.by_state(state)
  where(state: state)
end

.complete ⇒ Object 



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

def self.complete
  where.not(completed_at: nil)
end

.incomplete ⇒ Object 



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

def self.incomplete
  where(completed_at: nil)
end

.register_line_item_comparison_hook(hook) ⇒ Object

Use this method in other gems that wish to register their own custom logic that should be called when determining if two line items are equal.



153
154
155
 
# File 'app/models/spree/order.rb', line 153

def self.register_line_item_comparison_hook(hook)
  line_item_comparison_hooks.add(hook)
end

.register_update_hook(hook) ⇒ Object

Use this method in other gems that wish to register their own custom logic that should be called after Order#update



147
148
149
 
# File 'app/models/spree/order.rb', line 147

def self.register_update_hook(hook)
  update_hooks.add(hook)
end

Instance Method Details

#add_store_credit_payments ⇒ Object 



617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
 
# File 'app/models/spree/order.rb', line 617

def add_store_credit_payments
  return if user.nil?
  return if payments.store_credits.checkout.empty? && user.total_available_store_credit.zero?

  payments.store_credits.checkout.each(&:invalidate!)

  # this can happen when multiple payments are present, auto_capture is
  # turned off, and one of the payments fails when the user tries to
  # complete the order, which sends the order back to the 'payment' state.
  authorized_total = payments.pending.sum(:amount)

  remaining_total = outstanding_balance - authorized_total

  if user.store_credits.any?
    payment_method = Spree::PaymentMethod::StoreCredit.first

    user.store_credits.order_by_priority.each do |credit|
      break if remaining_total.zero?
      next if credit.amount_remaining.zero?

      amount_to_take = [credit.amount_remaining, remaining_total].min
      payments.create!(source: credit,
                       payment_method: payment_method,
                       amount: amount_to_take,
                       state: 'checkout',
                       response_code: credit.generate_authorization_code)
      remaining_total -= amount_to_take
    end
  end

  other_payments = payments.checkout.not_store_credits
  if remaining_total.zero?
    other_payments.each(&:invalidate!)
  elsif other_payments.size == 1
    other_payments.first.update_attributes!(amount: remaining_total)
  end

  payments.reset

  if payments.where(state: %w(checkout pending)).sum(:amount) != total
    errors.add(:base, Spree.t("store_credit.errors.unable_to_fund")) && (return false)
  end
end

#all_inventory_units_returned? ⇒ Boolean

Returns:

  • (Boolean) 


243
244
245
 
# File 'app/models/spree/order.rb', line 243

def all_inventory_units_returned?
  inventory_units.all?(&:returned?)
end

#allow_cancel? ⇒ Boolean

Returns:

  • (Boolean) 


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

def allow_cancel?
  return false unless completed? && state != 'canceled'
  shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
end

#amount ⇒ Object

For compatiblity with Calculator::PriceSack



158
159
160
 
# File 'app/models/spree/order.rb', line 158

def amount
  line_items.map(&:amount).sum
end

#apply_free_shipping_promotions ⇒ Object 



511
512
513
514
 
# File 'app/models/spree/order.rb', line 511

def apply_free_shipping_promotions
  Spree::PromotionHandler::FreeShipping.new(self).activate
  update!
end

#approved? ⇒ Boolean

Returns:

  • (Boolean) 


567
568
569
 
# File 'app/models/spree/order.rb', line 567

def approved?
  !!approved_at
end

#assign_billing_to_shipping_address ⇒ Object 



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

def assign_billing_to_shipping_address
  self.ship_address = bill_address if bill_address
  true
end

#associate_user!(user, override_email = true) ⇒ Object

Associates the specified user with the order.



260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'app/models/spree/order.rb', line 260

def associate_user!(user, override_email = true)
  self.user = user
  attrs_to_set = { user_id: user.try(:id) }
  attrs_to_set[:email] = user.try(:email) if override_email
  attrs_to_set[:created_by_id] = user.try(:id) if created_by.blank?

  if persisted?
    # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
    self.class.unscoped.where(id: id).update_all(attrs_to_set)
  end

  assign_attributes(attrs_to_set)
end

#available_payment_methods ⇒ Object 



416
417
418
419
420
421
422
423
 
# File 'app/models/spree/order.rb', line 416

def available_payment_methods
  @available_payment_methods ||= (
    PaymentMethod.available(:front_end, store: store) +
    PaymentMethod.available(:both, store: store)
  ).
  uniq.
  sort_by(&:position)
end

#backordered? ⇒ Boolean

Returns:

  • (Boolean) 


206
207
208
 
# File 'app/models/spree/order.rb', line 206

def backordered?
  shipments.any?(&:backordered?)
end

#can_add_coupon? ⇒ Boolean

Returns:

  • (Boolean) 


484
485
486
 
# File 'app/models/spree/order.rb', line 484

def can_add_coupon?
  Spree::Promotion.order_activatable?(self)
end

#can_approve? ⇒ Boolean

Returns:

  • (Boolean) 


571
572
573
 
# File 'app/models/spree/order.rb', line 571

def can_approve?
  !approved?
end

#can_ship? ⇒ Boolean

Returns:

  • (Boolean) 


364
365
366
 
# File 'app/models/spree/order.rb', line 364

def can_ship?
  complete? || resumed? || awaiting_return? || returned?
end

#canceled_by(user) ⇒ Object 



557
558
559
560
561
562
563
564
565
 
# File 'app/models/spree/order.rb', line 557

def canceled_by(user)
  transaction do
    cancel!
    update_columns(
      canceler_id: user.id,
      canceled_at: Time.current
    )
  end
end

#cancellations ⇒ Object 



255
256
257
 
# File 'app/models/spree/order.rb', line 255

def cancellations
  @cancellations ||= Spree::OrderCancellations.new(self)
end

#checkout_allowed? ⇒ Boolean

Indicates whether or not the user is allowed to proceed to checkout. Currently this is implemented as a check for whether or not there is at least one LineItem in the Order. Feel free to override this logic in your own application if you require additional steps before allowing a checkout.

Returns:

  • (Boolean) 


192
193
194
 
# File 'app/models/spree/order.rb', line 192

def checkout_allowed?
  line_items.count > 0
end

#completed? ⇒ Boolean

Returns:

  • (Boolean) 


184
185
186
 
# File 'app/models/spree/order.rb', line 184

def completed?
  completed_at.present?
end

#confirmation_required? ⇒ Boolean

Returns:

  • (Boolean) 


201
202
203
 
# File 'app/models/spree/order.rb', line 201

def confirmation_required?
  true
end

#contains?(variant, options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


299
300
301
 
# File 'app/models/spree/order.rb', line 299

def contains?(variant, options = {})
  find_line_item_by_variant(variant, options).present?
end

#contents ⇒ Object 



247
248
249
 
# File 'app/models/spree/order.rb', line 247

def contents
  @contents ||= Spree::OrderContents.new(self)
end

#covered_by_store_credit? ⇒ Boolean Also known as: covered_by_store_credit

Returns:

  • (Boolean) 


661
662
663
664
 
# File 'app/models/spree/order.rb', line 661

def covered_by_store_credit?
  return false unless user
  user.total_available_store_credit >= total
end

#create_proposed_shipments ⇒ Object 



498
499
500
501
502
503
504
505
506
507
508
509
 
# File 'app/models/spree/order.rb', line 498

def create_proposed_shipments
  return shipments if unreturned_exchange?

  if completed?
    raise CannotRebuildShipments.new(Spree.t(:cannot_rebuild_shipments_order_completed))
  elsif shipments.any? { |s| !s.pending? }
    raise CannotRebuildShipments.new(Spree.t(:cannot_rebuild_shipments_shipments_not_pending))
  else
    shipments.destroy_all
    self.shipments = Spree::Config.stock.coordinator_class.new(self).shipments
  end
end

#create_tax_charge! ⇒ Object

Creates new tax charges if there are any applicable rates. If prices already include taxes then price adjustments are created instead.



334
335
336
 
# File 'app/models/spree/order.rb', line 334

def create_tax_charge!
  Spree::Tax::OrderAdjuster.new(self).adjust!
end

#credit_cards ⇒ Object 



368
369
370
371
 
# File 'app/models/spree/order.rb', line 368

def credit_cards
  credit_card_ids = payments.from_credit_card.pluck(:source_id).uniq
  CreditCard.where(id: credit_card_ids)
end

#currency ⇒ Object 



172
173
174
 
# File 'app/models/spree/order.rb', line 172

def currency
  self[:currency] || Spree::Config[:currency]
end

#deliver_order_confirmation_email ⇒ Object 



406
407
408
409
 
# File 'app/models/spree/order.rb', line 406

def deliver_order_confirmation_email
  OrderMailer.confirm_email(self).deliver_later
  update_column(:confirmation_delivered, true)
end

#discounted_item_amount ⇒ Object

Sum of all line item amounts after promotions, before added tax



168
169
170
 
# File 'app/models/spree/order.rb', line 168

def discounted_item_amount
  line_items.to_a.sum(&:discounted_amount)
end

#display_store_credit_remaining_after_capture ⇒ Object 



688
689
690
 
# File 'app/models/spree/order.rb', line 688

def display_store_credit_remaining_after_capture
  Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: currency })
end

#display_total_applicable_store_credit ⇒ Object 



684
685
686
 
# File 'app/models/spree/order.rb', line 684

def display_total_applicable_store_credit
  Spree::Money.new(-total_applicable_store_credit, { currency: currency })
end

#empty! ⇒ Object 



446
447
448
449
450
451
452
453
454
 
# File 'app/models/spree/order.rb', line 446

def empty!
  line_items.destroy_all
  updater.update_item_count
  adjustments.destroy_all
  shipments.destroy_all

  update_totals
  persist_totals
end

#ensure_line_item_variants_are_not_deleted ⇒ Object

Check to see if any line item variants are soft, deleted. If so add error and restart checkout.



432
433
434
435
436
437
438
439
440
 
# File 'app/models/spree/order.rb', line 432

def ensure_line_item_variants_are_not_deleted
  if line_items.any? { |li| li.variant.paranoia_destroyed? }
    errors.add(:base, Spree.t(:deleted_variants_present))
    restart_checkout_flow
    false
  else
    true
  end
end

#ensure_shipping_address ⇒ Object 



492
493
494
495
496
 
# File 'app/models/spree/order.rb', line 492

def ensure_shipping_address
  unless ship_address && ship_address.valid?
    errors.add(:base, Spree.t(:ship_address_required)) && (return false)
  end
end

#ensure_updated_shipments ⇒ Object

Clean shipments and make order back to address state

At some point the might need to force the order to transition from address to delivery again so that proper updated shipments are created. e.g. customer goes back from payment step and changes order items



521
522
523
524
525
526
527
 
# File 'app/models/spree/order.rb', line 521

def ensure_updated_shipments
  if !completed? && shipments.all?(&:pending?)
    shipments.destroy_all
    update_column(:shipment_total, 0)
    restart_checkout_flow
  end
end

#finalize! ⇒ Object

Finalizes an in progress order after checkout is complete. Called after transition to complete state when payments will have been processed



380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'app/models/spree/order.rb', line 380

def finalize!
  # lock all adjustments (coupon promotions, etc.)
  all_adjustments.each(&:finalize!)

  # update payment and shipment(s) states, and save
  updater.update_payment_state
  shipments.each do |shipment|
    shipment.update!(self)
    shipment.finalize!
  end

  updater.update_shipment_state
  save!
  updater.run_hooks

  touch :completed_at

  deliver_order_confirmation_email unless confirmation_delivered?
end

#find_line_item_by_variant(variant, options = {}) ⇒ Object 



308
309
310
311
312
313
 
# File 'app/models/spree/order.rb', line 308

def find_line_item_by_variant(variant, options = {})
  line_items.detect { |line_item|
                line_item.variant_id == variant.id &&
                  line_item_options_match(line_item, options)
  }
end

#fulfill! ⇒ Object 



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

def fulfill!
  shipments.each { |shipment| shipment.update!(self) if shipment.persisted? }
  updater.update_shipment_state
  save!
end

#fully_discounted? ⇒ Boolean Also known as: fully_discounted

Deprecated.

Do not use this method. Behaviour is unreliable.

Returns:

  • (Boolean) 


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

def fully_discounted?
  adjustment_total + line_items.map(&:final_amount).sum == 0.0
end

#generate_order_number(options = {}) ⇒ Object 



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'app/models/spree/order.rb', line 274

def generate_order_number(options = {})
  options[:length]  ||= ORDER_NUMBER_LENGTH
  options[:letters] ||= ORDER_NUMBER_LETTERS
  options[:prefix]  ||= ORDER_NUMBER_PREFIX

  possible = (0..9).to_a
  possible += ('A'..'Z').to_a if options[:letters]

  self.number ||= loop do
    # Make a random number.
    random = "#{options[:prefix]}#{(0...options[:length]).map { possible.sample }.join}"
    # Use the random  number if no other order exists with it.
    if self.class.exists?(number: random)
      # If over half of all possible options are taken add another digit.
      options[:length] += 1 if self.class.count > (10**options[:length] / 2)
    else
      break random
    end
  end
end

#has_non_reimbursement_related_refunds? ⇒ Boolean

Returns:

  • (Boolean) 


584
585
586
587
 
# File 'app/models/spree/order.rb', line 584

def has_non_reimbursement_related_refunds?
  refunds.non_reimbursement.exists? ||
    payments.offset_payment.exists? # how old versions of spree stored refunds
end

#has_step?(step) ⇒ Boolean

Returns:

  • (Boolean) 


456
457
458
 
# File 'app/models/spree/order.rb', line 456

def has_step?(step)
  checkout_steps.include?(step)
end

#insufficient_stock_lines ⇒ Object 



425
426
427
 
# File 'app/models/spree/order.rb', line 425

def insufficient_stock_lines
  line_items.select(&:insufficient_stock?)
end

#is_risky? ⇒ Boolean

Returns:

  • (Boolean) 


553
554
555
 
# File 'app/models/spree/order.rb', line 553

def is_risky?
  payments.risky.count > 0
end

#line_item_options_match(line_item, options) ⇒ Object

This method enables extensions to participate in the “Are these line items equal” decision.

When adding to cart, an extension would send something like: params=…

and would provide:

def product_customizations_match



324
325
326
327
328
329
330
 
# File 'app/models/spree/order.rb', line 324

def line_item_options_match(line_item, options)
  return true unless options

  line_item_comparison_hooks.all? { |hook|
    send(hook, line_item, options)
  }
end

#merge!(*args) ⇒ Object 



442
443
444
 
# File 'app/models/spree/order.rb', line 442

def merge!(*args)
  Spree::Config.order_merger_class.new(self).merge!(*args)
end

#name ⇒ Object 



358
359
360
361
362
 
# File 'app/models/spree/order.rb', line 358

def name
  if (address = bill_address || ship_address)
    "#{address.firstname} #{address.lastname}"
  end
end

#order_total_after_store_credit ⇒ Object 



672
673
674
 
# File 'app/models/spree/order.rb', line 672

def order_total_after_store_credit
  total - total_applicable_store_credit
end

#outstanding_balance ⇒ Object 



338
339
340
341
342
343
344
345
346
347
348
 
# File 'app/models/spree/order.rb', line 338

def outstanding_balance
  # If reimbursement has happened add it back to total to prevent balance_due payment state
  # See: https://github.com/spree/spree/issues/6229
  adjusted_payment_total = payment_total + refund_total

  if state == 'canceled'
    -1 * adjusted_payment_total
  else
    total - adjusted_payment_total
  end
end

#outstanding_balance? ⇒ Boolean

Returns:

  • (Boolean) 


350
351
352
 
# File 'app/models/spree/order.rb', line 350

def outstanding_balance?
  outstanding_balance != 0
end

#paid? ⇒ Boolean

Helper methods for checkout steps

Returns:

  • (Boolean) 


412
413
414
 
# File 'app/models/spree/order.rb', line 412

def paid?
  %w(paid credit_owed).include?(payment_state)
end

#payment_required? ⇒ Boolean

Is this a free order in which case the payment step should be skipped

Returns:

  • (Boolean) 


197
198
199
 
# File 'app/models/spree/order.rb', line 197

def payment_required?
  total.to_f > 0.0
end

#pre_tax_item_amount ⇒ Object

Sum of all line item amounts pre-tax



163
164
165
 
# File 'app/models/spree/order.rb', line 163

def pre_tax_item_amount
  line_items.to_a.sum(&:pre_tax_amount)
end

#quantity ⇒ Object 



580
581
582
 
# File 'app/models/spree/order.rb', line 580

def quantity
  line_items.sum(:quantity)
end

#quantity_of(variant, options = {}) ⇒ Object 



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

def quantity_of(variant, options = {})
  line_item = find_line_item_by_variant(variant, options)
  line_item ? line_item.quantity : 0
end

#refresh_shipment_rates ⇒ Object 



539
540
541
 
# File 'app/models/spree/order.rb', line 539

def refresh_shipment_rates
  shipments.map(&:refresh_rates)
end

#refund_total ⇒ Object 



354
355
356
 
# File 'app/models/spree/order.rb', line 354

def refund_total
  payments.flat_map(&:refunds).sum(&:amount)
end

#reload(options = nil) ⇒ Object 



575
576
577
578
 
# File 'app/models/spree/order.rb', line 575

def reload(options = nil)
  remove_instance_variable(:@tax_zone) if defined?(@tax_zone)
  super
end

#restart_checkout_flow ⇒ Object 



529
530
531
532
533
534
535
536
537
 
# File 'app/models/spree/order.rb', line 529

def restart_checkout_flow
  return if state == 'cart'

  update_columns(
    state: 'cart',
    updated_at: Time.current
  )
  next! if line_items.size > 0
end

#set_shipments_cost ⇒ Object 



547
548
549
550
551
 
# File 'app/models/spree/order.rb', line 547

def set_shipments_cost
  shipments.each(&:update_amounts)
  updater.update_shipment_total
  persist_totals
end

#shipped? ⇒ Boolean

Returns:

  • (Boolean) 


488
489
490
 
# File 'app/models/spree/order.rb', line 488

def shipped?
  %w(partial shipped).include?(shipment_state)
end

#shipped_shipments ⇒ Object 



295
296
297
 
# File 'app/models/spree/order.rb', line 295

def shipped_shipments
  shipments.shipped
end

#shipping ⇒ Object 



251
252
253
 
# File 'app/models/spree/order.rb', line 251

def shipping
  @shipping ||= Spree::OrderShipping.new(self)
end

#shipping_discount ⇒ Object 



176
177
178
 
# File 'app/models/spree/order.rb', line 176

def shipping_discount
  shipment_adjustments.eligible.sum(:amount) * - 1
end

#shipping_eq_billing_address? ⇒ Boolean

Returns:

  • (Boolean) 


543
544
545
 
# File 'app/models/spree/order.rb', line 543

def shipping_eq_billing_address?
  bill_address == ship_address
end

#state_changed(name) ⇒ Object 



460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
 
# File 'app/models/spree/order.rb', line 460

def state_changed(name)
  state = "#{name}_state"
  if persisted?
    old_state = send("#{state}_was")
    new_state = send(state)
    unless old_state == new_state
      state_changes.create(
        previous_state: old_state,
        next_state:     new_state,
        name:           name,
        user_id:        user_id
      )
    end
  end
end

#tax_address ⇒ Object

Returns the address for taxation based on configuration



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

def tax_address
  if Spree::Config[:tax_using_ship_address]
    ship_address
  else
    bill_address
  end || store.default_cart_tax_location
end

#tax_total ⇒ Object 



613
614
615
 
# File 'app/models/spree/order.rb', line 613

def tax_total
  additional_tax_total + included_tax_total
end

#tax_zone ⇒ Object

Returns the relevant zone (if any) to be used for taxation purposes. Uses default tax zone unless there is a specific match



212
213
214
 
# File 'app/models/spree/order.rb', line 212

def tax_zone
  @tax_zone ||= Zone.match(tax_address) || Zone.default_tax
end

#to_param ⇒ Object 



180
181
182
 
# File 'app/models/spree/order.rb', line 180

def to_param
  number
end

#token ⇒ Object 



589
590
591
592
 
# File 'app/models/spree/order.rb', line 589

def token
  Spree::Deprecation.warn("Spree::Order#token is DEPRECATED, please use #guest_token instead.", caller)
  guest_token
end

#total_applicable_store_credit ⇒ Object 



676
677
678
679
680
681
682
 
# File 'app/models/spree/order.rb', line 676

def total_applicable_store_credit
  if confirm? || complete?
    payments.store_credits.valid.sum(:amount)
  else
    [total, (user.try(:total_available_store_credit) || 0.0)].min
  end
end

#total_available_store_credit ⇒ Object 



667
668
669
670
 
# File 'app/models/spree/order.rb', line 667

def total_available_store_credit
  return 0.0 unless user
  user.total_available_store_credit
end

#unreturned_exchange? ⇒ Boolean

Returns:

  • (Boolean) 


601
602
603
604
605
606
607
608
609
610
611
 
# File 'app/models/spree/order.rb', line 601

def unreturned_exchange?
  # created_at - 1 is a hack to ensure that this doesn't blow up on MySQL,
  # records loaded from the DB on MySQL will have a precision of 1 second,
  # but records in memory may still have miliseconds on them, causing this
  # to be true where it shouldn't be.
  #
  # FIXME: find a better way to determine if an order is an unreturned
  # exchange
  shipment = shipments.first
  shipment.present? ? (shipment.created_at < created_at - 1) : false
end

#update! ⇒ Object 



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

def update!
  updater.update
end

#updater ⇒ Object 



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

def updater
  @updater ||= OrderUpdater.new(self)
end

#valid_credit_cards ⇒ Object 



373
374
375
376
 
# File 'app/models/spree/order.rb', line 373

def valid_credit_cards
  credit_card_ids = payments.from_credit_card.valid.pluck(:source_id).uniq
  CreditCard.where(id: credit_card_ids)
end