solidus_core 1.0.0.pre

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

@@ -0,0 +1,25 @@
+module Spree
+  class Reimbursement::Credit < Spree::Base
+    class_attribute :default_creditable_class
+    self.default_creditable_class = Spree::StoreCredit
+
+    belongs_to :reimbursement, inverse_of: :credits
+    belongs_to :creditable, polymorphic: true
+
+    validates :creditable, presence: true
+
+    class << self
+      def total_amount_reimbursed_for(reimbursement)
+        reimbursement.credits.to_a.sum(&:amount)
+      end
+    end
+
+    def description
+      creditable.class.name.demodulize
+    end
+
+    def display_amount
+      Spree::Money.new(amount, { currency: creditable.try(:currency) || "USD" })
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+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] = Array.new }
+    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
+        else
+          nil
+        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,15 @@
+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_performer.rb

@@ -0,0 +1,43 @@
+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,38 @@
+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.pre_tax_amount <= 0) ? 0 : return_item.pre_tax_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.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, :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,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, :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,70 @@
+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
+
+      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(
+        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,27 @@
+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/return_authorization.rb

@@ -0,0 +1,108 @@
+module Spree
+  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::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
+    before_create :generate_number
+
+    after_save :generate_expedited_exchange_reimbursements
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    validates :order, presence: true
+    validates :reason, presence: true
+    validates :stock_location, presence: true
+    validate :must_have_shipped_units, on: :create
+    validate :no_previously_exchanged_inventory_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
+      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
+
+    def pre_tax_total
+      return_items.sum(:pre_tax_amount)
+    end
+
+    def currency
+      order.nil? ? Spree::Config[:currency] : order.currency
+    end
+
+    def refundable_amount
+      order.pre_tax_item_amount + 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, Spree.t(: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, Spree.t(: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
+
+      def generate_expedited_exchange_reimbursements
+        return unless Spree::Config[:expedited_exchanges]
+
+        items_to_exchange = return_items.select(&:exchange_required?)
+        items_to_exchange.each(&:attempt_accept)
+        items_to_exchange.select!(&:accepted?)
+
+        return if items_to_exchange.blank?
+
+        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
+
+      end
+  end
+end