suretax 0.1.0

data/lib/suretax/api/request_item.rb

@@ -0,0 +1,84 @@
+module Suretax
+  module Api
+
+    class RequestItem
+
+      include Suretax::Concerns::Validatable
+
+      attr_accessor :bill_to_number,
+                    :customer_number,
+                    :invoice_number,
+                    :line_number,
+                    :orig_number,
+                    :p_to_p_plus_four,
+                    :p_to_p_zipcode,
+                    :plus_four,
+                    :regulatory_code,
+                    :revenue,
+                    :sales_type_code,
+                    :seconds,
+                    :tax_included_code,
+                    :tax_situs_rule,
+                    :term_number,
+                    :trans_date,
+                    :trans_type_code,
+                    :unit_type,
+                    :units,
+                    :zipcode,
+                    :tax_exemption_codes
+
+      validate :bill_to_number,
+               :customer_number,
+               :invoice_number,
+               :line_number,
+               :orig_number,
+               :regulatory_code,
+               :sales_type_code,
+               :tax_situs_rule,
+               :term_number,
+               :trans_type_code,
+               :tax_exemption_codes
+
+      def initialize(args = {})
+        args.each_pair do |key,value|
+          self.send("#{key.to_s}=",value.to_s)
+        end
+
+        @tax_exemption_codes = []
+        unless args[:tax_exemption_codes].nil?
+          args[:tax_exemption_codes].each do |code|
+            @tax_exemption_codes << code.to_s
+          end
+        end
+
+        validate!
+      end
+
+      def params
+        {
+          "LineNumber"           => line_number,
+          "InvoiceNumber"        => invoice_number,
+          "CustomerNumber"       => customer_number,
+          "OrigNumber"           => orig_number      || '',
+          "TermNumber"           => term_number      || '',
+          "BillToNumber"         => bill_to_number   || '',
+          "Zipcode"              => zipcode,
+          "Plus4"                => plus_four,
+          "P2PZipcode"           => p_to_p_zipcode   || '',
+          "P2PPlus4"             => p_to_p_plus_four || '',
+          "TransDate"            => trans_date       || Date.today.strftime('%m-%d-%Y'),
+          "Revenue"              => revenue.to_f,
+          "Units"                => units.to_i,
+          "UnitType"             => unit_type        || '00',
+          "Seconds"              => seconds.to_i,
+          "TaxIncludedCode"      => tax_included_code,
+          "TaxSitusRule"         => tax_situs_rule,
+          "TransTypeCode"        => trans_type_code,
+          "SalesTypeCode"        => sales_type_code,
+          "RegulatoryCode"       => regulatory_code,
+          "TaxExemptionCodeList" => tax_exemption_codes
+        }
+      end
+    end
+  end
+end

data/lib/suretax/api/response.rb

@@ -0,0 +1,53 @@
+require File.join( File.dirname(__FILE__), 'item_message.rb' )
+
+module Suretax
+  module Api
+    class Response
+      attr_reader :status, :message, :total_tax, :groups, :transaction,
+        :client_tracking, :item_messages, :body
+
+      def initialize(response_body)
+        @body = JSON.generate(response_body)
+        @status = response_body.fetch('ResponseCode')
+        @transaction = response_body.fetch('TransId').to_s
+        @message = response_body.fetch('HeaderMessage')
+        @success = response_body.fetch('Successful') == 'Y'
+        @client_tracking = response_body['ClientTracking'] || nil
+        @total_tax = Amount.new(response_body['TotalTax'])
+
+        build_groups(response_body)
+        build_item_messages(response_body)
+      end
+
+      def success?
+        @success
+      end
+
+      def item_errors?
+        @status == '9001'
+      end
+
+      private
+
+        def build_groups(response_body)
+          @groups = []
+          if response_body['GroupList'].respond_to?(:map)
+            @groups = response_body.fetch('GroupList').map do |group|
+              Group.new(group)
+            end
+          end
+        end
+
+        def build_item_messages(response_body)
+          @item_messages = if item_errors?
+            response_body.fetch('ItemMessages').map do |item_message|
+              ItemMessage.new(item_message)
+            end
+          else
+            []
+          end
+        end
+    end
+  end
+end
+

data/lib/suretax/api/tax.rb

@@ -0,0 +1,25 @@
+module Suretax
+  module Api
+    class Tax
+      attr_reader :code, :description, :amount, :revenue, :county, :city, :rate, :taxable
+
+      def initialize(response_params)
+        @code = response_params.fetch('TaxTypeCode')
+        @description = response_params.fetch('TaxTypeDesc')
+        @amount = set_amount(response_params.fetch('TaxAmount').to_f)
+        @revenue = response_params['Revenue']
+        @county = response_params['CountyName']
+        @city = response_params['CityName']
+        @rate = set_amount(response_params['TaxRate'])
+        @taxable = set_amount(response_params['PercentTaxable'])
+      end
+
+      private
+
+      def set_amount(value)
+        Amount.new(value) unless value.nil?
+      end
+
+    end
+  end
+end

