Argentīnas CUIT/CUIL ģenerators un validētājs

Ievads

Argentīnas CUIT (Clave Única de Identificación Tributaria) un CUIL (Clave Única de Identificación Laboral) ir unikāli identifikācijas numuri, kas tiek izmantoti Argentīnā nodokļu un nodarbinātības mērķiem. Šie 11 ciparu kodi ir būtiski, lai indivīdi un uzņēmumi varētu likumīgi darboties Argentīnas ekonomiskajā sistēmā. Mūsu CUIT/CUIL ģeneratora un validētāja rīks piedāvā vienkāršu un efektīvu veidu, kā ģenerēt derīgus CUIT/CUIL numurus testēšanas mērķiem un validēt esošos numurus, lai pārliecinātos, ka tie atbilst oficiālajam formātam un verifikācijas algoritmam.

Neatkarīgi no tā, vai esat izstrādātājs, kurš testē lietojumprogrammas, kas apstrādā Argentīnas nodokļu ID, QA speciālists, kas pārbauda sistēmas funkcionalitāti, vai vienkārši vēlaties saprast, kā šie identifikācijas numuri darbojas, šis rīks piedāvā vienkāršu risinājumu bez nevajadzīgām sarežģījumiem. Rīks piedāvā divas galvenās funkcijas: ģeneratoru, kas rada derīgus CUIT/CUIL numurus nejauši vai, pamatojoties uz specifiskiem parametriem, un validētāju, kas pārbauda, vai dotais CUIT/CUIL numurs atbilst pareizajam formātam un aprēķinu noteikumiem.

CUIT/CUIL struktūra un aprēķins

Formāta izpratne

Derīgs CUIT/CUIL numurs sastāv no 11 cipariem, kas parasti tiek attēloti formātā XX-XXXXXXXX-X:

Veida kods (pirmie 2 cipari): Norāda subjekta veidu
- 20, 23, 24: Vīriešu indivīdi (CUIL)
- 27: Sieviešu indivīdi (CUIL)
- 30, 33, 34: Uzņēmumi un organizācijas (CUIT)
DNI numurs (vidējie 8 cipari): Individuāliem gadījumiem tas ir viņu nacionālā identitātes dokumenta numurs (DNI), kas, ja nepieciešams, ir papildināts ar vadošajiem nullēm, lai sasniegtu 8 ciparus. Uzņēmumiem tas ir unikāls piešķirtais numurs.
Verifikācijas cipars (pēdējais cipars): Pārbaudes cipars, ko aprēķina, izmantojot specifisku algoritmu, lai validētu visu numuru.

Verifikācijas cipara aprēķins

Verifikācijas cipars tiek aprēķināts, izmantojot sekojošu algoritmu:

Paņemiet pirmos 10 ciparus no CUIT/CUIL (veida kods + DNI)
Reiziniet katru ciparu ar atbilstošo svaru no šīs secības: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Sadaliet visus iegūtos produktus
Aprēķiniet 11 mīnus atlikumu no summas, dalot ar 11
Ja rezultāts ir 11, verifikācijas cipars ir 0
Ja rezultāts ir 10, verifikācijas cipars ir 9
Citādi rezultāts ir verifikācijas cipars

Matemātiski to var izteikt kā:

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

Kur:

$VD$ ir verifikācijas cipars
$d_i$ ir $i$ -tais cipars no pirmajiem 10 cipariem
$w_i$ ir atbilstošais svars no secības [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
Īpaši gadījumi: ja $VD = 11$ , tad $VD = 0$ , ja $VD = 10$ , tad $VD = 9$

Soli pa solim ceļvedis

Ģeneratora izmantošana

Izvēlieties "Ģeneratora" cilni rīka saskarnes augšdaļā.
Izvēlieties veida kodu no nolaižamā saraksta:
- 20: Vīriešu (CUIL)
- 23: Uzņēmums (CUIT)
- 24: Pagaidu uzņēmums (CUIT)
- 27: Sieviešu (CUIL)
- 30: Korporācija (CUIT)
- 33: Civila asociācija (CUIT)
- 34: Fonds (CUIT)
Ievadiet DNI numuru (pēc izvēles):
- Ievadiet 8 ciparu DNI numuru norādītajā laukā
- Ja atstājat tukšu, rīks izmantos nejauši ģenerētu DNI
- Ja ievadāt mazāk nekā 8 ciparus, sistēma papildinās ar vadošajām nullēm
Ģenerēt nejaušu DNI (pēc izvēles):
- Noklikšķiniet uz "Nejauši" pogas, lai ģenerētu nejaušu 8 ciparu DNI numuru
Skatiet ģenerēto CUIT/CUIL:
- Rīks automātiski parāda derīgu CUIT/CUIL, pamatojoties uz jūsu ievadiem
- Formāts būs XX-XXXXXXXX-X ar pareizo verifikācijas ciparu
Kopējiet rezultātu:
- Noklikšķiniet uz kopēšanas ikonas, lai kopētu ģenerēto CUIT/CUIL uz jūsu starpliktuvi
- Apstiprinājuma ziņojums parādīsies, kad tas veiksmīgi nokopēts

Validētāja izmantošana

Izvēlieties "Validētāja" cilni rīka saskarnes augšdaļā.
Ievadiet CUIT/CUIL, ko validēt:
- Ievadiet CUIT/CUIL formātā XX-XXXXXXXX-X
- Rīks automātiski formatēs jūsu ievadi ar svītrām, kamēr rakstāt
- Jūs varat arī ievadīt numuru bez svītrām (XXXXXXXXXXX)
Noklikšķiniet uz "Validēt" pogas:
- Rīks pārbaudīs formātu, veida kodu un verifikācijas ciparu
Skatiet validācijas rezultātu:
- Derīgiem CUIT/CUIL numuriem parādīsies zaļš panākumu ziņojums
- Neatbilstošiem numuriem parādīsies sarkans kļūdas ziņojums, kas izskaidro problēmu:
  - Nepareizs formāts (jābūt XX-XXXXXXXX-X)
  - Nepareizs veida kods (jābūt vienam no: 20, 23, 24, 27, 30, 33, 34)
  - Nepareizs verifikācijas cipars
Papildu informācija:
- Derīgiem numuriem rīks parāda komponentu sadalījumu:
  - Veida kods un tā nozīme
  - DNI numurs
  - Verifikācijas cipars

Lietošanas gadījumi

Izstrāde un testēšana

Programmatūras izstrāde: Ģenerējiet derīgus CUIT/CUIL numurus, lai testētu lietojumprogrammas, kas apstrādā Argentīnas nodokļu identifikāciju, piemēram:
- E-komercijas platformas
- Grāmatvedības programmatūra
- HR vadības sistēmas
- Valdības pakalpojumu portāli
- Banku lietojumprogrammas
Datu bāzes apdzīvošana: Izveidojiet reālistiskus testu datus sistēmām, kas glabā Argentīnas lietotāju informāciju, nodrošinot, ka datu bāzes ierobežojumi un validācijas noteikumi darbojas pareizi.
Formu validācijas testēšana: Testējiet ievades validāciju tīmekļa formās, kas apkopo CUIT/CUIL informāciju, pārbaudot, vai pareizi kļūdas ziņojumi parādās nepareiziem ierakstiem.
API testēšana: Ģenerējiet derīgus slodzes datus API galapunktiem, kas prasa CUIT/CUIL numurus, nodrošinot, ka jūsu integrācijas testi izmanto derīgus datus.
QA automatizācija: Iekļaujiet CUIT/CUIL ģenerēšanu automatizētajos testu skriptos, lai izveidotu dinamiskus testu gadījumus, nevis izmantotu statiskus testu datus.

Izglītības mērķi

Validācijas algoritmu mācīšanās: Saprotiet, kā pārbaudes ciparu algoritmi darbojas praksē, redzot CUIT/CUIL verifikācijas procesu darbībā.
Datu validācijas mācīšana: Izmantojiet kā izglītojošu piemēru, mācot formu validācijas tehnikas jaunajiem izstrādātājiem.
Argentīnas biznesa prasību izpratne: Uzziniet par identifikācijas sistēmu, kas tiek izmantota Argentīnā starptautiskās biznesa attīstības nolūkiem.

Alternatīvas

Lai gan mūsu rīks nodrošina vienkāršu veidu, kā ģenerēt un validēt CUIT/CUIL numurus, ir arī alternatīvas pieejas, kuras varat apsvērt:

Oficiālā valdības validācija: Ražošanas vidēs vienmēr validējiet CUIT/CUIL numurus, salīdzinot ar oficiālo AFIP (Administración Federal de Ingresos Públicos) datu bāzi, kad tas ir iespējams.
Bibliotēkas un pakotnes: Dažas programmēšanas valodas ir izstrādājušas bibliotēkas, kas īpaši paredzētas Argentīnas nodokļu ID validācijai:
- JavaScript: validar-cuit npm pakotne
- PHP: afip-php bibliotēka
- Python: py-cuit pakotne
Rokas aprēķins: Izglītības nolūkos varat manuāli aprēķināt verifikācijas ciparu, izmantojot iepriekš aprakstīto algoritmu.
Visaptverošas biznesa validācijas pakalpojumi: Uzņēmuma lietojumprogrammām apsveriet iespēju izmantot visaptverošus validācijas pakalpojumus, kas ne tikai pārbauda formātu, bet arī apstiprina subjekta, kas saistīts ar CUIT/CUIL, esamību un statusu.

CUIT/CUIL sistēmas vēsture

CUIT/CUIL identifikācijas sistēma Argentīnā ir ievērojami attīstījusies kopš tās pirmsākumiem:

Izcelsme un īstenošana

CUIT (Clave Única de Identificación Tributaria) pirmo reizi tika ieviests Argentīnā 1970. gados kā daļa no centieniem modernizēt nodokļu iekasēšanas sistēmu. Federālā ieņēmumu administrācija (AFIP) īstenoja šo unikālo identifikatoru, lai efektīvāk izsekotu nodokļu maksātājus un samazinātu nodokļu izvairīšanos.

CUIL (Clave Única de Identificación Laboral) vēlāk tika ieviests, lai īpaši identificētu darbiniekus sociālās nodrošināšanas sistēmā, radot atšķirību starp nodokļu identifikāciju un darba identifikāciju, vienlaikus saglabājot konsekventu formātu.

Evolūcija un digitalizācija

gados, kad Argentīna piedzīvoja ievērojamas ekonomiskas reformas, CUIT/CUIL sistēma kļuva arvien svarīgāka ekonomiskās aktivitātes izsekošanai. Sistēma tika tālāk digitalizēta, un tika ieviesti tiešsaistes verifikācijas sistēmas.

Agrīnā 2000. gadu periodā CUIT/CUIL sistēma tika integrēta ar dažādiem digitālajiem valdības pakalpojumiem, padarot to par būtisku Argentīnas e-valdības iniciatīvu sastāvdaļu. Šajā periodā tika standartizēts verifikācijas algoritms un formāts, kas joprojām tiek izmantots šodien.

Jaunākie notikumi

Pēdējos gados AFIP ir uzlabojusi CUIT/CUIL numuru drošības un verifikācijas procesus, ieviešot sarežģītākas validācijas sistēmas un integrējot tās ar citām valdības datu bāzēm. Sistēma tagad spēlē nozīmīgu lomu Argentīnas centienos cīnīties pret nodokļu izvairīšanos un formalizēt ekonomiku.

Šodien CUIT/CUIL tiek izmantots ne tikai nodokļu un nodarbinātības mērķiem, bet arī plaša spektra aktivitātēm, tostarp banku, īpašumu darījumiem, komunālo pakalpojumu, un tiešsaistes pirkumu veikšanai, padarot to par būtisku identifikatoru gan indivīdiem, gan uzņēmumiem, kas darbojas Argentīnā.

Koda piemēri

Python

1def calculate_verification_digit(type_code, dni):
2    # Pārvēršam par virkni un nodrošinām, ka DNI ir 8 cipari ar vadošajām nullēm
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Apvienojam veida kodu un DNI
7    digits = type_code_str + dni_str
8    
9    # Svari katrai pozīcijai
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Aprēķinām produktu summu
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Aprēķinām verifikācijas ciparu
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Īpaši gadījumi
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    # Derīgi veida kodi
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"Nederīgs veida kods. Tam jābūt vienam no: {valid_type_codes}")
34    
35    # Ģenerējam nejaušu DNI, ja nav norādīts
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Aprēķinām verifikācijas ciparu
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatējam CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Noņemam svītras, ja tās ir
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Pārbaudām pamata formātu
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Nederīgs formāts"
52    
53    # Izvelkam daļas
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    # Validējam veida kodu
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Nederīgs veida kods"
62    
63    # Aprēķinām un salīdzinām verifikācijas ciparu
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Nederīgs verifikācijas cipars"
67    
68    return True, "Derīgs CUIT/CUIL"
69
70# Piemēra izmantošana
71print(generate_cuit_cuil(20, 12345678))  # Ģenerējam konkrētam DNI
72print(generate_cuit_cuil(27))  # Ģenerējam ar nejaušu DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Validējam CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Pārvēršam par virkni un nodrošinām, ka DNI ir 8 cipari ar vadošajām nullēm
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Apvienojam veida kodu un DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Svari katrai pozīcijai
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Aprēķinām produktu summu
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Aprēķinām verifikācijas ciparu
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Īpaši gadījumi
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  // Derīgi veida kodi
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Nederīgs veida kods. Tam jābūt vienam no: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Ģenerējam nejaušu DNI, ja nav norādīts
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Aprēķinām verifikācijas ciparu
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatējam CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Noņemam svītras, ja tās ir
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Pārbaudām pamata formātu
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Nederīgs formāts' };
58  }
59  
60  // Izvelkam daļas
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  // Validējam veida kodu
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Nederīgs veida kods' };
69  }
70  
71  // Aprēķinām un salīdzinām verifikācijas ciparu
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Nederīgs verifikācijas cipars' };
75  }
76  
77  return { isValid: true };
78}
79
80// Piemēra izmantošana
81console.log(generateCuitCuil(20, 12345678)); // Ģenerējam konkrētam DNI
82console.log(generateCuitCuil(27)); // Ģenerējam ar nejaušu DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validējam 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        // Pārvēršam par virkni un nodrošinām, ka DNI ir 8 cipari ar vadošajām nullēm
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Apvienojam veida kodu un DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Aprēķinām produktu summu
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Aprēķinām verifikācijas ciparu
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Īpaši gadījumi
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("Nederīgs veida kods. Tam jābūt vienam no: " + VALID_TYPE_CODES);
39        }
40        
41        // Ģenerējam nejaušu DNI, ja nav norādīts
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Aprēķinām verifikācijas ciparu
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatējam CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Noņemam svītras, ja tās ir
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Pārbaudām pamata formātu
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Nederīgs formāts");
61        }
62        
63        // Izvelkam daļas
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        // Validējam veida kodu
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Nederīgs veida kods");
71        }
72        
73        // Aprēķinām un salīdzinām verifikācijas ciparu
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Nederīgs verifikācijas cipars");
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        // Piemēra izmantošana
102        System.out.println(generateCuitCuil(20, 12345678)); // Ģenerējam konkrētam DNI
103        System.out.println(generateCuitCuil(27, null)); // Ģenerējam ar nejaušu DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validējam CUIT/CUIL
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Pārvēršam par virkni un nodrošinām, ka DNI ir 8 cipari ar vadošajām nullēm
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Apvienojam veida kodu un DNI
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Svari katrai pozīcijai
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Aprēķinām produktu summu
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Aprēķinām verifikācijas ciparu
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Īpaši gadījumi
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    // Derīgi veida kodi
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Nederīgs veida kods. Tam jābūt vienam no: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Ģenerējam nejaušu DNI, ja nav norādīts
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Aprēķinām verifikācijas ciparu
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formatējam CUIT/CUIL
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Noņemam svītras, ja tās ir
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Pārbaudām pamata formātu
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Nederīgs formāts'];
60    }
61    
62    // Izvelkam daļas
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Validējam veida kodu
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Nederīgs veida kods'];
71    }
72    
73    // Aprēķinām un salīdzinām verifikācijas ciparu
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Nederīgs verifikācijas cipars'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Piemēra izmantošana
83echo generateCuitCuil(20, 12345678) . "\n"; // Ģenerējam konkrētam DNI
84echo generateCuitCuil(27) . "\n"; // Ģenerējam ar nejaušu DNI
85var_dump(validateCuitCuil("20-12345678-9")); // Validējam CUIT/CUIL
86?>
87

