spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/promotion_rule.rb

@@ -20,6 +20,16 @@ module Spree
       raise 'eligible? should be implemented in a sub-class of Spree::PromotionRule'
     end
 
+    # This states if a promotion can be applied to the specified line item
+    # It is true by default, but can be overridden by promotion rules to provide conditions
+    def actionable?(line_item)
+      true
+    end
+
+    def eligibility_errors
+      @eligibility_errors ||= ActiveModel::Errors.new(self)
+    end
+
     private
     def unique_per_promotion
       if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
@@ -27,5 +37,8 @@ module Spree
       end
     end
 
+    def eligibility_error_message(key, options = {})
+      Spree.t(key, Hash[scope: [:eligibility_errors, :messages]].merge(options))
+    end
   end
 end

data/app/models/spree/property.rb

@@ -11,8 +11,6 @@ module Spree
 
     after_touch :touch_all_products
 
-    self.whitelisted_ransackable_attributes = ['presentation']
-
     def self.find_all_by_prototype(prototype)
       id = prototype
       id = prototype.id if prototype.class == Prototype
@@ -23,7 +21,7 @@ module Spree
     private
 
     def touch_all_products
-      products.each(&:touch)
+      products.update_all(updated_at: Time.current)
     end
   end
 end

data/app/models/spree/refund.rb

@@ -0,0 +1,91 @@
+module Spree
+  class Refund < Spree::Base
+    belongs_to :payment, inverse_of: :refunds
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
+    belongs_to :reimbursement, inverse_of: :refunds
+
+    has_many :log_entries, as: :source
+
+    validates :payment, presence: true
+    validates :reason, presence: true
+    validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
+    validates :amount, presence: true, numericality: {greater_than: 0}
+
+    validate :check_payment_environment, on: :create, if: :payment
+    validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
+
+    after_create :perform!
+    after_create :create_log_entry
+
+    scope :non_reimbursement, -> { where(reimbursement_id: nil) }
+
+    def money
+      Spree::Money.new(amount, { currency: payment.currency })
+    end
+    alias display_amount money
+
+    class << self
+      def total_amount_reimbursed_for(reimbursement)
+        reimbursement.refunds.to_a.sum(&:amount)
+      end
+    end
+
+    def description
+      payment.payment_method.name
+    end
+
+    private
+
+    # attempts to perform the refund.
+    # raises an error if the refund fails.
+    def perform!
+      return true if transaction_id.present?
+
+      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).money.cents
+
+      @response = process!(credit_cents)
+
+      self.transaction_id = @response.authorization
+      update_columns(transaction_id: transaction_id)
+    end
+
+    # return an activemerchant response object if successful or else raise an error
+    def process!(credit_cents)
+      response = if payment.payment_method.payment_profiles_supported?
+        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, {originator: self})
+      else
+        payment.payment_method.credit(credit_cents, payment.transaction_id, {originator: self})
+      end
+
+      if !response.success?
+        logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        text = response.params['message'] || response.params['response_reason_text'] || response.message
+        raise Core::GatewayError.new(text)
+      end
+
+      response
+    rescue ActiveMerchant::ConnectionError => e
+      logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
+      raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
+    end
+
+    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+    # Ex. When testing in staging environment with a copy of production data.
+    def check_payment_environment
+      if payment.payment_method.environment != Rails.env
+        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
+        errors.add(:base, message)
+      end
+    end
+
+    def create_log_entry
+      log_entries.create!(details: @response.to_yaml)
+    end
+
+    def amount_is_less_than_or_equal_to_allowed_amount
+      if amount > payment.credit_allowed
+        errors.add(:amount, :greater_than_allowed)
+      end
+    end
+  end
+end

data/app/models/spree/refund_reason.rb

@@ -0,0 +1,13 @@
+module Spree
+  class RefundReason < Spree::Base
+    include Spree::NamedType
+
+    RETURN_PROCESSING_REASON = 'Return processing'
+
+    has_many :refunds
+
+    def self.return_processing_reason
+      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+    end
+  end
+end

data/app/models/spree/reimbursement.rb

@@ -0,0 +1,148 @@
+module Spree
+  class Reimbursement < Spree::Base
+    class IncompleteReimbursement < 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
+
+    # 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 = [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
+      after_transition to: :reimbursed, do: :send_reimbursement_email
+
+      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 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.zero?
+        reimbursed!
+        reimbursement_success_hooks.each { |h| h.call self }
+      else
+        errored!
+        reimbursement_failure_hooks.each { |h| h.call self }
+        raise IncompleteReimbursement, 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 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::ReimbursementMailer.reimbursement_email(self.id).deliver
+    end
+  end
+end

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,12 @@
+module Spree
+  module Reimbursement::ReimbursementTypeValidator
+    def valid_preferred_reimbursement_type?(return_item)
+      !past_reimbursable_time_period?(return_item) || return_item.preferred_reimbursement_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