valvat 1.1.5 → 1.2.1

data/lib/valvat/lookup/vies.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'date'
+require 'net/http'
+require 'erb'
+require 'rexml'
+
+class Valvat
+  class Lookup
+    class VIES < Base
+      ENDPOINT_URI = URI('https://ec.europa.eu/taxation_customs/vies/services/checkVatService').freeze
+      HEADERS = {
+        'Accept' => 'text/xml;charset=UTF-8',
+        'Content-Type' => 'text/xml;charset=UTF-8',
+        'SOAPAction' => ''
+      }.freeze
+
+      BODY = <<-XML.gsub(/^\s+/, '')
+        <soapenv:Envelope
+        xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+        xmlns:urn="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
+          <soapenv:Header/>
+          <soapenv:Body>
+            <urn:checkVat<%= 'Approx' if @requester %>>
+                <urn:countryCode><%= @vat.vat_country_code %></urn:countryCode>
+                <urn:vatNumber><%= @vat.to_s_wo_country %></urn:vatNumber>
+                <% if @requester %>
+                <urn:requesterCountryCode><%= @vat.vat_country_code %></urn:requesterCountryCode>
+                <urn:requesterVatNumber><%= @vat.to_s_wo_country %></urn:requesterVatNumber>
+                <% end %>
+            </urn:checkVat<%= 'Approx' if @requester %>>
+          </soapenv:Body>
+        </soapenv:Envelope>
+      XML
+      BODY_TEMPLATE = ERB.new(BODY).freeze
+
+      private
+
+      def endpoint_uri
+        ENDPOINT_URI
+      end
+
+      def build_request(uri)
+        request = Net::HTTP::Post.new(uri.request_uri, HEADERS)
+        request.body = BODY_TEMPLATE.result(binding)
+        request
+      end
+
+      def parse(body)
+        doc = REXML::Document.new(body)
+        elements = doc.get_elements('/env:Envelope/env:Body').first.first
+        convert_values(elements.each_with_object({}) do |el, hash|
+          hash[convert_key(el.name)] = convert_value(el.text)
+        end)
+      end
+
+      def convert_key(key)
+        key.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .sub(/\Atrader_/, '')
+           .downcase.to_sym
+      end
+
+      def convert_value(value)
+        value == '---' ? nil : value
+      end
+
+      def convert_values(hash)
+        return build_fault(hash) if hash[:faultstring]
+
+        hash[:valid] = hash[:valid] == 'true' || (hash[:valid] == 'false' ? false : nil) if hash.key?(:valid)
+        hash[:request_date] = Date.parse(hash[:request_date]) if hash.key?(:request_date)
+        hash
+      end
+
+      FAULTS = {
+        'SERVICE_UNAVAILABLE' => ServiceUnavailable,
+        'MS_UNAVAILABLE' => MemberStateUnavailable,
+        'INVALID_REQUESTER_INFO' => InvalidRequester,
+        'TIMEOUT' => Timeout,
+        'VAT_BLOCKED' => BlockedError,
+        'IP_BLOCKED' => BlockedError,
+        'GLOBAL_MAX_CONCURRENT_REQ' => RateLimitError,
+        'GLOBAL_MAX_CONCURRENT_REQ_TIME' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ_TIME' => RateLimitError
+      }.freeze
+
+      def build_fault(hash)
+        fault = hash[:faultstring]
+        return hash.merge({ valid: false }) if fault == 'INVALID_INPUT'
+
+        hash.merge({ error: (FAULTS[fault] || UnknownLookupError).new(fault, self.class) })
+      end
+    end
+  end
+end

data/lib/valvat/lookup.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'lookup/vies'
+require_relative 'lookup/hmrc'
+
 class Valvat
   class Lookup
     def initialize(vat, options = {})
@@ -10,9 +13,9 @@ class Valvat
 
     def validate
       return false if !@options[:skip_local_validation] && !@vat.valid?
-      return handle_vies_error(response[:error]) if response[:error]
+      return handle_error(response[:error]) if response[:error]
 
