valvat 0.8.1 → 1.0.1

data/lib/valvat/lookup/fault.rb

@@ -0,0 +1,30 @@
+class Valvat
+  class Lookup
+    class Fault < Response
+      private
+
+      def self.cleanup(hash)
+        fault = hash[:fault][:faultstring]
+        return {valid: false} if fault == "INVALID_INPUT"
+        {error: fault_to_error(fault)}
+      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
+      }
+
+      def self.fault_to_error(fault)
+        (FAULTS[fault] || UnknownViesError).new(fault)
+      end
+    end
+  end
+end

data/lib/valvat/lookup/request.rb

@@ -1,30 +1,51 @@
+require 'savon'
+
 class Valvat
   class Lookup
     class Request
-      def initialize(vat)
-        @vat = vat
+      VIES_WSDL_URL = 'https://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl'
+
+      def initialize(vat, options)
+        @vat = Valvat(vat)
+        @options = options || {}
+        @requester = @options[:requester] && Valvat(@options[:requester])
       end
 
-      def perform(client)
-        client.call(action, :message => body, :message_tag => message_tag).to_hash[response_key]
+      def perform
+        begin
+          Response.new(
+            client.call(action, message: message, message_tag: message_tag)
+          )
+        rescue Savon::SOAPFault => fault
+          Fault.new(fault)
+        end
       end
 
       private
 
-      def body
-        {:country_code => @vat.vat_country_code, :vat_number => @vat.to_s_wo_country}
+      def client
+        Savon::Client.new({
+          wsdl: VIES_WSDL_URL, log: false, follow_redirects: true
+        }.merge(@options[:savon] || {}))
       end
 
-      def message_tag
-        :checkVat
+      def message
+        {
+          country_code: @vat.vat_country_code,
+          vat_number: @vat.to_s_wo_country
+        }.merge(@requester ? {
+            requester_country_code: @requester.vat_country_code,
+            requester_vat_number: @requester.to_s_wo_country
+          } : {}
+        )
       end
 
-      def action
-        :check_vat
+      def message_tag
+        @requester ? :checkVatApprox : :checkVat
       end
 
-      def response_key
-        :check_vat_response
+      def action
+        @requester ? :check_vat_approx : :check_vat
       end
     end
   end

data/lib/valvat/lookup/response.rb

@@ -0,0 +1,36 @@
+class Valvat
+  class Lookup
+    class Response
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def [](key)
+        to_hash[key]
+      end
+
+      def to_hash
+        @hash ||= self.class.cleanup(@raw.to_hash)
+      end
+
+      private
+
+      def self.cleanup(hash)
+        (hash[:check_vat_approx_response] || hash[:check_vat_response] || {}).inject({}) do |hash, (key, value)|
+          hash[cleanup_key(key)] = cleanup_value(value) unless key == :"@xmlns"
+          hash
+        end
+      end
+
+      TRADER_PREFIX = /\Atrader_/
+
+      def self.cleanup_key(key)
+        key.to_s.sub(TRADER_PREFIX, "").to_sym
+      end
+
+      def self.cleanup_value(value)
+        value == "---" ? nil : value
+      end
+    end
+  end
+end

data/lib/valvat/utils.rb

@@ -1,15 +1,19 @@
+require 'date'
+
 class Valvat
   module Utils
 
-    EU_COUNTRIES = %w(AT BE BG CY CZ DE DK EE ES FI FR GB GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK)
+    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)
+    SUPPORTED_STATES = EU_MEMBER_STATES + %w(GB)
+    EU_COUNTRIES = EU_MEMBER_STATES # TODO: Remove constant
     COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/
-    NORMALIZE_PATTERN = /[-\.:_\s,;]+/
+    NORMALIZE_PATTERN = /[[:space:][:punct:][:cntrl:]]+/
 
     def self.split(vat)
       COUNTRY_PATTERN =~ vat
       result = [$1, $2]
       iso_country = vat_country_to_iso_country(result[0])
-      EU_COUNTRIES.include?(iso_country) ? result : [nil, nil]
+      country_is_supported?(iso_country) ? result : [nil, nil]
     end
 
     def self.normalize(vat)
@@ -23,5 +27,9 @@ class Valvat
     def self.iso_country_to_vat_country(iso_country)
       iso_country == "GR" ? "EL" : iso_country
     end
