solidus_core 1.0.0.pre

data/app/models/spree/order_cancellations.rb

@@ -0,0 +1,72 @@
+# This class represents all of the actions one can take to modify an Order after it is complete
+class Spree::OrderCancellations
+
+  # If you need to message a third party service when an item is canceled then
+  # set short_ship_tax_notifier to an object that responds to:
+  #     #call(unit_cancels)
+  class_attribute :short_ship_tax_notifier
+
+  # allows sending an email when inventory is cancelled
+  class_attribute :send_cancellation_mailer
+  self.send_cancellation_mailer = true
+
+  def initialize(order)
+    @order = order
+  end
+
+  def short_ship(inventory_units, whodunnit:nil)
+    if inventory_units.map(&:order_id).uniq != [@order.id]
+      raise ArgumentError, "Not all inventory units belong to this order"
+    end
+
+    unit_cancels = []
+
+    Spree::OrderMutex.with_lock!(@order) do
+
+      Spree::InventoryUnit.transaction do
+        inventory_units.each do |iu|
+          unit_cancels << short_ship_unit(iu, whodunnit: whodunnit)
+        end
+
+        update_shipped_shipments(inventory_units)
+        Spree::OrderMailer.inventory_cancellation_email(@order, inventory_units).deliver if Spree::OrderCancellations.send_cancellation_mailer
+      end
+
+      @order.update!
+
+      if short_ship_tax_notifier
+        short_ship_tax_notifier.call(unit_cancels)
+      end
+    end
+
+    unit_cancels
+  end
+
+  private
+
+  def short_ship_unit(inventory_unit, whodunnit:nil)
+    unit_cancel = Spree::UnitCancel.create!(
+      inventory_unit: inventory_unit,
+      reason: Spree::UnitCancel::SHORT_SHIP,
+      created_by: whodunnit,
+    )
+    unit_cancel.adjust!
+    inventory_unit.cancel!
+
+    unit_cancel
+  end
+
+  # if any shipments are now fully shipped then mark them as such
+  def update_shipped_shipments(inventory_units)
+    shipments = Spree::Shipment.
+      includes(:inventory_units).
+      where(id: inventory_units.map(&:shipment_id)).
+      to_a
+
+    shipments.each do |shipment|
+      if shipment.inventory_units.all? {|iu| iu.shipped? || iu.canceled? }
+        shipment.update_attributes!(state: 'shipped', shipped_at: Time.now)
+      end
+    end
+  end
+end

data/app/models/spree/order_capturing.rb

@@ -0,0 +1,49 @@
+class Spree::OrderCapturing
+  # Allows for prioritizing payment methods in the order to be captured
+  class_attribute :sorted_payment_method_classes
+  self.sorted_payment_method_classes = []
+
+  # Allows your store to void unused payments and release auths
+  class_attribute :void_unused_payments
+  self.void_unused_payments = false
+
+  class_attribute :failure_handler
+  self.failure_handler = ->(failures) { raise Spree::OrderCapturingFailures.new(failures.to_json) }
+
+  def initialize(order, sorted_payment_method_classes = nil)
+    @order = order
+    @sorted_payment_method_classes = sorted_payment_method_classes || Spree::OrderCapturing.sorted_payment_method_classes
+  end
+
+  def capture_payments
+    return if @order.paid?
+
+    Spree::OrderMutex.with_lock!(@order) do
+      uncaptured_amount = @order.display_total.cents
+
+      begin
+        sorted_payments(@order).each do |payment|
+          amount = [uncaptured_amount, payment.money.cents].min
+
+          if amount > 0
+            payment.capture!(amount)
+            uncaptured_amount -= amount
+          elsif Spree::OrderCapturing.void_unused_payments
+            payment.void_transaction!
+          end
+        end
+      ensure
+        @order.update!
+      end
+    end
+  end
+
+  private
+
+  def sorted_payments(order)
+    payments = order.pending_payments
+    payments = payments.sort_by { |p| [@sorted_payment_method_classes.index(p.payment_method.class), p.id] }
+  end
+end
+
+class Spree::OrderCapturingFailures < StandardError; end

data/app/models/spree/order_contents.rb

