Argentin CUIT/CUIL Generátor és Érvényesítő

Bevezetés

Az argentin CUIT (Clave Única de Identificación Tributaria) és CUIL (Clave Única de Identificación Laboral) egyedi azonosító számok, amelyeket Argentínában adó- és munkavállalási célokra használnak. Ezek a 11 számjegyből álló kódok alapvető fontosságúak az egyének és vállalkozások számára, hogy legálisan működhessenek az argentin gazdasági rendszerben. CUIT/CUIL Generátor és Érvényesítő eszközünk egyszerű és hatékony módot kínál érvényes CUIT/CUIL számok generálására tesztelési célokra, és meglévő számok érvényesítésére, hogy biztosítsa, hogy azok megfelelnek a hivatalos formátumnak és ellenőrzési algoritmusnak.

Akár fejlesztő vagy, aki argentin adóazonosítókkal foglalkozó alkalmazásokat tesztel, QA szakember, aki a rendszer funkcionalitását ellenőrzi, vagy egyszerűen csak meg akarod érteni, hogyan működnek ezek az azonosító számok, ez az eszköz egy egyszerű megoldást kínál felesleges bonyodalmak nélkül. Az eszköz két fő funkcióval rendelkezik: egy generátor, amely véletlenszerűen vagy specifikus paraméterek alapján érvényes CUIT/CUIL számokat hoz létre, és egy érvényesítő, amely ellenőrzi, hogy egy adott CUIT/CUIL szám követi-e a helyes formátumot és számítási szabályokat.

CUIT/CUIL Struktúra és Számítás

A Formátum Megértése

Egy érvényes CUIT/CUIL szám 11 számjegyből áll, amelyeket általában a következő formátumban jelenítenek meg: XX-XXXXXXXX-X:

Típus Kód (első 2 számjegy): Jelzi a jogi entitás típusát
- 20, 23, 24: Férfi egyének (CUIL)
- 27: Női egyének (CUIL)
- 30, 33, 34: Vállalatok és szervezetek (CUIT)
DNI Szám (középső 8 számjegy): Egyének esetében ez a nemzeti személyazonosító okmány szám (DNI), amelyet szükség esetén vezető nullákkal töltenek ki, hogy elérje a 8 számjegyet. Vállalatok esetében ez egyedi hozzárendelt szám.
Ellenőrző Számjegy (utolsó számjegy): Egy ellenőrző számjegy, amelyet egy specifikus algoritmus segítségével számítanak ki az egész szám érvényesítésére.

Ellenőrző Számjegy Számítása

Az ellenőrző számjegy a következő algoritmus segítségével számítható ki:

Vedd az első 10 számjegyet a CUIT/CUIL-ból (típus kód + DNI)
Szorozd meg minden számjegyet a következő súlyokkal: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
Összegezd az összes kapott szorzatot
Számítsd ki a 11 mínusz a hányados maradékát az összeg osztva 11-tel
Ha az eredmény 11, az ellenőrző számjegy 0
Ha az eredmény 10, az ellenőrző számjegy 9
Különben az eredmény az ellenőrző számjegy

Matematikailag ez kifejezhető a következőképpen:

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

Ahol:

$VD$ az ellenőrző számjegy
$d_i$ az $i$ -edik számjegy az első 10 számjegyből
$w_i$ a megfelelő súly az [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] sorozatból
Különleges esetek: ha $VD = 11$ , akkor $VD = 0$ , ha $VD = 10$ , akkor $VD = 9$

Lépésről Lépésre Útmutató

A Generátor Használata