+
+    def self.country_is_supported?(iso_country)
+      SUPPORTED_STATES.include?(iso_country)
+    end
   end
 end

data/lib/valvat/version.rb

@@ -1,3 +1,3 @@
 class Valvat
-  VERSION = "0.8.1"
+  VERSION = "1.0.1"
 end

data/spec/active_model/validations/valvat_validator_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 
 if defined?(ActiveModel)
   class Invoice < ModelBase
-    validates :vat_number, :valvat => true
+    validates :vat_number, valvat: true
   end
 
   class InvoiceWithLookup < ModelBase
-    validates :vat_number, :valvat => {:lookup => true}
+    validates :vat_number, valvat: {lookup: true}
   end
 
   class InvoiceWithLookupAndFailIfDown < ModelBase
-    validates :vat_number, :valvat => {:lookup => :fail_if_down}
+    validates :vat_number, valvat: {lookup: :fail_if_down}
   end
 
   class InvoiceAllowBlank < ModelBase
-    validates :vat_number, :valvat => {:allow_blank => true}
+    validates :vat_number, valvat: {allow_blank: true}
   end
 
   class InvoiceAllowBlankOnAll < ModelBase
-    validates :vat_number, :valvat => true, :allow_blank => true
+    validates :vat_number, valvat: true, allow_blank: true
   end
 
   class InvoiceCheckCountry < ModelBase
-    validates :vat_number, :valvat => {:match_country => :country}
+    validates :vat_number, valvat: {match_country: :country}
 
     def country
       @attributes[:country]
@@ -30,7 +30,7 @@ if defined?(ActiveModel)
   end
 
   class InvoiceCheckCountryWithLookup < ModelBase
-    validates :vat_number, :valvat => {:match_country => :country, :lookup => true}
+    validates :vat_number, valvat: {match_country: :country, lookup: true}
 
     def country
       @attributes[:country]
@@ -38,18 +38,22 @@ if defined?(ActiveModel)
   end
 
   class InvoiceWithChecksum < ModelBase
-    validates :vat_number, :valvat => {:checksum => true}
+    validates :vat_number, valvat: {checksum: true}
   end
 
   describe Invoice do
-    context "with valid vat number" do
+    before do
+      I18n.locale = :en
+    end
+
+    context "with valid VAT number" do
       it "should be valid" do
-        expect(Invoice.new(:vat_number => "DE259597697")).to be_valid
+        expect(Invoice.new(vat_number: "DE259597697")).to be_valid
       end
     end
 
-    context "with invalid vat number" do
-      let(:invoice) { Invoice.new(:vat_number => "DE259597697123") }
+    context "with invalid VAT number" do
+      let(:invoice) { Invoice.new(vat_number: "DE259597697123") }
 
       it "should not be valid" do
         expect(invoice).not_to be_valid
@@ -57,13 +61,35 @@ if defined?(ActiveModel)
 
       it "should add default (country specific) error message" do
         invoice.valid?
-        expect(invoice.errors[:vat_number]).to eql(["is not a valid German vat number"])
+        expect(invoice.errors[:vat_number]).to eql(["is not a valid German VAT number"])
+      end
+
+      context "on DE locale" do
+        before do
+          I18n.locale = :de
+        end
+
+        it "should add translated error message" do
+          invoice.valid?
+          expect(invoice.errors[:vat_number]).to eql(["ist keine gültige deutsche USt-IdNr."])
+        end
+      end
+
+      context "on PT locale" do
+        before do
+          I18n.locale = :pt
+        end
+
+        it "should add translated error message" do
+          invoice.valid?
+          expect(invoice.errors[:vat_number]).to eql(["O NIF alemão não é válido."])
+        end
       end
 
       context "with i18n translation in place" do
         before do
