spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/reimbursement_type.rb

@@ -0,0 +1,16 @@
+module Spree
+  class ReimbursementType < Spree::Base
+    include Spree::NamedType
+
+    ORIGINAL = 'original'
+
+    has_many :return_items
+
+    # This method will reimburse the return items based on however it child implements it
+    # By default it takes a reimbursement, the return items it needs to reimburse, and if
+    # it is a simulation or a real reimbursement. This should return an array
+    def self.reimburse(reimbursement, return_items, simulate)
+      raise "Implement me"
+    end
+  end
+end

data/app/models/spree/reimbursement_type/credit.rb

@@ -0,0 +1,13 @@
+module Spree
+  class ReimbursementType::Credit < Spree::ReimbursementType
+    extend Spree::ReimbursementType::ReimbursementHelpers
+
+    class << self
+      def reimburse(reimbursement, return_items, simulate)
+        unpaid_amount = return_items.sum(&:total).round(2)
+        reimbursement_list, unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
+        reimbursement_list
+      end
+    end
+  end
+end

data/app/models/spree/reimbursement_type/exchange.rb

@@ -0,0 +1,9 @@
+class Spree::ReimbursementType::Exchange < Spree::ReimbursementType
+  def self.reimburse(reimbursement, return_items, simulate)
+    return [] unless return_items.present?
+
+    exchange = Spree::Exchange.new(reimbursement.order, return_items)
+    exchange.perform! unless simulate
+    [exchange]
+  end
+end

data/app/models/spree/reimbursement_type/original_payment.rb

@@ -0,0 +1,13 @@
+class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
+  extend Spree::ReimbursementType::ReimbursementHelpers
+
+  class << self
+    def reimburse(reimbursement, return_items, simulate)
+      unpaid_amount = return_items.sum(&:total).round(2)
+      payments = reimbursement.order.payments.completed
+
+      refund_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)
+      refund_list
+    end
+  end
+end

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -0,0 +1,50 @@
+module Spree
+  module ReimbursementType::ReimbursementHelpers
+    def create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list = [])
+      payments.map do |payment|
+        break if unpaid_amount <= 0
+        next unless payment.can_credit?
+
+        amount = [unpaid_amount, payment.credit_allowed].min
+        reimbursement_list << create_refund(reimbursement, payment, amount, simulate)
+        unpaid_amount -= amount
+      end
+
+      return reimbursement_list, unpaid_amount
+    end
+
+    def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [])
+      credits = [create_credit(reimbursement, unpaid_amount, simulate)]
+      unpaid_amount -= credits.sum(&:amount)
+      reimbursement_list += credits
+
+      return reimbursement_list, unpaid_amount
+    end
+
+    private
+
+    def create_refund(reimbursement, payment, amount, simulate)
+      refund = reimbursement.refunds.build({
+        payment: payment,
+        amount: amount,
+        reason: Spree::RefundReason.return_processing_reason,
+      })
+
+      simulate ? refund.readonly! : refund.save!
+      refund
+    end
+
+    # If you have multiple methods of crediting a customer, overwrite this method
+    # Must return an array of objects the respond to #description, #display_amount
+    def create_credit(reimbursement, unpaid_amount, simulate)
+      creditable = create_creditable(reimbursement, unpaid_amount)
+      credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
+      simulate ? credit.readonly! : credit.save!
+      credit
+    end
+
+    def create_creditable(reimbursement, unpaid_amount)
+      Spree::Reimbursement::Credit.default_creditable_class.new(reimbursement: reimbursement, amount: unpaid_amount)
+    end
+  end
+end

data/app/models/spree/return_authorization.rb

@@ -1,114 +1,98 @@
 module Spree
   class ReturnAuthorization < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
+    belongs_to :order, class_name: 'Spree::Order'
+
+    has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
+    has_many :inventory_units, through: :return_items
+    has_many :customer_returns, through: :return_items
 
-    has_many :inventory_units, dependent: :nullify, inverse_of: :return_authorization
     belongs_to :stock_location
+    belongs_to :reason, class_name: 'Spree::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
     before_create :generate_number
-    before_save :force_positive_amount
+
+    after_save :generate_expedited_exchange_reimbursements
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
 
     validates :order, presence: true
