Class: Spree::Shipment

Inherits:
Base
  • Object
show all
Extended by:
FriendlyId, DisplayMoney
Includes:
NumberGenerator
Defined in:
app/models/spree/shipment.rb

Defined Under Namespace

Classes: ManifestItem

Constant Summary

Constants included from NumberGenerator

NumberGenerator::NUMBER_LENGTH, NumberGenerator::NUMBER_LETTERS, NumberGenerator::NUMBER_PREFIX

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from DisplayMoney

money_methods

Methods included from NumberGenerator

by_number

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_instructionsObject

Returns the value of attribute special_instructions.



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

def special_instructions
  @special_instructions
end

Instance Method Details

#add_shipping_method(shipping_method, selected = false) ⇒ Object



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

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

#after_cancelObject



96
97
98
# File 'app/models/spree/shipment.rb', line 96

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

#after_resumeObject



100
101
102
# File 'app/models/spree/shipment.rb', line 100

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

#backordered?Boolean

Returns:

  • (Boolean)


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

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

#currencyObject



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

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



117
118
119
120
121
122
123
# File 'app/models/spree/shipment.rb', line 117

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_costObject Also known as: discounted_amount



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

def discounted_cost
  cost + promo_total
end

#editable_by?(user) ⇒ Boolean

Returns:

  • (Boolean)


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

def editable_by?(user)
  !shipped?
end

#final_priceObject



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

def final_price
  cost + adjustment_total
end

#final_price_with_itemsObject



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

def final_price_with_items
  item_cost + final_price
end

#finalize!Object



142
143
144
145
# File 'app/models/spree/shipment.rb', line 142

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

#generate_number(options = {}) ⇒ Object



10
11
12
13
14
# File 'app/models/spree/shipment.rb', line 10

def generate_number(options = {})
  options[:prefix] ||= 'H'
  options[:length] ||= 11
  super(options)
end

#include?(variant) ⇒ Boolean

Returns:

  • (Boolean)


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

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

#inventory_units_for(variant) ⇒ Object



151
152
153
# File 'app/models/spree/shipment.rb', line 151

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

#inventory_units_for_item(line_item, variant = nil) ⇒ Object



155
156
157
# File 'app/models/spree/shipment.rb', line 155

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_costObject



159
160
161
# File 'app/models/spree/shipment.rb', line 159

def item_cost
  manifest.map { |m| (m.line_item.price + (m.line_item.adjustment_total / m.line_item.quantity)) * m.quantity }.sum
end

#line_itemsObject



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

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

#manifestObject



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

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_paymentsObject



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
# File 'app/models/spree/shipment.rb', line 185

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

  shipment_to_pay = final_price_with_items
  payments_amount = 0

  payments_pool = pending_payments.each_with_object([]) do |payment, pool|
    break 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

#ready_or_pending?Boolean

Returns:

  • (Boolean)


211
212
213
# File 'app/models/spree/shipment.rb', line 211

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

#refresh_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END) ⇒ Object



215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
# File 'app/models/spree/shipment.rb', line 215

def refresh_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
  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, shipping_method_filter)

  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_rateObject



235
236
237
# File 'app/models/spree/shipment.rb', line 235

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

#selected_shipping_rate_idObject



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

def selected_shipping_rate_id
  selected_shipping_rate.try(:id)
end

#selected_shipping_rate_id=(id) ⇒ Object



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

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



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

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



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

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

#shipping_methodObject



263
264
265
# File 'app/models/spree/shipment.rb', line 263

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

#tax_categoryObject



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

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

#tax_totalObject

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.



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

def tax_total
  included_tax_total + additional_tax_total
end

#to_packageObject



278
279
280
281
282
283
284
# File 'app/models/spree/shipment.rb', line 278

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

#tracking_urlObject



286
287
288
# File 'app/models/spree/shipment.rb', line 286

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

#transfer_to_location(variant, quantity, stock_location) ⇒ Object



343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
# File 'app/models/spree/shipment.rb', line 343

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



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
# File 'app/models/spree/shipment.rb', line 360

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.



333
334
335
336
337
338
339
340
341
# File 'app/models/spree/shipment.rb', line 333

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_amountsObject



290
291
292
293
294
295
296
297
298
# File 'app/models/spree/shipment.rb', line 290

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



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
# File 'app/models/spree/shipment.rb', line 301

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