Argentiniškas CUIT/CUIL generatorius ir validatorius

Įvadas

Argentiniškas CUIT (Clave Única de Identificación Tributaria) ir CUIL (Clave Única de Identificación Laboral) yra unikalūs identifikavimo numeriai, naudojami Argentinoje mokesčių ir darbo tikslais. Šie 11 skaitmenų kodai yra būtini asmenims ir įmonėms, kad teisėtai veiktų Argentinos ekonomikos sistemoje. Mūsų CUIT/CUIL generatorius ir validatorius suteikia paprastą ir efektyvų būdą generuoti galiojančius CUIT/CUIL numerius testavimo tikslais ir patikrinti esamus numerius, kad užtikrintume, jog jie atitinka oficialų formatą ir patikros algoritmą.

Ar esate kūrėjas, testuojantis programas, kurios tvarko Argentinos mokesčių ID, QA specialistas, tikrinantis sistemos funkcionalumą, ar tiesiog norite suprasti, kaip veikia šie identifikavimo numeriai, šis įrankis siūlo paprastą sprendimą be nereikalingų sudėtingumų. Įrankis turi dvi pagrindines funkcijas: generatorių, kuris atsitiktinai sukuria galiojančius CUIT/CUIL numerius arba remiasi specifiniais parametrais, ir validatorių, kuris tikrina, ar pateiktas CUIT/CUIL numeris atitinka teisingą formatą ir skaičiavimo taisykles.

CUIT/CUIL struktūra ir skaičiavimas

Formatų supratimas

Galiojantis CUIT/CUIL numeris susideda iš 11 skaitmenų, paprastai rodomų formatu XX-XXXXXXXX-X:

Tipų kodas (pirmi 2 skaitmenys): Nurodo subjekto tipą
- 20, 23, 24: Vyrų asmenys (CUIL)
- 27: Moterų asmenys (CUIL)
- 30, 33, 34: Įmonės ir organizacijos (CUIT)
DNI numeris (viduriniai 8 skaitmenys): Asmenims tai yra jų nacionalinio tapatybės dokumento numeris (DNI), jei reikia, papildytas pirmaujančiais nuliais, kad pasiektų 8 skaitmenis. Įmonėms tai yra unikalus priskirtas numeris.
Patikros skaitmuo (paskutinis skaitmuo): Patikros skaitmuo, apskaičiuotas naudojant specifinį algoritmą, kad patvirtintų visą numerį.

Patikros skaitmens skaičiavimas

Patikros skaitmuo skaičiuojamas naudojant šį algoritmą:

Paimkite pirmus 10 CUIT/CUIL skaitmenų (tipų kodas + DNI)
Kiekvieną skaitmenį padauginkite iš atitinkamo svorio iš šios sekos: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Sudėkite visus gautus produktus
Apskaičiuokite 11 minus likutį, dalijant sumą iš 11
Jei rezultatas yra 11, patikros skaitmuo yra 0
Jei rezultatas yra 10, patikros skaitmuo yra 9
Kitaip, rezultatas yra patikros skaitmuo

Matematiškai tai galima išreikšti taip:

$VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)$

Kur:

