super_good-solidus_taxjar 0.18.1 → 1.0.0

data/lib/super_good/solidus_taxjar/calculator_helper.rb

@@ -4,19 +4,25 @@ module SuperGood
       extend ActiveSupport::Concern
 
       def incomplete_address?(address)
-        return true if address.is_a?(Spree::Tax::TaxLocation)
+        return true if address.is_a?(::Spree::Tax::TaxLocation)
 
-        [
+        fields = [
           address.address1,
           address.city,
-          address.state&.abbr || address.state_name,
           address.zipcode,
           address.country&.iso
-        ].any?(&:blank?)
+        ]
+
+        if state_required?(address.country)
+          fields << (address.state&.abbr || address.state_name)
+        end
+
+        fields.any?(&:blank?)
       end
 
       def taxable_address?(address)
-        SuperGood::SolidusTaxjar.taxable_address_check.call(address)
+        SuperGood::SolidusTaxjar.taxable_address_check.call(address) &&
+          address_in_nexus_region?(address)
       end
 
       def cache
@@ -33,6 +39,29 @@ module SuperGood
       def exception_handler
         SuperGood::SolidusTaxjar.exception_handler
       end
+
+      # Only require a "state" value if this is an address for Canada or the
+      # USA. This aligns with TaxJar's API requirement for `to_state`.
+      #
+      # @param country [Spree::Country] The country to check.
+      # @return [Boolean] True if the "state" field is required for the country
+      def state_required?(country)
+        ["CA", "US"].include?(country&.iso)
+      end
+
+      private
+
+      # Nexus regions are only a concept for US states. For non-US addresses
+      # we always want to defer to the configuration in TaxJar.
+      def address_in_nexus_region?(address)
+        return true unless address&.country&.iso == "US"
+
+        ::SuperGood::SolidusTaxjar::CachedApi
+          .new
+          .nexus_regions
+          .map(&:region_code)
+          .include?(address.state.abbr)
+      end
     end
   end
 end

data/lib/super_good/solidus_taxjar/discount_calculator.rb

@@ -6,7 +6,7 @@ module SuperGood
       end
 
       def discount
-        -line_item.promo_total
+        -1 * line_item.adjustments.select { |value| !value.tax? && value.eligible? }.sum(&:amount)
       end
 
       private

data/lib/super_good/solidus_taxjar/overrides/request_override.rb

@@ -0,0 +1,15 @@
+module SuperGood
+  module SolidusTaxjar
+    module RequestOverride
+      def build_http_client
+        if SuperGood::SolidusTaxjar.logging_enabled
+          super.use(logging: {logger: SuperGood::SolidusTaxjar.logger})
+        else
+          super
+        end
+      end
+
+      Taxjar::API::Request.prepend(self)
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/reportable.rb

@@ -0,0 +1,91 @@
+module SuperGood
+  module SolidusTaxjar
+    module Reportable
+      ORDER_TOO_OLD_MESSAGE = "Order cannot be synced because it was completed before TaxJar reporting was enabled"
+
+      def self.included(base)
+        # Omnes subscribers are classes, whereas the legacy event system uses
+        # modules for subscribers. The type check ensures this is forwards
+        # compatible and can be removed when we drop support for the legacy
+        # event system.
+        base.extend(base) unless base.is_a?(Class)
+      end
+
+      def with_reportable(order, &block)
+        raise "Please provide a block!" unless block_given?
+
+        return unless order_reportable?(order)
+        return if completed_before_reporting_enabled?(order)
+        return unless order.taxjar_order_transactions.none?
+
+        yield
+      end
+
+      def with_replaceable(order, &block)
+        return unless order_reportable?(order)
+        return if completed_before_reporting_enabled?(order)
+        return unless transaction_replaceable?(order)
+
+        yield
+      end
+
+      # @return [Boolean] true if the TaxJar reporting is currently enabled
+      #   and the order meets all the other requirements for reporting.
+      def order_reportable?(order)
+        return SuperGood::SolidusTaxjar.configuration.preferred_reporting_enabled &&
+          order.completed? &&
+          order.shipped? &&
+          order.payment_state == "paid"
+      end
+
+      # @return [Boolean] true if the transaction has been previously reported
+      #   to TaxJar, the order is currently in `paid` state and there is a
+      #   difference between the total (before tax) on the order in Solidus
+      #   and the transaction amount on TaxJar.
+      def transaction_replaceable?(order)
+        order.taxjar_order_transactions.present? &&
+          amount_changed?(order)
+      end
+
+      private
+
+      def completed_before_reporting_enabled?(order)
+        configuration = SuperGood::SolidusTaxjar.configuration
+
+        completed_before_reporting_enabled = configuration.preferred_reporting_enabled &&
+          configuration.preferred_reporting_enabled_at > order.completed_at
+
+        if completed_before_reporting_enabled
+          log_order_too_old_to_sync(order)
+        end
+
+        completed_before_reporting_enabled
+      end
+
+      # Logs and notifies the custom exception handler for orders which are
+      # too old to be reported. If a log for this already exists a new one
+      # won't be created and the exception handler won't be called.
+      def log_order_too_old_to_sync(order)
+        sync_log = order.taxjar_transaction_sync_logs.find_or_initialize_by(
+          status: :error,
+          error_message: ORDER_TOO_OLD_MESSAGE
+        )
+
+        unless sync_log.persisted?
+          sync_log.save!
+
+          SuperGood::SolidusTaxjar.exception_handler.call(
+            RuntimeError.new(ORDER_TOO_OLD_MESSAGE)
+          )
+        end
+      end
+
+      def amount_changed?(order)
+        # We use `order.payment_total` to ensure we capture any total changes
+        # from refunds.
+        SuperGood::SolidusTaxjar.api.show_latest_transaction_for(order).amount !=
+          (order.payment_total - order.additional_tax_total)
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/reporting.rb

