spree-returnly 0.13.0

data/lib/returnly/refund/return_item_restock_policy.rb

@@ -0,0 +1,15 @@
+module Returnly
+  module Refund
+    class ReturnItemRestockPolicy
+      attr_accessor :refund
+
+      def initialize(refund)
+        self.refund = refund
+      end
+
+      def should_return_item?(return_item)
+        return_item.resellable?
+      end
+    end
+  end
+end

data/lib/returnly/refund_calculator.rb

@@ -0,0 +1,62 @@
+module Returnly
+  class RefundCalculator
+    attr_accessor :line_items, :order
+    extend ::Returnly::RefundsConfiguration
+
+    def self.process(order, line_items)
+      refund_presenter_class.present_estimate new(order, line_items)
+    end
+
+    def initialize(order, line_items)
+      self.line_items = line_items
+      self.order = order
+    end
+
+    def discount
+      Returnly::DiscountCalculator.new(order).calculate(line_items)
+    end
+
+    def line_item_tax(line_item)
+      (line_item.adjustments.tax.sum(&:amount).to_d / line_item.quantity).round(2, :down)
+    end
+
+    def line_items_return_items
+      available_return_items.each_with_object({}) do |return_item, return_items|
+        line_item_id = return_item.inventory_unit.line_item_id
+        return_items[line_item_id] ||= []
+        return_items[line_item_id] << set_tax(return_item)
+        return_items
+      end
+    end
+
+    def shipping_tax
+      order.all_adjustments.where(source_type: 'Spree::TaxRate', adjustable_type: 'Spree::Shipment').sum(&:amount).to_d.round(2, :down)
+    end
+
+    def gift_card
+      @gift_card ||= self.class.gift_card_estimate_class.new(order)
+    end
+
+    protected
+
+    def available_return_items
+      self.class.return_item_builder_class.new(order).build_by_requested_line_items(line_items)
+    end
+
+    def set_tax(return_item)
+      percent_of_tax = if return_item.amount <= 0
+                         0
+                       else
+                         return_item.amount / Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
+                       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.additional_tax_total = additional_tax_total
+      return_item.included_tax_total = included_tax_total
+
+      return_item
+    end
+  end
+end

data/lib/returnly/refund_presenter.rb

@@ -0,0 +1,115 @@
+module Returnly
+  class RefundPresenter
+    class << self
+      def present_refund(refunder)
+        customer_return = refunder.customer_return
+        refund = refunder.order.reload.refunds.last
+
+        {
+          refund_id: refund.try(:id).try(:to_s),
+          user_id: refunder.order.user_id,
+          line_items: customer_return.return_items.group_by { |ri| ri.inventory_unit.line_item.id }.map do |_, return_items|
+            first_return_item = return_items.first
+            {
+              refund_line_item_id: first_return_item.id.to_s,
+              order_line_item_id: first_return_item.inventory_unit.line_item.id.to_s,
+              units: return_items.size,
+              restock: first_return_item.resellable
+            }
+          end,
+          transactions: refunder.reimbursement.refunds.map do |refund|
+            {
+              id: refund.transaction_id,
+              amount: refund.amount.to_s,
+              status: transaction_status(refund.payment),
+              type: 'REFUND',
+              gateway: refund.payment.payment_method.type.demodulize,
+              is_online: true,
+              is_test: !Rails.env.match?(/production/),
+              payment_details: transaction_payment_details(refund.payment, refunder.gift_card_class.new(refund)),
+              created_at: refund.created_at.iso8601(3),
+              updated_at: refund.updated_at.iso8601(3)
+            }
+          end,
+          created_at: refund.try(:created_at).try(:iso8601, 3),
+          updated_at: refund.try(:updated_at).try(:iso8601, 3)
+        }
+      end
+
+      def present_estimate(calculator)
+        sub_total = Money.new 0
+        tax = Money.new 0
+
+        calculator.line_items_return_items.values.flatten.each do |return_item|
+          sub_total += Money.from_amount return_item.inventory_unit.line_item.price
+          tax += Money.from_amount calculator.line_item_tax(return_item.inventory_unit.line_item)
+        end
+
+        discount = Money.from_amount(calculator.discount)
+        total_refund_amount = sub_total + tax - (discount * -1) # discount is negative, so we multiply it by -1 to make it positive for subtraction
+        shipping_tax        = calculator.shipping_tax
+        {
+          product_amount: sub_total.to_s,
+          tax_amount: tax.to_s,
+          discount_amount: (discount * -1).to_s,
+          total_refund_amount: total_refund_amount.to_s,
+          refundable_shipping_amount: Money.from_amount(calculator.order.shipment_total).to_s,
+          refundable_shipping_tax_amount: Money.from_amount(shipping_tax).to_s,
+          max_refundable_amount: Money.from_amount(calculator.order.total - calculator.order.refunds.reload.sum(&:amount)).to_s,
+          transactions: transactions_for_estimate(
+            calculator.order,
+            calculator.gift_card,
+            total_refund_amount.to_d + calculator.order.shipment_total + shipping_tax
+          )
+        }
+      end
+
+      def present_refund_with_zero_amount(refunder)
+        {
+          refund_id: '1',
+          line_items: refunder.line_items.map do |line_item|
+            {
+              refund_line_item_id: '1',
+              order_line_item_id: line_item[:order_line_item_id].to_s,
+              units: line_item[:units].to_i,
+              restock: line_item[:restock].match?(/true/)
+            }
+          end,
+          transactions: [],
+          created_at: Time.zone.now.iso8601(3)
+        }
+      end
+
+      private
+
+      def transaction_status(payment)
+        return 'SUCCESS' if payment.completed?
+        return 'FAILURE' if payment.failed? || payment.invalid?
+        'PENDING'
+      end
+
+      def transaction_payment_details(payment, gift_card)
+        details = {}
+
+        details[:avs_result_code] = payment.avs_response if payment.avs_response.present?
+        details[:cvv_result_code] = payment.cvv_response_code if payment.cvv_response_code.present?
+
+        source = payment.source
+
+        if source.respond_to?(:number) || source.respond_to?(:last_digits)
+          details[:credit_card_number] = source.number || source.last_digits if source.number.present? || source.last_digits.present?
+          details[:credit_card_company] = source.brand if source.brand.present?
+        end
+
+        details[:gift_card_id] = gift_card.id if gift_card.id.present?
+        details[:gift_card_code] = gift_card.code if gift_card.code.present?
+
+        details
+      end
+
+      def transactions_for_estimate(order, gift_card, payment_amount)
+        ::RefundPayments.new(order, gift_card).perform!(payment_amount)
+      end
+    end
+  end
+end

