Argentiina CUIT/CUIL generaator ja valideerija

Sissejuhatus

Argentiina CUIT (Clave Única de Identificación Tributaria) ja CUIL (Clave Única de Identificación Laboral) on unikaalsed identifitseerimisnumbrid, mida kasutatakse Argentiinas maksude ja tööalaste eesmärkide jaoks. Need 11-kohalised koodid on hädavajalikud, et isikud ja ettevõtted saaksid seaduslikult tegutseda Argentiina majandussüsteemis. Meie CUIT/CUIL generaatori ja valideerija tööriist pakub lihtsat ja tõhusat viisi kehtivate CUIT/CUIL numbrite genereerimiseks testimise eesmärkidel ning olemasolevate numbrite valideerimiseks, et tagada nende vastavus ametlikule formaadile ja kontrollimise algoritmile.

Olenemata sellest, kas olete arendaja, kes testib rakendusi, mis käsitlevad Argentiina maksutunnuseid, QA spetsialist, kes kontrollib süsteemi funktsionaalsust, või lihtsalt vajate arusaamist, kuidas need identifitseerimisnumbrid töötavad, pakub see tööriist lihtsat lahendust ilma liigsete keerukusteta. Tööriistal on kaks peamist funktsiooni: generaator, mis loob kehtivaid CUIT/CUIL numbreid juhuslikult või konkreetsete parameetrite põhjal, ja valideerija, mis kontrollib, kas antud CUIT/CUIL number järgib õiget formaati ja arvutusreegleid.

CUIT/CUIL struktuur ja arvutamine

Formaadi mõistmine

Kehtiv CUIT/CUIL number koosneb 11 numbrist, mis on tavaliselt esitatud formaadis XX-XXXXXXXX-X:

Tüüp kood (esimesed 2 numbrit): Näitab üksuse tüüpi
- 20, 23, 24: Mehed (CUIL)
- 27: Naised (CUIL)
- 30, 33, 34: Ettevõtted ja organisatsioonid (CUIT)
DNI number (keskmised 8 numbrit): Isikute puhul on see nende rahvuslik identiteedidokument (DNI), millele on vajadusel lisatud eesnumbrit, et jõuda 8 numbrini. Ettevõtete puhul on see unikaalselt määratud number.
Kontrollimisnumber (viimane number): Kontrollnumber, mis arvutatakse spetsiifilise algoritmi abil, et valideerida kogu number.

Kontrollimisnumbrite arvutamine

Kontrollimisnumber arvutatakse järgmise algoritmi abil:

Võtke CUIT/CUIL esimesed 10 numbrit (tüüp kood + DNI)
Korrutage iga number vastava kaalu järgi järgmisest järjestusest: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Summeerige kõik saadud korrutised
Arvutage 11 miinus jääk, kui summa jagada 11-ga
Kui tulemus on 11, on kontrollimisnumber 0
Kui tulemus on 10, on kontrollimisnumber 9
Muul juhul on tulemus kontrollimisnumber

Matemaatiliselt saab seda väljendada järgmiselt:

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

Kus:

