Class: Spree::Shipment

Inherits:
Base
  • Object
show all
Defined in:
app/models/spree/shipment.rb

Defined Under Namespace

Classes: ManifestItem

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Base

page

Methods included from Preferences::Preferable

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

Instance Attribute Details

#special_instructions ⇒ Object

Returns the value of attribute special_instructions.



19
20
21
 
# File 'app/models/spree/shipment.rb', line 19

def special_instructions
  @special_instructions
end

Instance Method Details

#add_shipping_method(shipping_method, selected = false) ⇒ Object 



77
78
79
 
# File 'app/models/spree/shipment.rb', line 77

def add_shipping_method(shipping_method, selected = false)
  shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
end

#after_cancel ⇒ Object 



81
82
83
 
# File 'app/models/spree/shipment.rb', line 81

def after_cancel
  manifest.each { |item| manifest_restock(item) }
end

#after_resume ⇒ Object 



85
86
87
 
# File 'app/models/spree/shipment.rb', line 85

def after_resume
  manifest.each { |item| manifest_unstock(item) }
end

#backordered? ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'app/models/spree/shipment.rb', line 89

def backordered?
  inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
end

#currency ⇒ Object 



93
94
95
 
# File 'app/models/spree/shipment.rb', line 93

def currency
  order ? order.currency : Spree::Config[:currency]
end

#determine_state(order) ⇒ Object

Determines the appropriate state according to the following logic:

pending unless order is complete and order.payment_state is paid shipped if already shipped (ie. does not change the state) ready all other cases



102
103
104
105
106
107
108
 
# File 'app/models/spree/shipment.rb', line 102

def determine_state(order)
  return 'canceled' if order.canceled?
  return 'pending' unless order.can_ship?
  return 'pending' if inventory_units.any? &:backordered?
  return 'shipped' if state == 'shipped'
  order.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
end

#discounted_cost ⇒ Object Also known as: discounted_amount 



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

def discounted_cost
  cost + promo_total
end

#display_cost ⇒ Object Also known as: display_amount 



115
116
117
 
# File 'app/models/spree/shipment.rb', line 115

def display_cost
  Spree::Money.new(cost, { currency: currency })
end

#display_discounted_cost ⇒ Object 



120
121
122
 
# File 'app/models/spree/shipment.rb', line 120

def display_discounted_cost
  Spree::Money.new(discounted_cost, { currency: currency })
end

#display_final_price ⇒ Object 



124
125
126
 
# File 'app/models/spree/shipment.rb', line 124

def display_final_price
  Spree::Money.new(final_price, { currency: currency })
end

#display_item_cost ⇒ Object 



128
129
130
 
# File 'app/models/spree/shipment.rb', line 128

def display_item_cost
  Spree::Money.new(item_cost, { currency: currency })
end

#editable_by?(user) ⇒ Boolean

Returns:

  • (Boolean) 


132
133
134
 
# File 'app/models/spree/shipment.rb', line 132

def editable_by?(user)
  !shipped?
end

#final_price ⇒ Object 



136
137
138
 
# File 'app/models/spree/shipment.rb', line 136

def final_price
  cost + adjustment_total
end

#final_price_with_items ⇒ Object 



140
141
142
 
# File 'app/models/spree/shipment.rb', line 140

def final_price_with_items
  item_cost + final_price
end

#finalize! ⇒ Object 



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

def finalize!
  InventoryUnit.finalize_units!(inventory_units)
  manifest.each { |item| manifest_unstock(item) }
end

#include?(variant) ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
 
# File 'app/models/spree/shipment.rb', line 149

def include?(variant)
  inventory_units_for(variant).present?
end

#inventory_units_for(variant) ⇒ Object 



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

def inventory_units_for(variant)
  inventory_units.where(variant_id: variant.id)
end

#inventory_units_for_item(line_item, variant = nil) ⇒ Object 



157
158
159
 
# File 'app/models/spree/shipment.rb', line 157

def inventory_units_for_item(line_item, variant = nil)
  inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant.id || variant.id)
end

#item_cost ⇒ Object 



161
162
163
 