$VD$ yra patikros skaitmuo
$d_i$ yra $i$ -asis pirmųjų 10 skaitmenų
$w_i$ yra atitinkamas svoris iš sekos [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Specialūs atvejai: jei $VD = 11$ , tada $VD = 0$ , jei $VD = 10$ , tada $VD = 9$

Žingsnis po žingsnio vadovas

Naudojantis generatoriumi

Pasirinkite "Generatorius" skirtuką įrankio sąsajos viršuje.
Pasirinkite tipų kodą iš išskleidžiamojo meniu:
- 20: Vyras (CUIL)
- 23: Įmonė (CUIT)
- 24: Laikina įmonė (CUIT)
- 27: Moteris (CUIL)
- 30: Korporacija (CUIT)
- 33: Civilinė asociacija (CUIT)
- 34: Fondas (CUIT)
Įveskite DNI numerį (pasirinktinai):
- Įveskite 8 skaitmenų DNI numerį pateiktoje srityje
- Jei paliksite tuščią, įrankis naudos atsitiktinai sugeneruotą DNI
- Jei įvesite mažiau nei 8 skaitmenis, sistema papildys pirmaujančiais nuliais
Generuoti atsitiktinį DNI (pasirinktinai):
- Spustelėkite "Atsitiktinis" mygtuką, kad sugeneruotumėte atsitiktinį 8 skaitmenų DNI numerį
Peržiūrėkite sugeneruotą CUIT/CUIL:
- Įrankis automatiškai rodo galiojantį CUIT/CUIL pagal jūsų įvestis
- Formatavimas bus XX-XXXXXXXX-X su teisingu patikros skaitmeniu
Kopijuokite rezultatą:
- Spustelėkite kopijavimo ikoną, kad nukopijuotumėte sugeneruotą CUIT/CUIL į savo iškarpinę
- Patvirtinimo pranešimas pasirodys, kai sėkmingai nukopijuota

Naudojantis validatoriumi

Pasirinkite "Validatorius" skirtuką įrankio sąsajos viršuje.
Įveskite CUIT/CUIL, kurį norite patikrinti:
- Įveskite CUIT/CUIL formatu XX-XXXXXXXX-X
- Įrankis automatiškai suformatuos jūsų įvestį su brūkšneliais, kai rašysite
- Taip pat galite įvesti numerį be brūkšnelių (XXXXXXXXXXX)
Spustelėkite "Patvirtinti" mygtuką:
- Įrankis patikrins formatą, tipų kodą ir patikros skaitmenį
Peržiūrėkite patikros rezultatą:
- Galiojantiems CUIT/CUIL numeriams pasirodys žalia sėkmės žinutė
- Negaliojantiems numeriams pasirodys raudona klaidos žinutė, paaiškinanti problemą:
  - Neteisingas formatas (turi būti XX-XXXXXXXX-X)
  - Neteisingas tipų kodas (turi būti vienas iš: 20, 23, 24, 27, 30, 33, 34)
  - Neteisingas patikros skaitmuo
Papildoma informacija:
- Galiojantiems numeriams įrankis rodo komponentų išskaidymą:
  - Tipų kodas ir jo reikšmė
  - DNI numeris
  - Patikros skaitmuo

Naudojimo atvejai

Plėtra ir testavimas

Programinės įrangos plėtra: Generuokite galiojančius CUIT/CUIL numerius, kad testuotumėte programas, kurios tvarko Argentinos mokesčių identifikavimą, pavyzdžiui:
- E. prekybos platformos
- Apskaitos programinė įranga
- Žmogiškųjų išteklių valdymo sistemos
- Vyriausybes paslaugų portalai
- Bankininkystės programos
Duomenų bazės užpildymas: Sukurkite realistiškus testavimo duomenis sistemoms, kurios saugo Argentinos vartotojų informaciją, užtikrindami, kad duomenų bazės apribojimai ir patikros taisyklės veiktų teisingai.
Formų patikros testavimas: Išbandykite įvesties patikrą žiniatinklio formose, kurios renka CUIT/CUIL informaciją, patikrinant, ar tinkamos klaidos žinutės pasirodo neteisingiems įrašams.
API testavimas: Generuokite galiojančius krovinius API galams, kuriems reikia CUIT/CUIL numerių, užtikrindami, kad jūsų integracijos testai naudotų galiojančius duomenis.
QA automatizavimas: Įtraukite CUIT/CUIL generavimą į automatizuotus testavimo scenarijus, kad sukurtumėte dinamiškus testavimo atvejus, o ne naudotumėte statinius testavimo duomenis.

Švietimo tikslai

Patikros algoritmų mokymasis: Supraskite, kaip veikia patikros skaitmenų algoritmai praktikoje, stebėdami CUIT/CUIL patikros procesą.
Duomenų patikros mokymas: Naudokite kaip švietimo pavyzdį, mokydami formų patikros technikų naujus programuotojus.
Argentinos verslo reikalavimų supratimas: Sužinokite apie identifikavimo sistemą, naudojamą Argentinoje, tarptautinio verslo plėtrai.

Alternatyvos

Nors mūsų įrankis teikia paprastą būdą generuoti ir patikrinti CUIT/CUIL numerius, yra alternatyvūs metodai, kuriuos galite apsvarstyti:

Oficiali vyriausybinė patikra: Produkcijos aplinkose visada patikrinkite CUIT/CUIL numerius su oficialia AFIP (Administración Federal de Ingresos Públicos) duomenų baze, kai tai įmanoma.
Bibliotekos ir paketai: Kelios programavimo kalbos turi bibliotekas, specialiai sukurtas Argentinos mokesčių ID patikrai:
- JavaScript: validar-cuit npm paketas
- PHP: afip-php biblioteka
- Python: py-cuit paketas
Rankinis skaičiavimas: Švietimo tikslais galite rankiniu būdu apskaičiuoti patikros skaitmenį, naudodami anksčiau aprašytą algoritmą.
Išsamios verslo patikros paslaugos: Įmonių programoms apsvarstykite galimybę naudoti išsamias patikros paslaugas, kurios ne tik patikrina formatą, bet ir patvirtina, ar subjektas, susijęs su CUIT/CUIL, yra egzistuojantis ir aktyvus.

CUIT/CUIL sistemos istorija

CUIT/CUIL identifikavimo sistema Argentinoje nuo savo įkūrimo žymiai išsivystė:

Kilmė ir įgyvendinimas

CUIT (Clave Única de Identificación Tributaria) pirmą kartą buvo pristatytas Argentinoje 1970-aisiais, kaip dalis pastangų modernizuoti mokesčių surinkimo sistemą. Federalinė mokesčių administracija (AFIP) įgyvendino šį unikalų identifikatorių, kad efektyviau stebėtų mokesčių mokėtojus ir sumažintų mokesčių vengimą.

CUIL (Clave Única de Identificación Laboral) vėliau buvo pristatytas, kad specialiai identifikuotų darbuotojus socialinės apsaugos sistemoje, sukuriant skirtumą tarp mokesčių identifikavimo ir darbo identifikavimo, išlaikant nuoseklų formatą.

Raida ir skaitmeninimas

1990-aisiais, kai Argentina patyrė reikšmingų ekonominių reformų, CUIT/CUIL sistema tapo vis svarbesnė stebint ekonominę veiklą. Sistema buvo toliau skaitmenizuota, o internetinės patikros sistemos buvo įdiegtos.

Antrąjį 2000-ųjų dešimtmetį CUIT/CUIL sistema buvo integruota su įvairiomis skaitmeninėmis vyriausybinėmis paslaugomis, padarant ją esminiu Argentinos e-vyriausybes iniciatyvų komponentu. Šiame laikotarpyje taip pat buvo standartizuotas patikros algoritmo ir formato, kuris išlieka naudojamas iki šiol, procesas.

Naujausi pokyčiai

Pastaraisiais metais AFIP pagerino CUIT/CUIL numerių saugumo ir patikros procesus, įdiegdama sudėtingesnes patikros sistemas ir integruodama jas su kitomis vyriausybinėmis duomenų bazėmis. Sistema dabar atlieka svarbų vaidmenį Argentinos pastangose kovoti su mokesčių vengimu ir formalizuoti ekonomiką.

Šiandien CUIT/CUIL naudojamas ne tik mokesčių ir darbo tikslais, bet ir įvairiose veiklose, įskaitant bankininkystę, nekilnojamojo turto sandorius, komunalines paslaugas ir internetinius pirkimus, todėl jis yra esminis identifikatorius tiek asmenims, tiek įmonėms, veikiančioms Argentinoje.

Kodo pavyzdžiai

Python

1def calculate_verification_digit(type_code, dni):
2    # Paversti į string ir užtikrinti, kad DNI būtų 8 skaitmenys su pirmaujančiais nuliais
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Sujungti tipų kodą ir DNI
7    digits = type_code_str + dni_str
8    
9    # Svoriai kiekvienai pozicijai
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Apskaičiuoti produktų sumą
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Apskaičiuoti patikros skaitmenį
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Specialūs atvejai
19    if verification_digit == 11:
20        verification_digit = 0
21    elif verification_digit == 10:
22        verification_digit = 9
23    
24    return verification_digit
25
26def generate_cuit_cuil(type_code, dni=None):
27    import random
28    
29    # Galimi tipų kodai
30    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
31    
32    if type_code not in valid_type_codes:
33        raise ValueError(f"Neteisingas tipų kodas. Turi būti vienas iš: {valid_type_codes}")
34    
35    # Generuoti atsitiktinį DNI, jei nepateiktas
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Apskaičiuoti patikros skaitmenį
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatuoti CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Pašalinti brūkšnelius, jei yra
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Patikrinti pagrindinį formatą
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Neteisingas formatas"
52    
53    # Išskirti dalis
54    type_code = int(cuit_cuil_clean[0:2])
55    dni = int(cuit_cuil_clean[2:10])
56    verification_digit = int(cuit_cuil_clean[10])
57    
58    # Patikrinti tipų kodą
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Neteisingas tipų kodas"
62    
63    # Apskaičiuoti ir palyginti patikros skaitmenį
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Neteisingas patikros skaitmuo"
67    
68    return True, "Galiojantis CUIT/CUIL"
69
70# Pavyzdžio naudojimas
71print(generate_cuit_cuil(20, 12345678))  # Generuoti konkrečiam DNI
72print(generate_cuit_cuil(27))  # Generuoti su atsitiktiniu DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Patikrinti CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Paversti į string ir užtikrinti, kad DNI būtų 8 skaitmenys su pirmaujančiais nuliais
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Sujungti tipų kodą ir DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Svoriai kiekvienai pozicijai
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Apskaičiuoti produktų sumą
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Apskaičiuoti patikros skaitmenį
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Specialūs atvejai
22  if (verificationDigit === 11) {
23    verificationDigit = 0;
24  } else if (verificationDigit === 10) {
25    verificationDigit = 9;
26  }
27  
28  return verificationDigit;
29}
30
31function generateCuitCuil(typeCode, dni) {
32  // Galimi tipų kodai
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Neteisingas tipų kodas. Turi būti vienas iš: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Generuoti atsitiktinį DNI, jei nepateiktas
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Apskaičiuoti patikros skaitmenį
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatuoti CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Pašalinti brūkšnelius, jei yra
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Patikrinti pagrindinį formatą
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Neteisingas formatas' };
58  }
59  
60  // Išskirti dalis
61  const typeCode = parseInt(cuitCuilClean.substring(0, 2));
62  const dni = parseInt(cuitCuilClean.substring(2, 10));
63  const verificationDigit = parseInt(cuitCuilClean.substring(10, 11));
64  
65  // Patikrinti tipų kodą
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Neteisingas tipų kodas' };
69  }
70  
71  // Apskaičiuoti ir palyginti patikros skaitmenį
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Neteisingas patikros skaitmuo' };
75  }
76  
77  return { isValid: true };
78}
79
80// Pavyzdžio naudojimas
81console.log(generateCuitCuil(20, 12345678)); // Generuoti konkrečiam DNI
82console.log(generateCuitCuil(27)); // Generuoti su atsitiktiniu DNI
83console.log(validateCuitCuil("20-12345678-9")); // Patikrinti CUIT/CUIL
84