-    validates :amount, numericality: true
-    validate :must_have_shipped_units
+    validates :reason, presence: true
+    validates :stock_location, presence: true
+    validate :must_have_shipped_units, on: :create
+
+
+    # These are called prior to generating expedited exchanges shipments.
+    # Should respond to a "call" method that takes the list of return items
+    class_attribute :pre_expedited_exchange_hooks
+    self.pre_expedited_exchange_hooks = []
 
     state_machine initial: :authorized do
-      after_transition to: :received, do: :process_return
+      before_transition to: :canceled, do: :cancel_return_items
 
-      event :receive do
-        transition to: :received, from: :authorized, if: :allow_receive?
-      end
       event :cancel do
         transition to: :canceled, from: :authorized
       end
-    end
 
-    self.whitelisted_ransackable_attributes = ['reason']
+    end
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
     end
 
-    def currency
-      order.nil? ? Spree::Config[:currency] : order.currency
-    end
-
-    def display_amount
-      Spree::Money.new(amount, { currency: currency })
+    def display_pre_tax_total
+      Spree::Money.new(pre_tax_total, { currency: currency })
     end
 
-    def add_variant(variant_id, quantity)
-      order_units = returnable_inventory.group_by(&:variant_id)
-      returned_units = inventory_units.group_by(&:variant_id)
-      return false if order_units.empty?
-
-      count = 0
-
-      if returned_units[variant_id].nil? || returned_units[variant_id].size < quantity
-        count = returned_units[variant_id].nil? ? 0 : returned_units[variant_id].size
-
-        order_units[variant_id].each do |inventory_unit|
-          next unless inventory_unit.return_authorization.nil? && count < quantity
-
-          inventory_unit.return_authorization = self
-          inventory_unit.save!
-
-          count += 1
-        end
-      elsif returned_units[variant_id].size > quantity
-        (returned_units[variant_id].size - quantity).times do |i|
-          returned_units[variant_id][i].return_authorization_id = nil
-          returned_units[variant_id][i].save!
-        end
-      end
-
-      order.authorize_return! if inventory_units.reload.size > 0 && !order.awaiting_return?
+    def currency
+      order.nil? ? Spree::Config[:currency] : order.currency
     end
 
-    def returnable_inventory
-      order.shipped_shipments.collect{|s| s.inventory_units.to_a}.flatten
+    def refundable_amount
+      order.pre_tax_item_amount + order.promo_total
     end
 
-    # Used when Adjustment#update! wants to update the related adjustment
-    def compute_amount(*args)
-      amount.abs * -1
+    def customer_returned_items?
+      customer_returns.exists?
     end
 
     private
 
       def must_have_shipped_units
-        errors.add(:order, Spree.t(:has_no_shipped_units)) if order.nil? || !order.shipped_shipments.any?
+        if order.nil? || order.inventory_units.shipped.none?
+          errors.add(:order, Spree.t(:has_no_shipped_units))
+        end
       end
 
       def generate_number
         self.number ||= loop do
-          random = "RMA#{Array.new(9){rand(9)}.join}"
+          random = "RA#{Array.new(9){rand(9)}.join}"
           break random unless self.class.exists?(number: random)
         end
       end
 
-      def process_return
-        inventory_units(include: :variant).each do |iu|
-          iu.return!
+      def cancel_return_items
+        return_items.each(&:cancel!)
+      end
 
-          if iu.variant.should_track_inventory?
-            if stock_item = Spree::StockItem.find_by(variant_id: iu.variant_id, stock_location_id: stock_location_id)
-              Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1)
-            end
-          end
-        end
+      def generate_expedited_exchange_reimbursements
+        return unless Spree::Config[:expedited_exchanges]
 
-        Adjustment.create(adjustable: order, amount: compute_amount, label: Spree.t(:rma_credit), order: order, source: self)
-        order.update!
+        items_to_exchange = return_items.select(&:exchange_required?)
+        items_to_exchange.each(&:attempt_accept)
+        items_to_exchange.select!(&:accepted?)
 
-        order.return if inventory_units.all?(&:returned?)
-      end
+        return if items_to_exchange.blank?
 
