solidus_avatax_certified 1.0.0

data/app/models/solidus_avatax_certified/avatax_log.rb

@@ -0,0 +1,69 @@
+module SolidusAvataxCertified
+  class AvataxLog
+    def initialize(path_name, file_name, log_info = nil, schedule = nil)
+      if !Spree::AvalaraPreference.log_to_stdout.is_true?
+        schedule = 'weekly' unless schedule != nil
+        @logger ||= Logger.new("#{Rails.root}/log/#{path_name}.log", schedule)
+        progname(file_name.split('/').last.chomp('.rb'))
+        info(log_info) unless log_info.nil?
+      else
+        log_info = "-#{file_name} #{log_info}"
+        @logger ||= Logger.new(STDOUT)
+      end
+    end
+
+    def logger
+      @logger
+    end
+
+    def enabled?
+      Spree::AvalaraPreference.log.is_true? || Spree::AvalaraPreference.log_to_stdout.is_true?
+    end
+
+    def progname(progname = nil)
+      if enabled?
+        progname.nil? ? logger.progname : logger.progname = progname
+      end
+    end
+
+    def info(log_info = nil)
+      if enabled?
+        unless log_info.nil?
+          logger.info "[AVATAX] #{log_info}"
+        end
+      end
+    end
+
+    def info_and_debug(log_info, response)
+      if enabled?
+        logger.info "[AVATAX] #{log_info}"
+        if response.is_a?(Hash)
+          logger.debug "[AVATAX] #{JSON.generate(response)}"
+        else
+          logger.debug "[AVATAX] #{response}"
+        end
+      end
+    end
+
+
+    def debug(obj, text = nil)
+      if enabled?
+        logger.debug "[AVATAX] #{obj.inspect}"
+        if text.nil?
+          obj
+        else
+          logger.debug "[AVATAX] text"
+          text
+        end
+      end
+    end
+
+    def error(log_info = nil)
+      if enabled?
+        unless log_info.nil?
+          logger.error "[AVATAX] #{log_info}"
+        end
+      end
+    end
+  end
+end

data/app/models/solidus_avatax_certified/line.rb