@@ -0,0 +1,44 @@
+module SuperGood
+  module SolidusTaxjar
+    class Reporting
+      def initialize(api: SuperGood::SolidusTaxjar.api)
+        @api = api
+      end
+
+      def refund_and_create_new_transaction(order)
+        latest_order_transaction = OrderTransaction.latest_for(order)
+
+        unless latest_order_transaction.refund_transaction
+          transaction_response = @api.create_refund_transaction_for(order)
+          latest_order_transaction.create_refund_transaction!(
+            transaction_id: transaction_response.transaction_id,
+            transaction_date: transaction_response.transaction_date
+          )
+        end
+
+        return if order.total.zero?
+
+        if transaction_response = @api.create_transaction_for(order)
+          order.taxjar_order_transactions.create!(
+            transaction_id: transaction_response.transaction_id,
+            transaction_date: transaction_response.transaction_date
+          )
+        end
+      end
+
+      def show_or_create_transaction(order)
+        if transaction_response = @api.show_latest_transaction_for(order)
+          SuperGood::SolidusTaxjar::OrderTransaction.find_by!(
+            transaction_id: transaction_response.transaction_id
+          )
+        else
+          transaction_response = @api.create_transaction_for(order)
+          order.taxjar_order_transactions.create!(
+            transaction_id: transaction_response.transaction_id,
+            transaction_date: transaction_response.transaction_date
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/spree/legacy_reporting_subscriber.rb

@@ -0,0 +1,41 @@
+module SuperGood
+  module SolidusTaxjar
+    module Spree
+      module LegacyReportingSubscriber
+        include ::Spree::Event::Subscriber
+        include SolidusSupport::LegacyEventCompat::Subscriber
+        include SuperGood::SolidusTaxjar::Reportable
+
+        # FIXME:
+        # This is a workaround until we add a new Solidus event we can subscribe
+        # to. "order_recalculated" occurs too early.
+        #
+        # This delay helps us be sure that `Spree::OrderUpdater#persist_totals`
+        #  has been called, and the `order` transaction has been completed,
+        #  before we report this transaction to TaxJar.
+        #
+        DELAY = 2
+
+        event_action :report_or_replace_transaction, event_name: :order_recalculated
+
+        def report_or_replace_transaction(event)
+          order = event.payload[:order]
+
+          with_reportable(order) do
+            SuperGood::SolidusTaxjar::ReportTransactionJob
+              .set(wait: DELAY.seconds)
+              .perform_later(order)
+
+            return
+          end
+
+          with_replaceable(order) do
+            SuperGood::SolidusTaxjar::ReplaceTransactionJob
+              .set(wait: DELAY.seconds)
+              .perform_later(order)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/spree/reporting_subscriber.rb

@@ -0,0 +1,40 @@
+module SuperGood
+  module SolidusTaxjar
+    module Spree
+      class ReportingSubscriber
+        include Omnes::Subscriber
+        include SuperGood::SolidusTaxjar::Reportable
+
+        # FIXME:
+        # This is a workaround until we add a new Solidus event we can subscribe
+        # to. "order_recalculated" occurs too early.
+        #
+        # This delay helps us be sure that `Spree::OrderUpdater#persist_totals`
+        #  has been called, and the `order` transaction has been completed,
+        #  before we report this transaction to TaxJar.
+        #
+        DELAY = 2
+
+        handle :order_recalculated, with: :report_or_replace_transaction
+
+        def report_or_replace_transaction(event)
+          order = event.payload[:order]
+
+          with_reportable(order) do
+            SuperGood::SolidusTaxjar::ReportTransactionJob
+              .set(wait: DELAY.seconds)
+              .perform_later(order)
+
+            return
+          end
+
+          with_replaceable(order) do
+            SuperGood::SolidusTaxjar::ReplaceTransactionJob
+              .set(wait: DELAY.seconds)
+              .perform_later(order)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/tax_calculator.rb

@@ -17,7 +17,7 @@ module SuperGood
         cache do
           next no_tax unless taxjar_breakdown
 
-          Spree::Tax::OrderTax.new(
+          ::Spree::Tax::OrderTax.new(
             order_id: order.id,
             line_item_taxes: line_item_taxes,
             shipment_taxes: shipment_taxes
@@ -41,7 +41,7 @@ module SuperGood
             # orders aren't going to have a huge number of line items.
             spree_line_item = order.line_items.find { |li| li.id == spree_line_item_id }
 
-            Spree::Tax::ItemTax.new(
+            ::Spree::Tax::ItemTax.new(
               item_id: spree_line_item_id,
               label: line_item_tax_label(taxjar_line_item, spree_line_item),
               tax_rate: tax_rate,
@@ -102,15 +102,21 @@ module SuperGood
       end
 
       def no_tax
-        Spree::Tax::OrderTax.new(
+        ::Spree::Tax::OrderTax.new(
           order_id: order.id,
           line_item_taxes: [],
           shipment_taxes: []
         )
       end
 
+      # Tax adjustments require an associated Tax Rate. This tax rate is not
+      # used in the extension's calculations as the rates from the TaxJar API
+      # are used, so a placeholder rate and calculator is created.
       def tax_rate
-        Spree::TaxRate.find_by(name: "Sales Tax")
+        ::Spree::TaxRate.find_or_create_by!(name: "Solidus TaxJar Rate") do |tax_rate|
+          tax_rate.calculator = ::Spree::Calculator.new
+          tax_rate.amount = 0
+        end
       end
 
       def cache_key

data/lib/super_good/solidus_taxjar/testing_support/factories/address_factory.rb

@@ -0,0 +1,11 @@
+FactoryBot.modify do
+  # Solidus's default address factories provide an invalid state and zipcode
+  # combination.
+  factory :address do
+    zipcode { "11430" }
+
+    transient do
+      state_code { "NY" }
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/testing_support/factories/configuration_factory.rb

@@ -0,0 +1,11 @@
+FactoryBot.define do
+  factory :taxjar_configuration, class: "SuperGood::SolidusTaxjar::Configuration" do
+    trait :reporting_enabled do
+      preferred_reporting_enabled_at_integer { DateTime.now.to_i }
+    end
+
+    trait :reporting_disabled do
+      preferred_reporting_enabled_at_integer { nil }
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/testing_support/factories/order_transaction_factory.rb

@@ -0,0 +1,22 @@
+FactoryBot.define do
+  factory :taxjar_order_transaction, class: "SuperGood::SolidusTaxjar::OrderTransaction" do
+    order
+    transaction_date { Date.current }
+
+    transient do
+      last_transaction_id {
+        SuperGood::SolidusTaxjar::OrderTransaction
+          .latest_for(order)
+          &.transaction_id
+      }
+    end
+
+    transaction_id {
+      SuperGood::SolidusTaxjar::TransactionIdGenerator
+        .next_transaction_id(
+          order: order,
+          current_transaction_id: last_transaction_id
+        )
+    }
+  end
+end

data/lib/super_good/solidus_taxjar/testing_support/factories/refund_transaction_factory.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :taxjar_refund_transaction, class: "SuperGood::SolidusTaxjar::RefundTransaction" do
+    order_transaction { create :taxjar_order_transaction }
+    sequence(:transaction_id) { |n| "RefundTransaction-#{n}" }
+    transaction_date { Date.current }
+  end
+end

data/lib/super_good/solidus_taxjar/testing_support/factories/transaction_sync_batch_factory.rb

@@ -0,0 +1,9 @@
+FactoryBot.define do
+  factory :transaction_sync_batch, class: "SuperGood::SolidusTaxjar::TransactionSyncBatch" do
+    trait :with_logs do
+      after :build do |batch|
+        batch.transaction_sync_logs << build(:transaction_sync_log)
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/testing_support/factories/transaction_sync_log_factory.rb

@@ -0,0 +1,18 @@
+FactoryBot.define do
+  factory :transaction_sync_log, class: "SuperGood::SolidusTaxjar::TransactionSyncLog" do
+    association :order, strategy: :create
+
+    trait :success do
+      status { "success" }
+
+      after :build do |log|
+        log.order_transaction = build(:taxjar_order_transaction, order: log.order)
+      end
+    end
+
+    trait :error do
+      status { "error" }
+      error_message { "Sync failed" }
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/transaction_id_generator.rb

@@ -0,0 +1,45 @@
+module SuperGood
+  module SolidusTaxjar
+    # Responsible for generating `transaction_id` references for transactions
+    # we create on TaxJar for Solidus orders. This class handles creating
+    # associated ID's for transactions which need to be cancelled and recreated
+    # when the order is updated in Solidus after it has been sent to the TaxJar
+    # reporting API.
+    class TransactionIdGenerator
+      class << self
+        # Generates the next sequential `transaction_id` given an order and
+        # optionally the current transaction ID on TaxJar. This handles the
+        # case where a transaction already has been created on TaxJar and later
+        # needs to be cancelled and we need to create an updated transaction
+        # with an associated identifier.
+        #
+        # @param order [Spree::Order] the order for which we want to generate a
+        #   transaction ID.
+        # @param current_transaction_id [String] the current transaction ID for
+        #   the order if it exists on TaxJar.
+        # @return [String] the next sequential `transaction_id`
+        def next_transaction_id(order:, current_transaction_id: nil)
+          if current_transaction_id.nil?
+            "#{order.number}"
+          elsif order.number == current_transaction_id
+            "#{current_transaction_id}-1"
+          else
+            parts = current_transaction_id.rpartition("-")
+            parts.last.next!
+            parts.join
+          end
+        end
+
+        # Generates a `transaction_id` for a refund transaction based on the
+        # ID of the transaction we're refunding.
+        #
+        # @param transaction_id [String] the ID of the transaction we are
+        #   refunding.
+        # @return [String] the expected refund transaction ID.
+        def refund_transaction_id(transaction_id)
+          "#{transaction_id}-REFUND"
+        end
+      end
+    end
+  end
+end

data/lib/super_good/solidus_taxjar/version.rb

@@ -1,5 +1,5 @@
 module SuperGood
   module SolidusTaxjar
-    VERSION = "0.18.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/super_good/solidus_taxjar.rb

@@ -1,15 +1,22 @@
 require "solidus_core"
 require "solidus_support"
+require "deface"
 require "taxjar"
+require "super_good/solidus_taxjar/overrides/request_override"
 
 require "super_good/solidus_taxjar/version"
+require "super_good/solidus_taxjar/transaction_id_generator"
 require "super_good/solidus_taxjar/api_params"
 require "super_good/solidus_taxjar/api"
+require "super_good/solidus_taxjar/cached_api"
 require "super_good/solidus_taxjar/calculator_helper"
 require "super_good/solidus_taxjar/tax_calculator"
 require "super_good/solidus_taxjar/tax_rate_calculator"
 require "super_good/solidus_taxjar/discount_calculator"
 require "super_good/solidus_taxjar/addresses"
+require "super_good/solidus_taxjar/reporting"
+require "super_good/solidus_taxjar/reportable"
+require "super_good/solidus_taxjar/backfill_transactions"
 
 module SuperGood
   module SolidusTaxjar
@@ -19,6 +26,7 @@ module SuperGood
       attr_accessor :custom_order_params
       attr_accessor :discount_calculator
       attr_accessor :exception_handler
+      attr_accessor :job_queue
       attr_accessor :line_item_tax_label_maker
       attr_accessor :logging_enabled
       attr_accessor :shipping_calculator
@@ -26,10 +34,27 @@ module SuperGood
       attr_accessor :taxable_address_check
       attr_accessor :taxable_order_check
       attr_accessor :test_mode
+      attr_writer :logger
+
+      def configuration
+        ::SuperGood::SolidusTaxjar::Configuration.default
+      end
 
       def api
         ::SuperGood::SolidusTaxjar::Api.new
       end
+
+      def table_name_prefix
+        "solidus_taxjar_"
+      end
+
+      def reporting
+        ::SuperGood::SolidusTaxjar::Reporting.new
+      end
+
+      def logger
+        @logger || Rails.logger
+      end
     end
 
     self.cache_duration = 3.hours
@@ -40,11 +65,13 @@ module SuperGood
     self.custom_order_params = ->(order) { {} }
     self.discount_calculator = ::SuperGood::SolidusTaxjar::DiscountCalculator
     self.exception_handler = ->(e) {
-      Rails.logger.error "An error occurred while fetching TaxJar tax rates - #{e}: #{e.message}"
+      self.logger.error "An error occurred while fetching TaxJar tax rates - #{e}: #{e.message}"
     }
+    self.job_queue = :default
     self.line_item_tax_label_maker = ->(taxjar_line_item, spree_line_item) { "Sales Tax" }
-    self.logging_enabled = false
-    self.shipping_calculator = ->(order) { order.shipment_total }
+    self.logging_enabled = true
+
+    self.shipping_calculator = ->(order) { order.shipments.sum(&:total_before_tax) }
     self.shipping_tax_label_maker = ->(shipment, shipping_tax) { "Sales Tax" }
     self.taxable_address_check = ->(address) { true }
     self.taxable_order_check = ->(order) { true }