Java

1import java.util.Arrays;
2import java.util.List;
3import java.util.Random;
4
5public class CuitCuilUtils {
6    private static final List<Integer> VALID_TYPE_CODES = Arrays.asList(20, 23, 24, 27, 30, 33, 34);
7    private static final int[] WEIGHTS = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
8    
9    public static int calculateVerificationDigit(int typeCode, int dni) {
10        // Paversti į string ir užtikrinti, kad DNI būtų 8 skaitmenys su pirmaujančiais nuliais
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Sujungti tipų kodą ir DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Apskaičiuoti produktų sumą
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Apskaičiuoti patikros skaitmenį
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Specialūs atvejai
27        if (verificationDigit == 11) {
28            verificationDigit = 0;
29        } else if (verificationDigit == 10) {
30            verificationDigit = 9;
31        }
32        
33        return verificationDigit;
34    }
35    
36    public static String generateCuitCuil(int typeCode, Integer dni) {
37        if (!VALID_TYPE_CODES.contains(typeCode)) {
38            throw new IllegalArgumentException("Neteisingas tipų kodas. Turi būti vienas iš: " + VALID_TYPE_CODES);
39        }
40        
41        // Generuoti atsitiktinį DNI, jei nepateiktas
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Apskaičiuoti patikros skaitmenį
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatuoti CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Pašalinti brūkšnelius, jei yra
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Patikrinti pagrindinį formatą
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Neteisingas formatas");
61        }
62        
63        // Išskirti dalis
64        int typeCode = Integer.parseInt(cuitCuilClean.substring(0, 2));
65        int dni = Integer.parseInt(cuitCuilClean.substring(2, 10));
66        int verificationDigit = Integer.parseInt(cuitCuilClean.substring(10, 11));
67        
68        // Patikrinti tipų kodą
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Neteisingas tipų kodas");
71        }
72        
73        // Apskaičiuoti ir palyginti patikros skaitmenį
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Neteisingas patikros skaitmuo");
77        }
78        
79        return new ValidationResult(true, null);
80    }
81    
82    public static class ValidationResult {
83        private final boolean isValid;
84        private final String errorMessage;
85        
86        public ValidationResult(boolean isValid, String errorMessage) {
87            this.isValid = isValid;
88            this.errorMessage = errorMessage;
89        }
90        
91        public boolean isValid() {
92            return isValid;
93        }
94        
95        public String getErrorMessage() {
96            return errorMessage;
97        }
98    }
99    
100    public static void main(String[] args) {
101        // Pavyzdžio naudojimas
102        System.out.println(generateCuitCuil(20, 12345678)); // Generuoti konkrečiam DNI
103        System.out.println(generateCuitCuil(27, null)); // Generuoti su atsitiktiniu DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Patikrinti CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Paversti į string ir užtikrinti, kad DNI būtų 8 skaitmenys su pirmaujančiais nuliais
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Sujungti tipų kodą ir DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Svoriai kiekvienai pozicijai
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Apskaičiuoti produktų sumą
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Apskaičiuoti patikros skaitmenį
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Specialūs atvejai
24    if ($verificationDigit == 11) {
25        $verificationDigit = 0;
26    } else if ($verificationDigit == 10) {
27        $verificationDigit = 9;
28    }
29    
30    return $verificationDigit;
31}
32
33function generateCuitCuil($typeCode, $dni = null) {
34    // Galimi tipų kodai
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Neteisingas tipų kodas. Turi būti vienas iš: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Generuoti atsitiktinį DNI, jei nepateiktas
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Apskaičiuoti patikros skaitmenį
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatuoti CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Pašalinti brūkšnelius, jei yra
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Patikrinti pagrindinį formatą
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Neteisingas formatas'];
60    }
61    
62    // Išskirti dalis
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Patikrinti tipų kodą
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Neteisingas tipų kodas'];
71    }
72    
73    // Apskaičiuoti ir palyginti patikros skaitmenį
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Neteisingas patikros skaitmuo'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Pavyzdžio naudojimas
83echo generateCuitCuil(20, 12345678) . "\n"; // Generuoti konkrečiam DNI
84echo generateCuitCuil(27) . "\n"; // Generuoti su atsitiktiniu DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Patikrinti CUIT/CUIL
86?>
87

