├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── composer.json
├── phpunit.xml.dist
├── src
    └── NifValidator.php
└── tests
    └── NifValidatorTest.php


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | .idea/
3 | composer.lock


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | php:
 3 |   - 7.0
 4 |   - 7.1
 5 |   - 7.2
 6 |   - 7.3
 7 |   - 7.4
 8 |   - 8.0
 9 |   - 8.1
10 | 
11 | before_script: composer install
12 | script: vendor/bin/phpunit
13 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2011-2017 Ulabox SL
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # nif-validator
 2 | 
 3 | [![Build Status](https://api.travis-ci.org/ulabox/nif-validator.png?branch=master)](http://travis-ci.org/ulabox/nif-validator)
 4 | 
 5 | A modern PHP 7.0+ Spanish NIF (Número de Indentifación Fiscal) validator.
 6 | 
 7 | ## Why another NIF validator? 
 8 | 
 9 | Other NIF validators we saw either had really obscure code or just implemented a validator for the DNI/NIE, not the CIF. 
10 | 
11 | ## Installation
12 | 
13 | Using Composer:
14 | 
15 | ```
16 | composer require ulabox/nif-validator
17 | ```
18 | 
19 | ## Usage
20 | 
21 | 
22 | ```php
23 | <?php
24 | 
25 | use NifValidator\NifValidator;
26 | 
27 | //CIF
28 | assert(NifValidator::isValid('B65410011'));
29 | //DNI
30 | assert(NifValidator::isValid('93471790C'));
31 | //NIE
32 | assert(NifValidator::isValid('X5102754C'));
33 | 
34 | ```
35 | 
36 | Starting from version 1.1.x you can also separetely validate personal and entity nifs
37 | 
38 | ```php
39 | <?php
40 | 
41 | use NifValidator\NifValidator;
42 | 
43 | //CIF
44 | assert(NifValidator::isValidEntity('B65410011'));
45 | //DNI
46 | assert(NifValidator::isValidPersonal('93471790C'));
47 | //NIE
48 | assert(NifValidator::isValidPersonal('X5102754C'));
49 | 
50 | ```
51 | 
52 | Starting from version 1.2.x you can also separetely validate individual nif types
53 | 
54 | ```php
55 | <?php
56 | 
57 | use NifValidator\NifValidator;
58 | 
59 | //CIF
60 | assert(NifValidator::isValidCif('B65410011'));
61 | //DNI
62 | assert(NifValidator::isValidDni('93471790C'));
63 | //NIE
64 | assert(NifValidator::isValidNie('X5102754C'));
65 | 
66 | 
67 | This validator does not strip or uppercase any character, it's your responsibility to previously filter the input.
68 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "ulabox/nif-validator",
 3 |     "description": "Yet another(?) PHP implementation of the spanish NIF validator",
 4 |     "keywords": ["NIF", "validator"],
 5 |     "homepage": "https://github.com/ulabox/nif-validator",
 6 |     "type": "library",
 7 |     "license": "MIT",
 8 |     "authors": [
 9 |         {
10 |             "name": "Albert Casademont",
11 |             "email": "albert@ulabox.com"
12 |         }
13 |     ],
14 |     "require": {
15 |         "php": ">=7.0"
16 |     },
17 |     "require-dev": {
18 |         "phpunit/phpunit": "~6.2"
19 |     },
20 |     "autoload": {
21 |         "psr-4": {
22 |             "NifValidator\\": "src/"
23 |         }
24 |     },
25 |     "autoload-dev": {
26 |         "psr-4": {
27 |             "NifValidator\\": "tests/"
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |          xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.5/phpunit.xsd"
 5 |          backupGlobals="false"
 6 |          colors="true"
 7 |          bootstrap="vendor/autoload.php"
 8 | >
 9 |     <testsuites>
10 |         <testsuite name="Ulabox NifValidator Test Suite">
11 |             <directory>./tests/</directory>
12 |         </testsuite>
13 |     </testsuites>
14 | 
15 |     <filter>
16 |         <whitelist>
17 |             <directory>./tests/</directory>
18 |         </whitelist>
19 |     </filter>
20 | </phpunit>


--------------------------------------------------------------------------------
/src/NifValidator.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace NifValidator;
  4 | 
  5 | class NifValidator
  6 | {
  7 |     const NIE_TYPES = 'XYZ';
  8 |     const DNINIE_CHECK_TABLE = 'TRWAGMYFPDXBNJZSQVHLCKE';
  9 | 
 10 |     const NIF_TYPES_WITH_LETTER_CHECK = 'PQSW';
 11 |     const NIF_TYPES_WITH_NUMBER_CHECK = 'ABEH';
 12 | 
 13 |     const NIF_LETTER_CHECK_TABLE = 'JABCDEFGHI';
 14 | 
 15 |     const DNI_REGEX = '#^(?<number>[0-9]{8})(?<check>[A-Z])$#';
 16 |     const NIE_REGEX = '#^(?<type>['. self::NIE_TYPES .'])(?<number>[0-9]{7})(?<check>[A-Z])$#';
 17 |     const OTHER_PERSONAL_NIF_REGEX = '#^(?<type>[KLM])(?<number>[0-9]{7})(?<check>[0-9A-Z])$#';
 18 |     const CIF_REGEX = '#^(?<type>[ABCDEFGHJNPQRSUVW])(?<number>[0-9]{7})(?<check>[0-9A-Z])$#';
 19 | 
 20 |     /**
 21 |      * Validate Spanish NIFS
 22 |      * Input is not uppercased, or stripped of any incorrect characters
 23 |      */
 24 |     public static function isValid(string $nif): bool
 25 |     {
 26 |         return self::isValidDni($nif) || self::isValidNie($nif) || self::isValidCif($nif) || self::isValidOtherPersonalNif($nif);
 27 |     }
 28 | 
 29 |     /**
 30 |      * Validate Spanish NIFS given to persons
 31 |      */
 32 |     public static function isValidPersonal(string $nif): bool
 33 |     {
 34 |         return self::isValidDni($nif) || self::isValidNie($nif) || self::isValidOtherPersonalNif($nif);
 35 |     }
 36 | 
 37 |     /**
 38 |      * Validate Spanish NIFS given to non-personal entities (e.g. companies, public corporations, ngos...)
 39 |      */
 40 |     public static function isValidEntity(string $nif): bool
 41 |     {
 42 |         return self::isValidCif($nif);
 43 |     }
 44 | 
 45 |     /**
 46 |      * DNI validation is pretty straight forward.
 47 |      * Just mod 23 the 8 digit number and compare it to the check table
 48 |      */
 49 |     public static function isValidDni(string $dni): bool
 50 |     {
 51 |         if (!preg_match(self::DNI_REGEX, $dni, $matches)) {
 52 |             return false;
 53 |         }
 54 |         if ('00000000' === $matches['number']) {
 55 |             return false;
 56 |         }
 57 | 
 58 |         return self::DNINIE_CHECK_TABLE[$matches['number'] % 23] === $matches['check'];
 59 |     }
 60 | 
 61 |     /**
 62 |      * NIE validation is similar to the DNI.
 63 |      * The first letter needs an equivalent number before the mod operation
 64 |      */
 65 |     public static function isValidNie(string $nie): bool
 66 |     {
 67 |         if (!preg_match(self::NIE_REGEX, $nie, $matches)) {
 68 |             return false;
 69 |         }
 70 | 
 71 |         $nieType = strpos(self::NIE_TYPES, $matches['type']);
 72 |         $nie = $nieType . $matches['number'];
 73 | 
 74 |         return self::DNINIE_CHECK_TABLE[$nie % 23] === $matches['check'];
 75 |     }
 76 | 
 77 |     /**
 78 |      * Other personal NIFS are meant for temporary residents that do not qualify for a NIE but nonetheless need a NIF
 79 |      *
 80 |      * See references
 81 |      *
 82 |      * @see https://es.wikipedia.org/wiki/N%C3%BAmero_de_identificaci%C3%B3n_fiscal
 83 |      * @see https://es.wikipedia.org/wiki/C%C3%B3digo_de_identificaci%C3%B3n_fiscal
 84 |      */
 85 |     public static function isValidOtherPersonalNif(string $nif): bool
 86 |     {
 87 |         if (!preg_match(self::OTHER_PERSONAL_NIF_REGEX, $nif, $matches)) {
 88 |             return false;
 89 |         }
 90 | 
 91 |         return self::isValidNifCheck($nif, $matches);
 92 |     }
 93 | 
 94 |     /**
 95 |      * CIFS are only meant for non-personal entities
 96 |      *
 97 |      * See references
 98 |      *
 99 |      * @see https://es.wikipedia.org/wiki/N%C3%BAmero_de_identificaci%C3%B3n_fiscal
100 |      * @see https://es.wikipedia.org/wiki/C%C3%B3digo_de_identificaci%C3%B3n_fiscal
101 |      */
102 |     public static function isValidCif(string $cif): bool
103 |     {
104 |         if (!preg_match(self::CIF_REGEX, $cif, $matches)) {
105 |             return false;
106 |         }
107 | 
108 |         return self::isValidNifCheck($cif, $matches);
109 |     }
110 | 
111 |     private static function isValidNifCheck(string $nif, array $matches): bool
112 |     {
113 |         $split = str_split($matches['number']);
114 | 
115 |         $even = array_filter($split, function($key) {
116 |             return $key & 1;
117 |         }, ARRAY_FILTER_USE_KEY);
118 |         $sumEven = array_sum($even);
119 | 
120 |         $odd = array_filter($split, function($key) {
121 |             return !($key & 1);
122 |         }, ARRAY_FILTER_USE_KEY);
123 |         $sumOdd = array_reduce($odd, function($carry, $item) {
124 |             return $carry + array_sum(str_split($item * 2));
125 |         });
126 | 
127 |         $calculatedCheckDigit = (10 - ($sumEven + $sumOdd) % 10) % 10;
128 | 
129 |         //Nifs with only letters
130 |         if (self::nifHasLetterCheck($matches['type'], $nif)) {
131 |             return self::checkNifLetter($calculatedCheckDigit, $matches['check']);
132 |         }
133 | 
134 |         //Nifs with only numbers
135 |         if (self::nifHasNumberCheck($matches['type'], $nif)) {
136 |             return self::checkNifNumber($calculatedCheckDigit, $matches['check']);
137 |         }
138 | 
139 |         //Nifs that accept both
140 |         return
141 |             self::checkNifLetter($calculatedCheckDigit, $matches['check'])
142 |             || self::checkNifNumber($calculatedCheckDigit, $matches['check'])
143 |             ;
144 |     }
145 | 
146 |     private static function nifHasLetterCheck(string $nifType, string $nif): bool
147 |     {
148 |         return
149 |             false !== strpos(self::NIF_TYPES_WITH_LETTER_CHECK, $nifType)
150 |             || ('0' === $nif[0] && '0' === $nif[1])
151 |             ;
152 |     }
153 | 
154 |     private static function checkNifLetter(int $calculatedCheckDigit, string $checkDigit): bool
155 |     {
156 |         return self::NIF_LETTER_CHECK_TABLE[$calculatedCheckDigit] === $checkDigit;
157 |     }
158 | 
159 |     private static function nifHasNumberCheck(string $nifType, string $nif): bool
160 |     {
161 |         return false !== strpos(self::NIF_TYPES_WITH_NUMBER_CHECK, $nifType);
162 |     }
163 | 
164 |     private static function checkNifNumber(string $calculatedCheckDigit, string $checkDigit): bool
165 |     {
166 |         return $calculatedCheckDigit === $checkDigit;
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/tests/NifValidatorTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace NifValidator;
  4 | 
  5 | use PHPUnit\Framework\TestCase;
  6 | 
  7 | class NifValidatorTest extends TestCase
  8 | {
  9 |     /**
 10 |      * @dataProvider validPersonalNifs
 11 |      * @dataProvider validEntityNifs
 12 |      */
 13 |     public function testValidNif(string $nif)
 14 |     {
 15 |         self::assertTrue(NifValidator::isValid($nif));
 16 |     }
 17 | 
 18 |     /**
 19 |      * @dataProvider invalidNifs
 20 |      * @dataProvider invalidPersonalNifs
 21 |      * @dataProvider invalidEntityNifs
 22 |      */
 23 |     public function testInvalidNif(string $nif)
 24 |     {
 25 |         self::assertFalse(NifValidator::isValid($nif));
 26 |     }
 27 | 
 28 |     /**
 29 |      * @dataProvider validPersonalNifs
 30 |      */
 31 |     public function testValidPersonalNif(string $nif)
 32 |     {
 33 |         self::assertTrue(NifValidator::isValidPersonal($nif));
 34 |     }
 35 | 
 36 |     /**
 37 |      * @dataProvider invalidPersonalNifs
 38 |      * @dataProvider validEntityNifs
 39 |      */
 40 |     public function testInvalidPersonalNif(string $nif)
 41 |     {
 42 |         self::assertFalse(NifValidator::isValidPersonal($nif));
 43 |     }
 44 | 
 45 |     /**
 46 |      * @dataProvider validDnis
 47 |      */     
 48 |     public function testValidDni(string $nif)
 49 |     {
 50 |         self::assertTrue(NifValidator::isValidDni($nif));
 51 |     }
 52 | 
 53 |     /**
 54 |      * @dataProvider invalidDnis
 55 |      */     
 56 |     public function testInvalidDni(string $nif)
 57 |     {
 58 |         self::assertFalse(NifValidator::isValidDni($nif));
 59 |     }
 60 | 
 61 |     /**
 62 |      * @dataProvider validNies
 63 |      */     
 64 |     public function testValidNie(string $nif)
 65 |     {
 66 |         self::assertTrue(NifValidator::isValidNie($nif));
 67 |     }
 68 | 
 69 |     /**
 70 |      * @dataProvider invalidNies
 71 |      */     
 72 |     public function testInvalidNie(string $nif)
 73 |     {
 74 |         self::assertFalse(NifValidator::isValidNie($nif));
 75 |     }
 76 | 
 77 |     /**
 78 |      * @dataProvider validOtherNifs
 79 |      */     
 80 |     public function testValidOtherNif(string $nif)
 81 |     {
 82 |         self::assertTrue(NifValidator::isValidOtherPersonalNif($nif));
 83 |     }
 84 | 
 85 |     /**
 86 |      * @dataProvider invalidOtherNifs
 87 |      */     
 88 |     public function testInvalidOtherNif(string $nif)
 89 |     {
 90 |         self::assertFalse(NifValidator::isValidOtherPersonalNif($nif));
 91 |     }
 92 | 
 93 |     /**
 94 |      * @dataProvider validEntityNifs
 95 |      */
 96 |     public function testValidEntityNif(string $nif)
 97 |     {
 98 |         self::assertTrue(NifValidator::isValidEntity($nif));
 99 |     }
100 | 
101 |     /**
102 |      * @dataProvider invalidEntityNifs
103 |      * @dataProvider validPersonalNifs
104 |      */
105 |     public function testInvalidEntityNif(string $nif)
106 |     {
107 |         self::assertFalse(NifValidator::isValidEntity($nif));
108 |     }
109 | 
110 |     /**
111 |      * @dataProvider validEntityNifs
112 |      */
113 |     public function testValidCif(string $nif)
114 |     {
115 |         self::assertTrue(NifValidator::isValidCif($nif));
116 |     }
117 | 
118 |     /**
119 |      * @dataProvider invalidEntityNifs
120 |      * @dataProvider validPersonalNifs
121 |      */
122 |     public function testInvalidCif(string $nif)
123 |     {
124 |         self::assertFalse(NifValidator::isValidCif($nif));
125 |     }
126 | 
127 |     public function invalidNifs()
128 |     {
129 |         return [
130 |             //Garbage
131 |             ['AAAAAAAAA'],
132 |             ['999999999'],
133 |             ['BBBBB'],
134 |             ['1'],
135 |             ['93471790C0'],
136 |             ['00000000T'],
137 |         ];
138 |     }
139 | 
140 |     public function validDnis()
141 |     {
142 |         return [
143 |             //DNI
144 |             ['93471790C'],
145 |             ['43596386R'],
146 |             ['00000010X'],
147 |         ];        
148 |     }
149 | 
150 |     public function invalidDnis()
151 |     {
152 |         return [
153 |             //DNI
154 |             ['93471790A'],
155 |             ['43596386B'],
156 |             ['00000010Y'],
157 |         ];        
158 |     }
159 | 
160 |     public function validNies()
161 |     {
162 |         return [
163 |             //NIE
164 |             ['X5102754C'],
165 |             ['Z8327649K'],
166 |             ['Y4174455S'],
167 |         ];
168 |     }
169 | 
170 |     public function invalidNies()
171 |     {
172 |         //NIE
173 |         return [
174 |             ['X5102754A'],
175 |             ['Z8327649B'],
176 |             ['Y4174455C'],        
177 |         ];
178 |     }
179 | 
180 |     public function validOtherNifs()
181 |     {
182 |         return [
183 |             //Other NIF
184 |             ['K9514336H'],            
185 |         ];
186 |     }
187 | 
188 |     public function invalidOtherNifs()
189 |     {
190 |         //Other NIF
191 |         return [
192 |             ['M3118299M'],                
193 |         ];
194 |     }
195 | 
196 |     public function validPersonalNifs()    
197 |     {        
198 |         return array_merge($this->validDnis(), $this->validNies(), $this->validOtherNifs());
199 |     }
200 | 
201 |     public function invalidPersonalNifs()
202 |     {
203 |         return array_merge($this->invalidDnis(), $this->invalidNies(), $this->invalidOtherNifs());
204 |     }
205 | 
206 |     public function validEntityNifs()
207 |     {
208 |         return [
209 |             //CIF
210 |             ['A58818501'],
211 |             ['B65410011'],
212 |             ['V7565938C'],
213 |             ['V75659383'],
214 |             ['F0605378I'],
215 |             ['Q2238877A'],
216 |             ['D40022956'],
217 |         ];
218 |     }
219 | 
220 |     public function invalidEntityNifs()
221 |     {
222 |         return [
223 |             //CIF
224 |             ['A5881850B'],
225 |             ['B65410010'],
226 |             ['V75659382'],
227 |             ['V7565938B'],
228 |             ['F06053787'],
229 |             ['Q22388770'],
230 |             ['D4002295J'],
231 |         ];
232 |     }
233 | }
234 | 


--------------------------------------------------------------------------------