-      def allow_receive?
-        !inventory_units.empty?
-      end
+        pre_expedited_exchange_hooks.each { |h| h.call items_to_exchange }
+
+        reimbursement = Reimbursement.new(return_items: items_to_exchange, order: order)
+
+        if reimbursement.save
+          reimbursement.perform!
+        else
+          errors.add(:base, reimbursement.errors.full_messages)
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
 
-      def force_positive_amount
-        self.amount = amount.abs
       end
   end
 end

data/app/models/spree/return_authorization_reason.rb

@@ -0,0 +1,7 @@
+module Spree
+  class ReturnAuthorizationReason < Spree::Base
+    include Spree::NamedType
+
+    has_many :return_authorizations
+  end
+end

data/app/models/spree/return_item.rb

@@ -0,0 +1,230 @@
+module Spree
+  class ReturnItem < Spree::Base
+    COMPLETED_RECEPTION_STATUSES = %w(received given_to_customer)
+
+    class_attribute :return_eligibility_validator
+    self.return_eligibility_validator = ReturnItem::EligibilityValidator::DefaultEligibilityValidator
+
+    class_attribute :exchange_variant_engine
+    self.exchange_variant_engine = ReturnItem::ExchangeVariantEligibility::SameProduct
+
+    class_attribute :refund_amount_calculator
+    self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
+
+    belongs_to :return_authorization, inverse_of: :return_items
+    belongs_to :inventory_unit, inverse_of: :return_items
+    belongs_to :exchange_variant, class_name: 'Spree::Variant'
+    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
+    belongs_to :customer_return, inverse_of: :return_items
+    belongs_to :reimbursement, inverse_of: :return_items
+    belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
+    belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
+
+    validate :belongs_to_same_customer_order
+    validate :validate_acceptance_status_for_reimbursement
+    validates :inventory_unit, presence: true
+    validate :validate_no_other_completed_return_items, on: :create
+
+    after_create :cancel_others, unless: :cancelled?
+
+    scope :awaiting_return, -> { where(reception_status: 'awaiting') }
+    scope :not_cancelled, -> { where.not(reception_status: 'cancelled') }
+    scope :pending, -> { where(acceptance_status: 'pending') }
+    scope :accepted, -> { where(acceptance_status: 'accepted') }
+    scope :rejected, -> { where(acceptance_status: 'rejected') }
+    scope :manual_intervention_required, -> { where(acceptance_status: 'manual_intervention_required') }
+    scope :undecided, -> { where(acceptance_status: %w(pending manual_intervention_required)) }
+    scope :decided, -> { where.not(acceptance_status: %w(pending manual_intervention_required)) }
+    scope :reimbursed, -> { where.not(reimbursement_id: nil) }
+    scope :not_reimbursed, -> { where(reimbursement_id: nil) }
+    scope :exchange_requested, -> { where.not(exchange_variant: nil) }
+    scope :exchange_processed, -> { where.not(exchange_inventory_unit: nil) }
+    scope :exchange_required, -> { exchange_requested.where(exchange_inventory_unit: nil) }
+
+    serialize :acceptance_status_errors
+
+    delegate :eligible_for_return?, :requires_manual_intervention?, to: :validator
+    delegate :variant, to: :inventory_unit
+    delegate :shipment, to: :inventory_unit
+
+    before_create :set_default_pre_tax_amount, unless: :pre_tax_amount_changed?
+    before_save :set_exchange_pre_tax_amount
+
+    state_machine :reception_status, initial: :awaiting do
+      before_transition to: :received, do: :process_inventory_unit!
+      after_transition to: :received, do: :attempt_accept
+
+      event :receive do
+        transition to: :received, from: :awaiting
+      end
+
+      event :cancel do
+        transition to: :cancelled, from: :awaiting
+      end
+
+      event :give do
+        transition to: :given_to_customer, from: :awaiting
+      end
+    end
+
+    def reception_completed?
+      COMPLETED_RECEPTION_STATUSES.include?(reception_status)
+    end
+
+    state_machine :acceptance_status, initial: :pending do
+      event :attempt_accept do
+        transition to: :accepted, from: :accepted
+        transition to: :accepted, from: :pending, if: ->(return_item) { return_item.eligible_for_return? }
+        transition to: :manual_intervention_required, from: :pending, if: ->(return_item) { return_item.requires_manual_intervention? }
+        transition to: :rejected, from: :pending
+      end
+
+      # bypasses eligibility checks
+      event :accept do
+        transition to: :accepted, from: [:accepted, :pending, :manual_intervention_required]
+      end
+
+      # bypasses eligibility checks
+      event :reject do
+        transition to: :rejected, from: [:accepted, :pending, :manual_intervention_required]
+      end
+
+      # bypasses eligibility checks
+      event :require_manual_intervention do
+        transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
+      end
+
+      after_transition any => any, :do => :persist_acceptance_status_errors
+    end
+
+    def self.from_inventory_unit(inventory_unit)
+      not_cancelled.find_by(inventory_unit: inventory_unit) ||
+        new(inventory_unit: inventory_unit).tap(&:set_default_pre_tax_amount)
+    end
+
+    def exchange_requested?
+      exchange_variant.present?
+    end
+
+    def exchange_processed?
+      exchange_inventory_unit.present?
+    end
+
+    def exchange_required?
+      exchange_requested? && !exchange_processed?
+    end
+
+    def display_pre_tax_amount
+      Spree::Money.new(pre_tax_amount, { currency: currency })
+    end
+
+    def total
+      pre_tax_amount + additional_tax_total
+    end
+
+    def display_total
+      Spree::Money.new(total, { currency: currency })
+    end
+
+    def eligible_exchange_variants
+      exchange_variant_engine.eligible_variants(variant)
+    end
+
+    def build_exchange_inventory_unit
+      # The inventory unit needs to have the new variant
+      # but it also needs to know the original line item
+      # for pricing information for if the inventory unit is
+      # ever returned. This means that the inventory unit's line_item
+      # will have a different variant than the inventory unit itself
+      super(variant: exchange_variant, line_item: inventory_unit.line_item, order: inventory_unit.order) if exchange_required?
+    end
+
+    def exchange_shipment
+      exchange_inventory_unit.try(:shipment)
+    end
+
+    def set_default_pre_tax_amount
+      self.pre_tax_amount = refund_amount_calculator.new.compute(self)
+    end
+
+    private
+
+    def persist_acceptance_status_errors
+      self.update_attributes(acceptance_status_errors: validator.errors)
+    end
+
+    def stock_item
+      return unless customer_return
+
+      Spree::StockItem.find_by({
+        variant_id: inventory_unit.variant_id,
+        stock_location_id: customer_return.stock_location_id,
+      })
+    end
+
+    def currency
+      return_authorization.try(:currency) || Spree::Config[:currency]
+    end
+
+    def process_inventory_unit!
+      inventory_unit.return!
+
+      Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1) if should_restock?
+    end
+
+    # This logic is also present in the customer return. The reason for the
+    # duplication and not having a validates_associated on the customer_return
+    # is that it would lead to duplicate error messages for the customer return.
+    # Not specifying a stock location for example would add an error message about
+    # the mandatory field when validating the customer return and again when saving
+    # the associated return items.
+    def belongs_to_same_customer_order
+      return unless customer_return && inventory_unit
+
+      if customer_return.order_id != inventory_unit.order_id
+        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+      end
+    end
+
+    def validator
+      @validator ||= return_eligibility_validator.new(self)
+    end
+
+    def validate_acceptance_status_for_reimbursement
+      if reimbursement && !accepted?
+        errors.add(:reimbursement, :cannot_be_associated_unless_accepted)
+      end
+    end
+
+    def set_exchange_pre_tax_amount
+      self.pre_tax_amount = 0.0.to_d if exchange_requested?
+    end
+
+    def validate_no_other_completed_return_items
+      other_return_item = Spree::ReturnItem.where({
+        inventory_unit_id: inventory_unit_id,
+        reception_status: COMPLETED_RECEPTION_STATUSES,
+      }).first
+
+      if other_return_item
+        errors.add(:inventory_unit, :other_completed_return_item_exists, {
+          inventory_unit_id: inventory_unit_id,
+          return_item_id: other_return_item.id,
+        })
+      end
+    end
+
+    def cancel_others
+      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id)
+                       .where.not(id: id)
+                       .where.not(reception_status: 'cancelled')
+                       .each do |return_item|
+        return_item.cancel!
+      end
+    end
+
+    def should_restock?
+      variant.should_track_inventory? && stock_item && Spree::Config[:restock_inventory]
+    end
+  end
+end