@@ -0,0 +1,146 @@
+module SolidusAvataxCertified
+  class Line
+    attr_reader :order, :lines
+
+    def initialize(order, invoice_type, refund = nil)
+      @order = order
+      @invoice_type = invoice_type
+      @lines = []
+      @refund = refund
+      @refunds = []
+      build_lines
+    end
+
+    def build_lines
+      if %w(ReturnInvoice ReturnOrder).include?(@invoice_type)
+        refund_lines
+      else
+        item_lines_array
+        shipment_lines_array
+      end
+
+      logger.debug @lines
+    end
+
+    def item_line(line_item)
+      {
+        LineNo: "#{line_item.id}-LI",
+        Description: line_item.name[0..255],
+        TaxCode: line_item.tax_category.try(:tax_code) || '',
+        ItemCode: line_item.variant.sku,
+        Qty: line_item.quantity,
+        Amount: line_item.amount.to_f,
+        OriginCode: get_stock_location(line_item),
+        DestinationCode: 'Dest',
+        CustomerUsageType: order.customer_usage_type,
+        Discounted: discounted?(line_item),
+        TaxIncluded: tax_included_in_price?(line_item)
+      }
+    end
+
+    def item_lines_array
+      order.line_items.each do |line_item|
+        lines << item_line(line_item)
+      end
+    end
+
+    def shipment_lines_array
+      order.shipments.each do |shipment|
+        next unless shipment.tax_category
+        lines << shipment_line(shipment)
+      end
+    end
+
+    def shipment_line(shipment)
+      {
+        LineNo: "#{shipment.id}-FR",
+        ItemCode: shipment.shipping_method.name,
+        Qty: 1,
+        Amount: shipment.discounted_amount.to_f,
+        OriginCode: "#{shipment.stock_location_id}",
+        DestinationCode: 'Dest',
+        CustomerUsageType: order.customer_usage_type,
+        Description: 'Shipping Charge',
+        TaxCode: shipment.shipping_method_tax_code,
+        Discounted: false,
+        TaxIncluded: tax_included_in_price?(shipment)
+      }
+    end
+
+    def refund_lines
+      return lines << refund_line if @refund.reimbursement.nil?
+
+      return_items = @refund.reimbursement.customer_return.return_items
+      inventory_units = Spree::InventoryUnit.where(id: return_items.pluck(:inventory_unit_id))
+
+      inventory_units.group_by(&:line_item_id).each_value do |inv_unit|
+
+        inv_unit_ids = inv_unit.map { |iu| iu.id }
+        return_items = Spree::ReturnItem.where(inventory_unit_id: inv_unit_ids)
+        quantity = inv_unit.uniq.count
+
+        amount = if return_items.first.respond_to?(:amount)
+            return_items.sum(:amount)
+        else
+          return_items.sum(:pre_tax_amount)
+        end
+
+        lines << return_item_line(inv_unit.first.line_item, quantity, amount)
+      end
+    end
+
+    def refund_line
+      {
+        LineNo: "#{@refund.id}-RA",
+        ItemCode: @refund.transaction_id || 'Refund',
+        Qty: 1,
+        Amount: -@refund.amount.to_f,
+        OriginCode: 'Orig',
+        DestinationCode: 'Dest',
+        CustomerUsageType: order.customer_usage_type,
+        Description: 'Refund',
+        TaxIncluded: true
+      }
+    end
+
+    def return_item_line(line_item, quantity, amount)
+      {
+        LineNo: "#{line_item.id}-LI",
+        Description: line_item.name[0..255],
+        TaxCode: line_item.tax_category.try(:tax_code) || '',
+        ItemCode: line_item.variant.sku,
+        Qty: quantity,
+        Amount: -amount.to_f,
+        OriginCode: get_stock_location(line_item),
+        DestinationCode: 'Dest',
+        CustomerUsageType: order.customer_usage_type
+      }
+    end
+
+    def get_stock_location(li)
+      inventory_units = li.inventory_units
+
+      return 'Orig' if inventory_units.blank?
+
+      stock_loc_id = inventory_units.first.try(:shipment).try(:stock_location_id)
+
+      stock_loc_id.nil? ? 'Orig' : "#{stock_loc_id}"
+    end
+
+    private
+
+    def discounted?(line_item)
+      line_item.adjustments.promotion.eligible.any? || order.adjustments.promotion.eligible.any?
+    end
+
+    def logger
+      @logger ||= SolidusAvataxCertified::AvataxLog.new('avalara_order_lines', 'SolidusAvataxCertified::Line', "Building Lines for Order#: #{order.number}")
+    end
+
+    def tax_included_in_price?(item)
+      # Need better error handling
+      # if no tax rates, raise error tax rates needs to be set up
+      order.tax_zone.tax_rates.where(tax_category: item.tax_category).try(:first).included_in_price
+    end
+  end
+end

data/app/models/solidus_avatax_certified/preference_updater.rb

@@ -0,0 +1,74 @@
+module SolidusAvataxCertified
+  class PreferenceUpdater
+
+    def initialize(params)
+      @avatax_origin = params[:address]
+      @avatax_preferences = params[:settings]
+    end
+
+    def update
+      update_validation_enabled_countries
+      update_origin_address
+      update_stored_preferences
+      update_boolean_preferences
+    end
+
+    private
+
+    def update_stored_preferences
+      Spree::AvalaraPreference.storable_envs.each do |preference|
+        if !ENV["AVATAX_#{preference.name.upcase}"].blank?
+          update_value(preference, ENV["AVATAX_#{preference.name.upcase}"])
+        else
+          update_value(preference, @avatax_preferences[preference.name.downcase])
+        end
+      end
+    end
+
+    def update_boolean_preferences
+      Spree::AvalaraPreference.booleans.each do |boolean|
+        if !@avatax_preferences[boolean.name].nil?
+          update_value(boolean, 'true')
+        else
+          update_value(boolean, 'false')
+        end
+      end
+    end
+
+    def update_origin_address
+      set_region
+      set_country
+      update_value(Spree::AvalaraPreference.origin_address, @avatax_origin.to_json)
+    end
+
+    def update_validation_enabled_countries
+      if @avatax_preferences['address_validation_enabled_countries'].present?
+        update_value(Spree::AvalaraPreference.validation_enabled_countries, @avatax_preferences['address_validation_enabled_countries'].join(','))
+      end
+    end
+
+    def update_value(preference, param)
+      if value_changed?(preference, param)
+        preference.update_attributes(value: param)
+      end
+    end
+
+    def value_changed?(preference, param)
+      preference.value != param
+    end
+
+    def set_region
+      region = @avatax_origin['Region']
+      unless region.blank?
+        @avatax_origin['Region'] = Spree::State.find(region).try(:abbr)
+      end
+    end
+
+    def set_country
+      country = @avatax_origin['Country']
+      unless country.blank?
+        @avatax_origin['Country'] = Spree::Country.find(country).try(:iso)
+      end
+    end
+  end
+end

