spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/return_item/default_eligibility_validator.rb

@@ -0,0 +1,27 @@
+module Spree
+  class ReturnItem::DefaultEligibilityValidator < Spree::ReturnItem::EligibilityValidator::BaseValidator
+    class_attribute :permitted_eligibility_validators
+    self.permitted_eligibility_validators = [
+                                              ReturnItem::EligibilityValidator::TimeSincePurchase,
+                                              ReturnItem::EligibilityValidator::RMARequired,
+                                            ]
+
+    def eligible_for_return?
+      validators.all? {|v| v.eligible_for_return? }
+    end
+
+    def requires_manual_intervention?
+      validators.any? {|v| v.requires_manual_intervention? }
+    end
+
+    def errors
+      validators.map(&:errors).reduce({}, :merge)
+    end
+
+    private
+
+    def validators
+      @validators ||= permitted_eligibility_validators.map{|v| v.new(@return_item) }
+    end
+  end
+end

data/app/models/spree/return_item/eligibility_validator/base_validator.rb

@@ -0,0 +1,24 @@
+module Spree
+  class Spree::ReturnItem::EligibilityValidator::BaseValidator
+    attr_reader :errors
+
+    def initialize(return_item)
+      @return_item = return_item
+      @errors = {}
+    end
+
+    def eligible_for_return?
+      raise 'Implement me'
+    end
+
+    def requires_manual_intervention?
+      raise 'Implement me'
+    end
+
+    private
+
+    def add_error(key, error)
+      @errors[key] = error
+    end
+  end
+end

data/app/models/spree/return_item/eligibility_validator/rma_required.rb

@@ -0,0 +1,17 @@
+module Spree
+  class ReturnItem::EligibilityValidator::RMARequired < Spree::ReturnItem::EligibilityValidator::BaseValidator
+    def eligible_for_return?
+      if @return_item.return_authorization.present?
+        return true
+      else
+        add_error(:rma_required, Spree.t('return_item_rma_ineligible'))
+        return false
+      end
+    end
+
+    def requires_manual_intervention?
+      false
+    end
+  end
+end
+

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -0,0 +1,16 @@
+module Spree
+  class ReturnItem::EligibilityValidator::TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
+    def eligible_for_return?
+      if (@return_item.inventory_unit.created_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.now
+        return true
+      else
+        add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))
+        return false
+      end
+    end
+
+    def requires_manual_intervention?
+      false
+    end
+  end
+end

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -0,0 +1,34 @@
+module Spree
+  module ReturnItem::ExchangeVariantEligibility
+    class SameOptionValue
+      class_attribute :option_type_restrictions
+      self.option_type_restrictions = []
+      # This can be configured in an initializer, e.g.:
+      # Spree::ReturnItem::ExchangeVariantEligibility::SameOptionValue.option_type_restrictions = ["size", "color"]
+      #
+      # This restriction causes only variants that share the same option value for the
+      # specified option types to be returned. e.g.:
+      #
+      # option_type_restrictions = ["color", "waist"]
+      # Variant: blue pants with 32 waist and 30 inseam
+      #
+      # can be exchanged for:
+      # blue pants with 32 waist and 31 inseam
+      #
+      # cannot be exchanged for:
+      # green pants with 32 waist and 30 inseam
+      # blue pants with 34 waist and 32 inseam
+
+      def self.eligible_variants(variant)
+        product_variants = SameProduct.eligible_variants(variant).includes(option_values: :option_type)
+
+        relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
+        if relevant_option_values.present?
+          product_variants.select { |v| (relevant_option_values & v.option_values) == relevant_option_values }
+        else
+          product_variants
+        end
+      end
+    end
+  end
+end

data/app/models/spree/return_item/exchange_variant_eligibility/same_product.rb

@@ -0,0 +1,10 @@
+module Spree
+  module ReturnItem::ExchangeVariantEligibility
+    class SameProduct
+
+      def self.eligible_variants(variant)
+        Spree::Variant.where.not(id: variant.id).where(product_id: variant.product_id, is_master: false)
+      end
+    end
+  end
+end

data/app/models/spree/returns_calculator.rb

@@ -0,0 +1,8 @@
+module Spree
+  class ReturnsCalculator < Calculator
+
+    def compute(return_item)
+      raise NotImplementedError, "Please implement 'compute(return_item)' in your calculator: #{self.class.name}"
+    end
+  end
+end

data/app/models/spree/shipment.rb