-          I18n.backend.store_translations(:en, :activemodel => {
-            :errors => {:models => {:invoice => {:invalid_vat => "is ugly."}}}
+          I18n.backend.store_translations(:en, activemodel: {
+            errors: {models: {invoice: {invalid_vat: "is ugly."}}}
           })
         end
 
@@ -77,165 +103,165 @@ if defined?(ActiveModel)
 
       context "with i18n translation with country adjective placeholder in place" do
         before do
-          I18n.backend.store_translations(:en, :activemodel => {
-            :errors => {:models => {:invoice => {:invalid_vat => "is not a %{country_adjective} vat"}}}
+          I18n.backend.store_translations(:en, activemodel: {
+            errors: {models: {invoice: {invalid_vat: "is not a %{country_adjective} vat"}}}
           })
         end
 
         after { I18n.reload! }
 
         it "should replace country adjective placeholder" do
-          invoice = Invoice.new(:vat_number => "IE123")
+          invoice = Invoice.new(vat_number: "IE123")
           invoice.valid?
           expect(invoice.errors[:vat_number]).to eql(["is not a Irish vat"])
         end
 
         it "should fall back to 'European' if country is missing" do
-          invoice = Invoice.new(:vat_number => "XX123")
+          invoice = Invoice.new(vat_number: "XX123")
           invoice.valid?
           expect(invoice.errors[:vat_number]).to eql(["is not a European vat"])
         end
       end
     end
 
-    context "with blank vat number" do
+    context "with blank VAT number" do
       it "should not be valid" do
-        expect(Invoice.new(:vat_number => "")).not_to be_valid
-        expect(Invoice.new(:vat_number => nil)).not_to be_valid
+        expect(Invoice.new(vat_number: "")).not_to be_valid
+        expect(Invoice.new(vat_number: nil)).not_to be_valid
       end
     end
   end
 
   describe InvoiceWithLookup do
-    context "with valid but not existing vat number" do
+    context "with valid but not existing VAT number" do
       before do
-        allow(Valvat::Syntax).to receive_messages(:validate => true)
-        allow(Valvat::Lookup).to receive_messages(:validate => false)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: false)
       end
 
       it "should not be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).not_to be_valid
+        expect(InvoiceWithLookup.new(vat_number: "DE123")).not_to be_valid
       end
     end
 
-    context "with valid and existing vat number" do
+    context "with valid and existing VAT number" do
       before do
-        allow(Valvat::Syntax).to receive_messages(:validate => true)
-        allow(Valvat::Lookup).to receive_messages(:validate => true)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: true)
       end
 
       it "should be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).to be_valid
+        expect(InvoiceWithLookup.new(vat_number: "DE123")).to be_valid
       end
     end
 
-    context "with valid vat number and VIES country service down" do
+    context "with valid VAT number and VIES country service down" do
       before do
-        allow(Valvat::Syntax).to receive_messages(:validate => true)
-        allow(Valvat::Lookup).to receive_messages(:validate => nil)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: nil)
       end
 
       it "should be valid" do
-        expect(InvoiceWithLookup.new(:vat_number => "DE123")).to be_valid
+        expect(InvoiceWithLookup.new(vat_number: "DE123")).to be_valid
       end
     end
   end
 
   describe InvoiceWithLookupAndFailIfDown do
-    context "with valid vat number and VIES country service down" do
+    context "with valid VAT number and VIES country service down" do
       before do
-        allow(Valvat::Syntax).to receive_messages(:validate => true)
-        allow(Valvat::Lookup).to receive_messages(:validate => nil)
+        allow(Valvat::Syntax).to receive_messages(validate: true)
+        allow(Valvat::Lookup).to receive_messages(validate: nil)
       end
 
       it "should not be valid" do
-        expect(InvoiceWithLookupAndFailIfDown.new(:vat_number => "DE123")).not_to be_valid
+        expect(InvoiceWithLookupAndFailIfDown.new(vat_number: "DE123")).not_to be_valid
       end
     end
   end
 
   describe InvoiceAllowBlank do
-    context "with blank vat number" do
+    context "with blank VAT number" do
       it "should be valid" do
-        expect(InvoiceAllowBlank.new(:vat_number => "")).to be_valid
-        expect(InvoiceAllowBlank.new(:vat_number => nil)).to be_valid
+        expect(InvoiceAllowBlank.new(vat_number: "")).to be_valid
+        expect(InvoiceAllowBlank.new(vat_number: nil)).to be_valid
       end
     end
   end
 
   describe InvoiceAllowBlankOnAll do
-    context "with blank vat number" do
+    context "with blank VAT number" do
       it "should be valid" do
-        expect(InvoiceAllowBlankOnAll.new(:vat_number => "")).to be_valid
-        expect(InvoiceAllowBlankOnAll.new(:vat_number => nil)).to be_valid
+        expect(InvoiceAllowBlankOnAll.new(vat_number: "")).to be_valid
+        expect(InvoiceAllowBlankOnAll.new(vat_number: nil)).to be_valid
       end
     end
   end
 
   describe InvoiceCheckCountry do
     it "should be not valid on blank country" do
-      expect(InvoiceCheckCountry.new(:country => nil, :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "", :vat_number => "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: nil, vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "", vat_number: "DE259597697")).not_to be_valid
     end
 
     it "should be not valid on wired country" do
-      expect(InvoiceCheckCountry.new(:country => "XAXXX", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "ZO", :vat_number => "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "XAXXX", vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "ZO", vat_number: "DE259597697")).not_to be_valid
     end
 
     it "should be not valid on mismatching (eu) country" do
-      expect(InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "AT", :vat_number => "DE259597697")).not_to be_valid
-      expect(InvoiceCheckCountry.new(:country => "DE", :vat_number => "ATU65931334")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "FR", vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "AT", vat_number: "DE259597697")).not_to be_valid
+      expect(InvoiceCheckCountry.new(country: "DE", vat_number: "ATU65931334")).not_to be_valid
     end
 
     it "should be valid on matching country" do
-      expect(InvoiceCheckCountry.new(:country => "DE", :vat_number => "DE259597697")).to be_valid
-      expect(InvoiceCheckCountry.new(:country => "AT", :vat_number => "ATU65931334")).to be_valid
+      expect(InvoiceCheckCountry.new(country: "DE", vat_number: "DE259597697")).to be_valid
+      expect(InvoiceCheckCountry.new(country: "AT", vat_number: "ATU65931334")).to be_valid
     end
 
     it "should give back error message with country from :country_match" do
-      invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")
+      invoice = InvoiceCheckCountry.new(country: "FR", vat_number: "DE259597697")
       invoice.valid?
-      expect(invoice.errors[:vat_number]).to eql(["is not a valid French vat number"])
+      expect(invoice.errors[:vat_number]).to eql(["is not a valid French VAT number"])
     end
 
-    it "should give back error message with country from :country_match even on invalid vat number" do
-      invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697123")
+    it "should give back error message with country from :country_match even on invalid VAT number" do
+      invoice = InvoiceCheckCountry.new(country: "FR", vat_number: "DE259597697123")
       invoice.valid?
-      expect(invoice.errors[:vat_number]).to eql(["is not a valid French vat number"])
+      expect(invoice.errors[:vat_number]).to eql(["is not a valid French VAT number"])
     end
   end
 
   describe InvoiceCheckCountryWithLookup do
     before do
-      allow(Valvat::Syntax).to receive_messages(:validate => true)
-      allow(Valvat::Lookup).to receive_messages(:validate => true)
+      allow(Valvat::Syntax).to receive_messages(validate: true)
+      allow(Valvat::Lookup).to receive_messages(validate: true)
     end
 
     it "avoids lookup or syntax check on failed because of mismatching country" do
       expect(Valvat::Syntax).not_to receive(:validate)
       expect(Valvat::Lookup).not_to receive(:validate)
-      InvoiceCheckCountryWithLookup.new(:country => "FR", :vat_number => "DE259597697").valid?
+      InvoiceCheckCountryWithLookup.new(country: "FR", vat_number: "DE259597697").valid?
     end
 
     it "check syntax and looup on matching country" do
       expect(Valvat::Syntax).to receive(:validate).and_return(true)
       expect(Valvat::Lookup).to receive(:validate).and_return(true)
-      InvoiceCheckCountryWithLookup.new(:country => "DE", :vat_number => "DE259597697").valid?
+      InvoiceCheckCountryWithLookup.new(country: "DE", vat_number: "DE259597697").valid?
     end
   end
 
   describe InvoiceWithChecksum do
-    context "with valid vat number" do
+    context "with valid VAT number" do
       it "should be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597697")).to be_valid
+        expect(InvoiceWithChecksum.new(vat_number: "DE259597697")).to be_valid
       end
     end
 
-    context "with invalid vat number" do
+    context "with invalid VAT number" do
       it "should not be valid" do
-        expect(InvoiceWithChecksum.new(:vat_number => "DE259597687")).not_to be_valid
+        expect(InvoiceWithChecksum.new(vat_number: "DE259597687")).not_to be_valid
       end
     end
   end