solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/order_cancellations.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# This class represents all of the actions one can take to modify an Order after it is complete
+class Spree::OrderCancellations
+  extend ActiveModel::Translation
+
+  # 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
+
+  # Marks inventory units short shipped. Adjusts the order based on the value of the inventory.
+  # Sends an email to the customer about what inventory has been short shipped.
+  #
+  # @api public
+  #
+  # @param [Array<InventoryUnit>] inventory_units the inventory units to be short shipped
+  # @param [String] whodunnit the system or person that is short shipping the inventory units
+  #
+  # @return [Array<UnitCancel>] the units that have been canceled due to short shipping
+  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::Config.order_mailer_class.inventory_cancellation_email(@order, inventory_units.to_a).deliver_later if Spree::OrderCancellations.send_cancellation_mailer
+      end
+
+      @order.recalculate
+
+      if short_ship_tax_notifier
+        short_ship_tax_notifier.call(unit_cancels)
+      end
+    end
+
+    unit_cancels
+  end
+
+  # Marks inventory unit canceled. Optionally allows specifying the reason why and who is performing the action.
+  #
+  # @api public
+  #
+  # @param [InventoryUnit] inventory_unit the inventory unit to be canceled
+  # @param [String] reason the reason that you are canceling the inventory unit
+  # @param [String] whodunnit the system or person that is canceling the inventory unit
+  #
+  # @return [UnitCancel] the unit that has been canceled
+  def cancel_unit(inventory_unit, reason: Spree::UnitCancel::DEFAULT_REASON, whodunnit: nil)
+    unit_cancel = nil
+
+    Spree::OrderMutex.with_lock!(@order) do
+      unit_cancel = Spree::UnitCancel.create!(
+        inventory_unit: inventory_unit,
+        reason: reason,
+        created_by: whodunnit
+      )
+
+      inventory_unit.cancel!
+    end
+
+    unit_cancel
+  end
+
+  # Reimburses inventory units due to cancellation.
+  #
+  # @api public
+  # @param [Array<InventoryUnit>] inventory_units the inventory units to be reimbursed
+  # @return [Reimbursement] the reimbursement for inventory being canceled
+  def reimburse_units(inventory_units)
+    reimbursement = nil
+
+    Spree::OrderMutex.with_lock!(@order) do
+      return_items = inventory_units.map(&:current_or_new_return_item)
+      reimbursement = Spree::Reimbursement.new(order: @order, return_items: return_items)
+      reimbursement.return_all
+    end
+
+    reimbursement
+  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.current)
+      end
+    end
+  end
+end

data/app/models/spree/order_capturing.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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)
+    Spree::Deprecation.warn "Spree::OrderCapturing is deprecated and will be removed without replacement. " \
+      "Please implement your own automated capturing logic in your store."
+    @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
+
+      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
+    end
+  end
+
+  private
+
+  def sorted_payments(order)
+    order.payments.pending.sort_by do |p|
+      [@sorted_payment_method_classes.index(p.payment_method.class), p.id]
+    end
+  end
+end
+
+class Spree::OrderCapturingFailures < StandardError; end