data/lib/returnly/refunder.rb

@@ -0,0 +1,110 @@
+module Returnly
+  class Refunder
+    include Returnly::RefundsConfiguration
+
+    attr_accessor :order,
+                  :line_items,
+                  :product_refund_amount,
+                  :shipping_refund_amount,
+                  :customer_return,
+                  :return_item_amount_calculator,
+                  :return_item_restock_policy,
+                  :refund_calculator
+
+    def initialize(order:, line_items:, product_refund_amount:, shipping_refund_amount:)
+      self.order = order
+      self.line_items = line_items
+      self.product_refund_amount = product_refund_amount
+      self.shipping_refund_amount = shipping_refund_amount
+
+      configure
+    end
+
+    def process_return_items
+      each_return_item do |return_item|
+        return_item.amount               = return_item_amount_calculator.return_item_refund_amount return_item
+        return_item.additional_tax_total = 0
+        return_item.resellable           = return_item_restock_policy.should_return_item? return_item
+      end
+    end
+
+    def proceed!
+      return proceed_without_line_items if line_items.empty?
+      return proceed_with_product_zero_amount if product_refund_amount.to_d.zero?
+      process_return_items
+
+      if customer_return.save!
+        perform_reimbursement
+        RefundPresenter.present_refund(self)
+      end
+    end
+
+    def refund_available_amount
+      @available_amount ||= Money.from_amount(product_available_amount)
+    end
+
+    def reimbursement
+      @_reimbursement ||= Spree::Reimbursement.build_from_customer_return(customer_return)
+    end
+
+    def product_available_amount
+      total = order.total - (order.shipment_total + refund_calculator.shipping_tax + refunds)
+      [total, product_refund_amount.to_d].min
+    end
+
+    private
+
+    def add_shipping_amount!
+      ::ReimbursementShipping.new(reimbursement).update!(shipping_refund_amount.to_d)
+    end
+
+    def refunds
+      order.refunds.sum(&:amount).to_d.round(2, :down)
+    end
+
+    def configure
+      self.return_item_amount_calculator = return_item_amount_calculator_class.new(self)
+      self.return_item_restock_policy = return_item_restock_policy_class.new(self)
+      self.refund_calculator = refund_calculator_class.new(order, line_items)
+    end
+
+    def proceed_without_line_items
+      self.customer_return = Returnly::Builders::CustomerReturn.build_by_stock_location(stock_location)
+      reimburse_without_items!
+      RefundPresenter.present_refund(self)
+    end
+
+    def proceed_with_product_zero_amount
+      Returnly::Services::MarkItemsAsReturned.new(order, line_items).perform!
+      RefundPresenter.present_refund_with_zero_amount(self)
+    end
+
+    def perform_reimbursement
+      Returnly::Services::CreateReimbursement.new(reimbursement).perform!
+      add_shipping_amount!
+    end
+
+    def reimburse_without_items!
+      reimbursement_total = product_refund_amount.to_d + shipping_refund_amount.to_d
+      @_reimbursement = Spree::Reimbursement.new(
+        order: order,
+        total: reimbursement_total.round(2, :down)
+      )
+      reimbursement.save!
+      ::ReimbursementType::OriginalPaymentNoItems.reimburse(reimbursement, nil, false)
+    end
+
+    def each_return_item
+      return_items = refund_calculator.line_items_return_items.values.flatten
+      self.customer_return = Returnly::Builders::CustomerReturn.build_by_return_items(return_items)
+
+      return_items.each do |return_item|
+        yield return_item
+      end
+    end
+
+    def stock_location
+      order.shipments.last.stock_location
+    end
+  end
+end

