solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/reimbursement/reimbursement_type_engine.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Spree
+  class Reimbursement::ReimbursementTypeEngine
+    include Spree::Reimbursement::ReimbursementTypeValidator
+
+    class_attribute :refund_time_constraint
+    self.refund_time_constraint = 90.days
+
+    class_attribute :default_reimbursement_type
+    self.default_reimbursement_type = Spree::ReimbursementType::OriginalPayment
+
+    class_attribute :expired_reimbursement_type
+    self.expired_reimbursement_type = Spree::ReimbursementType::StoreCredit
+
+    class_attribute :exchange_reimbursement_type
+    self.exchange_reimbursement_type = Spree::ReimbursementType::Exchange
+
+    def initialize(return_items)
+      @return_items = return_items
+      @reimbursement_type_hash = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def calculate_reimbursement_types
+      @return_items.each do |return_item|
+        reimbursement_type = calculate_reimbursement_type(return_item)
+        add_reimbursement_type(return_item, reimbursement_type)
+      end
+
+      @reimbursement_type_hash
+    end
+
+    private
+
+    def calculate_reimbursement_type(return_item)
+      if return_item.exchange_required?
+        exchange_reimbursement_type
+      elsif return_item.override_reimbursement_type.present?
+        return_item.override_reimbursement_type.class
+      elsif return_item.preferred_reimbursement_type.present?
+        if valid_preferred_reimbursement_type?(return_item)
+          return_item.preferred_reimbursement_type.class
+        end
+      elsif past_reimbursable_time_period?(return_item)
+        expired_reimbursement_type
+      else
+        default_reimbursement_type
+      end
+    end
+
+    def add_reimbursement_type(return_item, reimbursement_type)
+      return unless reimbursement_type
+      @reimbursement_type_hash[reimbursement_type] << return_item
+    end
+  end
+end

data/app/models/spree/reimbursement/reimbursement_type_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Reimbursement::ReimbursementTypeValidator
+    def valid_preferred_reimbursement_type?(return_item)
+      preferred_type = return_item.preferred_reimbursement_type.class
+
+      !past_reimbursable_time_period?(return_item) ||
+        preferred_type == expired_reimbursement_type
+    end
+
+    def past_reimbursable_time_period?(return_item)
+      shipped_at = return_item.inventory_unit.shipment.shipped_at
+      shipped_at && shipped_at < refund_time_constraint.ago
+    end
+  end
+end