data/app/models/spree/order_contents.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderContents
+    attr_accessor :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # Add a line items to the order if there is inventory to do so
+    # and populate Promotions
+    #
+    # @param [Spree::Variant] variant The variant the line_item should
+    #   be associated with
+    # @param [Integer] quantity The line_item quantity
+    # @param [Hash] options Options for the adding proccess
+    #   Valid options:
+    #     shipment: [Spree::Shipment] LineItem target shipment
+    #
+    # @return [Spree::LineItem]
+    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 remove_line_item(line_item, options = {})
+      order.line_items.destroy(line_item)
+      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.current
+      )
+    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
+      reload_totals
+      line_item
+    end
+
+    def reload_totals
+      @order.recalculate
+    end
+
+    def add_to_line_item(variant, quantity, options = {})
+      line_item = grab_line_item_by_variant(variant, false, options)
+
+      line_item ||= order.line_items.new(
+        quantity: 0,
+        variant: variant,
+      )
+
+      line_item.quantity += quantity.to_i
+      line_item.options = ActionController::Parameters.new(options).permit(PermittedAttributes.line_item_attributes).to_h
+
+      line_item.target_shipment = options[: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
+        order.line_items.destroy(line_item)
+      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
+  end
+end

data/app/models/spree/order_inventory.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+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?
+
+        existing_quantity = inventory_units.count
+        desired_quantity = line_item.quantity - existing_quantity
+        if desired_quantity > 0
+          shipment ||= determine_target_shipment
+          add_to_shipment(shipment, desired_quantity)
+        elsif desired_quantity < 0
+          remove(-desired_quantity, shipment)
+        end
+      end
+    end
+
+    def inventory_units
+      line_item.inventory_units
+    end
+
+    private
+
+    def remove(quantity, shipment = nil)
+      if shipment.present?
+        remove_from_shipment(shipment, quantity)
+      else
+        remove_from_any_shipment(quantity)
+      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
+      potential_shipments = order.shipments.select(&:ready_or_pending?)
+
+      potential_shipments.detect do |shipment|
+        shipment.include?(variant)
+      end || potential_shipments.detect do |shipment|
+        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_any_shipment(quantity)
+      order.shipments.each do |shipment|
+        break if quantity == 0
+        quantity -= remove_from_shipment(shipment, quantity)
+      end
+    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
+
+      if shipment.inventory_units.count.zero?
+        order.shipments.destroy(shipment)
+      end
+
+      # 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_merger.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Spree
+  # Spree::OrderMerger is responsible for taking two orders and merging them
+  # together by adding the line items from additional orders to the order
+  # that the OrderMerger is initialized with.
+  #
+  # Orders that are merged should be incomplete orders which should belong to
+  # the same user. They should also be in the same currency.
+  class OrderMerger
+    # @!attribute order
+    #   @api public
+    #   @return [Spree::Order] The order which items wll be merged into.
+    attr_accessor :order
+
+    delegate :updater, to: :order
+
+    # Create the OrderMerger
+    #
+    # @api public
+    # @param [Spree::Order] order The order which line items will be merged
+    # into.
+    def initialize(order)
+      @order = order
+    end
+
+    # Merge a second order in to the order the OrderMerger was initialized with
+    #
+    # The line items from `other_order` will be merged in to the `order` for
+    # this OrderMerger object. If the line items are for the same variant, it
+    # will add the quantity of the incoming line item to the existing line item.
+    # Otherwise, it will assign the line item to the new order.
+    #
+    # After the orders have been merged the `other_order` will be destroyed.
+    #
+    # @example
+    #   initial_order = Spree::Order.find(1)
+    #   order_to_merge = Spree::Order.find(2)
+    #   merger = Spree::OrderMerger.new(initial_order)
+    #   merger.merge!(order_to_merge)
+    #   # order_to_merge is destroyed, initial order now contains the line items
+    #   # of order_to_merge
+    #
+    # @api public
+    # @param [Spree::Order] other_order An order which will be merged in to the
+    # order the OrderMerger was initialized with.
+    # @param [Spree::User] user Associate the order the user specified. If not
+    # specified, the order user association will not be changed.
+    # @return [void]
+    def merge!(other_order, user = nil)
+      if other_order.currency == order.currency
+        other_order.line_items.each do |other_order_line_item|
+          current_line_item = find_matching_line_item(other_order_line_item)
+          handle_merge(current_line_item, other_order_line_item)
+        end
+      end
+
+      set_user(user)
+      persist_merge
+
+      # So that the destroy doesn't take out line items which may have been re-assigned
+      other_order.line_items.reload
+      other_order.destroy
+    end
+
+    private
+
+    # Retreive a matching line item from the existing order
+    #
+    # It will compare line items based on variants, and all line item
+    # comparison hooks on the order.
+    #
+    # @api private
+    # @param [Spree::LineItem] other_order_line_item The line item from
+    # `other_order` we are attempting to merge in.
+    # @return [Spree::LineItem] A matching line item from the order. nil if none
+    # exist.
+    def find_matching_line_item(other_order_line_item)
+      order.line_items.detect do |my_li|
+        my_li.variant == other_order_line_item.variant &&
+          order.line_item_comparison_hooks.all? do |hook|
+            order.send(hook, my_li, other_order_line_item.serializable_hash)
+          end
+      end
+    end
+
+    # Associate the user with the order
+    #
+    # @api private
+    # @param [Spree::User] user The user to associate with the order. If nil
+    # the order user association will remain the same. If the order is already
+    # associated with a user, it will not be changed.
+    # @return [void]
+    def set_user(user)
+      order.associate_user!(user) if !order.user && user
+    end
+
+    # Merge the `other_order_line_item` into `current_line_item`
+    #
+    # If `current_line_item` is nil, the `other_order_line_item` will be
+    # re-assigned to the `order`.
+    #
+    # If the merged line item can not be saved, an error will be added to
+    # `order`.
+    #
+    # @api private
+    # @param [Spree::LineItem] current_line_item The line item to be merged
+    # into. If nil, the `other_order_line_item` will be re-assigned.
+    # @param [Spree::LineItem] other_order_line_item The line item to merge in.
+    # @return [void]
+    def handle_merge(current_line_item, other_order_line_item)
+      if current_line_item
+        current_line_item.quantity += other_order_line_item.quantity
+        handle_error(current_line_item) unless current_line_item.save
+      else
+        order.line_items << other_order_line_item
+        handle_error(other_order_line_item) unless other_order_line_item.save
+      end
+    end
+
+    # Handle an error from saving the `line_item`
+    #
+    # This adds errors from the line item to the `errors[:base]` of the order.
+    #
+    # @api private
+    # @param [Spree::LineItem] line_item The line item which could not be saved
+    # @return [void]
+    def handle_error(line_item)
+      order.errors[:base] << line_item.errors.full_messages
+    end
+
+    # Save the order totals after merge
+    #
+    # It triggers the order updater to ensure that item counts and totals are
+    # up to date.
+    #
+    # @api private
+    # @return [void]
+    def persist_merge
+      updater.update
+    end
+  end
+end

data/app/models/spree/order_mutex.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderMutex < Spree::Base
+    class LockFailed < StandardError; end
+
+    belongs_to :order, class_name: "Spree::Order"
+
+    scope :expired, -> { where(arel_table[:created_at].lteq(Spree::Config[:order_mutex_max_age].seconds.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,27 @@
+# frozen_string_literal: true
+
+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 < Spree::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?
+
+    self.whitelisted_ransackable_associations = %w[promotion_code]
+
+    private
+
+    def require_promotion_code?
+      promotion && promotion.codes.any?
+    end
+  end
+end