spree_avatax_official 1.7.1

data/app/presenters/spree_avatax_official/transactions/full_refund_presenter.rb

@@ -0,0 +1,32 @@
+module SpreeAvataxOfficial
+  module Transactions
+    class FullRefundPresenter
+      def initialize(order:, transaction_code:)
+        @order            = order
+        @transaction_code = transaction_code
+      end
+
+      # based on https://developer.avalara.com/api-reference/avatax/rest/v2/models/RefundTransactionModel/
+      def to_json
+        {
+          refundTransactionCode: transaction_code,
+          referenceCode:         reference_code,
+          refundDate:            refund_date,
+          refundType:            'Full'
+        }
+      end
+
+      private
+
+      attr_reader :order, :transaction_code
+
+      def reference_code
+        order.number
+      end
+
+      def refund_date
+        order.completed_at.strftime('%Y-%m-%d')
+      end
+    end
+  end
+end

data/app/presenters/spree_avatax_official/transactions/partial_refund_presenter.rb

@@ -0,0 +1,46 @@
+module SpreeAvataxOfficial
+  module Transactions
+    class PartialRefundPresenter < CreatePresenter
+      OVERRIDE_TYPE   = 'TaxDate'.freeze
+      OVERRIDE_REASON = 'Refund'.freeze
+
+      def initialize(order:, refund_items:, transaction_code:)
+        @order            = order
+        @refund_items     = refund_items
+        @transaction_code = transaction_code
+        @transaction_type = SpreeAvataxOfficial::Transaction::RETURN_INVOICE
+      end
+
+      # based on https://developer.avalara.com/api-reference/avatax/rest/v2/models/CreateTransactionModel/
+      # date should be refund date, taxDate should be order's completed_at date
+      def to_json
+        super.merge(
+          date:        formatted_date(Time.current),
+          taxOverride: tax_override
+        )
+      end
+
+      private
+
+      attr_reader :refund_items
+
+      def tax_override
+        {
+          type:    self.class::OVERRIDE_TYPE,
+          reason:  self.class::OVERRIDE_REASON,
+          taxDate: formatted_date(order.completed_at)
+        }
+      end
+
+      def items_payload
+        refund_items.map do |item, (quantity, amount)|
+          SpreeAvataxOfficial::ItemPresenter.new(
+            item:            item,
+            custom_quantity: quantity,
+            custom_amount:   amount
+          ).to_json
+        end
+      end
+    end
+  end
+end

data/app/services/spree_avatax_official/address/validate.rb

@@ -0,0 +1,27 @@
+module SpreeAvataxOfficial
+  module Address
+    class Validate < SpreeAvataxOfficial::Base
+      def call(address:)
+        response = send_request(address)
+
+        return failure(response) if errors?(response)
+
+        success(response)
+      end
+
+      private
+
+      def errors?(response)
+        response.body['messages'] || response.body['error']
+      end
+
+      def send_request(address)
+        ship_to_address_model = SpreeAvataxOfficial::ShipToAddressPresenter.new(
+          address: address
+        ).to_json
+
+        client.resolve_address(ship_to_address_model)
+      end
+    end
+  end
+end

data/app/services/spree_avatax_official/base.rb