@@ -2,15 +2,15 @@ require 'ostruct'
 
 module Spree
   class Shipment < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
     belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
+    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
+    has_many :adjustments, as: :adjustable, dependent: :delete_all
+    has_many :inventory_units, dependent: :delete_all, inverse_of: :shipment
     has_many :shipping_rates, -> { order('cost ASC') }, dependent: :delete_all
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
-    has_many :inventory_units, dependent: :delete_all, inverse_of: :shipment
-    has_many :adjustments, as: :adjustable, dependent: :delete_all
 
     after_save :update_adjustments
 
@@ -23,11 +23,13 @@ module Spree
 
     make_permalink field: :number, length: 11, prefix: 'H'
 
-    scope :shipped, -> { with_state('shipped') }
-    scope :ready,   -> { with_state('ready') }
     scope :pending, -> { with_state('pending') }
-    scope :with_state, ->(*s) { where(state: s) }
+    scope :ready,   -> { with_state('ready') }
+    scope :shipped, -> { with_state('shipped') }
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
+    scope :with_state, ->(*s) { where(state: s) }
+    # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
+    scope :reverse_chronological, -> { order('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc', id: :desc) }
 
     # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :pending, use_transactions: false do
@@ -43,7 +45,7 @@ module Spree
       end
 
       event :ship do
-        transition from: :ready, to: :shipped
+        transition from: [:ready, :canceled], to: :shipped
       end
       after_transition to: :shipped, do: :after_ship
 
@@ -61,7 +63,7 @@ module Spree
         }
         transition from: :canceled, to: :pending
       end
-      after_transition from: :canceled, to: [:pending, :ready], do: :after_resume
+      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
 
       after_transition do |shipment, transition|
         shipment.state_changes.create!(
@@ -72,113 +74,96 @@ module Spree
       end
     end
 
-    def to_param
-      number
-    end
-
-    def backordered?
-      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
+    def add_shipping_method(shipping_method, selected = false)
+      shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
     end
 
-    def ready_or_pending?
-      self.ready? || self.pending?
+    def after_cancel
+      manifest.each { |item| manifest_restock(item) }
     end
 
-    def shipped=(value)
-      return unless value == '1' && shipped_at.nil?
-      self.shipped_at = Time.now
+    def after_resume
+      manifest.each { |item| manifest_unstock(item) }
     end
 
-    def shipping_method
-      selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
+    def backordered?
+      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
     end
 
-    self.whitelisted_ransackable_attributes = ['number']
-
-    def add_shipping_method(shipping_method, selected = false)
-      shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
+    def currency
+      order ? order.currency : Spree::Config[:currency]
     end
 
-    def selected_shipping_rate
-      shipping_rates.where(selected: true).first
+    # 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
+    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
 
-    def selected_shipping_rate_id
-      selected_shipping_rate.try(:id)
+    def discounted_cost
+      cost + promo_total
     end
+    alias discounted_amount discounted_cost
 
-    def selected_shipping_rate_id=(id)
-      shipping_rates.update_all(selected: false)
-      shipping_rates.update(id, selected: true)
-      self.save!
+    def display_cost
+      Spree::Money.new(cost, { currency: currency })
     end
+    alias display_amount display_cost
 
-    def tax_category
-      selected_shipping_rate.try(:tax_rate).try(:tax_category)
+    def display_discounted_cost
+      Spree::Money.new(discounted_cost, { currency: currency })
     end
 
-    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
+    def display_final_price
+      Spree::Money.new(final_price, { currency: currency })
     end
 
-    def currency
-      order ? order.currency : Spree::Config[:currency]
+    def display_item_cost
+      Spree::Money.new(item_cost, { currency: currency })
     end
 
-    def display_cost
-      Spree::Money.new(cost, { currency: currency })
+    def editable_by?(user)
+      !shipped?
     end
-    alias display_amount display_cost
 
-    def item_cost
-      line_items.map(&:amount).sum
+    def final_price
+      cost + adjustment_total
     end
 
-    def discounted_cost
-      cost + promo_total
+    def final_price_with_items
+      item_cost + final_price
     end
-    alias discounted_amount discounted_cost
 
-    # 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.
-    def tax_total
-      included_tax_total + additional_tax_total
+    def finalize!
+      InventoryUnit.finalize_units!(inventory_units)
+      manifest.each { |item| manifest_unstock(item) }
     end
 
-    def final_price
-      cost + adjustment_total
+    def include?(variant)
+      inventory_units_for(variant).present?
     end
 
-    def display_discounted_cost
-      Spree::Money.new(discounted_cost, { currency: currency })
+    def inventory_units_for(variant)
+      inventory_units.where(variant_id: variant.id)
     end
 
-    def display_final_price
-      Spree::Money.new(final_price, { currency: currency })
+    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
 
-    def display_item_cost
-      Spree::Money.new(item_cost, { currency: currency })
+    def item_cost
+      line_items.map(&:amount).sum
     end
 
-    def editable_by?(user)
-      !shipped?
+    def line_items
+      inventory_units.includes(:line_item).map(&:line_item).uniq
     end
 
     ManifestItem = Struct.new(:line_item, :variant, :quantity, :states)
@@ -199,84 +184,119 @@ module Spree
       end.flatten
     end
 
-    def line_items
-      inventory_units.includes(:line_item).map(&:line_item).uniq
+    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
 
-    def finalize!
-      InventoryUnit.finalize_units!(inventory_units)
-      manifest.each { |item| manifest_unstock(item) }
+    def ready_or_pending?
+      self.ready? || self.pending?
     end
 
-    def after_cancel
-      manifest.each { |item| manifest_restock(item) }
+    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
 
-    def after_resume
-      manifest.each { |item| manifest_unstock(item) }
+    def selected_shipping_rate
+      shipping_rates.where(selected: true).first
     end
 
-    # 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.
-    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'
+    def selected_shipping_rate_id
+      selected_shipping_rate.try(:id)
     end
 
-    # 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
-    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? ? 'ready' : 'pending'
+    def selected_shipping_rate_id=(id)
+      shipping_rates.update_all(selected: false)
+      shipping_rates.update(id, selected: true)
+      self.save!
     end
 
-    def tracking_url
-      @tracking_url ||= shipping_method.build_tracking_url(tracking)
+    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
 
-    def include?(variant)
-      inventory_units_for(variant).present?
+    def shipped=(value)
+      return unless value == '1' && shipped_at.nil?
+      self.shipped_at = Time.now
     end
 
-    def inventory_units_for(variant)
-      inventory_units.where(variant_id: variant.id)
+    def shipping_method
+      selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
     end
 
-    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)
+    def tax_category
+      selected_shipping_rate.try(:tax_rate).try(:tax_category)
     end
 