Biežāk uzdotie jautājumi

Kāda ir atšķirība starp CUIT un CUIL?

CUIT (Clave Única de Identificación Tributaria) tiek izmantots nodokļu identifikācijas mērķiem un tiek piešķirts gan indivīdiem, gan juridiskām personām, kurām ir jāmaksā nodokļi Argentīnā. CUIL (Clave Única de Identificación Laboral) ir īpaši paredzēts darbinieku identificēšanai sociālās nodrošināšanas sistēmā, radot atšķirību starp nodokļu identifikāciju un darba identifikāciju, vienlaikus saglabājot konsekventu formātu.

Kuri veida kodi tiek izmantoti indivīdiem un kuri uzņēmumiem?

Indivīdiem:

20, 23, 24: Vīriešu indivīdi (CUIL)
27: Sieviešu indivīdi (CUIL)

Uzņēmumiem un organizācijām:

30: Korporācijas (CUIT)
33: Civila asociācijas (CUIT)
34: Fondi (CUIT)

Kā tiek aprēķināts verifikācijas cipars?

Verifikācijas cipars tiek aprēķināts, izmantojot svaru summas algoritmu. Katrs no pirmajiem 10 cipariem tiek reizināts ar atbilstošu svaru (5, 4, 3, 2, 7, 6, 5, 4, 3, 2), un rezultāti tiek summēti. Verifikācijas cipars ir 11 mīnus atlikums, dalot šo summu ar 11. Īpaši gadījumi: ja rezultāts ir 11, verifikācijas cipars ir 0; ja rezultāts ir 10, verifikācijas cipars ir 9.