Dažnai užduodami klausimai

Koks skirtumas tarp CUIT ir CUIL?

CUIT (Clave Única de Identificación Tributaria) naudojamas mokesčių identifikavimui ir priskiriamas tiek asmenims, tiek juridiniams asmenims, kurie turi mokėti mokesčius Argentinoje. CUIL (Clave Única de Identificación Laboral) yra specialiai skirtas darbuotojams ir naudojamas darbo ir socialinės apsaugos tikslais. Nors jie turi tą patį formatą ir skaičiavimo algoritmą, jie atlieka skirtingas administracines funkcijas.

Kurie tipų kodai naudojami asmenims, o kurie įmonėms?

Asmenims:

20, 23, 24: Vyrų asmenys (CUIL)
27: Moterų asmenys (CUIL)

Įmonėms ir organizacijoms:

30: Korporacijos (CUIT)
33: Civilinės asociacijos (CUIT)
34: Fondai (CUIT)

Kaip apskaičiuojamas patikros skaitmuo?

Patikros skaitmuo skaičiuojamas naudojant svorinę sumos algoritmą. Kiekvienas iš pirmųjų 10 skaitmenų padauginamas iš atitinkamo svorio (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), o rezultatai sudedami. Patikros skaitmuo yra 11 minus likutis, dalijant šią sumą iš 11. Specialūs atvejai: jei rezultatas yra 11, patikros skaitmuo yra 0; jei rezultatas yra 10, patikros skaitmuo yra 9.