$VD$ on kontrollimisnumber
$d_i$ on $i$ -ne number esimesest 10 numbrist
$w_i$ on vastav kaal järjestusest [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Erilised juhtumid: kui $VD = 11$ , siis $VD = 0$ , kui $VD = 10$ , siis $VD = 9$

Samm-sammuline juhend

Generaatori kasutamine

Valige tööriista liidese ülaosas "Generaatori" vahekaart.
Valige rippmenüüst tüüp kood:
- 20: Mees (CUIL)
- 23: Ettevõte (CUIT)
- 24: Ajutine ettevõte (CUIT)
- 27: Naine (CUIL)
- 30: Korporatsioon (CUIT)
- 33: Tsiviiliühing (CUIT)
- 34: Sihtasutus (CUIT)
Sisestage DNI number (valikuline):
- Sisestage antud väljal 8-kohaline DNI number
- Kui see jääb tühjaks, kasutab tööriist juhuslikult genereeritud DNI
- Kui sisestate vähem kui 8 numbrit, täidab süsteem eesnumbrit
Genereeri juhuslik DNI (valikuline):
- Klõpsake nuppu "Juhuslik", et genereerida juhuslik 8-kohaline DNI number
Vaadake genereeritud CUIT/CUIL:
- Tööriist kuvab automaatselt kehtiva CUIT/CUIL vastavalt teie sisenditele
- Formaat on XX-XXXXXXXX-X koos õige kontrollimisnumbriga
Kopeerige tulemus:
- Klõpsake kopeerimise ikoonil, et kopeerida genereeritud CUIT/CUIL oma lõikepuhvrisse
- Kinnitamismärge kuvatakse, kui kopeerimine on edukalt toimunud

Valideerija kasutamine

Valige tööriista liidese ülaosas "Valideerija" vahekaart.
Sisestage valideeritav CUIT/CUIL:
- Sisestage CUIT/CUIL formaadis XX-XXXXXXXX-X
- Tööriist vormindab teie sisendi automaatselt hüülikutega, kui te kirjutate
- Samuti võite numbreid sisestada ilma hüülikuteta (XXXXXXXXXXX)
Klõpsake nuppu "Valideeri":
- Tööriist kontrollib formaati, tüüp koodi ja kontrollimisnumbrit
Vaadake valideerimise tulemust:
- Kehtivate CUIT/CUIL numbrite puhul kuvatakse roheline edusammude sõnum
- Kehtetute numbrite puhul kuvatakse punane veateade, mis selgitab probleemi:
  - Vale formaat (peab olema XX-XXXXXXXX-X)
  - Vale tüüp kood (peab olema üks järgmistest: 20, 23, 24, 27, 30, 33, 34)
  - Vale kontrollimisnumber
Lisainformatsioon:
- Kehtivate numbrite puhul kuvab tööriist komponentide jaotuse:
  - Tüüp kood ja selle tähendus
  - DNI number
  - Kontrollimisnumber

Kasutuse juhtumid

Arendus ja testimine

Tarkvaraarendus: Generaator kehtivate CUIT/CUIL numbrite loomiseks rakenduste testimiseks, mis käsitlevad Argentiina maksutunnuseid, nagu:
- E-kaubanduse platvormid
- Raamatupidamisprogrammid
- HR haldustooted
- Valitsuse teenuste portaalid
- Pangandusrakendused
Andmebaasi täitmine: Looge realistlik testandmestik süsteemide jaoks, mis salvestavad Argentiina kasutaja teavet, tagades, et andmebaasi piirangud ja valideerimisreeglid töötavad õigesti.
Vormide valideerimise testimine: Testige sisendi valideerimist veebivormides, mis koguvad CUIT/CUIL teavet, kontrollides, et vale sisendi korral kuvatakse õiged veateated.
API testimine: Generaator kehtivate koormuste loomiseks API lõpp-punktide jaoks, mis nõuavad CUIT/CUIL numbreid, tagades, et teie integratsioonitestid kasutavad kehtivat teavet.
QA automatiseerimine: Integreerige CUIT/CUIL genereerimine automatiseeritud testiskripti, et luua dünaamilisi testjuhte, mitte kasutada staatilisi testandmeid.

Hariduslikud eesmärgid

Kontrollimisalgoritmide õppimine: Mõistke, kuidas kontrollimisnumbrite algoritmid praktikas töötavad, nägemiseks CUIT/CUIL valideerimisprotsessi tegevuses.
Andmete valideerimise õpetamine: Kasutage hariduslikku näidet, kui õpetate uutelt arendajatelt vormide valideerimise tehnikaid.
Argentiina äri nõuete mõistmine: Tutvuge Argentiinas kasutatava identifitseerimissüsteemiga rahvusvahelise äriarenduse jaoks.

Alternatiivid

Kuigi meie tööriist pakub lihtsat viisi CUIT/CUIL numbrite genereerimiseks ja valideerimiseks, võiksite kaaluda ka alternatiivseid lähenemisviise:

Ametlik valiidimine: Tootmis keskkondades valideerige alati CUIT/CUIL numbreid ametliku AFIP (Administración Federal de Ingresos Públicos) andmebaasi vastu, kui see on võimalik.
Raamatukogud ja paketid: Mitmed programmeerimiskeeled omavad raamatukogusid, mis on spetsiaalselt loodud Argentiina maksutunnuste valideerimiseks:
- JavaScript: validar-cuit npm pakett
- PHP: afip-php raamatukogu
- Python: py-cuit pakett
Käsitsi arvutamine: Hariduslikel eesmärkidel võite arvutada kontrollimisnumbrit käsitsi, kasutades eespool kirjeldatud algoritmi.
Kohandatud äri valideerimisteenused: Ettevõtte rakenduste jaoks kaaluge terviklikke valideerimisteenuseid, mis mitte ainult ei kontrolli formaati, vaid ka valideerivad CUIT/CUIL-ga seotud üksuse olemasolu ja staatust.

CUIT/CUIL süsteemi ajalugu

CUIT/CUIL identifitseerimissüsteem Argentiinas on alates selle loomisest oluliselt arenenud:

Algused ja rakendamine

CUIT (Clave Única de Identificación Tributaria) tutvustati esmakordselt Argentiinas 1970. aastatel osana jõupingutustest moderniseerida maksukogumise süsteemi. Föderaalse Maksuhalduri (AFIP) rakendatud see unikaalne identifikaator, et jälgida maksumaksjaid tõhusamalt ja vähendada maksupettusi.

Hiljem tutvustati CUIL-i (Clave Única de Identificación Laboral), et tuvastada töötajaid sotsiaalkindlustussüsteemis, luues eristuse maksutuvastuse ja tööalase identifitseerimise vahel, säilitades samas ühtse formaadi.

Aja jooksul ja digitaliseerimine

aastatel, kui Argentiina läbis olulisi majandusreforme, muutus CUIT/CUIL süsteem üha olulisemaks majandustegevuse jälgimisel. Süsteem digitaliseeriti veelgi ja rakendati veebipõhiseid valideerimissüsteeme.
aastate alguses integreeriti CUIT/CUIL süsteem mitmete digitaalsete valitsusteenustega, muutes selle Argentiina e-valitsuse algatuste oluliseks osaks. Selle perioodi jooksul standardiseeriti ka kontrollimisalgoritm ja formaat, mis on tänapäeval kasutusel.

Viimased arengud

Viimastel aastatel on AFIP parandanud CUIT/CUIL numbrite turvalisust ja valideerimisprotsesse, rakendades keerukamaid valideerimissüsteeme ja integreerides need teiste valitsuse andmebaasidega. Süsteem mängib nüüd olulist rolli Argentiina püüdlustes võidelda maksupettuste vastu ja formaliseerida majandust.

Tänapäeval kasutatakse CUIT/CUIL numbreid mitte ainult maksude ja tööalaste eesmärkide jaoks, vaid ka laia valikut tegevusi, sealhulgas pangandust, kinnisvaratehinguid, utiliiditeenuseid ja veebipõhiseid oste, muutes selle hädavajalikuks identifikaatoriks nii isikutele kui ka ettevõtetele, kes tegutsevad Argentiinas.

Koodinäited

Python

1def calculate_verification_digit(type_code, dni):
2    # Muuda stringiks ja veendu, et DNI on 8 numbrit eesnumbritena
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Ühenda tüüp kood ja DNI
7    digits = type_code_str + dni_str
8    
9    # Kaalu järjestus iga positsiooni jaoks
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Arvuta toodete summa
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Arvuta kontrollimisnumber
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Erilised juhtumid
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    # Kehtivad tüüp koodid
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"Vale tüüp kood. Peab olema üks järgmistest: {valid_type_codes}")
34    
35    # Genereeri juhuslik DNI, kui see pole antud
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Arvuta kontrollimisnumber
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formaat CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Eemalda hüülikud, kui need on olemas
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Kontrolli põhiformaati
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Vale formaat"
52    
53    # Eemalda osad
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    # Valideeri tüüp kood
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Vale tüüp kood"
62    
63    # Arvuta ja võrdle kontrollimisnumber
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Vale kontrollimisnumber"
67    
68    return True, "Kehtiv CUIT/CUIL"
69
70# Näide kasutamisest
71print(generate_cuit_cuil(20, 12345678))  # Generaator konkreetse DNI jaoks
72print(generate_cuit_cuil(27))  # Generaator juhusliku DNI jaoks
73print(validate_cuit_cuil("20-12345678-9"))  # Valideeri CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Muuda stringiks ja veendu, et DNI on 8 numbrit eesnumbritena
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Ühenda tüüp kood ja DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Kaalu järjestus iga positsiooni jaoks
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Arvuta toodete summa
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Arvuta kontrollimisnumber
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Erilised juhtumid
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  // Kehtivad tüüp koodid
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Vale tüüp kood. Peab olema üks järgmistest: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Genereeri juhuslik DNI, kui see pole antud
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Arvuta kontrollimisnumber
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formaat CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Eemalda hüülikud, kui need on olemas
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Kontrolli põhiformaati
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Vale formaat' };
58  }
59  
60  // Eemalda osad
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  // Valideeri tüüp kood
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Vale tüüp kood' };
69  }
70  
71  // Arvuta ja võrdle kontrollimisnumber
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Vale kontrollimisnumber' };
75  }
76  
77  return { isValid: true };
78}
79
80// Näide kasutamisest
81console.log(generateCuitCuil(20, 12345678)); // Generaator konkreetse DNI jaoks
82console.log(generateCuitCuil(27)); // Generaator juhusliku DNI jaoks
83console.log(validateCuitCuil("20-12345678-9")); // Valideeri 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        // Muuda stringiks ja veendu, et DNI on 8 numbrit eesnumbritena
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Ühenda tüüp kood ja DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Arvuta toodete summa
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Arvuta kontrollimisnumber
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Erilised juhtumid
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("Vale tüüp kood. Peab olema üks järgmistest: " + VALID_TYPE_CODES);
39        }
40        
41        // Genereeri juhuslik DNI, kui see pole antud
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Arvuta kontrollimisnumber
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formaat CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Eemalda hüülikud, kui need on olemas
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Kontrolli põhiformaati
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Vale formaat");
61        }
62        
63        // Eemalda osad
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        // Valideeri tüüp kood
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Vale tüüp kood");
71        }
72        
73        // Arvuta ja võrdle kontrollimisnumber
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Vale kontrollimisnumber");
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        // Näide kasutamisest
102        System.out.println(generateCuitCuil(20, 12345678)); // Generaator konkreetse DNI jaoks
103        System.out.println(generateCuitCuil(27, null)); // Generaator juhusliku DNI jaoks
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Valideeri CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Muuda stringiks ja veendu, et DNI on 8 numbrit eesnumbritena
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Ühenda tüüp kood ja DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Kaalu järjestus iga positsiooni jaoks
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Arvuta toodete summa
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Arvuta kontrollimisnumber
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Erilised juhtumid
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    // Kehtivad tüüp koodid
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Vale tüüp kood. Peab olema üks järgmistest: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Genereeri juhuslik DNI, kui see pole antud
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Arvuta kontrollimisnumber
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formaat CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Eemalda hüülikud, kui need on olemas
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Kontrolli põhiformaati
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Vale formaat'];
60    }
61    
62    // Eemalda osad
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Valideeri tüüp kood
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Vale tüüp kood'];
71    }
72    
73    // Arvuta ja võrdle kontrollimisnumber
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Vale kontrollimisnumber'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Näide kasutamisest
83echo generateCuitCuil(20, 12345678) . "\n"; // Generaator konkreetse DNI jaoks
84echo generateCuitCuil(27) . "\n"; // Generaator juhusliku DNI jaoks
85var_dump(validateCuitCuil("20-12345678-9")); // Valideeri CUIT/CUIL
86?>
87

