solidus-returnly 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2043001dcfb19498dc6e5ef56b5b39248485632a
-  data.tar.gz: ec0c2f446acf7b5eac9687c8efa8d81e71f7b020
+  metadata.gz: cdcc6a311bd8b506654e3f98002a2e5d50c5149f
+  data.tar.gz: 639068f9abf9fdb9aa33b34f7315bd898a217234
 SHA512:
-  metadata.gz: 29c6dfe656d053f93198ce4a5987b3070b7a0511d361b44f6cf0a79912f267bb086503e7c445b549a7900c894541965788b5c26d341adb5915fedfb752616964
-  data.tar.gz: b315483a1960b7640f5004e537a2ecaa21d7300a8a3cc06d4754007a1cf7f1a1a46c190d59f44a8aab59817c7c70ec03aa9af0a0292e81e735f878ac924638d4
+  metadata.gz: eee6692d5dfdf2c0c23ea2dafa60c42b4788dae0f6828962f1fc41f1b239cda93da934f448c0ecc290f12aa397015a631e254432e4bb8b98768e4a44bdae8593
+  data.tar.gz: 1cd8a79ad38584d16619574af858a3759a0c3f4516ff2c04b1e5dce8e7eaa7e476d17f86e5ae62d5fafc6c4b8d8e3a429af97b506f8e5c99103bc5724cf6dc7c

data/app/models/reimbursement_shipping.rb

@@ -0,0 +1,61 @@
+class ReimbursementShipping
+  attr_accessor :reimbursement
+  attr_reader :order
+
+  include Spree::ReimbursementType::ReimbursementHelpers
+
+  def initialize(reimbursement)
+    @order         = reimbursement.order
+    @reimbursement = reimbursement
+  end
+
+  def update!(shipping_amount)
+    reimbursement.update!(total: calculated_amount(shipping_amount))
+    create_refund_payment!(shipping_amount)
+  end
+
+  private
+
+  def calculate_shipping_amount(shipping_amount)
+    [shipping_amount, available_shipment_amount].min
+  end
+
+  def calculated_amount(shipping_amount)
+    calculate_shipping_amount(shipping_amount) + reimbursement.total
+  end
+
+  def available_shipment_amount
+    order.shipment_total + order_shipping_tax - refunded_shipping
+  end
+
+  def refunded_shipping
+    order.refunds.where(refund_reason_id: refund_reason.id).sum(&:amount)
+  end
+
+  def create_refund_payment!(shipping_amount)
+    create_refunds(reimbursement, payments, calculate_shipping_amount(shipping_amount), false)
+  end
+
+  def order_shipping_tax
+    order.all_adjustments.where(source_type: 'Spree::TaxRate', adjustable_type: 'Spree::Shipment').sum(&:amount)
+  end
+
+  def payments
+    reimbursement.order.payments.completed
+  end
+
+  def create_refund(reimbursement, payment, amount, simulate)
+    refund = reimbursement.refunds.build({
+                                           payment: payment,
+                                           amount:  amount,
+                                           reason:  refund_reason
+                                         })
+
+    simulate ? refund.readonly! : refund.save!
+    refund
+  end
+
+  def refund_reason
+    @refund_reason ||= Spree::RefundReason.find_or_create_by!(name: 'Returnly Shipping Refund')
+  end
+end

data/app/services/refund_methods.rb

@@ -0,0 +1,21 @@
+module RefundMethods
+  extend ActiveSupport::Concern
+  included do
+    class_attribute :eligible_refund_methods
+    self.eligible_refund_methods = whitelisted_refund_methods || defined_refund_methods
+  end
+
+  class_methods do
+    def whitelisted_refund_methods
+      # Solidus 2.3.0 deprecates "Spree::Gateway::Bogus" and recommends using "Spree::PaymentMethod::BogusCreditCard" instead.
+      %w[Spree::Gateway::Bogus Spree::PaymentMethod::SimpleBogusCreditCard Spree::PaymentMethod::BogusCreditCard Spree::PaymentMethod::Check Spree::PaymentMethod::StoreCredit].inject([]) do |methods, payment_method|
+        methods << payment_method.constantize if Object.const_defined?(payment_method)
+        methods
+      end
+    end
+
+    def defined_refund_methods
+      Spree::PaymentMethod.order('id DESC').pluck(:type).map(&:constantize)
+    end
+  end
+end

