solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/order_shipping.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# 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.order.ship_address,
+      shipping_method: shipment.shipping_method,
+      shipped_at: Time.current,
+      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.current, 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)
+
+      next unless shipment.inventory_units.reload.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.current)
+    end
+
+    send_shipment_emails(carton) if stock_location.fulfillable? && !suppress_mailer # e.g. digital gift cards that aren't actually shipped
+    @order.recalculate
+
+    carton
+  end
+
+  private
+
+  def send_shipment_emails(carton)
+    carton.orders.each do |order|
+      Spree::Config.carton_shipped_email_class.shipped_email(order: order, carton: carton).deliver_later
+    end
+  end
+end

data/app/models/spree/order_taxation.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Spree
+  # Relatively simple class used to apply a {Spree::Tax::OrderTax} to a
+  # {Spree::Order}.
+  #
+  # This class will create or update adjustments on the taxed items and remove
+  # any now inapplicable tax adjustments from the order.
+  class OrderTaxation
+    # Create a new order taxation.
+    #
+    # @param [Spree::Order] order the order to apply taxes to
+    # @return [Spree::OrderTaxation] a {Spree::OrderTaxation} object
+    def initialize(order)
+      @order = order
+    end
+
+    # Apply taxes to the order.
+    #
+    # This method will create or update adjustments on all line items and
+    # shipments in the order to reflect the appropriate taxes passed in. It
+    # will also remove any now inapplicable tax adjustments.
+    #
+    # @param [Spree::Tax::OrderTax] taxes the taxes to apply to the order
+    # @return [void]
+    def apply(taxes)
+      @order.line_items.each do |item|
+        taxed_items = taxes.line_item_taxes.select { |i| i.item_id == item.id }
+        update_adjustments(item, taxed_items)
+      end
+
+      @order.shipments.each do |item|
+        taxed_items = taxes.shipment_taxes.select { |i| i.item_id == item.id }
+        update_adjustments(item, taxed_items)
+      end
+    end
+
+    private
+
+    # Walk through the taxes for an item and update adjustments for it. Once
+    # all of the taxes have been added as adjustments, remove any old tax
+    # adjustments that weren't touched.
+    #
+    # @private
+    # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+    # @param [Array<Spree::Tax::ItemTax>] taxed_items a list of calculated taxes for an item
+    # @return [void]
+    def update_adjustments(item, taxed_items)
+      tax_adjustments = item.adjustments.select(&:tax?)
+
+      active_adjustments = taxed_items.map do |tax_item|
+        update_adjustment(item, tax_item)
+      end
+
+      # Remove any tax adjustments tied to rates which no longer match.
+      unmatched_adjustments = tax_adjustments - active_adjustments
+      item.adjustments.destroy(unmatched_adjustments)
+    end
+
+    # Update or create a new tax adjustment on an item.
+    #
+    # @private
+    # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+    # @param [Spree::Tax::ItemTax] tax_item calculated taxes for an item
+    # @return [Spree::Adjustment] the created or updated tax adjustment
+    def update_adjustment(item, tax_item)
+      tax_adjustment = item.adjustments.detect do |adjustment|
+        adjustment.source == tax_item.tax_rate
+      end
+
+      tax_adjustment ||= item.adjustments.new(
+        source: tax_item.tax_rate,
+        order_id: item.order_id,
+        label: tax_item.label,
+        included: tax_item.included_in_price
+      )
+      tax_adjustment.update_attributes!(amount: tax_item.amount)
+      tax_adjustment
+    end
+  end
+end

data/app/models/spree/order_update_attributes.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderUpdateAttributes
+    # @param order [Order] existing (persisted) order
+    # @param attributes [Hash] attributes which are assigned to the new order.
+    #   These attributes should already have been filtered.
+    #   * :payments_attributes attributes
+    def initialize(order, attributes, request_env: nil)
+      @order = order
+      @attributes = attributes.dup
+      @payments_attributes = @attributes.delete(:payments_attributes) || []
+      @request_env = request_env
+    end
+
+    # Assign the attributes to the order and save the order
+    # @return true if saved, otherwise false and errors will be set on the order
+    def apply
+      order.validate_payments_attributes(@payments_attributes)
+
+      assign_order_attributes
+      assign_payments_attributes
+
+      order.save
+    end
+
+    private
+
+    attr_reader :attributes, :payments_attributes, :order
+
+    def assign_order_attributes
+      order.assign_attributes attributes
+    end
+
+    def assign_payments_attributes
+      @payments_attributes.each do |payment_attributes|
+        PaymentCreate.new(order, payment_attributes, request_env: @request_env).build
+      end
+    end
+  end
+end