@@ -0,0 +1,71 @@
+module SpreeAvataxOfficial
+  class Base
+    prepend ::Spree::ServiceModule::Base
+
+    APP_NAME           = 'a0o0b000005HsXPAA0'.freeze
+    APP_VERSION        = 'Spree by Spark'.freeze
+    SUCCESS_STATUSES   = [200, 201].freeze
+    CONNECTION_OPTIONS = ::AvaTax::Configuration::DEFAULT_CONNECTION_OPTIONS.merge(
+      request: {
+        timeout:      SpreeAvataxOfficial::Config.read_timeout,
+        open_timeout: SpreeAvataxOfficial::Config.open_timeout
+      }
+    ).freeze
+
+    private
+
+    def client
+      AvaTax::Client.new(
+        app_name:           APP_NAME,
+        app_version:        APP_VERSION,
+        connection_options: CONNECTION_OPTIONS,
+        logger:             true,
+        faraday_response:   true,
+        endpoint:           SpreeAvataxOfficial::Config.endpoint,
+        username:           SpreeAvataxOfficial::Config.account_number,
+        password:           SpreeAvataxOfficial::Config.license_key
+      )
+    end
+
+    def company_code(order)
+      order.store&.avatax_company_code || SpreeAvataxOfficial::Config.company_code
+    end
+
+    def request_result(response, object = nil)
+      status        = response.try(:status)
+      response_body = status ? response.body : response
+
+      if request_error?(status, response_body)
+        logger.error(object, response)
+
+        failure(response_body)
+      else
+        yield if block_given?
+
+        logger.info(response, object)
+
+        success(response_body)
+      end
+    end
+
+    def request_error?(status, response_body)
+      response_body['error'].present? || !status.in?(SUCCESS_STATUSES)
+    end
+
+    def refund_transaction_code(order_number, refundable_id)
+      "#{order_number}-#{refundable_id}"
+    end
+
+    def create_transaction!(order:, code: nil, transaction_type: nil)
+      SpreeAvataxOfficial::Transaction.create!(
+        code:             code || order.number,
+        order:            order,
+        transaction_type: transaction_type || SpreeAvataxOfficial::Transaction::SALES_INVOICE
+      )
+    end
+
+    def logger
+      @logger ||= SpreeAvataxOfficial::AvataxLog.new
+    end
+  end
+end

data/app/services/spree_avatax_official/create_tax_adjustments_service.rb