-      response[:valid] && show_details? ? response.to_hash : response[:valid]
+      response[:valid] && show_details? ? response : response[:valid]
     end
 
     class << self
@@ -28,15 +31,23 @@ class Valvat
     end
 
     def response
-      @response ||= Request.new(@vat, @options).perform
+      @response ||= webservice.new(@vat, @options).perform
+    end
+
+    def webservice
+      case @vat.vat_country_code
+      when 'GB' then HMRC
+      else
+        VIES
+      end
     end
 
     def show_details?
       @options[:requester] || @options[:detail]
     end
 
-    def handle_vies_error(error)
-      if error.is_a?(ViesMaintenanceError)
+    def handle_error(error)
+      if error.is_a?(MaintenanceError)
         raise error if @options[:raise_error]
       else
         raise error unless @options[:raise_error] == false

data/lib/valvat/utils.rb

@@ -6,7 +6,6 @@ class Valvat
   module Utils
     EU_MEMBER_STATES = %w[AT BE BG CY CZ DE DK EE ES FI FR GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK].freeze
     SUPPORTED_STATES = EU_MEMBER_STATES + %w[GB]
-    EU_COUNTRIES = EU_MEMBER_STATES # TODO: Remove constant
     COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/.freeze
     NORMALIZE_PATTERN = /([[:punct:][:cntrl:]]|[[:space:]])+/.freeze
     CONVERT_VAT_TO_ISO_COUNTRY = { 'EL' => 'GR', 'XI' => 'GB' }.freeze

data/lib/valvat/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Valvat
-  VERSION = '1.1.5'
+  VERSION = '1.2.1'
 end

data/lib/valvat.rb

@@ -1,16 +1,62 @@
 # frozen_string_literal: true
 
 require 'valvat/error'
-require 'valvat/local'
+require 'valvat/utils'
+require 'valvat/syntax'
+require 'valvat/checksum'
+require 'valvat/version'
 require 'valvat/lookup'
-require 'valvat/lookup/request'
-require 'valvat/lookup/response'
-require 'valvat/lookup/fault'
 require 'active_model/validations/valvat_validator' if defined?(ActiveModel)
 
 class Valvat
+  def initialize(raw)
+    @raw = Valvat::Utils.normalize(raw || '')
+    @vat_country_code, @to_s_wo_country = to_a
+  end
+
+  attr_reader :raw, :vat_country_code, :to_s_wo_country
+
+  def blank?
+    raw.nil? || raw.strip == ''
+  end
+
+  def valid?
+    Valvat::Syntax.validate(self)
+  end
+
+  def valid_checksum?
+    Valvat::Checksum.validate(self)
+  end
+
   def exists?(options = {})
     Valvat::Lookup.validate(self, options)
   end
   alias exist? exists?
+
+  def iso_country_code
+    Valvat::Utils.vat_country_to_iso_country(vat_country_code)
+  end
+
+  # TODO: Remove method / not in use
+  def european?
+    puts 'DEPRECATED: #european? is deprecated. Instead access Valvat::Utils::EU_MEMBER_STATES directly.'
+
+    Valvat::Utils::EU_MEMBER_STATES.include?(iso_country_code)
+  end
+
+  def to_a
+    Valvat::Utils.split(raw)
+  end
+
+  def to_s
+    raw
+  end
+
+  def inspect
+    "#<Valvat #{[raw, iso_country_code].compact.join(' ')}>"
+  end
+end
+
+def Valvat(vat) # rubocop:disable Naming/MethodName
+  vat.is_a?(Valvat) ? vat : Valvat.new(vat)
 end

data/spec/spec_helper.rb

@@ -8,12 +8,13 @@ rescue LoadError
 end
 
 require "#{File.dirname(__FILE__)}/../lib/valvat.rb"
+require 'webmock/rspec'
+WebMock.allow_net_connect!
 
 RSpec.configure do |config|
   config.mock_with :rspec
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-  config.backtrace_exclusion_patterns = [%r{rspec/(core|expectations)}]
 end
 
 I18n.enforce_available_locales = false if defined?(I18n)