data/app/services/refund_payments.rb

@@ -0,0 +1,33 @@
+class RefundPayments
+  attr_accessor :order
+
+  include RefundMethods
+
+  def initialize(order)
+    @order = order
+  end
+
+  def perform!(payment_amount)
+    sorted_payments = sorted_eligible_refund_payments(order.payments.completed)
+    sorted_payments.each_with_object([]) do |payment, payments|
+      break payments if payment_amount <= 0
+      next payments unless payment.can_credit?
+
+      allowed_amount = [payment_amount, payment.credit_allowed].min
+      payment_amount -= allowed_amount
+
+      payments << {
+        code:                    payment.source_type.constantize.model_name.human,
+        amount:                  allowed_amount.to_f,
+        original_transaction_id: ''
+      }
+    end
+  end
+
+  private
+
+  def sorted_eligible_refund_payments(payments)
+    payments = payments.select { |p| eligible_refund_methods.include? p.payment_method.class }
+    payments.sort_by { |p| eligible_refund_methods.index(p.payment_method.class) }
+  end
+end

data/lib/returnly.rb

@@ -9,4 +9,5 @@ require 'returnly/refund_calculator'
 require 'returnly/version'
 require 'returnly/refund/amount_calculator'
 require 'returnly/refund/return_item_restock_policy'
+require 'returnly/services/create_reimbursement'
 require 'returnly/refund_presenter'

data/lib/returnly/refund/amount_calculator.rb

@@ -8,13 +8,56 @@ module Returnly
       end
 
       def return_item_refund_amount(return_item)
-        default_amount(return_item)
+        (item_price(return_item) * item_price_percentage / 100).round(2, :down)
       end
 
       protected
-      def default_amount(return_item)
-        refund.refund_amount_per_item -
-            Money.from_amount(return_item.total - return_item.pre_tax_amount)
+
+      def total_single_items_price
+        refund.line_items.inject(0.0.to_d) do |amount, line_item_hash|
+          line_item = Spree::LineItem.find(line_item_hash['order_line_item_id'])
+          amount += (line_item_price(line_item) * line_item_hash['units'].to_d).round(2, :down)
+          amount
+        end.round(2, :down)
+      end
+
+      def line_item_price(line_item)
+        (line_item.price + line_item_tax_price(line_item) + line_item_discount_price(line_item)).round(2, :down)
+      end
+
+      def item_price_percentage
+        [(available_amount * 100 / total_single_items_price).round(2, :down), 100.0.to_d].min
+      end
+
+      def item_price(return_item)
+        line_item_price(return_item.inventory_unit.line_item)
+      end
+
+      def line_item_tax_price(line_item)
+        (line_item.adjustments.tax.sum(&:amount).to_d.round(2, :down) / line_item.quantity).round(2, :down)
+      end
+
+      def line_item_discount_price(line_item)
+        discounter_calculator.calculate(
+          [
+            {
+              order_line_item_id: line_item.id,
+              units: 1
+            }
+          ]
+        )
+      end
+
+      def line_items_price
+        refund.order.line_items.sum(&:price).round(2, :down)
+      end
+
+      def available_amount
+        refund.product_available_amount.round(2, :down)
+      end
+
+      def discounter_calculator
+        @discounter_calculator ||= Returnly::DiscountCalculator.new(refund.order)
       end
     end
   end

data/lib/returnly/refund_calculator.rb

@@ -29,7 +29,11 @@ module Returnly
     end
 
     def shipping_tax
-      order.all_adjustments.where(source_type: 'Spree::TaxRate', adjustable_type: 'Spree::Shipment').sum(&:amount)
+      order.all_adjustments.where(source_type: 'Spree::TaxRate', adjustable_type: 'Spree::Shipment').sum(&:amount).to_d.round(2, :down)
+    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

data/lib/returnly/refund_presenter.rb