Válaszd a "Generátor" fület az eszköz felületének tetején.
Válassz egy Típus Kódot a legördülő menüből:
- 20: Férfi (CUIL)
- 23: Vállalkozás (CUIT)
- 24: Ideiglenes Vállalkozás (CUIT)
- 27: Női (CUIL)
- 30: Társaság (CUIT)
- 33: Polgári Egyesület (CUIT)
- 34: Alapítvány (CUIT)
Írd be a DNI Számot (opcionális):
- Írj be egy 8 számjegyből álló DNI számot a megadott mezőbe
- Ha üresen hagyod, az eszköz véletlenszerűen generál egy DNI-t
- Ha kevesebb mint 8 számjegyet írsz be, a rendszer vezető nullákkal tölti ki
Generálj Véletlenszerű DNI-t (opcionális):
- Kattints a "Véletlen" gombra, hogy generálj egy véletlenszerű 8 számjegyből álló DNI számot
Nézd meg a Generált CUIT/CUIL-t:
- Az eszköz automatikusan megjeleníti az érvényes CUIT/CUIL-t a megadott adatok alapján
- A formátum XX-XXXXXXXX-X lesz a helyes ellenőrző számjeggyel
Másold a Eredményt:
- Kattints a másolás ikonra, hogy a generált CUIT/CUIL-t a vágólapodra másold
- Egy megerősítő üzenet jelenik meg, amikor a másolás sikeresen megtörtént

Az Érvényesítő Használata

Válaszd a "Érvényesítő" fület az eszköz felületének tetején.
Írd be az Érvényesíteni Kívánt CUIT/CUIL-t:
- Írd be a CUIT/CUIL-t a XX-XXXXXXXX-X formátumban
- Az eszköz automatikusan formázza a bemenetet kötőjelekkel, ahogy írsz
- A számot kötőjelek nélkül is beírhatod (XXXXXXXXXXX)
Kattints a "Érvényesít" Gombra:
- Az eszköz ellenőrzi a formátumot, a típus kódot és az ellenőrző számjegyet
Nézd meg az Érvényesítési Eredményt:
- Érvényes CUIT/CUIL számok esetén zöld sikerüzenet jelenik meg
- Érvénytelen számok esetén piros hibaüzenet jelenik meg, amely elmagyarázza a problémát:
  - Érvénytelen formátum (XX-XXXXXXXX-X kell, hogy legyen)
  - Érvénytelen típus kód (a következőknek kell lennie: 20, 23, 24, 27, 30, 33, 34)
  - Érvénytelen ellenőrző számjegy
További Információ:
- Érvényes számok esetén az eszköz megjeleníti az összetevők bontását:
  - Típus kód és jelentése
  - DNI szám
  - Ellenőrző számjegy

Használati Esetek

Fejlesztés és Tesztelés

Szoftver Fejlesztés: Generálj érvényes CUIT/CUIL számokat argentin adóazonosítókkal foglalkozó alkalmazások teszteléséhez, például:
- E-kereskedelmi platformok
- Könyvelő szoftverek
- HR menedzsment rendszerek
- Kormányzati szolgáltatási portálok
- Banki alkalmazások
Adatbázis Feltöltés: Hozz létre reális tesztadatokat olyan rendszerek számára, amelyek argentin felhasználói információkat tárolnak, biztosítva, hogy az adatbázis korlátozásai és érvényesítési szabályai helyesen működjenek.
Űrlap Érvényesítési Tesztelés: Teszteld az input érvényesítést webformák esetében, amelyek CUIT/CUIL információkat gyűjtenek, ellenőrizve, hogy megfelelő hibaüzenetek jelennek-e meg érvénytelen bejegyzések esetén.
API Tesztelés: Generálj érvényes payloadokat API végpontokhoz, amelyek CUIT/CUIL számokat igényelnek, biztosítva, hogy az integrációs tesztjeid érvényes adatokat használjanak.
QA Automatizálás: Incorporáld a CUIT/CUIL generálást automatizált teszt szkriptekbe, hogy dinamikus teszteseteket hozz létre statikus tesztadatok helyett.

Oktatási Célok