Korduma kippuvad küsimused

Mis vahe on CUIT-il ja CUIL-il?

CUIT (Clave Única de Identificación Tributaria) kasutatakse maksutuvastuse eesmärkidel ning seda määratakse nii isikutele kui ka juriidilistele isikutele, kes peavad Argentiinas makse maksma. CUIL (Clave Única de Identificación Laboral) on spetsiaalselt töötajate jaoks ja seda kasutatakse töö- ja sotsiaalkindlustuse eesmärkidel. Kuigi neil on sama formaat ja arvutusalgoritm, teenivad nad erinevaid halduslikke eesmärke.

Milliseid tüüp koode kasutatakse isikute ja ettevõtete jaoks?

Isikute jaoks:

20, 23, 24: Mehed (CUIL)
27: Naised (CUIL)

Ettevõtete ja organisatsioonide jaoks:

30: Korporatsioonid (CUIT)
33: Tsiviiliühingud (CUIT)
34: Sihtasutused (CUIT)

Kuidas kontrollimisnumber arvutatakse?

Kontrollimisnumber arvutatakse kaalutud summa algoritmi abil. Iga esimese 10 numbri puhul korrutatakse vastava kaalu (5, 4, 3, 2, 7, 6, 5, 4, 3, 2) järgi ja tulemused summeeritakse. Kontrollimisnumber on 11 miinus jääk, kui see summa jagatakse 11-ga. Erilised juhtumid: kui tulemus on 11, on kontrollimisnumber 0; kui tulemus on 10, on kontrollimisnumber 9.