Vai es varu izmantot šo rīku, lai ģenerētu reālus, oficiālus CUIT/CUIL numurus?

Nē, šis rīks ir paredzēts tikai testēšanai un izglītības mērķiem. Ģenerētie numuri ir matemātiski derīgi saskaņā ar CUIT/CUIL algoritmu, bet tie nav oficiāli reģistrēti Argentīnas nodokļu iestādēs (AFIP). Lai oficiāli reģistrētu CUIT/CUIL, indivīdiem un uzņēmumiem jāievēro pareizās juridiskās procedūras caur AFIP.

Kāpēc mana CUIT/CUIL validācija neizdodas, lai gan formāts izskatās pareizs?

Validācija var neizdoties vairāku iemeslu dēļ:

Veida kods nav viens no derīgajiem kodiem (20, 23, 24, 27, 30, 33, 34)
Verifikācijas cipars neatbilst aprēķinātajai vērtībai, pamatojoties uz algoritmu
Formāts ir nepareizs (jābūt XX-XXXXXXXX-X)
Ievadē ir ne-numeriskas rakstzīmes (izņemot svītras)

Vai svītras ir obligātas CUIT/CUIL numuros?

Lai gan CUIT/CUIL numuri parasti tiek rakstīti un attēloti ar svītrām (XX-XXXXXXXX-X), svītras nav daļa no faktiskā numura aprēķināšanas mērķiem. Mūsu validētājs pieņem abus formātus (ar vai bez svītrām) un pareizi validēs jebkuru formātu.