Érvényesítési Algoritmusok Megismerése: Értsd meg, hogyan működnek a számjegyellenőrző algoritmusok a gyakorlatban, látva a CUIT/CUIL ellenőrzési folyamatát működés közben.
Adat Érvényesítés Tanítása: Használj oktatási példaként, amikor új fejlesztőknek tanítasz űrlap érvényesítési technikákat.
Argentin Üzleti Követelmények Megértése: Ismerd meg az argentin azonosító rendszert a nemzetközi üzletfejlesztéshez.

Alternatívák

Bár az eszközünk egyszerű módot kínál a CUIT/CUIL számok generálására és érvényesítésére, más megközelítések is léteznek, amelyeket érdemes fontolóra venni:

Hivatalos Kormányzati Érvényesítés: Termelési környezetekben mindig érdemes érvényesíteni a CUIT/CUIL számokat a hivatalos AFIP (Administración Federal de Ingresos Públicos) adatbázissal, amikor csak lehetséges.
Könyvtárak és Csomagok: Számos programozási nyelv rendelkezik kifejezetten argentin adóazonosítók érvényesítésére szolgáló könyvtárakkal:
- JavaScript: validar-cuit npm csomag
- PHP: afip-php könyvtár
- Python: py-cuit csomag
Kézi Számítás: Oktatási célokra kézzel is kiszámíthatod az ellenőrző számjegyet a fent leírt algoritmus segítségével.
Átfogó Üzleti Érvényesítő Szolgáltatások: Vállalati alkalmazásokhoz fontold meg átfogó érvényesítő szolgáltatások használatát, amelyek nemcsak a formátumot ellenőrzik, hanem az azonosítóhoz tartozó entitás létezését és státuszát is.

A CUIT/CUIL Rendszer Története

Az argentin CUIT/CUIL azonosító rendszer jelentősen fejlődött az alapítása óta:

Eredetek és Megvalósítás

A CUIT (Clave Única de Identificación Tributaria) először az 1970-es években került bevezetésre Argentínában, a adóbeszedési rendszer modernizálására irányuló erőfeszítések részeként. A Szövetségi Adóhatóság (AFIP) vezette be ezt az egyedi azonosítót, hogy hatékonyabban nyomon követhesse az adófizetőket és csökkentse az adóelkerülést.

A CUIL (Clave Única de Identificación Laboral) később került bevezetésre, hogy kifejezetten a munkavállalók azonosítására szolgáljon a társadalombiztosítási rendszerben, létrehozva egy megkülönböztetést az adóazonosító és a munkavállalói azonosító között, miközben megőrzi a következetes formátumot.

Fejlődés és Digitalizáció

Az 1990-es években, amikor Argentína jelentős gazdasági reformokon ment keresztül, a CUIT/CUIL rendszer egyre fontosabbá vált a gazdasági tevékenység nyomon követésében. A rendszert tovább digitalizálták, és online érvényesítési rendszereket vezettek be.

A 2000-es évek elején a CUIT/CUIL rendszert integrálták különféle digitális kormányzati szolgáltatásokba, így az argentin e-kormányzati kezdeményezések alapvető összetevőjévé vált. Ez az időszak a számítási algoritmus és a formátum standardizálásának időszaka is volt, amely ma is használatban van.

Legutóbbi Fejlesztések

Az utóbbi években az AFIP javította a CUIT/CUIL számok biztonsági és érvényesítési folyamatait, kifinomultabb érvényesítési rendszereket vezetett be, és integrálta azokat más kormányzati adatbázisokkal. A rendszer ma kulcsszerepet játszik Argentína adóelkerülés elleni küzdelmében és a gazdaság formalizálásában.

Ma a CUIT/CUIL nemcsak adó- és munkavállalási célokra használatos, hanem számos tevékenységhez is, beleértve a banki, ingatlanügylet, közszolgáltatások és online vásárlások, így elengedhetetlen azonosítóvá válik mind az egyének, mind a vállalkozások számára, akik Argentínában működnek.