Ar galiu naudoti šį įrankį generuoti realius, oficialius CUIT/CUIL numerius?

Ne, šis įrankis skirtas tik testavimo ir švietimo tikslais. Sugeneruoti numeriai yra matematiškai galiojantys pagal CUIT/CUIL algoritmą, tačiau jie nėra oficialiai registruoti Argentinos mokesčių institucijoje (AFIP). Oficialiam CUIT/CUIL registravimui asmenys ir įmonės turi laikytis tinkamų teisinių procedūrų per AFIP.

Kodėl mano CUIT/CUIL patikra nepavyksta, nors formatas atrodo teisingas?

Patikra gali nepavykti dėl kelių priežasčių:

Tipų kodas nėra vienas iš galiojančių kodų (20, 23, 24, 27, 30, 33, 34)
Patikros skaitmuo nesutampa su apskaičiuotu vertinimu pagal algoritmą
Formatavimas yra neteisingas (turi būti XX-XXXXXXXX-X)
Įrašuose yra ne skaitmeninių simbolių (išskyrus brūkšnelius)

Ar brūkšneliai yra būtini CUIT/CUIL numeriuose?

Nors CUIT/CUIL numeriai dažnai rašomi ir rodomi su brūkšneliais (XX-XXXXXXXX-X), brūkšneliai nėra dalis tikrojo skaičiaus skaičiavimo tikslais. Mūsų validatorius priima abu formatus (su arba be brūkšnelių) ir tinkamai patikrina bet kurį formatą.

