spree_exactor 1.1.1.112920126

data/app/helpers/exactor_api_service.rb

@@ -0,0 +1,96 @@
+require 'exactor_api_objects'
+require 'net/http'
+require 'xmlsimple'
+
+module ExactorApi
+  API_URI = URI('https://taxrequest.exactor.com/request/xml')
+
+  class ExactorApiService
+
+    def send_request (taxRequest)
+
+      unless taxRequest.is_a? TaxRequest
+        return nil
+      end
+      request = create_request(taxRequest)
+      request.add_field("Content-Type","application/xml")
+      response = Net::HTTP.start(API_URI.hostname, 80) do |http|
+        http.request(request)
+      end
+
+      case response
+        when Net::HTTPSuccess then
+          return XmlSimple.xml_in(response.body)
+        when Net::HTTPBadRequest then
+          raise ArgumentError.new(response.body)
+        else
+          return nil
+      end
+
+      return nil
+    end
+
+    private
+    def create_request (taxRequest)
+      request = Net::HTTP::Post.new(API_URI.path)
+      request.body= serialize_to_xml(taxRequest)
+      return request
+    end
+
+    private
+    def serialize_to_xml(exactor_object)
+      return '<?xml version="1.0" encoding="utf-8" ?>'+serialize_object(exactor_object)
+    end
+
+    private
+    def serialize_object (exactorObject, object_name=nil)
+      result = "";
+      objectName = object_name.nil? ? objectName=exactorObject.class.to_s : obtain_object_name(object_name)
+      unless exactorObject.is_a? ComplexExactorObject or exactorObject.is_a? Array
+        return create_simple_tag(exactorObject, objectName)
+      else
+        if exactorObject.is_a? Array
+          exactorObject.each { |object| result << serialize_object(object, objectName) }
+          return result
+        end
+      end
+      attributes = {}
+      if exactorObject.instance_variable_defined?(:@__xmlattr)
+        attributes = exactorObject.instance_variable_get(:@__xmlattr)
+      end
+      result << create_open_tag(objectName, attributes)
+      exactorObject.instance_variable_names.each do |var_name|
+        var = exactorObject.instance_variable_get(var_name)
+        unless (var.nil? or var_name.starts_with? "@__")
+          result << serialize_object(var, var_name)
+        end
+      end
+      result << create_close_tag(objectName)
+      return result
+    end
+
+    private
+    def create_simple_tag(obj, name="")
+      value = CGI::escapeHTML(obj.to_s)
+      return "<#{name}>#{value}</#{name}>"
+    end
+
+    private
+    def create_open_tag(name, attributes = {})
+      attr_string = ""
+      attributes.each {|key, value| attr_string<<" #{key}=\"#{value}\" "}
+      return "<#{name} #{attr_string}>"
+    end
+
+    private
+    def create_close_tag(name)
+      return "</#{name}>"
+    end
+
+    private
+    def obtain_object_name(name)
+      return name.start_with?("@") ? name.sub("@", ""):name
+    end
+
+  end
+end

data/app/helpers/spree_exactor_connector.rb