Kód Példák

Python

1def calculate_verification_digit(type_code, dni):
2    # Konvertálás stringgé, és biztosítani, hogy a DNI 8 számjegy legyen vezető nullákkal
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Kombináld a típus kódot és a DNI-t
7    digits = type_code_str + dni_str
8    
9    # Súlyok minden pozícióhoz
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Számítsd ki a szorzatok összegét
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Számítsd ki az ellenőrző számjegyet
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Különleges esetek
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    # Érvényes típus kódok
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"Érvénytelen típus kód. A következők közül kell választani: {valid_type_codes}")
34    
35    # Véletlenszerű DNI generálása, ha nem megadva
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Számítsd ki az ellenőrző számjegyet
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formázd a CUIT/CUIL-t
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Távolítsd el a kötőjeleket, ha vannak
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Ellenőrizd az alapformátumot
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Érvénytelen formátum"
52    
53    # Szedd ki a részeket
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    # Érvényesítsd a típus kódot
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Érvénytelen típus kód"
62    
63    # Számítsd ki és hasonlítsd össze az ellenőrző számjegyet
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Érvénytelen ellenőrző számjegy"
67    
68    return True, "Érvényes CUIT/CUIL"
69
70# Példa használat
71print(generate_cuit_cuil(20, 12345678))  # Generálás adott DNI-hoz
72print(generate_cuit_cuil(27))  # Generálás véletlenszerű DNI-val
73print(validate_cuit_cuil("20-12345678-9"))  # Érvényesítés egy CUIT/CUIL-ra
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Konvertálás stringgé, és biztosítani, hogy a DNI 8 számjegy legyen vezető nullákkal
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Kombináld a típus kódot és a DNI-t
7  const digits = typeCodeStr + dniStr;
8  
9  // Súlyok minden pozícióhoz
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Számítsd ki a szorzatok összegét
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Számítsd ki az ellenőrző számjegyet
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Különleges esetek
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  // Érvényes típus kódok
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Érvénytelen típus kód. A következők közül kell választani: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Véletlenszerű DNI generálása, ha nem megadva
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Számítsd ki az ellenőrző számjegyet
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formázd a CUIT/CUIL-t
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Távolítsd el a kötőjeleket, ha vannak
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Ellenőrizd az alapformátumot
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Érvénytelen formátum' };
58  }
59  
60  // Szedd ki a részeket
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  // Érvényesítsd a típus kódot
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Érvénytelen típus kód' };
69  }
70  
71  // Számítsd ki és hasonlítsd össze az ellenőrző számjegyet
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Érvénytelen ellenőrző számjegy' };
75  }
76  
77  return { isValid: true };
78}
79
80// Példa használat
81console.log(generateCuitCuil(20, 12345678)); // Generálás adott DNI-hoz
82console.log(generateCuitCuil(27)); // Generálás véletlenszerű DNI-val
83console.log(validateCuitCuil("20-12345678-9")); // Érvényesítés egy CUIT/CUIL-ra
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        // Konvertálás stringgé, és biztosítani, hogy a DNI 8 számjegy legyen vezető nullákkal
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Kombináld a típus kódot és a DNI-t
15        String digits = typeCodeStr + dniStr;
16        
17        // Számítsd ki a szorzatok összegét
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Számítsd ki az ellenőrző számjegyet
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Különleges esetek
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("Érvénytelen típus kód. A következők közül kell választani: " + VALID_TYPE_CODES);
39        }
40        
41        // Véletlenszerű DNI generálása, ha nem megadva
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Számítsd ki az ellenőrző számjegyet
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formázd a CUIT/CUIL-t
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Távolítsd el a kötőjeleket, ha vannak
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Ellenőrizd az alapformátumot
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Érvénytelen formátum");
61        }
62        
63        // Szedd ki a részeket
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        // Érvényesítsd a típus kódot
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Érvénytelen típus kód");
71        }
72        
73        // Számítsd ki és hasonlítsd össze az ellenőrző számjegyet
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Érvénytelen ellenőrző számjegy");
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        // Példa használat
102        System.out.println(generateCuitCuil(20, 12345678)); // Generálás adott DNI-hoz
103        System.out.println(generateCuitCuil(27, null)); // Generálás véletlenszerű DNI-val
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Érvényesítés egy CUIT/CUIL-ra
105    }
106}
107

