goca-spree-core 3.1.14.rails.5.0

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 = nil
+
+    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::OriginalPayment
+
+    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.rb

@@ -0,0 +1,164 @@
+module Spree
+  class Reimbursement < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'RI', length: 9)
+
+    class IncompleteReimbursementError < StandardError; end
+
+    with_options inverse_of: :reimbursements do
+      belongs_to :order
+      belongs_to :customer_return, touch: true
+    end
+
+    with_options inverse_of: :reimbursement do
+      has_many :refunds
+      has_many :credits, class_name: 'Spree::Reimbursement::Credit'
+      has_many :return_items
+    end
+
+    validates :order, presence: true
+    validate :validate_return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    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 calculations.
+    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 = [Refund]
+
+    # 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
+      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 every return item individually to handle edge cases for consecutive partial
+      # returns where rounding might cause us to try to reimburse more than was originally billed
+      return_items.map { |ri| ri.total.to_d.round(2) }.sum
+    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, Spree.t("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
+
+    private
+
+    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::ReimbursementMailer.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.size 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,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,44 @@
+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)
+        calculated_refund = Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
+
+        percent_of_tax = if return_item.pre_tax_amount <= 0 || calculated_refund <= 0
+          0
+        else
+          return_item.pre_tax_amount / calculated_refund
+        end
+
+        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,13 @@
+module Spree
+  class ReimbursementType::Credit < Spree::ReimbursementType
+    extend Spree::ReimbursementType::ReimbursementHelpers
+
+    class << self
+      def reimburse(reimbursement, return_items, simulate)
+        unpaid_amount = return_items.map { |ri| ri.total.to_d.round(2) }.sum
+        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.map { |ri| ri.total.to_d.round(2) }.sum
+      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,67 @@
+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
+
+      [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)
+      category = Spree::StoreCreditCategory.default_reimbursement_category(category_options(reimbursement))
+      Spree::StoreCredit.new(store_credit_params(category, reimbursement, unpaid_amount))
+    end
+
+    def store_credit_params(category, reimbursement, unpaid_amount)
+      {
+        user: reimbursement.order.user,
+        amount: unpaid_amount,
+        category: category,
+        created_by: Spree::StoreCredit.default_created_by,
+        memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
+        currency: reimbursement.order.currency
+      }
+    end
+
+    # overwrite if you need options for the default reimbursement category
+    def category_options(_reimbursement)
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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,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/return_authorization.rb

@@ -0,0 +1,98 @@
+module Spree
+  class ReturnAuthorization < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'RA', length: 9)
+
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
+
+    has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
+    with_options through: :return_items do
+      has_many :inventory_units
+      has_many :customer_returns
+    end
+
+    belongs_to :stock_location
+    belongs_to :reason, class_name: 'Spree::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
+
+    after_save :generate_expedited_exchange_reimbursements
+
+    accepts_nested_attributes_for :return_items, allow_destroy: true
+
+    validates :order, :reason, :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
+      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
+
+    self.whitelisted_ransackable_attributes = ['memo', 'number', 'state']
+
+    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 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

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, dependent: :restrict_with_error
+  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 NotImplementedError, Spree.t(:implement_eligible_for_return)
+    end
+
+    def requires_manual_intervention?
+      raise NotImplementedError, Spree.t(:implement_requires_manual_intervention)
+    end
+
+    private
+
+    def add_error(key, error)
+      @errors[key] = error
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Spree
+  class ReturnItem::EligibilityValidator::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? {|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/inventory_shipped.rb

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