@@ -0,0 +1,125 @@
+module Spree
+  class OrderContents
+    attr_accessor :order, :currency
+
+    def initialize(order)
+      @order = order
+    end
+
+    def add(variant, quantity = 1, options = {})
+      line_item = add_to_line_item(variant, quantity, options)
+      after_add_or_remove(line_item, options)
+    end
+
+    def remove(variant, quantity = 1, options = {})
+      line_item = remove_from_line_item(variant, quantity, options)
+      after_add_or_remove(line_item, options)
+    end
+
+    def update_cart(params)
+      if order.update_attributes(params)
+        unless order.completed?
+          order.line_items = order.line_items.select {|li| li.quantity > 0 }
+          # Update totals, then check if the order is eligible for any cart promotions.
+          # If we do not update first, then the item total will be wrong and ItemTotal
+          # promotion rules would not be triggered.
+          reload_totals
+          PromotionHandler::Cart.new(order).activate
+          order.ensure_updated_shipments
+        end
+        reload_totals
+        true
+      else
+        false
+      end
+    end
+
+    def advance
+      while @order.next; end
+    end
+
+    def approve(user: nil, name: nil)
+      if user.blank? && name.blank?
+        raise ArgumentError, 'user or name must be specified'
+      end
+
+      order.update_attributes!(
+        approver: user,
+        approver_name: name,
+        approved_at: Time.now,
+      )
+    end
+
+
+    private
+      def after_add_or_remove(line_item, options = {})
+        reload_totals
+        shipment = options[:shipment]
+        shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
+        PromotionHandler::Cart.new(order, line_item).activate
+        ItemAdjustments.new(line_item).update
+        reload_totals
+        line_item
+      end
+
+      def order_updater
+        @updater ||= OrderUpdater.new(order)
+      end
+
+      def reload_totals
+        order_updater.update
+        order.reload
+      end
+
+      def add_to_line_item(variant, quantity, options = {})
+        line_item = grab_line_item_by_variant(variant, false, options)
+
+        if line_item
+          line_item.quantity += quantity.to_i
+          line_item.currency = currency unless currency.nil?
+        else
+          opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
+                                              permit(PermittedAttributes.line_item_attributes)
+          line_item = order.line_items.new(quantity: quantity,
+                                            variant: variant,
+                                            options: opts)
+          create_order_stock_locations(line_item, options[:stock_location_quantities])
+        end
+        line_item.target_shipment = options[:shipment] if options.has_key? :shipment
+        line_item.save!
+        line_item
+      end
+
+      def remove_from_line_item(variant, quantity, options = {})
+        line_item = grab_line_item_by_variant(variant, true, options)
+        line_item.quantity -= quantity
+        line_item.target_shipment= options[:shipment]
+
+        if line_item.quantity == 0
+          line_item.destroy
+        else
+          line_item.save!
+        end
+
+        line_item
+      end
+
+      def grab_line_item_by_variant(variant, raise_error = false, options = {})
+        line_item = order.find_line_item_by_variant(variant, options)
+
+        if !line_item.present? && raise_error
+          raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
+        end
+
+        line_item
+      end
+
+      def create_order_stock_locations(line_item, stock_location_quantities)
+        return unless stock_location_quantities.present?
+        order = line_item.order
+        stock_location_quantities.each do |stock_location_id, quantity|
+          order.order_stock_locations.create!(stock_location_id: stock_location_id, quantity: quantity, variant_id: line_item.variant_id) unless quantity.to_i.zero?
+        end
+      end
+  end
+end

data/app/models/spree/order_inventory.rb

