solidus_tax_cloud 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'solidus_dev_support/rake_tasks'
+SolidusDevSupport::RakeTasks.install
+
+task default: 'extension:specs'

data/app/assets/javascripts/spree/backend/solidus_tax_cloud.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'

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

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'

data/app/assets/stylesheets/spree/backend/solidus_tax_cloud.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

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

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

data/app/decorators/models/solidus_tax_cloud/spree/app_configuration_decorator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SolidusTaxCloud
+  module Spree
+    module AppConfigurationDecorator
+      def self.prepended(base)
+        base.class_eval do
+          preference :taxcloud_default_product_tic, :string, default: '00000'
+          preference :taxcloud_shipping_tic, :string, default: '11010'
+        end
+
+        Rails.application.config.spree.calculators.tax_rates << ::Spree::Calculator::TaxCloudCalculator
+      end
+
+      ::Spree::AppConfiguration.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_tax_cloud/spree/line_item_decorator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SolidusTaxCloud
+  module Spree
+    module LineItemDecorator
+      def tax_cloud_cache_key
+        if ActiveRecord::Base.try(:cache_versioning)
+          cache_key
+        else
+          key = "Spree::LineItem #{id}: #{quantity}x<#{variant.cache_key}>@#{total_excluding_vat}#{currency}"
+
+          if order.ship_address
+            key += "shipped_to<#{order.ship_address.try(:cache_key)}>"
+          elsif order.billing_address
+            key += "billed_to<#{order.bill_address.try(:cache_key)}>"
+          end
+
+          key
+        end
+      end
+
+      def tax_cloud_cache_version
+        if ActiveRecord::Base.try(:cache_versioning)
+          key = "Spree::LineItem #{id}: #{quantity}x<#{variant.cache_version}>@#{total_excluding_vat}#{currency}"
+
+          if order.ship_address
+            key += "shipped_to<#{order.ship_address.try(:cache_version)}>"
+          elsif order.billing_address
+            key += "billed_to<#{order.bill_address.try(:cache_version)}>"
+          end
+
+          key
+        end
+      end
+
+      def price_with_discounts
+        round_to_two_places(total_excluding_vat / quantity)
+      end
+
+      def round_to_two_places(amount)
+        BigDecimal(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+      end
+
+      ::Spree::LineItem.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_tax_cloud/spree/order_decorator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusTaxCloud
+  module Spree
+    module OrderDecorator
+      def self.prepended(base)
+        base.class_eval do
+          state_machine.after_transition to: :complete, do: :capture_tax_cloud
+        end
+      end
+
+      def capture_tax_cloud
+        return unless is_taxed_using_tax_cloud?
+
+        response = ::Spree::TaxCloud.transaction_from_order(self).authorized_with_capture
+        if response != 'OK'
+          Rails.logger.error "ERROR: TaxCloud returned an order capture response of #{response}."
+        end
+        log_tax_cloud(response)
+      end
+
+      # Order.tax_zone.tax_rates is used here to check if the order is taxable by Tax Cloud.
+      # It's not possible check against the order's tax adjustments because
+      # an adjustment is not created for 0% rates. However, US orders must be
+      # submitted to Tax Cloud even when the rate is 0%.
+      # Note that we explicitly use ship_address instead of tax_address,
+      # as per compliance with Tax Cloud instructions.
+      def is_taxed_using_tax_cloud?
+        ::Spree::TaxRate.for_address(ship_address).any? { |rate| rate.calculator_type == 'Spree::Calculator::TaxCloudCalculator' }
+      end
+
+      def log_tax_cloud(response)
+        # Implement into your own application.
+        # You could create your own Log::TaxCloud model then use either HStore or
+        # JSONB to store the response.
+        # The response argument carries the response from an order transaction.
+      end
+
+      ::Spree::Order.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_tax_cloud/spree/product_decorator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidusTaxCloud
+  module Spree
+    module ProductDecorator
+      def self.prepended(base)
+        base.class_eval do
+          validates_format_of :tax_cloud_tic, with: /\A\d{5}\z/, message: I18n.t('spree.standard_taxcloud_tic')
+        end
+      end
+
+      # Use the store-default TaxCloud product TIC if none is defined for this product
+      def tax_cloud_tic
+        read_attribute(:tax_cloud_tic) || ::Spree::Config.taxcloud_default_product_tic
+      end
+
+      # Empty strings are written as nil (which avoids the format validation)
+      def tax_cloud_tic=(tic)
+        write_attribute(:tax_cloud_tic, tic.presence)
+      end
+
+      ::Spree::Product.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_tax_cloud/spree/shipment_decorator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidusTaxCloud
+  module Spree
+    module ShipmentDecorator
+      def tax_cloud_cache_key
+        if ActiveRecord::Base.try(:cache_versioning)
+          cache_key
+        else
+          "#{cache_key}--from:#{stock_location.cache_key}--to:#{order.shipping_address.cache_key}"
+        end
+      end
+
+      def tax_cloud_cache_version
+        if ActiveRecord::Base.try(:cache_versioning)
+          "#{cache_version}--from:#{stock_location.cache_version}--to:#{order.shipping_address.cache_version}"
+        end
+      end
+
+      def price_with_discounts
+        total_excluding_vat
+      end
+
+      ::Spree::Shipment.prepend self
+    end
+  end
+end

data/app/models/spree/calculator/tax_cloud_calculator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator::TaxCloudCalculator < Calculator::DefaultTax
+    def self.description
+      I18n.t('spree.tax_cloud')
+    end
+
+    # Default tax calculator still needs to support orders for legacy reasons
+    # Orders created before Spree 2.1 had tax adjustments applied to the order, as a whole.
+    # Orders created with Spree 2.2 and after, have them applied to the line items individually.
+    def compute_order(_order)
+      raise 'Spree::TaxCloud is designed to calculate taxes at the shipment and line-item levels.'
+    end
+
+    # When it comes to computing shipments or line items: same same.
+    def compute_shipment_or_line_item(item)
+      if rate.included_in_price
+        raise 'TaxCloud cannot calculate inclusive sales taxes.'
+      else
+        round_to_two_places(tax_for_item(item))
+        # TODO: take discounted_amount into account. This is a problem because TaxCloud API does not take discounts nor does it return percentage rates.
+      end
+    end
+
+    alias compute_shipment compute_shipment_or_line_item
+    alias compute_line_item compute_shipment_or_line_item
+
+    def compute_shipping_rate(_shipping_rate)
+      if rate.included_in_price
+        raise 'TaxCloud cannot calculate inclusive sales taxes.'
+      else
+        # Sales tax will be applied to the Shipment itself, rather than to the Shipping Rates.
+        # Note that this method is called from ShippingRate.display_price, so if we returned
+        # the shipping sales tax here, it would display as part of the display_price of the
+        # ShippingRate, which is not consistent with how US sales tax typically works -- i.e.,
+        # it is an additional amount applied to a sale at the end, rather than being part of
+        # the displayed cost of a good or service.
+        0
+      end
+    end
+
+    private
+
+    def tax_for_item(item)
+      order = item.order
+      item_address = order.ship_address || order.billing_address
+
+      # Only calculate tax when we have an address and it's in our jurisdiction
+      return 0 unless item_address.present? && calculable.zone.include?(item_address)
+
+      # Cache will expire if the order, any of its line items, or any of its shipments change.
+      # When the cache expires, we will need to make another API call to TaxCloud.
+      Rails.cache.fetch(
+        ['TaxCloudRatesForItem', item.tax_cloud_cache_key],
+        version: item.tax_cloud_cache_version,
+        time_to_idle: 30.minutes,
+      ) do
+        # In the case of a cache miss, we recompute the amounts for _all_ the LineItems and Shipments for this Order.
+        # TODO An ideal implementation will break the order down by Shipments / Packages
+        # and use the actual StockLocation address for each separately, and create Adjustments
+        # for the Shipments to reflect tax on shipping.
+        transaction = Spree::TaxCloud.transaction_from_order(order)
+        lookup_cart_items = transaction.lookup.cart_items
+
+        # Now we will loop back through the items and assign them amounts from the lookup.
+        # This inefficient method is due to the fact that item_id isn't preserved in the lookup.
+        # TODO There may be a way to refactor this,
+        # possibly by overriding the TaxCloud::Responses::Lookup model
+        # or the CartItems model.
+        index = -1 # array is zero-indexed
+
+        item_tax_amount = nil
+
+        # Retrieve line_items from lookup
+        order.line_items.each do |line_item|
+          tax_amount = lookup_cart_items[index += 1].tax_amount
+
+          if line_item == item
+            item_tax_amount = tax_amount
+          else
+            Rails.cache.write(
+              ['TaxCloudRatesForItem', line_item.tax_cloud_cache_key],
+              tax_amount,
+              version: line_item.tax_cloud_cache_version,
+              time_to_idle: 30.minutes,
+            )
+          end
+        end
+
+        order.shipments.each do |shipment|
+          tax_amount = lookup_cart_items[index += 1].tax_amount
+
+          if shipment == item
+            item_tax_amount = tax_amount
+          else
+            Rails.cache.write(
+              ['TaxCloudRatesForItem', shipment.tax_cloud_cache_key],
+              tax_amount,
+              version: shipment.tax_cloud_cache_version,
+              time_to_idle: 30.minutes,
+            )
+          end
+        end
+
+        # Lastly, return the particular rate that we were initially looking for
+        item_tax_amount
+      end
+    end
+  end
+end

data/app/models/spree/tax_cloud.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Spree
+  class TaxCloud
+    def self.transaction_from_order(order)
+      stock_location = order.shipments.first.try(:stock_location) || Spree::StockLocation.active.where('city IS NOT NULL and state_id IS NOT NULL').first
+      raise I18n.t('spree.ensure_one_valid_stock_location') unless stock_location
+
+      destination = address_from_spree_address(order.ship_address || order.billing_address)
+      begin
+        destination = destination.verify # Address validation may fail, and that is okay.
+      rescue ::TaxCloud::Errors::ApiError
+      end
+
+      transaction = ::TaxCloud::Transaction.new(
+        customer_id: order.user_id || order.email,
+        order_id: order.number,
+        cart_id: order.number,
+        origin: address_from_spree_address(stock_location),
+        destination: destination
+      )
+
+      index = -1 # array is zero-indexed
+      # Prepare line_items for lookup
+      order.line_items.each { |line_item| transaction.cart_items << cart_item_from_item(line_item, index += 1) }
+      # Prepare shipments for lookup
+      order.shipments.each { |shipment| transaction.cart_items << cart_item_from_item(shipment, index += 1) }
+      transaction
+    end
+
+    # Note that this method can take either a Spree::StockLocation (which has address
+    # attributes directly on it) or a Spree::Address object
+    def self.address_from_spree_address(address)
+      ::TaxCloud::Address.new(
+        address1: address.address1,
+        address2: address.address2,
+        city: address.city,
+        state: address.try(:state).try(:abbr),
+        zip5: address.zipcode.try(:[], 0...5)
+      )
+    end
+
+    def self.cart_item_from_item(item, index)
+      case item
+      when Spree::LineItem
+        ::TaxCloud::CartItem.new(
+          index: index,
+          item_id: item.try(:variant).try(:sku).presence || "LineItem #{item.id}",
+          tic: (item.product.tax_cloud_tic || Spree::Config.taxcloud_default_product_tic),
+          price: item.price_with_discounts,
+          quantity: item.quantity
+        )
+      when Spree::Shipment
+        ::TaxCloud::CartItem.new(
+          index: index,
+          item_id: "Shipment #{item.number}",
+          tic: Spree::Config.taxcloud_shipping_tic,
+          price: item.price_with_discounts,
+          quantity: 1
+        )
+      else
+        raise I18n.t('spree.cart_item_cannot_be_made')
+      end
+    end
+  end
+end

data/app/overrides/spree/admin/products/_form.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Deface::Override.new(
+  virtual_path: 'spree/admin/products/_form',
+  name: 'add_tic_to_admin_product_edit',
+  insert_after: "[data-hook='admin_product_form_tax_category']",
+  partial: 'spree/admin/products/edit_tax_cloud_tic',
+  original: 'a6d7d1941bde020c34025a78466febd8453cf71a'
+)

data/app/overrides/spree/admin/shared/_configuration_menu.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_configuration_menu',
+  name: 'add_tax_cloud_admin_menu_link',
+  insert_bottom: "[data-hook='admin_configurations_sidebar_menu']",
+  text: "<%= configurations_sidebar_menu_item 'TaxCloud Settings', edit_admin_tax_cloud_settings_path %>",
+  original: 'dcaffe234d5b43d5b7673bc13f227500957c9e73'
+)

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solidus_tax_cloud"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/r

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/solidus_tax_cloud/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+app_root = 'spec/dummy'
+
+unless File.exist? "#{app_root}/bin/rails"
+  system "bin/rake", app_root or begin # rubocop:disable Style/AndOr
+    warn "Automatic creation of the dummy app failed"
+    exit 1
+  end
+end
+
+Dir.chdir app_root
+exec 'bin/rails', *ARGV