@@ -0,0 +1,133 @@
+module SpreeAvataxOfficial
+  class CreateTaxAdjustmentsService < SpreeAvataxOfficial::Base
+    include SpreeAvataxOfficial::TaxAdjustmentLabelHelper
+
+    def call(order:) # rubocop:disable Metrics/AbcSize
+      return failure(::Spree.t('spree_avatax_official.create_tax_adjustments.order_canceled')) if order.canceled?
+
+      order.all_adjustments.tax.destroy_all
+
+      return failure(::Spree.t('spree_avatax_official.create_tax_adjustments.tax_calculation_unnecessary')) unless order.avatax_tax_calculation_required?
+
+      transaction_cache_key = SpreeAvataxOfficial::GenerateTransactionCacheKeyService.call(order: order).value
+
+      avatax_response       = Rails.cache.fetch(transaction_cache_key, expires_in: 5.minutes) do
+        send_transaction_to_avatax(order)
+      end
+
+      return failure(build_error_message_from_response(avatax_response.value)) if avatax_failed_response?(avatax_response)
+
+      process_avatax_items(order, avatax_response.value['lines'])
+
+      success(true)
+    end
+
+    private
+
+    def send_transaction_to_avatax(order)
+      if order.avatax_sales_invoice_transaction.present?
+        SpreeAvataxOfficial::Transactions::AdjustService.call(
+          order:                  order,
+          adjustment_reason:      SpreeAvataxOfficial::Transaction::DEFAULT_ADJUSTMENT_REASON,
+          adjustment_description: ::Spree.t('spree_avatax_official.create_tax_adjustments.adjustment_description')
+        )
+      else
+        SpreeAvataxOfficial::Transactions::CreateService.call(order: order)
+      end
+    end
+
+    def avatax_failed_response?(avatax_response)
+      avatax_response.failure? || avatax_response.value['totalTax'].zero?
+    end
+
+    def process_avatax_items(order, avatax_items)
+      avatax_items.each { |avatax_item| process_avatax_item(order, avatax_item) }
+    end
+
+    def process_avatax_item(order, avatax_item)
+      tax_amount = avatax_item['taxCalculated']
+
+      return if tax_amount.zero?
+
+      item_suffix = avatax_item['lineNumber'].slice(0..2)
+      item_id     = avatax_item['lineNumber'].slice(3..-1)
+      item        = find_item(order, item_id, item_suffix)
+
+      # Spree allows to setup shipping methods without tax category and
+      # in that case it doesn't make sense to collect any tax,
+      # especially because of validation that requires presence of tax category
+      return if item.tax_category.nil?
+
+      tax_rate = find_or_create_tax_rate(item, avatax_item)
+
+      store_pre_tax_amount(item, tax_rate, tax_amount)
+
+      create_tax_adjustment(item, tax_rate, tax_amount)
+    end
+
+    def find_item(order, uuid, suffix)
+      case suffix
+      when 'LI-'
+        order.line_items.find_by(avatax_uuid: uuid)
+      when 'FR-'
+        order.shipments.find_by(avatax_uuid: uuid)
+      end
+    end
+
+    def find_or_create_tax_rate(item, avatax_item)
+      ::Spree::TaxRate.find_or_create_by!(
+        name:               tax_rate_name,
+        amount:             sum_rates_from_details(avatax_item),
+        zone:               item.tax_zone&.reload,
+        tax_category:       item.tax_category,
+        show_rate_in_label: false,
+        included_in_price:  item.included_in_price
+      ) do |tax_rate|
+        tax_rate.calculator = SpreeAvataxOfficial::Calculator::AvataxTransactionCalculator.new
+      end
+    end
+
+    def tax_rate_name
+      ENV.fetch('AVATAX_TAX_RATE_NAME', 'AvaTax Official Tax Rate')
+    end
+
+    def create_tax_adjustment(item, source, amount)
+      item.adjustments.create!(
+        source:   source,
+        amount:   amount,
+        included: item.included_in_price,
+        label:    tax_adjustment_label(item, source.amount),
+        order:    item.order
+      )
+    end
+
+    def store_pre_tax_amount(item, tax_rate, tax_amount)
+      pre_tax_amount = case item.class.name.demodulize
+                       when 'LineItem' then item.discounted_amount
+                       when 'Shipment' then item.discounted_cost
+                       end
+
+      pre_tax_amount -= tax_amount if tax_rate.included_in_price?
+
+      item.update_column(:pre_tax_amount, pre_tax_amount)
+    end
+
+    def sum_rates_from_details(avatax_item)
+      avatax_item['details']
+        .sum { |detail_entry| detail_entry['rate'] }
+        .round(6)
+    end
+
+    def build_error_message_from_response(avatax_response)
+      return ::Spree.t('spree_avatax_official.create_tax_adjustments.tax_calculation_failed') unless error_present?(avatax_response)
+
+      avatax_response['error']['details'].map do |error_detail_entry|
+        "#{error_detail_entry['number']} - #{error_detail_entry['message']} - #{error_detail_entry['description']}."
+      end.join(' ')
+    end
+
+    def error_present?(avatax_response)
+      avatax_response && avatax_response['error'].present?
+    end
+  end
+end

data/app/services/spree_avatax_official/generate_transaction_cache_key_service.rb