Ar CUIT/CUIL numeris gali turėti mažiau nei 8 skaitmenis DNI dalyje?

Ne, DNI dalis visada turi būti tiksliai 8 skaitmenys. Jei tikrasis DNI turi mažiau skaitmenų, jis turi būti papildytas pirmaujančiais nuliais, kad pasiektų 8 skaitmenis. Pavyzdžiui, jei kieno nors DNI yra 1234567, CUIT/CUIL jis būtų pateiktas kaip 01234567.

Kaip galiu patikrinti, ar CUIT/CUIL oficialiai registruotas Argentinoje?

Norėdami patikrinti, ar CUIT/CUIL yra oficialiai registruotas ir aktyvus, turėtumėte naudoti oficialią AFIP (Administración Federal de Ingresos Públicos) svetainę arba paslaugas. Mūsų įrankis tik patikrina matematinį numerio galiojimą, o ne jo oficialų registracijos statusą.

Ar galiu naudoti šį įrankį savo komercinėje programoje?

Taip, galite integruoti algoritmą ir logiką, parodytą šiame įrankyje, į savo komercines programas. CUIT/CUIL patikros algoritmas yra vieša norma. Tačiau produkcijos aplinkose rekomenduojame įgyvendinti tinkamą klaidų tvarkymą ir apsvarstyti papildomą patikrą su oficialiais šaltiniais, kai tai būtina.

Ar įrankis saugo kuriuos nors sugeneruotus ar patikrintus CUIT/CUIL numerius?

Ne, šis įrankis nesaugo jokios įvestos ar sugeneruotos informacijos. Visi apdorojimai vykdomi kliento pusėje jūsų naršyklėje, o jokie duomenys nėra siunčiami ar saugomi mūsų serveriuose. Tai užtikrina bet kurios įvestos informacijos privatumą ir saugumą.

Nuorodos

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Oficialioji svetainė. https://www.afip.gob.ar/
Ministerio de Trabajo, Empleo y Seguridad Social. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Gauti mano CUIL." https://www.anses.gob.ar/
Oficialus Argentinos Respublikos biuletenis. "AFIP 2854/2010 rezoliucija: Procedūra. Clave Única de Identificación Tributaria (C.U.I.T.)."
Argentinos Respublikos mokesčių kodeksas. "Identifikavimas ir registracija mokesčių mokėtojų."

Pasiruošę generuoti ar patikrinti Argentinos CUIT/CUIL numerius? Išbandykite mūsų įrankį dabar ir supaprastinkite savo testavimo procesą!

Argentinos CUIT/CUIL generatorius ir validatorius

CUIT/CUIL generatorius

Sugeneruotas CUIT/CUIL

Dokumentacija