PHP

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // Konvertálás stringgé, és biztosítani, hogy a DNI 8 számjegy legyen vezető nullákkal
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // Kombináld a típus kódot és a DNI-t
9    $digits = $typeCodeStr . $dniStr;
10    
11    // Súlyok minden pozícióhoz
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // Számítsd ki a szorzatok összegét
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // Számítsd ki az ellenőrző számjegyet
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // Különleges esetek
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    // Érvényes típus kódok
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("Érvénytelen típus kód. A következők közül kell választani: " . implode(', ', $validTypeCodes));
39    }
40    
41    // Véletlenszerű DNI generálása, ha nem megadva
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // Számítsd ki az ellenőrző számjegyet
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // Formázd a CUIT/CUIL-t
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // Távolítsd el a kötőjeleket, ha vannak
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // Ellenőrizd az alapformátumot
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'Érvénytelen formátum'];
60    }
61    
62    // Szedd ki a részeket
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // Érvényesítsd a típus kódot
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'Érvénytelen típus kód'];
71    }
72    
73    // Számítsd ki és hasonlítsd össze az ellenőrző számjegyet
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'Érvénytelen ellenőrző számjegy'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// Példa használat
83echo generateCuitCuil(20, 12345678) . "\n"; // Generálás adott DNI-hoz
84echo generateCuitCuil(27) . "\n"; // Generálás véletlenszerű DNI-val
85var_dump(validateCuitCuil("20-12345678-9")); // Érvényesítés egy CUIT/CUIL-ra
86?>
87

Gyakran Ismételt Kérdések

Mi a különbség a CUIT és a CUIL között?

A CUIT (Clave Única de Identificación Tributaria) adóazonosító célokra használatos, és mind az egyének, mind a jogi személyek számára kiadják, akiknek adót kell fizetniük Argentínában. A CUIL (Clave Única de Identificación Laboral) kifejezetten a munkavállalók azonosítására szolgál, és a munkavállalási és társadalombiztosítási célokra használják. Bár megosztják a formátumot és a számítási algoritmust, különböző adminisztratív célokat szolgálnak.

Mely típus kódokat használják az egyének és melyeket a vállalatok?

Egyének esetében:

20, 23, 24: Férfi egyének (CUIL)
27: Női egyének (CUIL)

Vállalatok és szervezetek esetében:

30: Társaságok (CUIT)
33: Polgári Egyesületek (CUIT)
34: Alapítványok (CUIT)

Hogyan számítják ki az ellenőrző számjegyet?

Az ellenőrző számjegy egy súlyozott összeg algoritmus segítségével számítható ki. Az első 10 számjegyet egy megfelelő súllyal (5, 4, 3, 2, 7, 6, 5, 4, 3, 2) szorozzák meg, és az eredményeket összeadják. Az ellenőrző számjegy 11 mínusz a hányados maradéka az összeg osztva 11-tel. Különleges esetek: ha az eredmény 11, az ellenőrző számjegy 0; ha az eredmény 10, az ellenőrző számjegy 9.

Használhatom ezt az eszközt valódi, hivatalos CUIT/CUIL számok generálására?

Nem, ez az eszköz tesztelési és oktatási célokra készült. A generált számok matematikailag érvényesek a CUIT/CUIL algoritmus szerint, de nem hivatalosan regisztráltak az argentin adóhatóságnál (AFIP). A hivatalos CUIT/CUIL regisztrációhoz az egyéneknek és vállalatoknak követniük kell a megfelelő jogi eljárásokat az AFIP-en keresztül.