@@ -2,25 +2,25 @@ module Returnly
   class RefundPresenter
 
     def self.present_estimate(calculator)
-      total = Money.new 0
       sub_total = Money.new 0
+      tax = Money.new 0
 
       calculator.line_items_return_items.values.flatten.each do |return_item|
-        total += Money.from_amount return_item.total
         sub_total += Money.from_amount return_item.pre_tax_amount
+        tax += Money.from_amount calculator.line_item_tax(return_item.inventory_unit.line_item)
       end
 
       discount = Money.from_amount(calculator.discount)
-      total_refund_amount = total - (discount * -1) # discount is negative, so we multiply it by -1 to make it positive for subtraction
+      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_f,
-        tax_amount:                     (total - sub_total).to_f,
+        tax_amount:                     tax.to_f,
         discount_amount:                discount.to_f,
         total_refund_amount:            total_refund_amount.to_f,
         refundable_shipping_amount:     calculator.order.shipment_total.to_f,
         refundable_shipping_tax_amount: shipping_tax.to_f,
-        max_refundable_amount:          (calculator.order.total - calculator.order.refunds.sum(&:amount)).to_f,
+        max_refundable_amount:          (calculator.order.total - calculator.order.refunds.reload.sum(&:amount)).to_f,
         refunds_by_payment_method:      refunds_by_payment(calculator.order, total_refund_amount.to_d + calculator.order.shipment_total + shipping_tax)
       }
     end
@@ -68,17 +68,8 @@ module Returnly
       }
     end
 
-    private_class_method def self.refunds_by_payment(order, amount)
-                           completed_payments = order.payments.completed
-                           payment_amount = amount / completed_payments.count
-
-                           completed_payments.each_with_object([]) do |payment, payments|
-                             payments << {
-                               code:                    payment.source_type.constantize.model_name.human,
-                               amount:                  payment_amount.to_f,
-                               original_transaction_id: ''
-                             }
-                           end
+    private_class_method def self.refunds_by_payment(order, payment_amount)
+                           ::RefundPayments.new(order).perform!(payment_amount)
                          end
   end
 end

data/lib/returnly/refunder.rb

@@ -23,8 +23,9 @@ module Returnly
 
     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.resellable = return_item_restock_policy.should_return_item? 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
 
@@ -39,19 +40,28 @@ module Returnly
     end
 
     def refund_available_amount
-      @available_amount ||= Money.from_amount(product_refund_amount.to_f + shipping_refund_amount.to_f)
-    end
-
-    def refund_amount_per_item
-      refund_available_amount / line_items.size
+      @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)
@@ -64,8 +74,8 @@ module Returnly
     end
 
     def perform_reimbursement
-      reimbursement.save!
-      reimbursement.perform!
+      Returnly::Services::CreateReimbursement.new(reimbursement).perform!
+      add_shipping_amount!
     end
 
     def reimburse_without_items!

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/version.rb

@@ -1,5 +1,5 @@
 module Returnly
-  VERSION = '0.6.1'
+  VERSION = '0.6.2'
 
   def platform_version
     defined?(Solidus)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solidus-returnly
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Returnly Technologies, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-11 00:00:00.000000000 Z
+date: 2017-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: solidus
@@ -330,8 +330,11 @@ files:
 - app/controllers/spree/api/returnly/api_controller.rb
 - app/controllers/spree/api/returnly/refunds_controller.rb
 - app/controllers/spree/api/returnly/version_controller.rb
+- app/models/reimbursement_shipping.rb
 - app/models/reimbursement_type/original_payment_no_items.rb
 - app/models/spree/return_item_decorator.rb
+- app/services/refund_methods.rb
+- app/services/refund_payments.rb
 - config/locales/en.yml
 - config/routes.rb
 - lib/returnly.rb
@@ -346,6 +349,7 @@ files:
 - lib/returnly/refund_presenter.rb
 - lib/returnly/refunder.rb
 - lib/returnly/refunds_configuration.rb
+- lib/returnly/services/create_reimbursement.rb
 - lib/returnly/version.rb
 - lib/solidus-returnly.rb
 - lib/spree-returnly.rb