Kas ma saan seda tööriista kasutada reaalse, ametliku CUIT/CUIL numbri genereerimiseks?

Ei, see tööriist on mõeldud ainult testimise ja hariduslikel eesmärkidel. Genereeritud numbrid on matemaatiliselt kehtivad vastavalt CUIT/CUIL algoritmile, kuid need ei ole ametlikult registreeritud Argentiina maksuhalduri (AFIP) juures. Ametliku CUIT/CUIL registreerimise jaoks peavad isikud ja ettevõtted järgima õigeid seaduslikke protseduure AFIP-i kaudu.

Miks mu CUIT/CUIL valideerimine ebaõnnestub, kuigi formaat näib õige?

Valideerimine võib ebaõnnestuda mitmel põhjusel:

Tüüp kood ei ole üks kehtivatest koodidest (20, 23, 24, 27, 30, 33, 34)
Kontrollimisnumber ei vasta arvutatud väärtusele algoritmi põhjal
Formaat on vale (peab olema XX-XXXXXXXX-X)
Sisendis on mitte-numerilised tähemärgid (välja arvatud hüülikud)

Kas hüülikud on CUIT/CUIL numbrites vajalikud?

Kuigi CUIT/CUIL numbreid kirjutatakse ja esitatakse tavaliselt hüülikutega (XX-XXXXXXXX-X), ei ole hüülikud osa tegelikust numbrist arvutamise eesmärgil. Meie valideerija aktsepteerib mõlemaid formaate (hüülikutega ja ilma) ning valideerib õigesti mõlemat vormingut.