@@ -0,0 +1,380 @@
+require 'exactor_api_service'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module SpreeExactorConnector
+  class SpreeExactorConnector
+    PLUGIN_VERSION = "20121018"
+    TEST_TRANSACTION_NAME = "Spree Test Transaction"
+    TEST_ITEM_DESRIPTION = "Exactor Account Verification. Plug-in version:"
+    PLUGIN_NAME = "SpreeCommerce"
+    SHIPPING_EUC_NO_HANDLING = "EUC-13010204"
+    SHIPPING_EUC_WITH_HANDLING = "EUC-13010101"
+    DISCOUNT_EUC="EUC-99010102"
+    NON_TAXABLE_EUC="EUC-99030101"
+    MARKUP_EUC="EUC-99010202"
+
+
+    def initialize
+      @settings = Spree::ExactorSetting.get_settings()
+    end
+
+    def send_test_transaction (addressType, merchantId, userId)
+      exactorApi = ExactorApi::ExactorApiService.new
+      testRequest = TaxRequest.new
+      testRequest.MerchantId=merchantId
+      testRequest.UserId=userId
+      testInvoice = InvoiceRequest.new
+      addressType.FullName = TEST_TRANSACTION_NAME
+      testInvoice.ShipFrom=addressType
+      testInvoice.ShipTo=addressType
+      testInvoice.BillTo=addressType
+      testInvoice.SaleDate=Date.current.to_s
+      testLineItem = InvoiceRequest::LineItem.new(nil, "#{TEST_ITEM_DESRIPTION} #{PLUGIN_VERSION}" , 1, 0.0)
+      testInvoice.LineItem=testLineItem
+      testRequest.InvoiceRequest= testInvoice
+      testRequest.xmlattr_version=PLUGIN_VERSION
+      testRequest.xmlattr_plugin = PLUGIN_NAME
+      return exactorApi.send_request(testRequest)
+    end
+
+
+
+    def calculate_tax_for_order(order)
+      response = nil
+      if @settings.nil?
+        response = create_tax_response(0)
+        return response
+      end
+      taxRequest = create_tax_request_skeleton()
+      taxRequest.InvoiceRequest=InvoiceRequest.new
+      taxRequest.InvoiceRequest.ShipFrom=@settings.get_ship_from()
+      taxRequest.InvoiceRequest.LineItem=[]
+      map_order_to_invoice!(order, taxRequest.InvoiceRequest)
+      exactorApi = ExactorApi::ExactorApiService.new
+      return map_calculation_response(exactorApi.send_request(taxRequest))
+    end
+
+    def commit_transaction(order)
+      taxRequest = create_tax_request_skeleton()
+      taxRequest.CommitRequest=CommitRequest.new
+      taxRequest.CommitRequest.PriorTransactionId=order.exactor_invoice_transaction
+      taxRequest.CommitRequest.InvoiceNumber=order.number
+      taxRequest.CommitRequest.CommitDate=Date.current.to_s
+      exactorApi = ExactorApi::ExactorApiService.new
+      return map_commit_response(exactorApi.send_request(taxRequest))
+    end
+
+    def commit_refund_transaction(order)
+      taxRequest = create_tax_request_skeleton()
+      taxRequest.CommitRequest=CommitRequest.new
+      taxRequest.CommitRequest.CommitDate=Date.current.to_s
+      taxRequest.CommitRequest.InvoiceNumber=order.number
+      invoice = InvoiceRequest.new
+      invoice.ShipFrom=@settings.get_ship_from()
+      invoice.ShipTo=map_from_spree_address(order.ship_address)
+      invoice.BillTo=map_from_spree_address(order.bill_address)
+      invoice.SaleDate=Date.current.to_s
+      invoice.PurchaseOrderNumber=order.number.to_s
+      if order.user.anonymous?.nil?
+        invoice.ExemptionId=order.user.exactor_exemption_id
+      end
+      #SPECIFICATION: refund_amount = amount + [amount/(total-S&H)] * total tax.
+      amount=order.current_payment.amount - (order.current_payment.amount*order.tax_total)/(order.total)
+      amount=(-1)*amount if amount>0
+      invoice.LineItem=[build_refund_lineitem(amount)]
+      taxRequest.CommitRequest.InvoiceRequest=invoice
+      exactorApi = ExactorApi::ExactorApiService.new
+      return map_commit_response(exactorApi.send_request(taxRequest))
+    end
+
+    def refund_transaction(order)
+      taxRequest = create_tax_request_skeleton()
+      taxRequest.RefundRequest=RefundRequest.new
+      taxRequest.RefundRequest.RefundDate=Date.current.to_s
+      taxRequest.RefundRequest.PriorTransactionId=order.exactor_commit_transaction
+      exactorApi = ExactorApi::ExactorApiService.new
+      return map_refund_response(exactorApi.send_request(taxRequest))
+    end
+
+    def do_commit!(order)
+      response = commit_transaction(order)
+      if (response.is_valid)
+        order.update_column(:exactor_invoice_transaction,nil)
+        order.update_column(:exactor_commit_transaction,response.commit_id)
+      else
+        order.errors[:base]<<"Tax calculation failure: #{response.error_code}:#{response.error_description}"
+      end
+      return response
+    end
+
+    def do_cancel!(order)
+      if can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::TRANSACTION_STATE, order) or can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::SHIPMENT_STATE, order)
+        if !order.exactor_commit_transaction.nil?
+          response = refund_transaction(order)
+          if (response.is_valid)
+            order.update_column(:exactor_commit_transaction, nil)
+          else
+            order.errors[:base]<<"Tax calculation failure: #{response.error_code}:#{response.error_description}"
+          end
+        end
+      end
+    end
+
+    def do_shipped!(order)
+      if (can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::SHIPMENT_STATE, order))
+        update_tax_if_needed(order)
+        resp = do_commit!(order)
+        if (!resp.is_valid)
+          order.shipment.errors[:base]<<"Tax synchronization failure: #{resp.error_code}:#{resp.error_description}"
+        end
+      end
+    end
+
+    def do_checkout!(order)
+       if (can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::TRANSACTION_STATE, order))
+        do_commit!(order)
+      end
+    end
+
+    def do_payment_completed!(order)
+      if (can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::PAYMENT_STATE, order))
+          update_tax_if_needed(order)
+          resp = nil
+          if order.exactor_commit_transaction
+            resp = refund_transaction(order)
+          end
+          if (!resp or resp.is_valid)
+            resp = do_commit!(order)
+          end
+          if (!resp.is_valid)
+            order.current_payment.errors[:base]<<"Tax synchronization failure: #{resp.error_code}:#{resp.error_description}"
+          end
+      end
+    end
+
+    def do_refund_payment!(order)
+      if (can_be_handled?(Spree::ExactorSetting::COMMIT_OPTIONS::PAYMENT_STATE, order))
+        response=nil
+        if (order.current_payment.amount==order.total)
+          response=refund_transaction(order)
+        else
+          if (!have_non_taxable_items?(order))
+            response = commit_refund_transaction(order)
+          else
+            return
+          end
+        end
+        if (response and response.is_valid)
+          order.update_column(:exactor_commit_transaction, nil)
+        else
+          order.errors[:base]<<"Tax synchronization failure: #{response.error_code}:#{response.error_description}"
+          order.current_payment.errors[:base]<<"Tax synchronization failure: #{response.error_code}:#{response.error_description}"
+        end
+      end
+    end
+
+
+
+    private
+
+    def can_be_handled?(commit_type, order)
+      if (!@settings.nil?)
+        if (@settings.commit_option== commit_type)
+          order_date = order.completed_at.nil? ? Date.current : order.completed_at
+          if (order_date >= @settings.effective_date)
+            return true
+          end
+        end
+      end
+      return false
+    end
+
+    def update_tax_if_needed(order)
+      if order.exactor_invoice_transaction.nil?
+        order.update_column(:exactor_order_hash_sum, nil)
+        order.update_adjustments
+      end
+    end
+
+    def have_non_taxable_items?(order)
+      order.line_items.each do |line_item|
+        if (!line_item.is_exactor_taxable?)
+          return true
+        end
+      end
+      return false
+    end
+
+    def create_tax_response(tax, invoice_id=nil)
+      calc_response = CalculationResponse.new
+      calc_response.total_tax=tax
+      calc_response.invoice_id=invoice_id
+      return calc_response
+    end
+
+    def create_tax_request_skeleton()
+      taxRequest = TaxRequest.new
+      taxRequest.MerchantId=@settings.merchant_id
+      taxRequest.UserId=@settings.user_id
+      taxRequest.xmlattr_version=PLUGIN_VERSION
+      taxRequest.xmlattr_plugin = PLUGIN_NAME
+      return taxRequest
+    end
+
+    def map_from_spree_address(address)
+      exactor_address = AddressType.new
+      exactor_address.FullName="#{address.firstname} #{address.lastname}"
+      exactor_address.Street1=address.address1
+      exactor_address.Street2=address.address2
+      exactor_address.City=address.city.to_s
+      exactor_address.StateOrProvince=address.state_id.nil?() ?address.state_name : address.state.to_s()
+      exactor_address.PostalCode=address.zipcode
+      exactor_address.Country=address.country
+      return exactor_address
+    end
+
+    def get_sku_according_to_settings(line_item)
+      sku_source = @settings.sku_source
+       sku = "";
+       if (sku_source == Spree::ExactorSetting::SKU_SOURCES::SKU_FIELD)
+        sku = line_item.variant.sku
+      elsif (sku_source == Spree::ExactorSetting::SKU_SOURCES::TAX_CATEGORY)
+        sku = line_item.product.tax_category.name unless line_item.product.tax_category.nil?
+      end
+       return sku
+    end
+
+    def map_from_spree_lineitem(line_item)
+      exactor_line = InvoiceRequest::LineItem.new
+      exactor_line.SKU=get_sku_according_to_settings(line_item)
+      exactor_line.Description=line_item.product.description
+      exactor_line.Quantity=line_item.quantity
+      exactor_line.GrossAmount=line_item.amount()
+      exactor_line.xmlattr_id= "_#{line_item.id}"
+      return exactor_line
+    end
+
+    def map_order_to_invoice!(order, invoice)
+      invoice.ShipTo=map_from_spree_address(order.ship_address)
+      invoice.BillTo=map_from_spree_address(order.bill_address)
+      order.line_items.each {|line_item| invoice.LineItem << map_from_spree_lineitem(line_item);}
+      invoice.LineItem.push(add_shipping_lineitem(order.ship_total))
+      index=0
+      order.adjustments.each do |adjustment|
+        line_item =  map_adjustment_as_lineitem(adjustment, index);
+        if line_item
+          index+=1
+          invoice.LineItem << line_item
+        end
+      end
+      invoice.SaleDate=Date.current.to_s
+      invoice.PurchaseOrderNumber=order.number.to_s
+      if order.user.anonymous?.nil?
+        invoice.ExemptionId=order.user.exactor_exemption_id
+      end
+      return invoice
+    end
+
+
+    def add_shipping_lineitem(shipping_amount)
+      exactor_line = InvoiceRequest::LineItem.new
+      exactor_line.SKU=@settings.shipping_include_handling ? SHIPPING_EUC_WITH_HANDLING : SHIPPING_EUC_NO_HANDLING
+      exactor_line.Description="Shipping"
+      exactor_line.Quantity=1
+      exactor_line.GrossAmount=shipping_amount
+      exactor_line.xmlattr_id="SHIPPING"
+      return exactor_line
+    end
+
+    def build_refund_lineitem(amount)
+      refund_line = InvoiceRequest::LineItem.new
+      refund_line.Description="Payment refund"
+      refund_line.Quantity=1
+      refund_line.GrossAmount=amount
+      refund_line.xmlattr_id="_0"
+      return refund_line
+    end
+
+    def map_adjustment_as_lineitem(adjustment, index)
+      #filters tax and shipping
+      if adjustment.originator.present? and (adjustment.originator.is_a?(Spree::TaxRate) or adjustment.originator.is_a?(Spree::ShippingMethod))
+         return nil
+      end
+      #filter non-eligible adjustments
+      return nil unless adjustment.eligible?
+      amount = adjustment.amount
+      euc=amount<0 ? DISCOUNT_EUC : MARKUP_EUC
+      description=  "Adjustment"
+      if adjustment.originator.calculator.is_a?(Spree::Calculator::FreeShipping)
+        amount = -1*adjustment.source.ship_total
+        euc=@settings.shipping_include_handling ? SHIPPING_EUC_WITH_HANDLING : SHIPPING_EUC_NO_HANDLING
+        description="Free shipping"
+      end
+      exactor_line = InvoiceRequest::LineItem.new(euc,description,1,amount)
+      exactor_line.xmlattr_id="ADJUSTMENT_#{index}"
+      return exactor_line
+    end
+
+    def map_error(error_response)
+      #response['ErrorResponse'][0]['ErrorDescription'][0]}. (Code #{response['ErrorResponse'][0]['ErrorCode'][0]
+      response = ErrorResponse.new
+      response.error_code=error_response['ErrorResponse'][0]['ErrorCode'][0].to_i
+      response.error_description=error_response['ErrorResponse'][0]['ErrorDescription'][0]
+      response.is_valid=false
+      return response
+    end
+
+    def map_invoice(invoice)
+      response = CalculationResponse.new
+      response.is_valid=true
+      response.invoice_id=invoice['InvoiceResponse'][0]['TransactionId'][0]
+      response.total_tax=invoice['InvoiceResponse'][0]['TotalTaxAmount'][0].to_d
+      invoice['InvoiceResponse'][0]['LineItem'].each do |line_item|
+        response.add_line_item(line_item["id"], line_item["TotalTaxAmount"][0].to_d)
+      end
+      return response
+    end
+
+    def map_commit(commit)
+      response = CommitResponse.new
+      response.is_valid=true
+      response.commit_id=commit['CommitResponse'][0]['TransactionId'][0]
+      if commit['CommitResponse'][0].has_key?('InvoiceResponse')
+        response.invoice=map_invoice(commit['CommitResponse'][0])
+      end
+      return response
+    end
+
+    def map_refund(refund)
+      response = RefundResponse.new
+      response.is_valid=true
+      return response
+    end
+
+    def map_calculation_response(response)
+      if response.has_key? 'ErrorResponse'
+        return map_error(response)
+      else
+        return map_invoice(response)
+      end
+    end
+
+    def map_commit_response(response)
+      if response.has_key? 'ErrorResponse'
+        return map_error(response)
+      else
+        return map_commit(response)
+      end
+    end
+
+    def map_refund_response(response)
+      if response.has_key? 'ErrorResponse'
+        return map_error(response)
+      else
+        return map_refund(response)
+      end
+    end
+
+  end
+end