data/app/models/spree/reimbursement.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Spree
+  class Reimbursement < Spree::Base
+    class IncompleteReimbursementError < StandardError; end
+
+    belongs_to :order, inverse_of: :reimbursements
+    belongs_to :customer_return, inverse_of: :reimbursements, touch: true
+
+    has_many :refunds, inverse_of: :reimbursement
+    has_many :credits, inverse_of: :reimbursement, class_name: 'Spree::Reimbursement::Credit'
+
+    has_many :return_items, inverse_of: :reimbursement
+
+    validates :order, presence: true
+    validate :validate_return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    before_create :generate_number
+
+    scope :reimbursed, -> { where(reimbursement_status: 'reimbursed') }
+
+    # The reimbursement_tax_calculator property should be set to an object that responds to "call"
+    # and accepts a reimbursement object. Invoking "call" should update the tax fields on the
+    # associated ReturnItems.
+    # This allows a store to easily integrate with third party tax services.
+    class_attribute :reimbursement_tax_calculator
+    self.reimbursement_tax_calculator = ReimbursementTaxCalculator
+    # A separate attribute here allows you to use a more performant calculator for estimates
+    # and a different one (e.g. one that hits a 3rd party API) for the final caluclations.
+    class_attribute :reimbursement_simulator_tax_calculator
+    self.reimbursement_simulator_tax_calculator = ReimbursementTaxCalculator
+
+    # The reimbursement_models property should contain an array of all models that provide
+    # reimbursements.
+    # This allows a store to incorporate custom reimbursement methods that Spree doesn't know about.
+    # Each model must implement a "total_amount_reimbursed_for" method.
+    # Example:
+    #   Refund.total_amount_reimbursed_for(reimbursement)
+    # See the `reimbursement_generator` property regarding the generation of custom reimbursements.
+    class_attribute :reimbursement_models
+    self.reimbursement_models = [Spree::Refund, Spree::Reimbursement::Credit]
+
+    # The reimbursement_performer property should be set to an object that responds to the following methods:
+    # - #perform
+    # - #simulate
+    # see ReimbursementPerformer for details.
+    # This allows a store to customize their reimbursement methods and logic.
+    class_attribute :reimbursement_performer
+    self.reimbursement_performer = ReimbursementPerformer
+
+    # These are called if the call to "reimburse!" succeeds.
+    class_attribute :reimbursement_success_hooks
+    self.reimbursement_success_hooks = []
+
+    # These are called if the call to "reimburse!" fails.
+    class_attribute :reimbursement_failure_hooks
+    self.reimbursement_failure_hooks = []
+
+    state_machine :reimbursement_status, initial: :pending do
+      event :errored do
+        transition to: :errored, from: [:pending, :errored]
+      end
+
+      event :reimbursed do
+        transition to: :reimbursed, from: [:pending, :errored]
+      end
+    end
+
+    class << self
+      def build_from_customer_return(customer_return)
+        order = customer_return.order
+        order.reimbursements.build({
+          customer_return: customer_return,
+          return_items: customer_return.return_items.accepted.not_reimbursed
+        })
+      end
+    end
+
+    def display_total
+      Spree::Money.new(total, { currency: order.currency })
+    end
+
+    def calculated_total
+      # rounding down to handle edge cases for consecutive partial returns where rounding
+      # might cause us to try to reimburse more than was originally billed
+      return_items.to_a.sum(&:total).to_d.round(2, :down)
+    end
+
+    def paid_amount
+      reimbursement_models.sum do |model|
+        model.total_amount_reimbursed_for(self)
+      end
+    end
+
+    def unpaid_amount
+      total - paid_amount
+    end
+
+    def perform!
+      reimbursement_tax_calculator.call(self)
+      reload
+      update!(total: calculated_total)
+
+      reimbursement_performer.perform(self)
+
+      if unpaid_amount_within_tolerance?
+        reimbursed!
+        reimbursement_success_hooks.each { |h| h.call self }
+        send_reimbursement_email
+      else
+        errored!
+        reimbursement_failure_hooks.each { |h| h.call self }
+        raise IncompleteReimbursementError, I18n.t("spree.validation.unpaid_amount_not_zero", amount: unpaid_amount)
+      end
+    end
+
+    def simulate
+      reimbursement_simulator_tax_calculator.call(self)
+      reload
+      update!(total: calculated_total)
+
+      reimbursement_performer.simulate(self)
+    end
+
+    def return_items_requiring_exchange
+      return_items.select(&:exchange_required?)
+    end
+
+    def any_exchanges?
+      return_items.any?(&:exchange_processed?)
+    end
+
+    def all_exchanges?
+      return_items.all?(&:exchange_processed?)
+    end
+
+    # Accepts all return items, saves the reimbursement, and performs the reimbursement
+    #
+    # @api public
+    # @return [void]
+    def return_all
+      return_items.each(&:accept!)
+      save!
+      perform!
+    end
+
+    private
+
+    def generate_number
+      self.number ||= loop do
+        random = "RI#{Array.new(9){ rand(9) }.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def validate_return_items_belong_to_same_order
+      if return_items.any? { |ri| ri.inventory_unit.order_id != order_id }
+        errors.add(:base, :return_items_order_id_does_not_match)
+      end
+    end
+
+    def send_reimbursement_email
+      Spree::Config.reimbursement_mailer_class.reimbursement_email(id).deliver_later
+    end
+
+    # If there are multiple different reimbursement types for a single
+    # reimbursement we open ourselves to a one-cent rounding error for every
+    # type over the first one. This is due to how we round #unpaid_amount and
+    # how each reimbursement type will round as well. Since at this point the
+    # payments and credits have already been processed, we should allow the
+    # reimbursement to show as 'reimbursed' and not 'errored'.
+    def unpaid_amount_within_tolerance?
+      reimbursement_count = reimbursement_models.count do |model|
+        model.total_amount_reimbursed_for(self) > 0
+      end
+      leniency = if reimbursement_count > 0
+                   (reimbursement_count - 1) * 0.01.to_d
+                 else
+                   0
+                 end
+      unpaid_amount.abs.between?(0, leniency)
+    end
+  end
+end