data/app/models/spree/address_decorator.rb

@@ -0,0 +1,13 @@
+Spree::Address.class_eval do
+  def validation_enabled?
+    Spree::AvalaraPreference.address_validation.is_true? && country_validation_enabled?
+  end
+
+  def country_validation_enabled?
+    Spree::Address.validation_enabled_countries.include?(country.try(:name))
+  end
+
+  def self.validation_enabled_countries
+    Spree::AvalaraPreference.validation_enabled_countries_array
+  end
+end

data/app/models/spree/adjustment_decorator.rb

@@ -0,0 +1,10 @@
+Spree::Adjustment.class_eval do
+  scope :not_tax, -> { where.not(source_type: 'Spree::TaxRate') }
+
+  def avatax_cache_key
+    key = ['Spree::Adjustment']
+    key << self.id
+    key << self.amount
+    key.join('-')
+  end
+end

data/app/models/spree/avalara_entity_use_code.rb

@@ -0,0 +1,5 @@
+module Spree
+  class AvalaraEntityUseCode < Spree::Base
+    has_many :users
+  end
+end

data/app/models/spree/avalara_preference.rb

@@ -0,0 +1,72 @@
+module Spree
+  class AvalaraPreference < Spree::Base
+    validates_uniqueness_of :name
+    validates_presence_of :name, :object_type
+
+    scope :booleans, -> { where(object_type: 'boolean') }
+    scope :strings, -> { where(object_type: 'string') }
+    scope :arrays, -> { where(object_type: 'array') }
+    scope :jsons, -> { where(object_type: 'json') }
+    scope :storable_envs, -> { where(name: ['company_code', 'license_key', 'account', 'endpoint']) }
+
+    def self.company_code
+      find_by(name: 'company_code')
+    end
+
+    def self.license_key
+      find_by(name: 'license_key')
+    end
+
+    def self.account
+      find_by(name: 'account')
+    end
+
+    def self.endpoint
+      find_by(name: 'endpoint')
+    end
+
+    def self.origin_address
+      find_by(name: 'origin_address')
+    end
+
+    def self.log
+      find_by(name: 'log')
+    end
+
+    def self.log_to_stdout
+      find_by(name: 'log_to_stdout')
+    end
+
+    def self.address_validation
+      find_by(name: 'address_validation')
+    end
+
+    def self.refuse_checkout_address_validation_error
+      find_by(name: 'refuse_checkout_address_validation_error')
+    end
+
+    def self.tax_calculation
+      find_by(name: 'tax_calculation')
+    end
+
+    def self.document_commit
+      find_by(name: 'document_commit')
+    end
+
+    def self.validation_enabled_countries
+      find_by(name: 'address_validation_enabled_countries')
+    end
+
+    def self.validation_enabled_countries_array
+      find_by(name: 'address_validation_enabled_countries').value.split(',')
+    end
+
+    def self.customer_can_validate
+      find_by(name: 'customer_can_validate')
+    end
+
+    def is_true?
+      [true, 1, "1", "t", "T", "true", "TRUE", "on", "ON"].include?(value)
+    end
+  end
+end

data/app/models/spree/avalara_transaction.rb

