spree_exactor 1.1.1.112920126

data/app/models/spree/adjustment_decorator.rb

@@ -0,0 +1,41 @@
+module Spree
+  class Adjustment
+    alias :super_update! :update!
+
+    #Spree sometimes lock adjustments. We will make to calculate Exactor Tax anyway!
+    def update!(src = nil)
+     if originator.present? and originator.is_a?(TaxRate) and originator.is_exactor_default?
+        self.locked = false
+        self.label = "Sales Tax"
+        self.update_attribute_without_callbacks(:label, label)
+     end
+     super_update!(src)
+    end
+
+  end
+
+  Adjustment.class_eval do
+    after_save :on_save
+    after_destroy :on_destroy
+
+    def on_save
+      fire_update()
+    end
+
+    def on_destroy
+      fire_update()
+    end
+
+    def is_exactor_taxable?
+      return exactor_inline_tax!=0
+    end
+
+    private
+    def fire_update
+      if adjustable.completed?
+        adjustable.exactor_is_edit="edit_lineitem"
+      end
+      adjustable.on_update()
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'spree_exactor_connector'
+require 'digest/md5'
+
+class Spree::Calculator::ExactorTaxCalculator < Spree::Calculator
+
+  def self.description
+    "Exactor sales tax compliance provider"
+  end
+
+  def calculate_hash_from_address(address)
+    address_line1 = "#{address.address1.to_s.gsub(/\s+/, "")}|#{address.address2.to_s.gsub(/\s+/, "")}|#{address.city.to_s.strip}"
+    address_line2= "#{address.state.to_s}|#{address.state_name.to_s.strip()}|#{address.zipcode}|#{address.country.to_s.strip}"
+    return "#{address_line1}|#{address_line2}".downcase()
+  end
+
+  def calculate_hash_from_items(items)
+    result = ""
+    items.each { |item| result+="|#{item.quantity}|#{item.price}|" }
+    return result
+  end
+
+  def calc_adjustment_amount(computable)
+     amount=0
+     computable.adjustments.each do |adjustment|
+      if ! adjustment.originator.present? or (adjustment.originator.present? and (!adjustment.originator.is_a?(Spree::TaxRate)))
+          if adjustment.eligible?
+            amount+=adjustment.amount
+          end
+      end
+    end
+    return amount
+  end
+
+  def calculate_hash(order)
+    addresses = "#{calculate_hash_from_address(order.ship_address)}|#{calculate_hash_from_address(order.bill_address)}"
+    amounts = "#{calculate_hash_from_items(order.line_items)}|#{order.ship_total}|#{calc_adjustment_amount(order)}"
+    return Digest::MD5.hexdigest("#{addresses}|#{amounts}")
+  end
+
+  def is_needed_to_calculate_tax?(computable)
+    order_hash = calculate_hash(computable)
+    current_order_hash = Spree::Order.find(computable.id).exactor_order_hash_sum
+    result = order_hash!=current_order_hash
+    if result
+      computable.update_column(:exactor_order_hash_sum, order_hash)
+    end
+    return result
+  end
+
+  def update_line_items_with_tax_info(computable, response)
+    computable.line_items.each do |line_item|
+      line_item.update_attribute_without_callbacks(:exactor_inline_tax, response.get_line_item_tax("_#{line_item.id}"))
+    end
+  end
+
+  def compute(computable=nil)
+    if computable
+      settings =  Spree::ExactorSetting.get_settings
+      if settings and (Date.current < settings.effective_date)
+        return 0
+      end
+      if (!computable.line_items.empty? and !computable.shipping_method.nil?) or computable.completed?
+        #Workaroud of double request to Exactor: without shipping cost and with included shipping cost.
+        #we need to return at least any non-zero value in order to have tax adjustment created. When we will have shipment
+        #we will send real transaction to Exactor
+        if computable.adjustments.shipping.empty? and !computable.completed?
+           return 0.001
+        end
+        exactor = SpreeExactorConnector::SpreeExactorConnector.new
+        if is_needed_to_calculate_tax?(computable)
+          response = exactor.calculate_tax_for_order(computable)
+          if response.is_valid
+            computable.update_column(:exactor_invoice_transaction, response.invoice_id)
+            update_line_items_with_tax_info(computable, response)
+            return response.total_tax
+          else
+            computable.update_column(:exactor_order_hash_sum, nil)
+            computable.errors.add(:base, "Unable to calculate tax: #{response.error_code}:#{response.error_description}")
+            return 0
+          end
+        end
+      end
+      return computable.tax_total
+    end
+  end
+
+end

data/app/models/spree/exactor_setting.rb