# File 'app/models/spree/shipment.rb', line 161

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

#line_items ⇒ Object 



165
166
167
 
# File 'app/models/spree/shipment.rb', line 165

def line_items
  inventory_units.includes(:line_item).map(&:line_item).uniq
end

#manifest ⇒ Object 



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'app/models/spree/shipment.rb', line 171

def manifest
  # Grouping by the ID means that we don't have to call out to the association accessor
  # This makes the grouping by faster because it results in less SQL cache hits.
  inventory_units.group_by(&:variant_id).map do |variant_id, units|
    units.group_by(&:line_item_id).map do |line_item_id, units|

      states = {}
      units.group_by(&:state).each { |state, iu| states[state] = iu.count }

      line_item = units.first.line_item
      variant = units.first.variant
      ManifestItem.new(line_item, variant, units.length, states)
    end
  end.flatten
end

#process_order_payments ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'app/models/spree/shipment.rb', line 187

def process_order_payments
  pending_payments =  order.pending_payments
                        .sort_by(&:uncaptured_amount).reverse

  # NOTE Do we really need to force orders to have pending payments on dispatch?
  if pending_payments.empty?
    raise Spree::Core::GatewayError, Spree.t(:no_pending_payments)
  else
    shipment_to_pay = final_price_with_items
    payments_amount = 0

    payments_pool = pending_payments.each_with_object([]) do |payment, pool|
      next if payments_amount >= shipment_to_pay
      payments_amount += payment.uncaptured_amount
      pool << payment
    end

    payments_pool.each do |payment|
      capturable_amount = if payment.amount >= shipment_to_pay
                            shipment_to_pay
                          else
                            payment.amount
                          end
      cents = (capturable_amount * 100).to_i
      payment.capture!(cents)
      shipment_to_pay -= capturable_amount
    end
  end
rescue Spree::Core::GatewayError => e
  errors.add(:base, e.message)
  return !!Spree::Config[:allow_checkout_on_gateway_error]
end

#ready_or_pending? ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
 
# File 'app/models/spree/shipment.rb', line 220

def ready_or_pending?
  self.ready? || self.pending?
end

#refresh_rates ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'app/models/spree/shipment.rb', line 224

def refresh_rates
  return shipping_rates if shipped?
  return [] unless can_get_rates?

  # StockEstimator.new assigment below will replace the current shipping_method
  original_shipping_method_id = shipping_method.try(:id)

  self.shipping_rates = Stock::Estimator.new(order).shipping_rates(to_package)

  if shipping_method
    selected_rate = shipping_rates.detect { |rate|
      rate.shipping_method_id == original_shipping_method_id
    }
    self.selected_shipping_rate_id = selected_rate.id if selected_rate
  end

  shipping_rates
end

#selected_shipping_rate ⇒ Object 



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

def selected_shipping_rate
  shipping_rates.where(selected: true).first
end

#selected_shipping_rate_id ⇒ Object 



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

def selected_shipping_rate_id
  selected_shipping_rate.try(:id)
end

#selected_shipping_rate_id=(id) ⇒ Object 



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

def selected_shipping_rate_id=(id)
  shipping_rates.update_all(selected: false)
  shipping_rates.update(id, selected: true)
  self.save!
end

#set_up_inventory(state, variant, order, line_item) ⇒ Object 



257
258
259
260
261
262
263
264
 
# File 'app/models/spree/shipment.rb', line 257

def set_up_inventory(state, variant, order, line_item)
  self.inventory_units.create(
    state: state,
    variant_id: variant.id,
    order_id: order.id,
    line_item_id: line_item.id
  )
end

#shipped=(value) ⇒ Object 



266
267
268
269
 
# File 'app/models/spree/shipment.rb', line 266

def shipped=(value)
  return unless value == '1' && shipped_at.nil?
  self.shipped_at = Time.now
end

#shipping_method ⇒ Object 



271
272
273
 
# File 'app/models/spree/shipment.rb', line 271

def shipping_method
  selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
end

#tax_category ⇒ Object 



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

def tax_category
  selected_shipping_rate.try(:tax_rate).try(:tax_category)
end