data/lib/suretax/api/tax_amount.rb

@@ -0,0 +1,46 @@
+require 'monetize'
+
+module Suretax
+  module Api
+    class Amount
+      attr_reader :precision, :divisor
+
+      def initialize(amount, currency = 'US6')
+        @amount = Monetize.parse(amount, currency)
+        @precision = count_significant_decimal_places
+        @divisor = @amount.currency.subunit_to_unit
+      end
+
+      def to_f
+        @amount.to_f
+      end
+
+      def to_s
+        @amount.to_s
+      end
+
+      def to_i
+        @amount.cents
+      end
+
+      def cents
+        (("%.2f" % to_f).to_f * 100 ).to_i
+      end
+
+      def params
+        {
+          amount: to_i,
+          precision: precision,
+          divisor: divisor
+        }
+      end
+
+      private
+
+      def count_significant_decimal_places
+        @amount.currency.subunit_to_unit.to_s.scan(/0/).count
+      end
+
+    end
+  end
+end

data/lib/suretax/concerns.rb

@@ -0,0 +1,7 @@
+module Suretax
+  module Concerns
+
+    require 'suretax/concerns/validatable'
+
+  end
+end

data/lib/suretax/concerns/validatable.rb

@@ -0,0 +1,208 @@
+module Suretax::Concerns
+
+  module Validatable
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, Validations)
+    end
+
+    def errors
+      @errors = Errors.new
+
+      self.class.validatable_attributes.each do |attribute_name|
+        value = self.send(attribute_name)
+        assertion = self.send("valid_#{attribute_name}?", value)
+
+        @errors[attribute_name] = Error.new(attribute_name, value) unless assertion
+      end
+
+      @errors
+    end
+    alias_method :validate!, :errors
+
+    class Error
+
+      attr_accessor :message, :value, :attribute
+
+      def initialize(attribute, value)
+        self.value     = value
+        self.attribute = attribute
+        self.message   = "Invalid #{attribute}: #{reason}"
+      end
+
+      private
+
+      def reason
+        nested_errors? ? format_nested_errors(value) : format_error(value)
+      end
+
+      def format_nested_errors(value)
+        value.map { |obj| obj.errors.messages.join(', ') }
+      end
+
+      def format_error(value)
+        if value.nil?
+          "nil"
+        elsif value.is_a?(String) && value.empty?
+          %Q{''}
+        else
+          value
+        end
+      end
+
+      def nested_errors?
+        value.respond_to?(:each) && value.all? { |obj| obj.respond_to?(:errors) }
+      end
+    end
+
+    class Errors < Hash 
+
+      def messages
+        self.map { |key, value| value.message }
+      end
+    end
+
+    module ClassMethods
+
+      attr_writer :validatable_attributes
+
+      def validate(*attribute_names)
+        self.validatable_attributes = attribute_names
+      end
+
+      def validatable_attributes
+        @validatable_attributes ||= []
+      end
+    end
+
+    module Validations
+
+      def valid_data_year?(value)
+        return false if blank?(value)
+        value.length == 4 &&
+          (value.to_i <= 2050 && value.to_i >= 1990)
+      end
+
+      def valid_data_month?(value)
+        matches?(value,month_list_subexpression)
+      end
+
+      def valid_items?(items)
+        ! items.any? {|item| item.errors.any? }
+      end
+
+      def valid_list?(value)
+        value.respond_to?(:each)
+      end
+
+      def valid_client_number?(value)
+        return false if blank?(value)
+        numeric?(value) && value.length <= 10
+      end
+      alias_method :valid_customer_number?, :valid_client_number?
+
+      def valid_business_unit?(value)
+        blank?(value) || (value.length <= 20 && alphanumeric?(value))
+      end
+
+      def valid_validation_key?(value)
+        return false if blank?(value)
+        value.length <= 36
+      end
+
+      def valid_total_revenue?(value)
+        matches?(value, total_revenue_positive_subexpression) ||
+          matches?(value, total_revenue_negative_subexpression)
+      end
+
+      def valid_return_file_code?(value)
+        matches?(value.to_s,'[Q0]')
+      end
+
+      def valid_client_tracking?(value)
+        blank?(value) || value.length <= 100
+      end
+
+      def valid_response_group?(value)
+        Suretax::RESPONSE_GROUPS.values.include?(value)
+      end
+
+      def valid_response_type?(value)
+        matches?(value, '[DS][1-9]')
+      end
+
+      def valid_line_number?(value)
+        blank?(value) || (value.length <= 20 && numeric?(value))
+      end
+
+      def valid_invoice_number?(value)
+        blank?(value) || (value.length <= 20 && alphanumeric?(value))
+      end
+
+      def valid_tax_situs_rule?(value)
+        Suretax::TAX_SITUS_RULES.values.include?(value)
+      end
+
+      def valid_trans_type_code?(value)
+        !blank?(value) && Suretax::TRANSACTION_TYPE_CODES.keys.include?(value)
+      end
+
+      def valid_sales_type_code?(value)
+        match_value = "[#{Suretax::SALES_TYPE_CODES.values.join}]"
+        !blank?(value) && matches?(value, match_value)
+      end
+
+      def valid_regulatory_code?(value)
+        !blank?(value) && Suretax::REGULATORY_CODES.values.include?(value)
+      end
+
+      def valid_tax_exemption_code_list?(value)
+        valid_list?(value) && !blank?(value.first)
+      end
+      alias_method :valid_tax_exemption_codes?, :valid_tax_exemption_code_list?
+
+      def optional_north_american_phone_number?(value)
+        blank?(value) || north_american_phone_number?(value)
+      end
+      alias_method :valid_bill_to_number?, :optional_north_american_phone_number?
+      alias_method :valid_orig_number?, :optional_north_american_phone_number?
+      alias_method :valid_term_number?, :optional_north_american_phone_number?
+
+      private
+
+      def north_american_phone_number?(value)
+        !blank?(value) && (value.length == 10 && numeric?(value))
+      end
+
+      def total_revenue_negative_subexpression
+        '-\d{,8}(?:\.\d{,4})?'
+      end
+
+      def total_revenue_positive_subexpression
+        '\d{,9}(?:\.\d{,4})?'
+      end
+
+      def numeric?(value)
+        matches?(value,'\d+')
+      end
+
+      def alphanumeric?(value)
+        matches?(value,'[a-z0-9]+')
+      end
+
+      def blank?(value)
+        value.nil? || matches?(value,'\s*')
+      end
+
+      def matches?(value,subexpression)
+        /\A#{subexpression}\z/i === value
+      end
+
+      # Month numbers 1-12 with optional leading zero
+      def month_list_subexpression
+        "0?(?:" + (1..12).to_a.join('|') + ")"
+      end
+    end
+  end
+end