@@ -0,0 +1,140 @@
+require 'exactor_api_objects'
+
+module Spree
+  class ExactorSettingsValidator < ActiveModel::Validator
+
+    def validate(record)
+      unless record.errors.empty?
+        return
+      end
+      connector = SpreeExactorConnector::SpreeExactorConnector.new
+      response = connector.send_test_transaction(record.get_ship_from, record.merchant_id, record.user_id)
+      if (response.nil?)
+        record.errors[:base] << "We are unable to communicate with Exactor"
+      elsif response.has_key? 'ErrorResponse'
+        record.errors[:base] << "Invalid Exactor Settings: #{response['ErrorResponse'][0]['ErrorDescription'][0]}. (Code #{response['ErrorResponse'][0]['ErrorCode'][0]}) "
+      end
+
+
+    end
+
+  end
+end
+
+module Spree
+
+  class ExactorOption
+    attr_accessor :id
+    attr_accessor :name
+
+    def initialize (id, name)
+      self.id = id
+      self.name = name
+    end
+  end
+
+  class ExactorSetting < ActiveRecord::Base
+
+    class COMMIT_OPTIONS
+      TRANSACTION_STATE ="trstate"
+      PAYMENT_STATE = "paystate"
+      SHIPMENT_STATE ="shistate"
+
+      def self.to_list
+        return [TRANSACTION_STATE, PAYMENT_STATE, SHIPMENT_STATE]
+      end
+
+    end
+
+
+    class SKU_SOURCES
+      SKU_FIELD ="prodsku"
+      TAX_CATEGORY = "prodcategory"
+
+      def self.to_list
+        return [SKU_FIELD, TAX_CATEGORY]
+      end
+
+    end
+
+    belongs_to :country,  :foreign_key=>"country_id"
+    belongs_to :state, :foreign_key=>"state_id"
+
+
+    attr_accessible :merchant_id, :user_id, :effective_date, :sku_source, :commit_option, :shipping_include_handling
+    attr_accessible  :ship_from_name, :ship_from_street1, :ship_from_street2,
+    :ship_from_city, :ship_from_zip, :country, :state, :country_id, :state_id, :state_name
+
+    after_create :create_additional_entities
+    after_update :create_additional_entities
+
+    before_validation :set_states
+
+    validate  :is_valid_state?
+    validates_presence_of :user_id
+    validates_format_of :merchant_id, :with=> /^\d{8}$/, :message => "must consist of 8 digits"
+    validates_size_of :ship_from_street1, :ship_from_city,  :within=>2..100
+    validates_format_of :ship_from_zip,  :with => /^\d{5}(-?\d{4})?$/, :message =>"has invalid format"
+    validates_inclusion_of :sku_source, :in=> SKU_SOURCES.to_list()
+    validates_inclusion_of :commit_option, :in=> COMMIT_OPTIONS.to_list()
+
+    validates_with  ExactorSettingsValidator
+
+
+
+
+    def is_valid_state?
+      if state_id.nil?  and state_name.to_s.empty?
+        errors[:state] << "is required field"
+      end
+    end
+
+    #called after create
+    def create_additional_entities
+      TaxRate.find_or_create_exactor_tax_rate()
+    end
+
+    #called before validation
+    def set_states
+      unless country.states.include?(state) or state.nil?
+        @attributes["state_id"] = nil
+      else
+        @attributes["state_name"] = nil
+      end
+    end
+
+    def all_commit_options
+      return [
+          ExactorOption.new(COMMIT_OPTIONS::TRANSACTION_STATE, "Commit based on transaction state"),
+          ExactorOption.new(COMMIT_OPTIONS::PAYMENT_STATE, "Commit based on payment state"),
+          ExactorOption.new(COMMIT_OPTIONS::SHIPMENT_STATE, "Commit based on shipping state")
+      ]
+    end
+
+    def all_sku_sources
+      return  [
+        ExactorOption.new(SKU_SOURCES::SKU_FIELD, "Use SKU field for SKU"),
+        ExactorOption.new(SKU_SOURCES::TAX_CATEGORY, "Use product tax category for SKU")
+      ]
+    end
+
+    def get_ship_from
+      companyAddress = AddressType.new
+      companyAddress.FullName= ship_from_name
+      companyAddress.Street1= ship_from_street1
+      companyAddress.Street2= ship_from_street2
+      companyAddress.City= ship_from_city
+      companyAddress.StateOrProvince= state_id.nil?() ? state_name : state
+      companyAddress.PostalCode= ship_from_zip
+      companyAddress.Country= country
+      return companyAddress
+    end
+
+
+   def self.get_settings
+     settings = Spree::ExactorSetting.all
+     return settings.empty?() ? nil:settings.first()
+   end
+  end
+
+end

data/app/models/spree/line_item_decorator.rb