data/app/models/spree/reimbursement_performer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  class ReimbursementPerformer
+    class << self
+      class_attribute :reimbursement_type_engine
+      self.reimbursement_type_engine = Spree::Reimbursement::ReimbursementTypeEngine
+
+      # Simulate performing the reimbursement without actually saving anything or refunding money, etc.
+      # This must return an array of objects that respond to the following methods:
+      # - #description
+      # - #display_amount
+      # so they can be displayed in the Admin UI appropriately.
+      def simulate(reimbursement)
+        execute(reimbursement, true)
+      end
+
+      # Actually perform the reimbursement
+      def perform(reimbursement)
+        execute(reimbursement, false)
+      end
+
+      private
+
+      def execute(reimbursement, simulate)
+        reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
+
+        reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
+          reimbursement_type.reimburse(reimbursement, return_items, simulate)
+        end
+      end
+
+      def calculate_reimbursement_types(reimbursement)
+        # Engine returns hash of preferred reimbursement types pointing at return items
+        # {Spree::ReimbursementType::OriginalPayment => [ReturnItem, ...], Spree::ReimbursementType::Exchange => [ReturnItem, ...]}
+        reimbursement_type_engine.new(reimbursement.return_items).calculate_reimbursement_types
+      end
+    end
+  end
+end

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  # Tax calculation is broken out at this level to allow easy integration with 3rd party
+  # taxation systems.  Those systems are usually geared toward calculating all items at once
+  # rather than one at a time.
+  #
+  # To use an alternative tax calculator do this:
+  #    Spree::ReturnAuthorization.reimbursement_tax_calculator = calculator_object
+  # where `calculator_object` is an object that responds to "call" and accepts a reimbursement object
+
+  class ReimbursementTaxCalculator
+    class << self
+      def call(reimbursement)
+        reimbursement.return_items.includes(:inventory_unit).each do |return_item|
+          set_tax!(return_item)
+        end
+      end
+
+      private
+
+      def set_tax!(return_item)
+        percent_of_tax = (return_item.amount <= 0) ? 0 : return_item.amount / Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
+
+        additional_tax_total = percent_of_tax * return_item.inventory_unit.additional_tax_total
+        included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
+
+        return_item.update_attributes!({
+          additional_tax_total: additional_tax_total,
+          included_tax_total:   included_tax_total
+        })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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, :down)
+        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,11 @@
+# frozen_string_literal: true
+
+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,15 @@
+# frozen_string_literal: true
+
+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, :down)
+      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,72 @@
+# frozen_string_literal: true
+
+module Spree
+  module ReimbursementType::ReimbursementHelpers
+    # Ordered list of payment methods that are valid for the reimbursement
+    # type to use for reimbursing. Leaving this nil allows anything.
+    attr_accessor :eligible_refund_methods
+
+    def create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list = [])
+      payments = sorted_eligible_refund_payments(payments)
+      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
+
+      [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
+
+      [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(
+        user: reimbursement.order.user,
+        amount: unpaid_amount,
+        category: Spree::StoreCreditCategory.reimbursement_category(reimbursement),
+        created_by: Spree::StoreCredit.default_created_by,
+        memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
+        currency: reimbursement.order.currency
+      )
+    end
+
+    def sorted_eligible_refund_payments(payments)
+      if eligible_refund_methods = self.eligible_refund_methods
+        payments = payments.select { |p| eligible_refund_methods.include? p.payment_method.class }
+        payments = payments.sort_by { |p| eligible_refund_methods.index(p.payment_method.class) }
+      end
+      payments
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
+  extend Spree::ReimbursementType::ReimbursementHelpers
+
+  class << self
+    def reimburse(reimbursement, return_items, simulate)
+      unpaid_amount = return_items.sum(&:total).to_d.round(2, :down)
+      payments = store_credit_payments(reimbursement)
+      reimbursement_list = []
+
+      # Credit each store credit that was used on the order
+      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list)
+
+      # If there is any amount left to pay out to the customer, then create credit with that amount
+      if unpaid_amount > 0.0
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
+      end
+
+      reimbursement_list
+    end
+
+    private
+
+    def store_credit_payments(reimbursement)
+      reimbursement.order.payments.completed.store_credits
+    end
+  end
+end

data/app/models/spree/reimbursement_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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/return_authorization.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Spree
+  # Models the return of Inventory Units to a Stock Location for an Order.
+  #
+  class ReturnAuthorization < Spree::Base
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
+
+    has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
+    has_many :inventory_units, through: :return_items, dependent: :nullify
+    has_many :customer_returns, through: :return_items
+
+    belongs_to :stock_location
+    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id
+
+    before_create :generate_number
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    validates :order, presence: true
+    validates :stock_location, presence: true
+    validate :must_have_shipped_units, on: :create
+    validate :no_previously_exchanged_inventory_units, on: :create
+
+    state_machine initial: :authorized do
+      before_transition to: :canceled, do: :cancel_return_items
+
+      event :cancel do
+        transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
+      end
+    end
+
+    extend DisplayMoney
+    money_methods :pre_tax_total, :amount, :total_excluding_vat
+    deprecate display_pre_tax_total: :display_total_excluding_vat, deprecator: Spree::Deprecation
+
+    self.whitelisted_ransackable_attributes = ['memo']
+
+    def total_excluding_vat
+      return_items.map(&:total_excluding_vat).sum
+    end
+    alias pre_tax_total total_excluding_vat
+    deprecate pre_tax_total: :total_excluding_vat, deprecator: Spree::Deprecation
+
+    def amount
+      return_items.sum(:amount)
+    end
+
+    def currency
+      order.currency
+    end
+
+    def refundable_amount
+      order.item_total_before_tax + order.promo_total
+    end
+
+    def customer_returned_items?
+      customer_returns.exists?
+    end
+
+    def can_cancel_return_items?
+      return_items.any?(&:can_cancel?) || return_items.blank?
+    end
+
+    private
+
+    def must_have_shipped_units
+      if order.nil? || order.inventory_units.shipped.none?
+        errors.add(:order, I18n.t('spree.has_no_shipped_units'))
+      end
+    end
+
+    def generate_number
+      self.number ||= loop do
+        random = "RA#{Array.new(9){ rand(9) }.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def no_previously_exchanged_inventory_units
+      if return_items.map(&:inventory_unit).any?(&:exchange_requested?)
+        errors.add(:base, I18n.t('spree.return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange'))
+      end
+    end
+
+    def cancel_return_items
+      return_items.each { |item| item.cancel! if item.can_cancel? }
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class BaseValidator
+        attr_reader :errors
+
+        def initialize(return_item)
+          @return_item = return_item
+          @errors = {}
+        end
+
+        def eligible_for_return?
+          raise NotImplementedError, I18n.t('spree.implement_eligible_for_return')
+        end
+
+        def requires_manual_intervention?
+          raise NotImplementedError, I18n.t('spree.implement_requires_manual_intervention')
+        end
+
+        private
+
+        def add_error(key, error)
+          @errors[key] = error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class Default < Spree::ReturnItem::EligibilityValidator::BaseValidator
+        class_attribute :permitted_eligibility_validators
+        self.permitted_eligibility_validators = [
+          ReturnItem::EligibilityValidator::OrderCompleted,
+          ReturnItem::EligibilityValidator::TimeSincePurchase,
+          ReturnItem::EligibilityValidator::RMARequired,
+          ReturnItem::EligibilityValidator::InventoryShipped,
+          ReturnItem::EligibilityValidator::NoReimbursements
+        ]
+
+        def eligible_for_return?
+          validators.all?(&:eligible_for_return?)
+        end
+
+        def requires_manual_intervention?
+          validators.any?(&: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
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  class ReturnItem < Spree::Base
+    module EligibilityValidator
+      class InventoryShipped < Spree::ReturnItem::EligibilityValidator::BaseValidator
+        def eligible_for_return?
+          if @return_item.inventory_unit.shipped?
+            true
+          else
+            add_error(:inventory_unit_shipped, I18n.t('spree.return_item_inventory_unit_ineligible'))
+            false
+          end
+        end
+
+        def requires_manual_intervention?
+          @errors.present?
+        end
+      end
+    end
+  end
+end