solidus_avatax 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c998021175378307065168f9f8986de374c1f25
+  data.tar.gz: b9bc111b7b45a443c12180eb64e4c44c1762ba2f
+SHA512:
+  metadata.gz: 382aedc870d8f820285a38130dc916ec0cfbbfaf6ee3146de453f96b7909b512eb64d8be82fa78567675d696a5d0d71d553ac2b205705d0c791c3620edc0aafa
+  data.tar.gz: 3000285496df31516db1b39f4ef5a12571a134543db6cec4f9e09c33b3f5cc9763ac7a465961895c2b96ae64ce4b6a1edf6de704fa7b8d66b9b1e8c71a884d69

data/.gitignore

@@ -0,0 +1,15 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy
+spec/avalara_config.yml

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.1.6

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+gem "solidus", git: "git@github.com:solidusio/solidus.git", branch: "master"
+gem "solidus_auth_devise", "~> 1.0"
+
+group :development, :test do
+  gem "pry-rails"
+  gem 'pry-byebug'
+  gem 'vcr'
+  gem 'webmock'
+  gem 'timecop'
+end
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2015 Solidus
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Solidus nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,71 @@
+Solidus Avatax
+===========
+
+Avatax integration with Solidus.
+
+Installation
+------------
+
+In your Gemfile:
+
+```ruby
+gem "solidus_avatax"
+```
+
+Then run from the command line:
+
+```shell
+bundle install
+rails g solidus_avatax:install
+```
+
+Configuration
+-------------
+
+If you want to notify Avatax about short ships you should configure the
+following:
+
+```ruby
+Spree::OrderCancellations.short_ship_tax_notifier = ->(unit_cancels) do
+  SpreeAvatax::ShortShipReturnInvoice.generate(unit_cancels: unit_cancels)
+end
+```
+
+Known Issues
+------------
+
+1. "Additional tax" (e.g. US taxes) *is* supported but "included tax" (e.g.
+   VAT) is *not*.  This feature is not on the roadmap but we'd be willing to
+   look at pull requests for it.
+2. Note for future development: There is currently a bug in Solidus where the
+   "open all adjustments" admin button doesn't work for line item adjustments.
+   See
+   [here](https://github.com/spree/spree/blob/v2.2.2/backend/app/controllers/spree/admin/orders_controller.rb#L103).
+   If that bug were ever fixed, we'd want to monkey patch the controller action
+   to prevent tax adjustments from ever being re-opened. We always want tax
+   adjustments to be "closed", which tells Solidus not to try to recalculate
+   them automatically.
+
+Testing
+-------
+
+First bundle your dependencies, then run `rake`. `rake` will default to
+building the dummy app if it does not exist, then it will run specs. The dummy
+app can be regenerated by using `rake test_app`.
+
+```shell
+bundle
+bundle exec rake
+```
+
+Live tests are provided to insure that the Avalara gem works as promised. The
+credentials must be provided under `spec/avalara_config.yml` to run them
+successfully. See the example YAML for guidance.
+
+```
+username: 'USERNAME'
+password: 'PASSWORD'
+company_code: 'COMPANY'
+```
+
+These tests will communicate against the test Avatax API.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir["spec/dummy"].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir("../../")
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'solidus_avatax'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/javascripts/spree/frontend/solidus_avatax.js

@@ -0,0 +1 @@
+// Only needed for Specs right now. Due to this stupid thing the test app generator does.

data/app/assets/stylesheets/spree/frontend/solidus_avatax.css

@@ -0,0 +1 @@
+/* Only needed for Specs right now. Due to this stupid thing the test app generator does. */

data/app/models/spree/adjustment_decorator.rb

@@ -0,0 +1,21 @@
+Spree::Adjustment.class_eval do
+  # We always want tax adjustments to be "closed" because that tells Spree not to try to recalculate them automatically.
+  validates(
+    :finalized,
+    {
+      inclusion: {
+        in: [true],
+        message: "Tax adjustments must always be finalized for Avatax",
+      },
+      if: 'source_type == "Spree::TaxRate"',
+    }
+  )
+
+  if !defined?(Spree::Adjustment.non_tax) # Spree 2.4+ has this scope already
+    scope :non_tax, -> do
+      source_type = arel_table[:source_type]
+      where(source_type.not_eq('Spree::TaxRate').or source_type.eq(nil))
+    end
+  end
+
+end

data/app/models/spree/order_contents_decorator.rb

@@ -0,0 +1,26 @@
+Spree::OrderContents.class_eval do
+  def add_with_avatax(*args)
+    add_without_avatax(*args).tap do
+      SpreeAvatax::SalesShared.reset_tax_attributes(order)
+    end
+  end
+
+  def remove_with_avatax(*args)
+    remove_without_avatax(*args).tap do
+      SpreeAvatax::SalesShared.reset_tax_attributes(order)
+    end
+  end
+
+  def update_cart_with_avatax(params)
+    if update_cart_without_avatax(params)
+      SpreeAvatax::SalesShared.reset_tax_attributes(order)
+      true
+    else
+      false
+    end
+  end
+
+  alias_method_chain :update_cart, :avatax
+  alias_method_chain :add, :avatax
+  alias_method_chain :remove, :avatax
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,43 @@
+Spree::Order.class_eval do
+
+  has_one  :avatax_sales_invoice, class_name: 'SpreeAvatax::SalesInvoice', inverse_of: :order
+
+  after_save :avatax_order_after_save
+
+  state_machine.after_transition from: :address do |order, transition|
+    SpreeAvatax::SalesShared.reset_tax_attributes(order)
+  end
+
+  state_machine.before_transition to: :payment do |order, transition|
+    SpreeAvatax::SalesInvoice.generate(order)
+  end
+
+  state_machine.after_transition to: :complete do |order, transition|
+    SpreeAvatax::SalesInvoice.commit(order)
+  end
+
+  state_machine.after_transition to: :canceled do |order, transition|
+    SpreeAvatax::SalesInvoice.cancel(order)
+  end
+
+  # The total of discounts and charges added at the order level.
+  # This intentionally excludes line item & shipment level discounts as those are sent to avatax
+  # by being wrapped into net amount of the line item/shipment itself.
+  def avatax_order_adjustment_total
+    # We invert the sign because avatax calls this the "discount" even though it can handle charges
+    # as well as discounts
+    -adjustments.non_tax.eligible.sum(:amount)
+  end
+
+  def avatax_order_after_save
+    # NOTE: DO NOT do anything that will trigger any saves inside of here.  It will cause infinite
+    #       recursion since it will cause another "after_save" to be called with the dirty attributes
+    #       in the same state. Instead just move the order out of the "confirm" state so that it
+    #       will have to go through tax calculations again.
+    if ship_address_id_changed? && confirm?
+      Rails.logger.info "[avatax] order address change detected for order #{number} while in confirm state. resetting order state to 'payment'."
+      update_columns(state: 'payment', updated_at: Time.now)
+    end
+  end
+
+end

data/app/models/spree/promotion_handler/coupon_decorator.rb

@@ -0,0 +1,11 @@
+Spree::PromotionHandler::Coupon.class_eval do
+  def apply_with_avatax
+    apply_without_avatax.tap do
+      if successful?
+        SpreeAvatax::SalesShared.reset_tax_attributes(order)
+      end
+    end
+  end
+
+  alias_method_chain :apply, :avatax
+end

data/app/models/spree/reimbursement_decorator.rb

@@ -0,0 +1 @@
+Spree::Reimbursement.has_one :return_invoice, class_name: "SpreeAvatax::ReturnInvoice"

data/app/models/spree/tax_rate_decorator.rb

@@ -0,0 +1,45 @@
+class SpreeAvatax::TaxRateInvalidOperation < StandardError; end
+
+Spree::TaxRate.class_eval do
+  validate :avatax_there_can_be_only_one, on: :create
+
+  class << self
+    def match(order)
+      [avatax_the_one_rate]
+    end
+
+    def adjust(order, items)
+      # do nothing.  we'll take care of this ourselves at different points via the various hooks we have in place
+    end
+
+    def store_pre_tax_amount
+      # do nothing.  this is only for "included" and we don't support included tax.
+      # also, we perform calculations at a different time.
+      # this should never be called anyway because only TaxRate.adjust calls it, but we override it just to be safe.
+    end
+
+    # require exactly one tax rate.  if that's not true then alert ourselves and carry on as best we can
+    def avatax_the_one_rate
+      rates = all.to_a
+      rates.sort_by(&:id).first
+    end
+  end
+
+  def adjust(order, item)
+    # We've overridden the class-level TaxRate.adjust so nothing should be calling this code
+    raise SpreeAvatax::TaxRateInvalidOperation.new("Spree::TaxRate#adjust should never be called when Avatax is present")
+  end
+
+  def compute_amount(item)
+    # Avatax tax adjustments should always be finalized so Spree should never attempt to call this code
+    raise SpreeAvatax::TaxRateInvalidOperation.new("Spree::TaxRate#compute_amount should never be called when Avatax is present")
+  end
+
+  private
+
+  def avatax_there_can_be_only_one
+    if Spree::TaxRate.count > 0
+      errors.add(:base, "only one tax rate is allowed and this would make #{Spree::TaxRate.count+1}")
+    end
+  end
+end

data/app/models/spree_avatax/calculator.rb

@@ -0,0 +1,26 @@
+require_dependency 'spree/calculator'
+
+#
+# This is a no-op calculator that just returns the existing value.
+# We hook our tax calculations in SpreeAvatax::TaxComputer at the order level instead of here at the line item level
+#
+
+class SpreeAvatax::Calculator < Spree::Calculator
+  class DoNotUseCompute < StandardError; end
+  class TooManyPossibleAdjustments < StandardError; end
+
+  def self.description
+    Spree.t(:avatax_description)
+  end
+
+  def compute(computable)
+    raise DoNotUseCompute.new("The avatax calculator should never use #compute")
+  end
+
+  def compute_shipping_rate(shipping_rate)
+    # always return zero here.  we'll take care of calculating this ourselves at different points
+    # via hooks into the order
+    0
+  end
+
+end

data/app/models/spree_avatax/return_invoice.rb

@@ -0,0 +1,197 @@
+class SpreeAvatax::ReturnInvoice < ActiveRecord::Base
+  DOC_TYPE = 'ReturnInvoice'
+
+  DESTINATION_CODE = "1"
+
+  TAX_OVERRIDE_TYPE = 'TaxDate'
+  TAX_OVERRIDE_REASON = 'Adjustment for return'
+
+  class AvataxApiError < StandardError; end
+  class AlreadyCommittedError < StandardError; end
+  class ReturnItemResponseMissing < StandardError; end
+
+  class_attribute :avatax_logger
+  self.avatax_logger = Logger.new(Rails.root.join('log/avatax.log'))
+
+  belongs_to :reimbursement, class_name: "Spree::Reimbursement"
+
+  validates :reimbursement, presence: true
+  validates :committed, inclusion: {in: [true, false], message: "must be true or false"}
+  # these are values we need for the post_tax call
+  validates(
+    :doc_id, :doc_code, :doc_date, :pre_tax_total, :additional_tax_total,
+    presence: true
+  )
+
+  class << self
+    # Calls the Avatax API to generate a return invoice and calculate taxes on the return items.
+    # On failure it will raise.
+    # On success it will update the tax amounts on each return item and create a ReturnInvoice record.
+    #   At this point an uncommitted return invoice has been created on Avatax's side.
+    # After the reimbursement completes the ".finalize" method will get called and we'll commit the
+    #   return invoice.
+    def generate(reimbursement)
+      success_result = get_tax(reimbursement)
+
+      if reimbursement.return_invoice
+        if reimbursement.return_invoice.committed?
+          raise AlreadyCommittedError.new("Return invoice #{reimbursement.return_invoice.id} is already committed.")
+        else
+          reimbursement.return_invoice.destroy
+        end
+      end
+
+      # Array.wrap required because the XML engine the Avatax gem uses turns child nodes into
+      #   {...} instead of [{...}] when there is only one child.
+      tax_lines = Array.wrap(success_result[:tax_lines][:tax_line])
+
+      reimbursement.return_items.each do |return_item|
+        tax_line = tax_lines.detect { |l| l[:no] == return_item.id.to_s }
+
+        if tax_line.nil?
+          Rails.logger.error("missing return item #{return_item.id} in avatax response: #{success_result.inspect}")
+          raise ReturnItemResponseMissing.new("couldn't find return item #{return_item.id} in avatax response")
+        end
+
+        tax = BigDecimal.new(tax_line[:tax]).abs
+
+        return_item.update_attributes!({
+          additional_tax_total: tax
+        })
+      end
+
+      reimbursement.create_return_invoice!({
+        committed:             false,
+        doc_id:                success_result[:doc_id],
+        doc_code:              success_result[:doc_code],
+        doc_date:              success_result[:doc_date],
+        pre_tax_total:         success_result[:total_amount],
+        additional_tax_total:  success_result[:total_tax],
+      })
+    end
+
+    # Commit the return invoice on Avatax's side after the reimbursement completes.
+    # On failure it will raise.
+    # On success it markes the invoice as committed.
+    def finalize(reimbursement)
+      post_tax(reimbursement.return_invoice)
+
+      reimbursement.return_invoice.update!(committed: true)
+    end
+
+    private
+
+    def get_tax(reimbursement)
+      params = get_tax_params(reimbursement)
+
+      avatax_logger.info "AVATAX_REQUEST context=get_tax reimbursement_id=#{reimbursement.id}"
+      avatax_logger.debug params.to_json
+
+      result = tax_svc.gettax(params)
+      require_success!(result, reimbursement, 'get_tax')
+
+      result
+    end
+
+    def post_tax(return_invoice)
+      params = post_tax_params(return_invoice)
+
+      avatax_logger.info "AVATAX_REQUEST context=post_tax reimbursement_id=#{return_invoice.reimbursement.id} return_invoice_id=#{return_invoice.id}"
+      avatax_logger.debug params.to_json
+
+      result = tax_svc.posttax(params)
+      require_success!(result, return_invoice.reimbursement, 'post_tax')
+
+      result
+    end
+
+    def require_success!(result, reimbursement, context)
+      if result[:result_code] == 'Success'
+        avatax_logger.info "AVATAX_RESPONSE context=#{context} result=success reimbursement_id=#{reimbursement.id} doc_id=#{result[:doc_id]}"
+        avatax_logger.debug result.to_json
+      else
+        avatax_logger.error "AVATAX_RESPONSE context=#{context} result=error reimbursement_id=#{reimbursement.id} doc_id=#{result[:doc_id]}"
+        avatax_logger.error result.to_json
+
+        raise AvataxApiError.new("#{context} error: #{result[:messages]}")
+      end
+    end
+
+    # see https://github.com/avadev/AvaTax-Calc-SOAP-Ruby/blob/master/GetTaxTest.rb
+    def get_tax_params(reimbursement)
+      {
+        doccode:       reimbursement.number,
+        referencecode: reimbursement.order.number,
+        customercode:  reimbursement.order.user_id,
+        companycode:   SpreeAvatax::Config.company_code,
+
+        doctype: DOC_TYPE,
+        docdate: Date.today,
+
+        commit: false, # we commit after the reimbursement succeeds
+
+        # These fields let Avatax know to use a different date for calculating tax
+        taxoverridetype: TAX_OVERRIDE_TYPE,
+        reason:          TAX_OVERRIDE_REASON,
+        taxdate:         reimbursement.order.avatax_invoice_at.try(:to_date) || reimbursement.order.completed_at.to_date,
+
+        addresses: [
+          {
+            addresscode: DESTINATION_CODE,
+            line1:       REXML::Text.normalize(reimbursement.order.ship_address.address1),
+            line2:       REXML::Text.normalize(reimbursement.order.ship_address.address2),
+            city:        REXML::Text.normalize(reimbursement.order.ship_address.city),
+            postalcode:  REXML::Text.normalize(reimbursement.order.ship_address.zipcode),
+          },
+        ],
+
+        lines: get_tax_line_params(reimbursement),
+      }
+    end
+
+    def get_tax_line_params(reimbursement)
+      return_items = reimbursement.return_items.includes(inventory_unit: {line_item: {variant: :product}})
+
+      return_items.map do |return_item|
+        {
+          # Required Parameters
+          no:                  return_item.id,
+          itemcode:            return_item.inventory_unit.line_item.variant.sku,
+          taxcode:             return_item.inventory_unit.line_item.tax_category.tax_code,
+          qty:                 1,
+          amount:              -return_item.pre_tax_amount,
+          origincodeline:      DESTINATION_CODE, # We don't really send the correct value here
+          destinationcodeline: DESTINATION_CODE,
+
+          # Best Practice Parameters
+          description: REXML::Text.normalize(return_item.inventory_unit.line_item.variant.product.description.to_s[0...100]),
+        }
+      end
+    end
+
+    # see https://github.com/avadev/AvaTax-Calc-SOAP-Ruby/blob/master/PostTaxTest.rb
+    def post_tax_params(return_invoice)
+      {
+        doccode:     return_invoice.doc_code,
+        companycode: SpreeAvatax::Config.company_code,
+
+        doctype: DOC_TYPE,
+        docdate: return_invoice.doc_date,
+
+        commit: true,
+
+        totalamount: return_invoice.pre_tax_total,
+        totaltax:    return_invoice.additional_tax_total,
+      }
+    end
+
+    def tax_svc
+      @tax_svc ||= AvaTax::TaxService.new({
+        username:               SpreeAvatax::Config.username,
+        password:               SpreeAvatax::Config.password,
+        service_url:            SpreeAvatax::Config.service_url,
+        clientname:             'Spree::Avatax',
+      })
+    end
+  end
+end