Miért nem érvényes a CUIT/CUIL számom, még ha a formátum helyesnek tűnik is?

Az érvényesítés több okból is megbukhat:

A típus kód nem az érvényes kódok egyike (20, 23, 24, 27, 30, 33, 34)
Az ellenőrző számjegy nem egyezik a számított értékkel az algoritmus alapján
A formátum helytelen (XX-XXXXXXXX-X kell, hogy legyen)
Nem numerikus karakterek találhatók a bemenetben (kivéve a kötőjeleket)

Szükségesek a kötőjelek a CUIT/CUIL számokban?

Bár a CUIT/CUIL számokat általában kötőjelekkel (XX-XXXXXXXX-X) írják és jelenítik meg, a kötőjelek nem részei a tényleges számnak a számítási célokra. Érvényesítőnk mindkét formátumot (kötőjelekkel vagy anélkül) elfogadja, és megfelelően érvényesíti bármely formátumot.

Lehet-e a CUIT/CUIL számnak kevesebb mint 8 számjegye a DNI részben?

Nem, a DNI résznek mindig pontosan 8 számjegyből kell állnia. Ha a tényleges DNI kevesebb számjegyből áll, akkor vezető nullákkal kell kitölteni, hogy elérje a 8 számjegyet. Például, ha valakinek a DNI-ja 1234567, akkor a CUIT/CUIL-ban 01234567-ként jelenik meg.

Hogyan ellenőrizhetem, hogy egy CUIT/CUIL hivatalosan regisztrálva van-e Argentínában?

A CUIT/CUIL hivatalos regisztráltságának és aktív státuszának ellenőrzéséhez használhatod a hivatalos AFIP (Administración Federal de Ingresos Públicos) weboldalát vagy szolgáltatásait. Eszközünk csak a szám matematikai érvényességét ellenőrzi, nem a hivatalos regisztrációs státuszát.

Használhatom ezt az eszközt a kereskedelmi alkalmazásomban?

Igen, integrálhatod az eszközben bemutatott algoritmust és logikát a kereskedelmi alkalmazásaidba. A CUIT/CUIL érvényesítési algoritmus nyilvános szabvány. Azonban a termelési környezetekben ajánljuk a megfelelő hibakezelés végrehajtását, és szükség esetén a hivatalos forrásokkal való további érvényesítést.

Tárolja az eszköz a generált vagy érvényesített CUIT/CUIL számokat?

Nem, ez az eszköz nem tárolja a megadott vagy generált információkat. Minden feldolgozás a böngésződben történik, és egyetlen adat sem kerül elküldésre vagy tárolásra a szervereinken. Ez biztosítja a megadott információk magánéletét és biztonságát.

Hivatkozások

AFIP (Administración Federal de Ingresos Públicos). "CUIT/CUIL/CDI." Hivatalos Weboldal. https://www.afip.gob.ar/
Munkaügyi, Foglalkoztatási és Szociális Biztonsági Minisztérium. "CUIL - Clave Única de Identificación Laboral." https://www.argentina.gob.ar/trabajo
ANSES (Administración Nacional de la Seguridad Social). "Obtener mi CUIL." https://www.anses.gob.ar/
Argentína Hivatalos Közlöny. "AFIP 2854/2010. Számú Határozat: Eljárás. Clave Única de Identificación Tributaria (C.U.I.T.)."
Argentína Adó Törvénykönyve. "Az Adófizetők Azonosítása és Regisztrálása."

Készen állsz az argentin CUIT/CUIL számok generálására vagy érvényesítésére? Próbáld ki eszközünket most, és egyszerűsítsd a tesztelési folyamatodat!

Argentin CUIT/CUIL Generáló és Érvényesítő Eszköz

CUIT/CUIL Generátor

Generált CUIT/CUIL

Dokumentáció