data/spec/valvat/checksum/es_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Valvat::Checksum::ES do
   %w[ESA13585625 ESB83871236 ESE54507058 ES25139013J ESQ1518001A ESQ5018001G ESX4942978W ESX7676464F ESB10317980
-     ESY3860557K ESY2207765D].each do |valid_vat|
+     ESY3860557K ESY2207765D ES28350472M ES41961720Z ESM1171170X ESK0928769Y].each do |valid_vat|
     it "returns true on valid VAT #{valid_vat}" do
       expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
@@ -22,4 +22,44 @@ describe Valvat::Checksum::ES do
       expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
+
+  describe 'some CIF categories (NPQRSW) require control-digit to be a letter' do
+    invalid_vat = 'ESP65474207'
+    valid_vat = 'ESP6547420G'
+
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+    end
+
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
+    end
+  end
+
+  describe 'some CIF categories (CDFGJNUV) allow both a numeric check digit and a letter' do
+    %w[ESC65474207 ESC6547420G].each do |valid_vat|
+      it "returns true on valid VAT #{valid_vat}" do
+        expect(Valvat::Checksum.validate(valid_vat)).to be(true)
+      end
+    end
+  end
+
+  describe 'applies special rules to validation' do
+    describe 'special NIF categories (KLM) require CD to be a letter and first two digits '\
+             'to be between 01 and 56 (inclusive)' do
+      %w[ESK8201230M ESK0001230B].each do |invalid_vat|
+        it "returns false on invalid VAT #{invalid_vat}" do
+          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+        end
+      end
+    end
+
+    describe 'arbitrarily invalid VATs' do
+      %w[ESX0000000T ES00000001R ES00000000T ES99999999R].each do |invalid_vat|
+        it "returns false on invalid VAT #{invalid_vat}" do
+          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+        end
+      end
+    end
+  end
 end

data/spec/valvat/checksum/gb_spec.rb

@@ -21,6 +21,7 @@ describe Valvat::Checksum::GB do
 
   it 'is true for a new format valid vat' do
     expect(Valvat::Checksum.validate('GB434031439')).to be true
+    expect(Valvat::Checksum.validate('GB727255821')).to be true
   end
 
   it 'is false for an old format VAT in forbidden group' do

data/spec/valvat/lookup/hmrc_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::HMRC do
+  before do
+    stub_const('Valvat::Lookup::HMRC::ENDPOINT_URL', 'https://test-api.service.hmrc.gov.uk/organisations/vat/check-vat-number/lookup')
+  end
+
+  it 'returns hash with valid: true on success' do
+    response = described_class.new('GB553557881', { uk: true }).perform
+
+    expect(response).to match({
+                                valid: true,
+                                address: "131B Barton Hamlet\nSW97 5CK\nGB",
+                                country_code: 'GB',
+                                vat_number: '553557881',
+                                name: 'Credite Sberger Donal Inc.',
+                                request_date: kind_of(Time)
+                              })
+  end
+
+  it 'returns hash with valid: false on invalid input' do
+    response = described_class.new('GB123456789', { uk: true }).perform
+    expect(response).to match({ valid: false })
+  end
+
+  it 'returns hash with valid: false on valid input with :uk option not set' do
+    response = described_class.new('GB553557881', {}).perform
+    expect(response).to match({ valid: false })
+  end
+end

data/spec/valvat/lookup/vies_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::VIES do
+  it 'returns hash with valid: true on success' do
+    response = described_class.new('IE6388047V', {}).perform
+
+    expect(response).to match({
+                                valid: true,
+                                address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
+                                country_code: 'IE',
+                                vat_number: '6388047V',
+                                name: 'GOOGLE IRELAND LIMITED',
+                                request_date: kind_of(Date)
+                              })
+  end
+
+  it 'returns hash with valid: false on invalid input' do
+    response = described_class.new('XC123123', {}).perform
+    expect(response.to_hash).to match({ valid: false, faultstring: 'INVALID_INPUT', faultcode: 'env:Server' })
+  end
+end