-    def to_package
-      package = Stock::Package.new(stock_location, order)
-      grouped_inventory_units = inventory_units.includes(:line_item).group_by do |iu|
-        [iu.line_item, iu.state_name]
-      end
+    # 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.
+    def tax_total
+      included_tax_total + additional_tax_total
+    end
 
-      grouped_inventory_units.each do |(line_item, state_name), inventory_units|
-        package.add line_item, inventory_units.count, state_name
+    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
 
-    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
-      )
+    def to_param
+      number
+    end
+
+    def tracking_url
+      @tracking_url ||= shipping_method.build_tracking_url(tracking)
     end
 
     def update_amounts
@@ -319,10 +339,63 @@ module Spree
       end
     end
 
+    # 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.
+    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
+
+    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
+
+    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
+
     private
 
-      def manifest_unstock(item)
-        stock_location.unstock item.variant, item.quantity, self
+      def after_ship
+        ShipmentHandler.factory(self).perform
+      end
+
+      def can_get_rates?
+        order.ship_address && order.ship_address.valid?
       end
 
       def manifest_restock(item)
@@ -335,23 +408,12 @@ module Spree
         end
       end
 
-      def description_for_shipping_charge
-        "#{Spree.t(:shipping)} (#{shipping_method.name})"
-      end
-
-      def after_ship
-        inventory_units.each &:ship!
-        send_shipped_email
-        touch :shipped_at
-        update_order_shipment_state
+      def manifest_unstock(item)
+        stock_location.unstock item.variant, item.quantity, self
       end
 
-      def update_order_shipment_state
-        new_state = OrderUpdater.new(order).update_shipment_state
-        order.update_columns(
-          shipment_state: new_state,
-          updated_at: Time.now,
-        )
+      def recalculate_adjustments
+        Spree::ItemAdjustments.new(self).update
       end
 
       def send_shipped_email
@@ -368,12 +430,5 @@ module Spree
         end
       end
 
-      def recalculate_adjustments
-        Spree::ItemAdjustments.new(self).update
-      end
-
-      def can_get_rates?
-        order.ship_address && order.ship_address.valid?
-      end
   end
 end