@@ -0,0 +1,94 @@
+module SpreeAvataxOfficial
+  class GenerateTransactionCacheKeyService < SpreeAvataxOfficial::Base
+    def call(order:)
+      reloaded_order = order.class.includes(
+        :line_items,
+        :adjustments,
+        :shipments               => :stock_location,
+        order.tax_address_symbol => %i[state country]
+      ).find(order.id)
+
+      success(transaction_cache_key(reloaded_order))
+    end
+
+    private
+
+    def transaction_cache_key(order)
+      transaction_cache_key = [
+        order_cache_key(order),
+        tax_address_cache_key(order.tax_address),
+        line_items_cache_key(order),
+        shipments_cache_key(order.shipments),
+        avatax_preferences_cache_key(order)
+      ].join('-')
+
+      # Cache key length has to be compressed as max_length is 250:
+      # https://github.com/memcached/memcached/blob/master/memcached.h#L36
+      "AvaTax-transaction-#{Digest::MD5.hexdigest(transaction_cache_key)}"
+    end
+
+    def order_cache_key(order)
+      [
+        order.number,
+        order.avatax_discount_amount
+      ].join('-')
+    end
+
+    def tax_address_cache_key(tax_address)
+      [
+        tax_address.address1,
+        tax_address.address2,
+        tax_address.city,
+        tax_address.state.try(:abbr),
+        tax_address.country.try(:iso),
+        tax_address.zipcode
+      ].join('-')
+    end
+
+    def line_items_cache_key(order) # rubocop:disable Metrics/MethodLength
+      order.line_items.map do |line_item|
+        [
+          line_item.avatax_uuid,
+          line_item.quantity,
+          line_item.variant_id,
+          line_item.price,
+          line_item.amount,
+          line_item.discounted_amount,
+          order.line_items_discounted_in_avatax?,
+          line_item.avatax_tax_code
+        ].join('-')
+      end.join('-')
+    end
+
+    def shipments_cache_key(shipments)
+      shipments.map do |shipment|
+        [
+          shipment.avatax_uuid,
+          shipment.discounted_cost,
+          shipment.avatax_tax_code,
+          stock_location_cache_key(shipment.stock_location)
+        ].join('-')
+      end.join('-')
+    end
+
+    def stock_location_cache_key(stock_location)
+      [
+        stock_location.address1,
+        stock_location.address2,
+        stock_location.city,
+        stock_location.state.try(:abbr),
+        stock_location.country.try(:iso)
+      ].join('-')
+    end
+
+    def avatax_preferences_cache_key(order)
+      ship_from_address_timestamp = ship_from_address_preference.try(:updated_at).try(:utc).try(:to_s, :number)
+
+      "#{company_code(order)}-#{ship_from_address_timestamp}"
+    end
+
+    def ship_from_address_preference
+      ::Spree::Preference.find_by(key: 'spree_avatax_official/configuration/ship_from_address')
+    end
+  end
+end

data/app/services/spree_avatax_official/get_tax_service.rb

@@ -0,0 +1,20 @@
+module SpreeAvataxOfficial
+  class GetTaxService < SpreeAvataxOfficial::Base
+    def call(order:, options: {})
+      response = send_request(order, options)
+
+      return failure(response) if response.body['error'].present?
+
+      success(taxCalculated: response.body['totalTaxCalculated'])
+    end
+
+    def send_request(order, options)
+      create_transaction_model = SpreeAvataxOfficial::Transactions::CreatePresenter.new(
+        order:            order,
+        transaction_type: SpreeAvataxOfficial::Transaction::SALES_ORDER
+      ).to_json
+
+      client.create_transaction(create_transaction_model, options)
+    end
+  end
+end

data/app/services/spree_avatax_official/settings/update_service.rb

@@ -0,0 +1,36 @@
+module SpreeAvataxOfficial
+  module Settings
+    class UpdateService < SpreeAvataxOfficial::Base
+      def call(params:)
+        update_settings(params)
+      end
+
+      private
+
+      def update_settings(params)
+        update_address_settings(params[:ship_from])
+
+        SpreeAvataxOfficial::Config.account_number             = params[:account_number] if params.key?(:account_number)
+        SpreeAvataxOfficial::Config.license_key                = params[:license_key] if params.key?(:license_key)
+        SpreeAvataxOfficial::Config.company_code               = params[:company_code] if params.key?(:company_code)
+        SpreeAvataxOfficial::Config.endpoint                   = params[:endpoint] if params.key?(:endpoint)
+        SpreeAvataxOfficial::Config.address_validation_enabled = params[:address_validation_enabled] if params.key?(:address_validation_enabled)
+        SpreeAvataxOfficial::Config.commit_transaction_enabled = params[:commit_transaction_enabled] if params.key?(:commit_transaction_enabled)
+        SpreeAvataxOfficial::Config.enabled                    = params[:enabled] if params.key?(:enabled)
+      end
+
+      def update_address_settings(ship_from_params)
+        return unless ship_from_params
+
+        SpreeAvataxOfficial::Config.ship_from_address = {
+            line1:      ship_from_params[:line1],
+            line2:      ship_from_params[:line2],
+            city:       ship_from_params[:city],
+            region:     ship_from_params[:region],
+            country:    ship_from_params[:country],
+            postalCode: ship_from_params[:postal_code]
+        }
+      end
+    end
+  end
+end