Kas CUIT/CUIL numbril võib olla vähem kui 8 numbrit DNI osas?

Ei, DNI osa peab alati olema täpselt 8 numbrit. Kui tegelik DNI on vähem numbreid, peab see olema eesnumbritena täiendatud, et jõuda 8 numbrini. Näiteks, kui kellegi DNI on 1234567, esitatakse CUIT/CUIL-is see kujul 01234567.

Kuidas saan kontrollida, kas CUIT/CUIL on Argentiinas ametlikult registreeritud?

CUIT/CUIL ametlikuks registreerimiseks ja aktiivsuse kontrollimiseks peaksite kasutama ametlikku AFIP (Administración Federal de Ingresos Públicos) veebisaiti või teenuseid. Meie tööriist kontrollib ainult numbri matemaatilist kehtivust, mitte selle ametlikku registreerimist.

Kas ma saan seda tööriista kasutada oma kaubanduslikus rakenduses?

Jah, saate integreerida selles tööriistas demonstreeritud algoritmi ja loogika oma kaubanduslikesse rakendustesse. CUIT/CUIL valideerimise algoritm on avalik standard. Siiski soovitame tootmis keskkondades rakendada korralikku veakäsitlust ja kaaluda täiendavat valideerimist ametlike allikate vastu, kui see on vajalik.

Kas tööriist salvestab mingeid genereeritud või valideeritud CUIT/CUIL numbreid?

Ei, see tööriist ei salvesta ühtegi sisestatud või genereeritud teavet. Kõik töötlemine toimub kliendi poolel teie brauseris ja ühtegi andmeid ei saadeta ega salvestata meie serveritesse. See tagab teie sisestatud teabe privaatsuse ja turvalisuse.

Viidatud allikad

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Ametlik veebisait. https://www.afip.gob.ar/
Töö-, Töö- ja Sotsiaalkindlustuse Ministeerium. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Saada oma CUIL." https://www.anses.gob.ar/
Argentina Vabariigi Ametlik Teade. "Resolución General AFIP 2854/2010: Protseduur. Clave Única de Identificación Tributaria (C.U.I.T.)."
Argentina Vabariigi Maksukood. "Identifitseerimine ja registreerimine maksukohustuste täitmiseks."

Kas olete valmis genereerima või valideerima Argentiina CUIT/CUIL numbreid? Proovige meie tööriista nüüd ja lihtsustage oma testimisprotsessi!

Argentiina CUIT/CUIL generaatori ja valideerimise tööriist

CUIT/CUIL generaator

Genereeritud CUIT/CUIL

Dokumentatsioon