@@ -0,0 +1,181 @@
+require 'logging'
+require_dependency 'spree/order'
+
+module Spree
+  class AvalaraTransaction < Spree::Base
+    belongs_to :order
+    validates :order, presence: true
+    validates :order_id, uniqueness: true
+    # has_many :adjustments, as: :source
+
+    def lookup_avatax
+      post_order_to_avalara(false, 'SalesOrder')
+    end
+
+    def commit_avatax(invoice_dt = nil, refund = nil)
+      if tax_calculation_enabled?
+        if %w(ReturnInvoice ReturnOrder).include?(invoice_dt)
+          post_return_to_avalara(false, invoice_dt, refund)
+        else
+          post_order_to_avalara(false, invoice_dt)
+        end
+      else
+        { TotalTax: '0.00' }
+      end
+    end
+
+    def commit_avatax_final(invoice_dt = nil, refund = nil)
+      if document_committing_enabled?
+        if tax_calculation_enabled?
+          if %w(ReturnInvoice ReturnOrder).include?(invoice_dt)
+            post_return_to_avalara(true, invoice_dt, refund)
+          else
+            post_order_to_avalara(true, invoice_dt)
+          end
+        else
+          { TotalTax: '0.00' }
+        end
+      else
+        logger.debug 'avalara document committing disabled'
+        'avalara document committing disabled'
+      end
+    end
+
+    def cancel_order
+      cancel_order_to_avalara('SalesInvoice') if tax_calculation_enabled?
+    end
+
+    private
+
+    def cancel_order_to_avalara(doc_type = 'SalesInvoice')
+      logger.info('cancel order to avalara')
+
+      cancel_tax_request = {
+        CompanyCode: Spree::AvalaraPreference.company_code.value,
+        DocType: doc_type,
+        DocCode: order.number,
+        CancelCode: 'DocVoided'
+      }
+
+      mytax = TaxSvc.new
+      cancel_tax_result = mytax.cancel_tax(cancel_tax_request)
+
+      logger.debug cancel_tax_result
+
+      if cancel_tax_result == 'Error in Cancel Tax'
+        return 'Error in Cancel Tax'
+      else
+        return cancel_tax_result
+      end
+    end
+
+    def post_order_to_avalara(commit = false, invoice_detail = nil)
+      logger.info('post order to avalara')
+      avatax_address = SolidusAvataxCertified::Address.new(order)
+      avatax_line = SolidusAvataxCertified::Line.new(order, invoice_detail)
+
+      doc_date = order.completed? ? order.completed_at.strftime('%F') : Date.today.strftime('%F')
+
+      gettaxes = {
+        DocCode: order.number,
+        DocDate: doc_date,
+        Discount: order.all_adjustments.promotion.eligible.sum(:amount).abs.to_s,
+        Commit: commit,
+        DocType: invoice_detail ? invoice_detail : 'SalesOrder',
+        Addresses: avatax_address.addresses,
+        Lines: avatax_line.lines
+      }.merge(base_tax_hash)
+
+      if !business_id_no.blank?
+        gettaxes[:BusinessIdentificationNo] = business_id_no
+      end
+
+      logger.debug gettaxes
+
+      mytax = TaxSvc.new
+
+      tax_result = mytax.get_tax(gettaxes)
+
+      logger.info_and_debug('tax result', tax_result)
+
+      return { TotalTax: '0.00' } if tax_result == 'error in Tax'
+      return tax_result if tax_result['ResultCode'] == 'Success'
+    end
+
+    def post_return_to_avalara(commit = false, invoice_detail = nil, refund = nil)
+      logger.info('starting post return order to avalara')
+
+      avatax_address = SolidusAvataxCertified::Address.new(order)
+      avatax_line = SolidusAvataxCertified::Line.new(order, invoice_detail, refund)
+
+      taxoverride = {
+        TaxOverrideType: 'TaxDate',
+        Reason: refund.try(:reason).try(:name).limit(255) || 'Return',
+        TaxDate: order.completed_at.strftime('%F')
+      }
+
+      gettaxes = {
+        DocCode: order.number.to_s + '.' + refund.id.to_s,
+        DocDate: Date.today.strftime('%F'),
+        Commit: commit,
+        DocType: invoice_detail ? invoice_detail : 'ReturnOrder',
+        Addresses: avatax_address.addresses,
+        Lines: avatax_line.lines
+      }.merge(base_tax_hash)
+
+      if !business_id_no.blank?
+        gettaxes[:BusinessIdentificationNo] = business_id_no
+      end
+
+      gettaxes[:TaxOverride] = taxoverride
+
+      logger.debug gettaxes
+
+      mytax = TaxSvc.new
+
+      tax_result = mytax.get_tax(gettaxes)
+
+      logger.info_and_debug('tax result', tax_result)
+
+      return { TotalTax: '0.00' } if tax_result == 'error in Tax'
+      return tax_result if tax_result['ResultCode'] == 'Success'
+    end
+
+    def base_tax_hash
+      {
+        CustomerCode: customer_code,
+        CompanyCode: Spree::AvalaraPreference.company_code.value,
+        CustomerUsageType: order.customer_usage_type,
+        ExemptionNo: order.user.try(:exemption_number),
+        Client:  avatax_client_version,
+        ReferenceCode: order.number,
+        DetailLevel: 'Tax',
+        CurrencyCode: order.currency
+      }
+    end
+
+    def customer_code
+      order.user ? order.user.id : order.email
+    end
+
+    def business_id_no
+      order.user.try(:vat_id)
+    end
+
+    def avatax_client_version
+      AVATAX_CLIENT_VERSION || 'a0o33000004FH8l'
+    end
+
+    def document_committing_enabled?
+      Spree::AvalaraPreference.document_commit.is_true?
+    end
+
+    def tax_calculation_enabled?
+      Spree::AvalaraPreference.tax_calculation.is_true?
+    end
+
+    def logger
+      @logger ||= SolidusAvataxCertified::AvataxLog.new('post_order_to_avalara', __FILE__)
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Spree
+  class Calculator::AvalaraTransaction < Calculator::DefaultTax
+    def self.description
+      Spree.t(:avalara_transaction_calculator)
+    end
+
+    def compute_order(order)
+      raise 'Spree::AvalaraTransaction is designed to calculate taxes at the shipment and line-item levels.'
+    end
+
+    def compute_shipment_or_line_item(item)
+      order = item.order
+      item_address = order.ship_address || order.billing_address
+      prev_tax_amount = prev_tax_amount(item)
+
+      return prev_tax_amount unless Spree::AvalaraPreference.tax_calculation.is_true?
+      return prev_tax_amount if %w(address cart).include?(order.state)
+      return prev_tax_amount if item_address.nil?
+      return prev_tax_amount unless calculable.zone.include?(item_address)
+
+      avalara_response = get_avalara_response(order)
+      tax_for_item(item, avalara_response)
+    end
+
+    alias_method :compute_shipment, :compute_shipment_or_line_item
+    alias_method :compute_line_item, :compute_shipment_or_line_item
+
+    def compute_shipping_rate(shipping_rate)
+      return 0
+    end
+
+    private
+
+    def prev_tax_amount(item)
+      if rate.included_in_price
+        item.included_tax_total
+      else
+        item.additional_tax_total
+      end
+    end
+
+    def get_avalara_response(order)
+      Rails.cache.fetch(cache_key(order), time_to_idle: 5.minutes) do
+        order.avalara_capture
+      end
+    end
+
+
+    def long_cache_key(order)
+      key = order.avatax_cache_key
+      key << (order.ship_address.try(:cache_key) || order.bill_address.try(:cache_key)).to_s
+      order.line_items.each do |line_item|
+        key << line_item.avatax_cache_key
+      end
+      order.shipments.each do |shipment|
+        key << shipment.avatax_cache_key
+      end
+      order.all_adjustments.not_tax do |adj|
+        key << adj.avatax_cache_key
+      end
+      key
+    end
+
+    # long keys blow up in dev with the default ActiveSupport::Cache::FileStore
+    # This transparently shrinks 'em
+    def cache_key(order)
+      long_key   = long_cache_key(order)
+      short_key  = Digest::SHA1.hexdigest(long_key)
+      "avtx_#{short_key}"
+    end
+
+    def tax_for_item(item, avalara_response)
+      prev_tax_amount = prev_tax_amount(item)
+
+      return prev_tax_amount if avalara_response.nil?
+      return 0 if avalara_response[:TotalTax] == '0.00'
+
+      avalara_response['TaxLines'].each do |line|
+        if line['LineNo'] == "#{item.id}-#{item.avatax_line_code}"
+          return line['TaxCalculated'].to_f
+        end
+      end
+      0
+    end
+  end
+end

data/app/models/spree/line_item_decorator.rb

@@ -0,0 +1,25 @@
+Spree::LineItem.class_eval do
+  def to_hash
+    {
+      'Index' => id,
+      'Name' => name,
+      'ItemID' => sku,
+      'Price' => price.to_s,
+      'Qty' => quantity,
+      'TaxCategory' => tax_category
+    }
+  end
+
+  def avatax_cache_key
+    key = ['Spree::LineItem']
+    key << self.id
+    key << self.quantity
+    key << self.price
+    key << self.promo_total
+    key.join('-')
+  end
+
+  def avatax_line_code
+    'LI'
+  end
+end