@@ -0,0 +1,108 @@
+module Spree
+  class OrderInventory
+    attr_accessor :order, :line_item, :variant
+
+    def initialize(order, line_item)
+      @order = order
+      @line_item = line_item
+      @variant = line_item.variant
+    end
+
+    # Only verify inventory for completed orders (as orders in frontend checkout
+    # have inventory assigned via +order.create_proposed_shipment+) or when
+    # shipment is explicitly passed
+    #
+    # In case shipment is passed the stock location should only unstock or
+    # restock items if the order is completed. That is so because stock items
+    # are always unstocked when the order is completed through +shipment.finalize+
+    def verify(shipment = nil)
+      if order.completed? || shipment.present?
+
+        if inventory_units.size < line_item.quantity
+          quantity = line_item.quantity - inventory_units.size
+
+          shipment = determine_target_shipment unless shipment
+          add_to_shipment(shipment, quantity)
+        elsif inventory_units.size > line_item.quantity
+          remove(inventory_units, shipment)
+        end
+      end
+    end
+
+    def inventory_units
+      line_item.inventory_units
+    end
+
+    private
+      def remove(item_units, shipment = nil)
+        quantity = item_units.size - line_item.quantity
+
+        if shipment.present?
+          remove_from_shipment(shipment, quantity)
+        else
+          order.shipments.each do |shipment|
+            break if quantity == 0
+            quantity -= remove_from_shipment(shipment, quantity)
+          end
+        end
+      end
+
+      # Returns either one of the shipment:
+      #
+      # first unshipped that already includes this variant
+      # first unshipped that's leaving from a stock_location that stocks this variant
+      def determine_target_shipment
+        shipment = order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && shipment.include?(variant)
+        end
+
+        shipment ||= order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && variant.stock_location_ids.include?(shipment.stock_location_id)
+        end
+      end
+
+      def add_to_shipment(shipment, quantity)
+        if variant.should_track_inventory?
+          on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
+
+          on_hand.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+          back_order.times { shipment.set_up_inventory('backordered', variant, order, line_item) }
+        else
+          quantity.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        end
+
+        # adding to this shipment, and removing from stock_location
+        if order.completed?
+          shipment.stock_location.unstock(variant, quantity, shipment)
+        end
+
+        quantity
+      end
+
+      def remove_from_shipment(shipment, quantity)
+        return 0 if quantity == 0 || shipment.shipped?
+
+        shipment_units = shipment.inventory_units_for_item(line_item, variant).reject do |variant_unit|
+          # TODO: exclude all 'shipped' states
+          variant_unit.state == 'shipped'
+        end.sort_by(&:state)
+
+        removed_quantity = 0
+
+        shipment_units.each do |inventory_unit|
+          break if removed_quantity == quantity
+          inventory_unit.destroy
+          removed_quantity += 1
+        end
+
+        shipment.destroy if shipment.inventory_units.count == 0
+
+        # removing this from shipment, and adding to stock_location
+        if order.completed?
+          shipment.stock_location.restock variant, removed_quantity, shipment
+        end
+
+        removed_quantity
+      end
+  end
+end

data/app/models/spree/order_mutex.rb

@@ -0,0 +1,35 @@
+module Spree
+  class OrderMutex < ActiveRecord::Base
+
+    class LockFailed < StandardError; end
+
+    belongs_to :order, class_name: "Spree::Order"
+
+    scope :expired, -> { where("#{quoted_table_name}.created_at <= ?", Spree::Config[:order_mutex_max_age].ago) }
+
+    class << self
+      # Obtain a lock on an order, execute the supplied block and then release the lock.
+      # Raise a LockFailed exception immediately if we cannot obtain the lock.
+      # We raise instead of blocking to avoid tying up multiple server processes waiting for the lock.
+      def with_lock!(order)
+        raise ArgumentError, "order must be supplied" if order.nil?
+
+        # limit the maximum lock time just in case a lock is somehow left in place accidentally
+        expired.where(order: order).delete_all
+
+        begin
+          order_mutex = create!(order: order)
+        rescue ActiveRecord::RecordNotUnique
+          error = LockFailed.new("Could not obtain lock on order #{order.id}")
+          logger.error error.inspect
+          raise error
+        end
+
+        yield
+
+      ensure
+        order_mutex.destroy if order_mutex
+      end
+    end
+  end
+end

data/app/models/spree/order_promotion.rb

@@ -0,0 +1,23 @@
+module Spree
+  # Spree::OrderPromotion represents the relationship between:
+  #
+  # 1. A promotion that a user attempted to apply to their order
+  # 2. The specific code that they used
+  class OrderPromotion < ActiveRecord::Base
+    self.table_name = 'spree_orders_promotions'
+
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :promotion, class_name: 'Spree::Promotion'
+    belongs_to :promotion_code, class_name: 'Spree::PromotionCode'
+
+    validates :order, presence: true
+    validates :promotion, presence: true
+    validates :promotion_code, presence: true, if: :require_promotion_code?
+
+    private
+
+    def require_promotion_code?
+      promotion && promotion.codes.any?
+    end
+  end
+end