@@ -0,0 +1,31 @@
+module Spree
+  LineItem.class_eval do
+    attr_accessible :exactor_inline_tax
+
+    after_save :on_save
+    after_destroy :on_destroy
+    #before save
+
+    def on_save
+      fire_update()
+    end
+
+    def on_destroy
+      fire_update()
+    end
+
+    def is_exactor_taxable?
+      return exactor_inline_tax!=0
+    end
+
+    private
+    def fire_update
+      if order.completed?
+        order.exactor_is_edit="edit_lineitem"
+      end
+      order.on_update()
+    end
+
+  end
+
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,126 @@
+module Spree
+  class Order
+    alias :super_finalize! :finalize!
+    alias :super_after_cancel :after_cancel
+    alias :super_after_resume :after_resume
+    alias :super_update_adjustments :update_adjustments
+    alias :super_update_payment_state :update_payment_state
+    alias :super_update_shipment_state :update_shipment_state
+
+    #check out handler
+    def finalize!
+      exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+      exactor_connector.do_checkout!(self)
+      super_finalize!
+    end
+
+    #cancel order handler
+    def after_cancel
+      exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+      exactor_connector.do_cancel!(self)
+      update_column(:exactor_order_hash_sum,nil)
+      super_after_cancel
+    end
+
+    #when order was resumed handler
+    def after_resume
+      update_adjustments
+      exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+      exactor_connector.do_checkout!(self)
+      super_after_resume
+    end
+
+    def edit_order
+      exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+      if (!exactor_invoice_transaction.nil?)
+        if (!exactor_commit_transaction.nil?)
+          exactor_connector.do_cancel!(self)
+        end
+        exactor_connector.do_checkout!(self)
+      end
+    end
+
+    def update_payment_state
+      super_update_payment_state
+      exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+      if (payment_state=='paid')
+         exactor_connector.do_payment_completed!(self)
+      elsif current_payment and current_payment.state == 'void' and current_payment.previous_state == 'completed'
+        exactor_connector.do_refund_payment!(self)
+      end
+    end
+
+    def update_shipment_state
+      super_update_shipment_state
+      if (shipment_state=='shipped')
+        exactor_connector = SpreeExactorConnector::SpreeExactorConnector.new
+        exactor_connector.do_shipp
+        ed!(self)
+      end
+    end
+
+    def create_tax_charge!
+      # destroy any previous adjustments (eveything is recalculated from scratch)
+      price_adjustments.each(&:destroy)
+      if (adjustments.tax.reload.size!=1)
+        adjustments.tax.each(&:destroy)
+        TaxRate.match(self).each { |rate| rate.adjust(self) }
+      end
+
+    end
+    def is_needed_to_create_adjustment?
+      settings =  Spree::ExactorSetting.get_settings
+       if self.completed? and ['complete', 'canceled', 'resumed'].include?(state)
+         if settings and completed_at >= settings.effective_date
+          return true
+         end
+       end
+      return false
+    end
+
+    #this method is intended to add adjustment to old transactions which was created without our plugin
+    def update_adjustments
+      if !is_needed_to_create_adjustment?
+        super_update_adjustments
+        return
+      end
+      count_of_tax_adj = adjustments.reload.tax.size
+      current_tax_adj = adjustments.reload.tax.first
+      unless count_of_tax_adj == 0 or
+          (count_of_tax_adj==1 and !current_tax_adj.originator.nil? and current_tax_adj.originator.is_exactor_default?)
+        adjustments.tax.each(&:destroy)
+        return
+      end
+      if (count_of_tax_adj == 0)
+        TaxRate.match(self).each { |rate| rate.adjust(self) }
+      end
+      super_update_adjustments
+    end
+  end
+
+  Order.class_eval do
+    attr_accessible :exactor_invoice_transaction, :exactor_commit_transaction, :exactor_order_hash_sum, :exactor_is_edit
+    before_save :on_update
+    after_save :on_saved
+    attr_accessor :current_payment
+
+    #before save
+    def on_update
+      if (adjustments.tax.reload.size==0 and !shipping_method.nil?)
+        create_tax_charge!
+      end
+      update_adjustments
+      if ['complete', 'resumed'].include?(state) and !changed_attributes.keys().include?('state')
+        if (!exactor_commit_transaction or exactor_invoice_transaction) and !exactor_is_edit.to_s.empty?
+          edit_order
+        end
+      end
+      return errors.empty?
+    end
+
+    #after save
+    def on_saved
+      update_column(:exactor_is_edit, nil);
+    end
+  end
+end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,15 @@
+module Spree
+  Payment.class_eval do
+    attr_accessor :previous_state
+    before_save :populate_order
+
+
+    def populate_order
+      if (self.changed_attributes.include?('state'))
+        self.previous_state=self.changed_attributes['state'].to_s.clone()
+      end
+      order.current_payment=self
+    end
+  end
+
+end