#tax_total ⇒ Object

Only one of either included_tax_total or additional_tax_total is set This method returns the total of the two. Saves having to check if tax is included or additional.



282
283
284
 
# File 'app/models/spree/shipment.rb', line 282

def tax_total
  included_tax_total + additional_tax_total
end

#to_package ⇒ Object 



286
287
288
289
290
291
292
 
# File 'app/models/spree/shipment.rb', line 286

def to_package
  package = Stock::Package.new(stock_location)
  inventory_units.group_by(&:state).each do |state, state_inventory_units|
    package.add_multiple state_inventory_units, state.to_sym
  end
  package
end

#to_param ⇒ Object 



294
295
296
 
# File 'app/models/spree/shipment.rb', line 294

def to_param
  number
end

#tracking_url ⇒ Object 



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

def tracking_url
  @tracking_url ||= shipping_method.build_tracking_url(tracking)
end

#transfer_to_location(variant, quantity, stock_location) ⇒ Object 



355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File 'app/models/spree/shipment.rb', line 355

def transfer_to_location(variant, quantity, stock_location)
  if quantity <= 0
    raise ArgumentError
  end

  transaction do
    new_shipment = order.shipments.create!(stock_location: stock_location)

    order.contents.remove(variant, quantity, {shipment: self})
    order.contents.add(variant, quantity, {shipment: new_shipment})

    refresh_rates
    save!
    new_shipment.save!
  end
end

#transfer_to_shipment(variant, quantity, shipment_to_transfer_to) ⇒ Object 



372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
 
# File 'app/models/spree/shipment.rb', line 372

def transfer_to_shipment(variant, quantity, shipment_to_transfer_to)
  quantity_already_shipment_to_transfer_to = shipment_to_transfer_to.manifest.find{|mi| mi.line_item.variant == variant}.try(:quantity) || 0
  final_quantity = quantity + quantity_already_shipment_to_transfer_to

  if (quantity <= 0 || self == shipment_to_transfer_to)
    raise ArgumentError
  end

  transaction do
    order.contents.remove(variant, quantity, {shipment: self})
    order.contents.add(variant, quantity, {shipment: shipment_to_transfer_to})

    refresh_rates
    save!
    shipment_to_transfer_to.refresh_rates
    shipment_to_transfer_to.save!
  end
end

#update!(order) ⇒ Object

Updates various aspects of the Shipment while bypassing any callbacks. Note that this method takes an explicit reference to the Order object. This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not yield the correct results.



345
346
347
348
349
350
351
352
353
 
# File 'app/models/spree/shipment.rb', line 345

def update!(order)
  old_state = state
  new_state = determine_state(order)
  update_columns(
    state: new_state,
    updated_at: Time.now,
  )
  after_ship if new_state == 'shipped' and old_state != 'shipped'
end

#update_amounts ⇒ Object 



302
303
304
305
306
307
308
309
310
 
# File 'app/models/spree/shipment.rb', line 302

def update_amounts
  if selected_shipping_rate
    self.update_columns(
      cost: selected_shipping_rate.cost,
      adjustment_total: adjustments.additional.map(&:update!).compact.sum,
      updated_at: Time.now,
    )
  end
end

#update_attributes_and_order(params = {}) ⇒ Object

Update Shipment and make sure Order states follow the shipment changes



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'app/models/spree/shipment.rb', line 313

def update_attributes_and_order(params = {})
  if self.update_attributes params
    if params.has_key? :selected_shipping_rate_id
      # Changing the selected Shipping Rate won't update the cost (for now)
      # so we persist the Shipment#cost before calculating order shipment
      # total and updating payment state (given a change in shipment cost
      # might change the Order#payment_state)
      self.update_amounts

      order.updater.update_shipment_total
      order.updater.update_payment_state

      # Update shipment state only after order total is updated because it
      # (via Order#paid?) affects the shipment state (YAY)
      self.update_columns(
        state: determine_state(order),
        updated_at: Time.now
      )

      # And then it's time to update shipment states and finally persist
      # order changes
      order.updater.update_shipment_state
      order.updater.persist_totals
    end

    true
  end
end