Vai CUIT/CUIL numuram var būt mazāk nekā 8 cipari DNI daļā?

Nē, DNI daļai vienmēr jābūt precīzi 8 cipariem. Ja faktiskajam DNI ir mazāk ciparu, tam jābūt papildinātam ar vadošajām nullēm, lai sasniegtu 8 ciparus. Piemēram, ja kāda cilvēka DNI ir 1234567, CUIT/CUIL tas tiks attēlots kā 01234567.

Kā es varu pārbaudīt, vai CUIT/CUIL ir oficiāli reģistrēts Argentīnā?

Lai pārbaudītu, vai CUIT/CUIL ir oficiāli reģistrēts un aktīvs, jums jāizmanto oficiālā AFIP (Administración Federal de Ingresos Públicos) tīmekļa vietne vai pakalpojumi. Mūsu rīks tikai pārbauda numura matemātisko derīgumu, nevis tā oficiālo reģistrācijas statusu.

Vai es varu izmantot šo rīku savā komerciālajā lietojumprogrammā?

Jā, jūs varat integrēt algoritmu un loģiku, kas demonstrēta šajā rīkā, savās komerciālajās lietojumprogrammās. CUIT/CUIL validācijas algoritms ir publiska standarts. Tomēr ražošanas vidēs mēs iesakām ieviest pareizu kļūdu apstrādi un ņemt vērā papildu validāciju pret oficiālajiem avotiem, kad tas ir nepieciešams.

Vai rīks saglabā kādus no ģenerētajiem vai validētajiem CUIT/CUIL numuriem?

Nē, šis rīks nesaglabā nevienu no ievadītajām vai ģenerētajām vērtībām. Visa apstrāde tiek veikta klienta pusē jūsu pārlūkprogrammā, un nav datu nosūtīšanas uz mūsu serveriem vai to saglabāšanas. Tas nodrošina jūsu ievadīto datu privātumu un drošību.

Atsauces

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Oficiālā tīmekļa vietne. https://www.afip.gob.ar/
Darba, nodarbinātības un sociālās drošības ministrija. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Iegūt manu CUIL." https://www.anses.gob.ar/
Argentīnas Republikas oficiālais biļetens. "AFIP 2854/2010. rezolūcija: Procedūra. Clave Única de Identificación Tributaria (C.U.I.T.)."
Argentīnas Republikas nodokļu kodekss. "Identifikācija un reģistrācija nodokļu maksātājiem."

Gatavs ģenerēt vai validēt Argentīnas CUIT/CUIL numurus? Izmēģiniet mūsu rīku tagad un vienkāršojiet savu testēšanas procesu!

Argentīnas CUIT/CUIL ģeneratora un validācijas rīks

CUIT/CUIL ģenerators

Ģenerētais CUIT/CUIL

Dokumentācija