data/lib/suretax/configuration.rb

@@ -0,0 +1,84 @@
+require "singleton"
+
+module Suretax
+  class Configuration
+    include Singleton
+
+    REQUEST_VERSIONS = [1, 3]
+    CANCEL_VERSIONS  = [1]
+
+    attr_accessor :validation_key, :base_url, :client_number, 
+      :request_version, :cancel_version, :logger
+
+    def initialize
+      register_currencies
+      @base_url        = test_host
+      @request_version = REQUEST_VERSIONS.max
+      @cancel_version  = CANCEL_VERSIONS.max
+    end
+
+    def test?
+      base_url == test_host
+    end
+
+    def request_version=(version_number)
+      version = version_number.to_i
+      if REQUEST_VERSIONS.include?(version.to_i)
+        @request_version = version
+      else
+        raise(ArgumentError, "version must be in #{REQUEST_VERSIONS.join(', ')}") 
+      end
+      @request_path = nil
+    end
+
+    def cancel_version=(version_number)
+      version = version_number.to_i
+      if CANCEL_VERSIONS.include?(version)
+        @cancel_version = version
+      else
+        raise(ArgumentError, "version must be in #{CANCEL_VERSIONS.join(', ')}") 
+      end
+      @cancel_path = nil
+    end
+
+    def request_path
+      @request_path ||=
+        '/Services/V%02d/SureTax.asmx/PostRequest' % request_version
+    end
+
+    def cancel_path
+      @cancel_path ||=
+        '/Services/V%02d/SureTax.asmx/CancelPostRequest' % cancel_version
+    end
+
+    private
+
+    def test_host
+      'https://testapi.taxrating.net'
+    end
+
+    def register_currencies
+      register_dollar_with_six_decimal_places
+    end
+
+    def register_dollar_with_six_decimal_places
+      Money::Currency.register(
+        {
+          priority: 1,
+          iso_code: "US6",
+          iso_numeric: "840",
+          name: "Dollar with six decimal places",
+          symbol: "$",
+          subunit: "Cent",
+          subunit_to_unit: 1000000,
+          symbol_first: true,
+          html_entity: "$",
+          decimal_mark: ".",
+          thousands_separator: ",",
+          symbolize_names: true
+        }
+      )
+    end
+
+  end
+end