data/lib/returnly/refunds_configuration.rb

@@ -0,0 +1,36 @@
+module Returnly
+  module RefundsConfiguration
+    def return_item_amount_calculator_class
+      Returnly.return_item_amount_calculator || Returnly::Refund::AmountCalculator
+    end
+
+    def return_item_builder_class
+      Returnly.return_item_builder || Returnly::Builders::ReturnItem
+    end
+
+    # return item qualifies to be restocked (after refund)
+    def return_item_restock_policy_class
+      Returnly.return_item_restock_policy || Returnly::Refund::ReturnItemRestockPolicy
+    end
+
+    def refunder_class
+      Returnly.refunder || Returnly::Refunder
+    end
+
+    def refund_calculator_class
+      Returnly.refund_calculator || Returnly::RefundCalculator
+    end
+
+    def refund_presenter_class
+      Returnly.refund_presenter || Returnly::RefundPresenter
+    end
+
+    def gift_card_class
+      Returnly.gift_card || Returnly::NilGiftCard
+    end
+
+    def gift_card_estimate_class
+      Returnly.git_card_estimate || Returnly::NilGiftCardEstimate
+    end
+  end
+end

data/lib/returnly/services/create_reimbursement.rb

@@ -0,0 +1,74 @@
+module Returnly
+  module Services
+    class CreateReimbursement
+      attr_accessor :reimbursement
+
+      delegate :return_items, to: :reimbursement
+
+      def initialize(reimbursement)
+        @reimbursement = reimbursement
+      end
+
+      def perform!
+        reimbursement.save!
+        reimbursement.update!(total: calculated_total)
+        performer.perform(reimbursement)
+
+        if unpaid_amount_within_tolerance?
+          reimbursement.reimbursed!
+          Spree::Reimbursement.reimbursement_success_hooks.each { |h| h.call reimbursement }
+          send_reimbursement_email
+        else
+          reimbursement.errored!
+          Spree::Reimbursement.reimbursement_failure_hooks.each { |h| h.call reimbursement }
+          raise incomplete_error_class, Spree.t('validation.unpaid_amount_not_zero', amount: unpaid_amount)
+        end
+      end
+
+      private
+
+      def incomplete_error_class
+        Spree::Reimbursement::IncompleteReimbursementError
+      end
+
+      def reimbursement_models
+        Spree::Reimbursement.reimbursement_models
+      end
+
+      def paid_amount
+        reimbursement_models.sum do |model|
+          model.total_amount_reimbursed_for(reimbursement)
+        end
+      end
+
+      def unpaid_amount
+        reimbursement.total - paid_amount
+      end
+
+      def calculated_total
+        return_items.to_a.sum(&:total).to_d.round(2, :down)
+      end
+
+      def performer
+        Spree::Reimbursement.reimbursement_performer
+      end
+
+      def send_reimbursement_email
+        Spree::ReimbursementMailer.reimbursement_email(reimbursement.id).deliver_later
+      end
+
+      def unpaid_amount_within_tolerance?
+        reimbursement_count = reimbursement_models.count do |model|
+          model.total_amount_reimbursed_for(reimbursement) > 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
+end

data/lib/returnly/services/mark_items_as_returned.rb

@@ -0,0 +1,25 @@
+module Returnly
+  module Services
+    class MarkItemsAsReturned
+      attr_accessor :order, :line_items
+
+      def initialize(order, line_items)
+        @order      = order
+        @line_items = line_items
+      end
+
+      def perform!
+        line_items.each do |line_item|
+          quantity = line_item[:units].to_i
+          inventory_units_by(line_item[:order_line_item_id]).take(quantity).each(&:return)
+        end
+      end
+
+      private
+
+      def inventory_units_by(line_item_id)
+        order.inventory_units.where(line_item_id: line_item_id)
+      end
+    end
+  end
+end

data/lib/returnly/version.rb

@@ -0,0 +1,7 @@
+module Returnly
+  VERSION = '0.13.0'
+
+  def platform_version
+    defined?(Solidus)
+  end
+end