data/app/models/spree/order_shipping.rb

@@ -0,0 +1,99 @@
+# A service layer that handles generating Carton objects when inventory units
+# are actually shipped.  It also takes care of things like updating order and
+# shipment states and delivering shipment emails as needed.
+class Spree::OrderShipping
+  def initialize(order)
+    @order = order
+  end
+
+  # A shortcut method that ships *all* inventory units in a shipment in a single
+  # carton.  See also {#ship}.
+  #
+  # @param shipment The shipment to create a carton from.
+  # @param external_number An optional external number. e.g. from a shipping company or 3PL.
+  # @param tracking_number An optional tracking number.
+  # @return The carton created.
+  def ship_shipment(shipment, external_number: nil, tracking_number: nil, suppress_mailer: false)
+    ship(
+      inventory_units: shipment.inventory_units.shippable,
+      stock_location: shipment.stock_location,
+      address: shipment.address,
+      shipping_method: shipment.shipping_method,
+      shipped_at: Time.now,
+      external_number: external_number,
+      # TODO: Remove the `|| shipment.tracking` once Shipment#ship! is called by
+      # OrderShipping#ship rather than vice versa
+      tracking_number: tracking_number || shipment.tracking,
+      suppress_mailer: suppress_mailer,
+    )
+  end
+
+  # Generate a carton from the supplied inventory units and marks those units
+  # as shipped.  Also sends shipment emails if appropriate and updates
+  # shipment_states for associated orders.
+  #
+  # @param inventory_units The units to put in a carton together.
+  # @param stock_location The location the carton shipped from.
+  # @param address The address the carton was shipped to.
+  # @param shipping_method Shipping method used for the carton.
+  # @param shipped_at The time at which the shipment was shipped.
+  # @param external_number An optional external number. e.g. from a shipping company or 3PL.
+  # @param tracking_number An option tracking number.
+  # @return The carton created.
+  def ship(inventory_units:, stock_location:, address:, shipping_method:,
+           shipped_at: Time.now, external_number: nil, tracking_number: nil, suppress_mailer: false)
+
+    carton = nil
+
+    Spree::InventoryUnit.transaction do
+      inventory_units.each &:ship!
+
+      carton = Spree::Carton.create!(
+        stock_location: stock_location,
+        address: address,
+        shipping_method: shipping_method,
+        inventory_units: inventory_units,
+        shipped_at: shipped_at,
+        external_number: external_number,
+        tracking: tracking_number,
+      )
+    end
+
+    inventory_units.map(&:shipment).uniq.each do |shipment|
+      # Temporarily propagate the tracking number to the shipment as well
+      # TODO: Remove tracking numbers from shipments.
+      shipment.update_attributes!(tracking: tracking_number)
+
+      if shipment.inventory_units.all? {|iu| iu.shipped? || iu.canceled? }
+        # TODO: make OrderShipping#ship_shipment call Shipment#ship! rather than
+        # having Shipment#ship! call OrderShipping#ship_shipment. We only really
+        # need this `update_columns` for the specs, until we make that change.
+        shipment.update_columns(state: 'shipped', shipped_at: Time.now)
+      end
+    end
+
+    send_shipment_email(carton) if stock_location.fulfillable? && !suppress_mailer # e.g. digital gift cards that aren't actually shipped
+    fulfill_order_stock_locations(stock_location)
+    update_order_state
+
+    carton
+  end
+
+  private
+
+  def fulfill_order_stock_locations(stock_location)
+    Spree::OrderStockLocation.fulfill_for_order_with_stock_location(@order, stock_location)
+  end
+
+  def update_order_state
+    new_state = Spree::OrderUpdater.new(@order).update_shipment_state
+    @order.update_columns(
+      shipment_state: new_state,
+      updated_at: Time.now,
+    )
+  end
+
+  def send_shipment_email(carton)
+    Spree::CartonMailer.shipped_email(carton.id).deliver_now
+  end
+end