data/app/models/spree/order_updater.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderUpdater
+    attr_reader :order
+    delegate :payments, :line_items, :adjustments, :all_adjustments, :shipments, :update_hooks, :quantity, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # This is a multi-purpose method for processing logic related to changes in the Order.
+    # It is meant to be called from various observers so that the Order is aware of changes
+    # that affect totals and other values stored in the Order.
+    #
+    # This method should never do anything to the Order that results in a save call on the
+    # object with callbacks (otherwise you will end up in an infinite recursion as the
+    # associations try to save and then in turn try to call +update!+ again.)
+    def update
+      @order.transaction do
+        update_item_count
+        update_shipment_amounts
+        update_totals
+        if order.completed?
+          update_payment_state
+          update_shipments
+          update_shipment_state
+        end
+        run_hooks
+        persist_totals
+      end
+    end
+
+    def run_hooks
+      update_hooks.each { |hook| order.send hook }
+    end
+
+    # Updates the +shipment_state+ attribute according to the following logic:
+    #
+    # shipped   when all Shipments are in the "shipped" state
+    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+    # ready     when all Shipments are in the "ready" state
+    # backorder when there is backordered inventory associated with an order
+    # pending   when all Shipments are in the "pending" state
+    #
+    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_shipment_state
+      log_state_change('shipment') do
+        order.shipment_state = determine_shipment_state
+      end
+
+      order.shipment_state
+    end
+
+    # Updates the +payment_state+ attribute according to the following logic:
+    #
+    # paid          when +payment_total+ is equal to +total+
+    # balance_due   when +payment_total+ is less than +total+
+    # credit_owed   when +payment_total+ is greater than +total+
+    # failed        when most recent payment is in the failed state
+    # void          when the order has been canceled and the payment total is 0
+    #
+    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_payment_state
+      log_state_change('payment') do
+        order.payment_state = determine_payment_state
+      end
+
+      order.payment_state
+    end
+
+    private
+
+    def determine_payment_state
+      if payments.present? && payments.valid.empty? && order.outstanding_balance != 0
+        'failed'
+      elsif order.state == 'canceled' && order.payment_total.zero?
+        'void'
+      elsif order.outstanding_balance > 0
+        'balance_due'
+      elsif order.outstanding_balance < 0
+        'credit_owed'
+      else
+        # outstanding_balance == 0
+        'paid'
+      end
+    end
+
+    def determine_shipment_state
+      if order.backordered?
+        'backorder'
+      else
+        # get all the shipment states for this order
+        shipment_states = shipments.states
+        if shipment_states.size > 1
+          # multiple shiment states means it's most likely partially shipped
+          'partial'
+        else
+          # will return nil if no shipments are found
+          shipment_states.first
+        end
+      end
+    end
+
+    # This will update and select the best promotion adjustment, update tax
+    # adjustments, update cancellation adjustments, and then update the total
+    # fields (promo_total, included_tax_total, additional_tax_total, and
+    # adjustment_total) on the item.
+    # @return [void]
+    def recalculate_adjustments
+      # Promotion adjustments must be applied first, then tax adjustments.
+      # This fits the criteria for VAT tax as outlined here:
+      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
+      # It also fits the criteria for sales tax as outlined here:
+      # http://www.boe.ca.gov/formspubs/pub113/
+      update_item_promotions
+      update_order_promotions
+      update_taxes
+      update_cancellations
+      update_item_totals
+    end
+
+    # Updates the following Order total values:
+    #
+    # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+    # +item_total+         The total value of all LineItems
+    # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
+    # +promo_total+        The total value of all promotion adjustments
+    # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
+    def update_totals
+      update_payment_total
+      update_item_total
+      update_shipment_total
+      update_adjustment_total
+    end
+
+    def update_shipment_amounts
+      shipments.each do |shipment|
+        shipment.update_amounts
+      end
+    end
+
+    # give each of the shipments a chance to update themselves
+    def update_shipments
+      shipments.each do |shipment|
+        shipment.update_state
+      end
+    end
+
+    def update_payment_total
+      order.payment_total = payments.completed.includes(:refunds).map { |payment| payment.amount - payment.refunds.sum(:amount) }.sum
+    end
+
+    def update_shipment_total
+      order.shipment_total = shipments.to_a.sum(&:cost)
+      update_order_total
+    end
+
+    def update_order_total
+      order.total = order.item_total + order.shipment_total + order.adjustment_total
+    end
+
+    def update_adjustment_total
+      recalculate_adjustments
+
+      all_items = line_items + shipments
+
+      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).sum(&:amount)
+      order.included_tax_total = all_items.sum(&:included_tax_total)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total)
+
+      order.promo_total = all_items.sum(&:promo_total) + adjustments.select(&:eligible?).select(&:promotion?).sum(&:amount)
+
+      update_order_total
+    end
+
+    def update_item_count
+      order.item_count = line_items.to_a.sum(&:quantity)
+    end
+
+    def update_item_total
+      order.item_total = line_items.to_a.sum(&:amount)
+      update_order_total
+    end
+
+    def persist_totals
+      order.save!(validate: false)
+    end
+
+    def log_state_change(name)
+      state = "#{name}_state"
+      old_state = order.public_send(state)
+      yield
+      new_state = order.public_send(state)
+      if old_state != new_state
+        order.state_changes.new(
+          previous_state: old_state,
+          next_state:     new_state,
+          name:           name,
+          user_id:        order.user_id
+        )
+      end
+    end
+
+    def update_item_promotions
+      [*line_items, *shipments].each do |item|
+        promotion_adjustments = item.adjustments.select(&:promotion?)
+
+        promotion_adjustments.each(&:recalculate)
+        Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+
+        item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
+      end
+    end
+
+    # Update and select the best promotion adjustment for the order.
+    # We don't update the order.promo_total yet. Order totals are updated later
+    # in #update_adjustment_total since they include the totals from the order's
+    # line items and/or shipments.
+    def update_order_promotions
+      promotion_adjustments = order.adjustments.select(&:promotion?)
+      promotion_adjustments.each(&:recalculate)
+      Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+    end
+
+    def update_taxes
+      Spree::Config.tax_adjuster_class.new(order).adjust!
+
+      [*line_items, *shipments].each do |item|
+        tax_adjustments = item.adjustments.select(&:tax?)
+        # Tax adjustments come in not one but *two* exciting flavours:
+        # Included & additional
+
+        # Included tax adjustments are those which are included in the price.
+        # These ones should not affect the eventual total price.
+        #
+        # Additional tax adjustments are the opposite, affecting the final total.
+        item.included_tax_total   = tax_adjustments.select(&:included?).sum(&:amount)
+        item.additional_tax_total = tax_adjustments.reject(&:included?).sum(&:amount)
+      end
+    end
+
+    def update_cancellations
+      line_items.each do |line_item|
+        line_item.adjustments.select(&:cancellation?).each(&:recalculate)
+      end
+    end
+
+    def update_item_totals
+      [*line_items, *shipments].each do |item|
+        # The cancellation_total isn't persisted anywhere but is included in
+        # the adjustment_total
+        item.adjustment_total = item.adjustments.
+          select(&:eligible?).
+          reject(&:included?).
+          sum(&:amount)
+
+        if item.changed?
+          item.update_columns(
+            promo_total:          item.promo_total,
+            included_tax_total:   item.included_tax_total,
+            additional_tax_total: item.additional_tax_total,
+            adjustment_total:     item.adjustment_total,
+            updated_at:           Time.current,
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/spree/payment/cancellation.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Spree
+  class Payment
+    # Payment cancellation handler
+    #
+    # Cancels a payment by trying to void first and if that fails
+    # creating a refund about the full amount instead.
+    #
+    class Cancellation
+      DEFAULT_REASON = 'Order canceled'.freeze
+
+      attr_reader :reason
+
+      # @param reason [String] (DEFAULT_REASON) -
+      #   The reason used to create the Spree::RefundReason
+      def initialize(reason: DEFAULT_REASON)
+        @reason = reason
+      end
+
+      # Cancels a payment
+      #
+      # Tries to void the payment by asking the payment method to try a void,
+      # if that fails create a refund about the allowed credit amount instead.
+      #
+      # @param payment [Spree::Payment] - the payment that should be canceled
+      #
+      def cancel(payment)
+        # For payment methods already implemeting `try_void`
+        if try_void_available?(payment.payment_method)
+          if response = payment.payment_method.try_void(payment)
+            payment.send(:handle_void_response, response)
+          else
+            payment.refunds.create!(amount: payment.credit_allowed, reason: refund_reason)
+          end
+        else
+          # For payment methods not yet implemeting `try_void`
+          deprecated_behavior(payment)
+        end
+      end
+
+      private
+
+      def refund_reason
+        Spree::RefundReason.where(name: reason).first_or_create
+      end
+
+      def try_void_available?(payment_method)
+        payment_method.respond_to?(:try_void) &&
+          payment_method.method(:try_void).owner != Spree::PaymentMethod
+      end
+
+      def deprecated_behavior(payment)
+        Spree::Deprecation.warn "#{payment.payment_method.class.name}#cancel is deprecated and will be removed. " \
+          'Please implement a `try_void` method instead that returns a response object if void succeeds ' \
+          'or `false|nil` if not. Solidus will refund the payment then.'
+        response = payment.payment_method.cancel(payment.response_code)
+        payment.send(:handle_void_response, response)
+      end
+    end
+  end
+end