Ugrás a tartalomra

CUIT/CUIL Generátor és Ellenőrző | Argentin Adóazonosító Eszköz

Érvényes argentin CUIT/CUIL tesztelési számok generálása vagy meglévő számok ellenőrzése. Ingyenes online eszköz fejlesztőknek az adóazonosító és bérszámfejtési rendszerek AFIP-kompatibilis ellenőrzéséhez.

CUIT/CUIL Generátor

Adjon meg egy 8 számjegyű DNI számot vagy használja a véletlenszerű generátort

Generált CUIT/CUIL
20-12681873-5

Véletlenszerűen generált DNI használata

Betöltési kalkulátor...
📚

Dokumentáció

Argentin CUIT/CUIL Generátor és Validáló

Bevezetés

Argentína adó- és munkaügyi rendszerében állandóan két kritikus azonosítóval találkozhat: CUIT (Clave Única de Identificación Tributaria) és CUIL (Clave Única de Identificación Laboral). Gondoljon a CUIT-ra mint az adóazonosítóra vállalkozások és adófizető magánszemélyek számára, míg a CUIL a munkavállalókat azonosítja a társadalombiztosítási rendszerben. Mindkettő ugyanazt a 11 számjegyű formátumot és ellenőrzési algoritmust használja, ami különösen fontossá teszi az ilyen számokat kezelő alkalmazások tesztelését.

Amikor argentin piacra fejleszt szoftvert, érvényes tesztadatokra van szüksége. Éppen ezért jött létre ez az eszköz. Matematikailag helyes CUIT/CUIL számokat generálhat teszteléshez valós személyes adatok használata nélkül, vagy ellenőrizheti a meglévő számokat, hogy azok megfeleljenek az AFIP hivatalos algoritmusának. Különösen hasznos, hogy az eszköz mind a generálási oldalt (érvényes számok igény szerinti létrehozása), mind az ellenőrzési oldalt kezeli (formátumhibák, érvénytelen típuskódok és helytelen ellenőrző számjegyek kiszűrése, mielőtt azok éles problémákat okozhatnának).

CUIT/CUIL Szerkezet és Számítás

A Formátum Megértése

Egy érvényes CUIT/CUIL szám 11 számjegyből áll, amelyet általában a XX-XXXXXXXX-X formátumban jelenítenek meg. Íme, hogyan épül fel:

  1. Típuskód (első 2 számjegy): Meghatározza a jogalany típusát

    • 20, 23, 24: Férfi magánszemélyek (CUIL)
    • 27: Női magánszemélyek (CUIL)
    • 30, 33, 34: Cégek és szervezetek (CUIT)
  2. DNI Szám (középső 8 számjegy): Magánszemélyeknél ez a nemzeti személyazonosító dokumentum száma (DNI). Egy gyakori buktató: ha a tényleges DNI kevesebb mint 8 számjegyű, akkor elöl nullákkal kell kitölteni. Például a DNI 1234567 01234567-té válik a CUIT/CUIL-ben. A cégek helyette egy egyedi hozzárendelt számot kapnak.

  3. Ellenőrző számjegy (utolsó számjegy): Ez az ellenőrző számjegy egy súlyozott algoritmus segítségével érvényesíti a teljes számot. Ha ez a számjegy nem egyezik a számítással, a teljes CUIT/CUIL érvénytelen - valami, ami gyakran megzavarja a fejlesztőket, amikor manuálisan állítanak elő tesztadatokat.

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

Az ellenőrző számjegy egy modulo-11 súlyozott algoritmust használ. Íme, hogyan működik:

  1. Vegyük a CUIT/CUIL első 10 számjegyét (típuskód + DNI)
  2. Szorozzuk meg minden számjegyet a megfelelő súlyával: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. Adjuk össze az összes szorzatot
  4. Számoljuk ki: 11 mínusz (összeg modulo 11)
  5. Kezeljük a speciális eseteket: ha az eredmény 11, használjuk a 0-t; ha 10, használjuk a 9-et

Ami legtöbbször megzavarja az embereket, azok a speciális esetek az 5. lépésben. Teszteléskor néha 10 vagy 11 az eredmény, és ha elfelejti leképezni ezeket 9-re és 0-ra, az érvényesítési hibákhoz vezet, amelyeket nehéz hibakeresni, ha nem ismeri ezt a szabályt.

Matematikailag ez így fejezhető ki:

VD=11((i=110di×wi)mod11)VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)

Ahol:

  • VDVD az ellenőrző számjegy
  • did_i az első 10 számjegy ii-edik számjegye
  • wiw_i a [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] sorozatból a megfelelő súly
  • Speciális esetek: ha VD=11VD = 11, akkor VD=0VD = 0, ha VD=10VD = 10, akkor VD=9VD = 9

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

A Generátor használata

  1. Válassza a "Generátor" fület a felület tetején.

  2. Válasszon egy Típuskó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ő (CUIL)
    • 30: Vállalat (CUIT)
    • 33: Civil Szervezet (CUIT)
    • 34: Alapítvány (CUIT)
  3. Adjon meg egy DNI Számot (opcionális):

    • Írjon be egy 8 számjegyű DNI számot a megadott mezőbe
    • Ha üresen hagyja, az eszköz véletlenszerűen generál egy DNI számot
    • Ha kevesebb mint 8 számjegyet ad meg, a rendszer nullákkal egészíti ki
  4. Véletlenszerű DNI generálása (opcionális):

    • Kattintson a "Véletlenszerű" gombra egy véletlenszerű 8 számjegyű DNI szám generálásához
  5. A generált CUIT/CUIL megtekintése:

    • Az eszköz automatikusan megjelenít egy érvényes CUIT/CUIL-t a bevitt adatok alapján
    • A formátum XX-XXXXXXXX-X lesz a helyes ellenőrző számjeggyel
  6. Eredmény másolása:

    • Kattintson a másolás ikonra a generált CUIT/CUIL vágólapra másolásához
    • Egy megerősítő üzenet jelenik meg a sikeres másolás után

A Validátor használata

  1. Válassza a "Validátor" fület a felület tetején.

  2. Adja meg a validálandó CUIT/CUIL-t:

    • Írja be a CUIT/CUIL-t XX-XXXXXXXX-X formátumban
    • Az eszköz automatikusan formázza a bevitelt kötőjelekkel gépelés közben
    • Kötőjelek nélkül is megadhatja a számot (XXXXXXXXXXX)
  3. Kattintson a "Validálás" gombra:

    • Az eszköz ellenőrzi a formátumot, típuskódot és ellenőrző számjegyet
  4. A validálás eredményének megtekintése:

    • Érvényes CUIT/CUIL számoknál zöld sikeres üzenet jelenik meg
    • Érvénytelen számoknál piros hibaüzenet magyarázza a problémát:
      • Érvénytelen formátum (XX-XXXXXXXX-X formátumúnak kell lennie)
      • Érvénytelen típuskód (a következők egyikének kell lennie: 20, 23, 24, 27, 30, 33, 34)
      • Érvénytelen ellenőrző számjegy
  5. Kiegészítő információk:

    • Érvényes számoknál az eszköz megjeleníti az összetevők részletezését:
      • Típuskód és jelentése
      • DNI szám
      • Ellenőrző számjegy

Gyakori hibák és ajánlott gyakorlatok

A CUIT/CUIL érvényesítés során az alkalmazásokban figyeljen ezekre a gyakori buktatókra:

Nulla-kitöltési problémák: A leggyakoribb hiba, amellyel találkoztam, a vezető nullákkal rendelkező DNI számok kezelése. Amikor valaki beír egy DNI számot, mint "1234567", a kódnak úgy kell kezelnie, mint "01234567" a CUIT/CUIL konstruálásánál. Sok implementáció egész számmá alakítja a feldolgozáshoz, ami eltávolítja a vezető nullákat. Használjon inkább karakterlánc műveleteket a megfelelő kitöltéshez.

Típuskód zavara: Nem minden kétjegyű szám érvényes típuskód. Csak a 20, 23, 24, 27, 30, 33, 34 működik. Láttam olyan rendszereket, amelyek bármilyen kétjegyű előtagot elfogadnak, ami "érvényesnek tűnő" számokhoz vezet, mint a 21-12345678-X, amelyek nem felelnek meg az AFIP érvényesítésének. Mindig ellenőrizze a típuskódot a ellenőrző számjegy kiszámítása előtt.

Nemi feltételezések: A 20-as típuskód (férfi) és a 27-es (nő) nem felcserélhetők. Ha automatikusan generál CUIL-t demográfiai adatok alapján, gondoskodjon arról, hogy a típuskód megegyezzen a RENAPER-nél (Argentína nemzeti nyilvántartása) regisztrált tényleges nemmel. A nem egyezése elutasítást okoz, amikor az egyének megpróbálják használni ezeket a számokat kormányzati szolgáltatásoknál.

Kötőjel kezelése: Egyes implementációk megkövetelik a kötőjeleket, míg mások elutasítják azokat. Ajánlott gyakorlat: fogadja el mindkét formátumot a beviteli mezőkben (kötőjellel vagy anélkül), távolítsa el a kötőjeleket az érvényesítés előtt, tárolja a kötőjel nélküli verziót az adatbázisban, és csak megjelenítéskor adja hozzá a kötőjeleket.

Hiányzó ellenőrzés: Az algoritmus érvényesítése észleli a formátumhibákat, de nem erősíti meg, hogy a CUIT/CUIL regisztrálva van-e. Éles üzemben először ellenőrizze a formátumot (gyors), majd ellenőrizze az AFIP adatbázisával (lassabb, de hiteles). Ez a kétlépcsős megközelítés azonnal észleli a gépelési hibákat, miközben biztosítja, hogy a szám valós.

Szélső esetek tesztelése: Mindig tesztelje az ellenőrző számjegyeket 0 és 9 értékekkel - ezek speciális eseteket eredményeznek az algoritmusban. Tesztelje a nullával kezdődő DNI számokat is, hogy biztosítsa a kitöltési logika helyes működését.

Felhasználási módok és gyakorlati alkalmazások

Fejlesztés és tesztelés

Szoftverfejlesztés: Argentínai piacra szánt alkalmazások készítésekor érvényes tesztadatokra van szükség, amelyek átmennek az ellenőrzésen valós felhasználói adatok nélkül. Íme, hol válik ez kritikussá:

  • E-kereskedelmi platformok: Fizetési feldolgozók és számlázási rendszerek érvényes CUIT/CUIL számokat igényelnek. Terheléses tesztelés során akár több ezer érvényes számra lehet szükség realisztikus felhasználói regisztrációk szimulálásához.
  • Könyvelési szoftverek: Adójelentési modulok ellenőrzik a CUIT/CUIL formátumot a AFIP-nak történő beküldés előtt. Ezen ellenőrzési szabályok teszteléséhez olyan számokra van szükség, amelyek átmennek az ellenőrző számjegy algoritmusán.
  • Humánerőforrás-kezelő rendszerek: A bérszámfejtés és társadalombiztosítási hozzájárulások érvényes CUIL számoktól függnek. Gyakori forgatókönyv: alkalmazott felvételi folyamatokat teszteli, és ellenőrizni kell, hogy az érvénytelen CUIL-ek megfelelő hibaüzeneteket váltanak-e ki.
  • Banki alkalmazások: A KYC (Ügyfél-azonosítási) folyamatok a CUIT/CUIL-t az számlanyitás részeként érvényesítik. Tapasztalataim szerint a típuskód eltérések gyakran integrációs tesztelés során merülnek fel.

Adatbázis feltöltés: Tesztadatbázisok feltöltésekor algoritmikusan érvényes CUIT/CUIL számok használata biztosítja, hogy az adatbázis korlátozások és triggerek a várt módon működjenek. Ez különösen fontos adatmigrációs szkriptek vagy ETL folyamatok tesztelésénél, amelyek azonosítószámokat érvényesítenek.

Űrlap érvényesítés tesztelése: Tesztelje mind a sikeres utat, mind a hibás eseteket. Generáljon érvényes számokat a sikeres beküldés megerősítéséhez, majd módosítsa az ellenőrző számjegyet, hogy bizonyosra vegye: frontend és backend érvényesítés észleli a hibát, mielőtt az adatbázisba kerülne.

API tesztelés: Integrációs tesztek során érvényes CUIT/CUIL számokat kell használni a kérések hasznos adataiban. Ez megakadályozza a hamis negatívokat, ahol a tesztek azért buknak el, mert érvénytelen tesztadatokat használnak, nem pedig tényleges hibák vannak az API logikájában.

Minőségbiztosítási automatizálás: A paraméteres tesztek előnyére válnak a dinamikus CUIT/CUIL generálásnak. Ahelyett, hogy rögzített tesztértékeket használnánk, amelyekütközhetnek a tesztek között, minden tesztelési futtatáskor friss, érvényes számokat generálunk.

Oktatási célok

Érvényesítési algoritmusok tanulása: A CUIT/CUIL ellenőrző algoritmus bemutatja a modulo aritmetika és súlyozott ellenőrző számjegyek gyakorlati alkalmazását. Ugyanez a minta megjelenik más azonosítási rendszerekben világszerte - hitelkártyaszámok (Luhn algoritmus), ISBN kódok és európai adószámok mind hasonló súlyozott ellenőrző összeg módszereket használnak. A CUIT/CUIL érvényesítés megértése betekintést nyújt abba, miért léteznek ezek az algoritmusok: képesek észlelni átírási hibákat, például felcserélt számjegyeket vagy egyjegyű hibákat.

Adatérvényesítés oktatása: Junior fejlesztők képzésekor az input érvényesítésről, a CUIT/CUIL rendszer valós világbeli példát kínál, amely összetettebb az e-mail érvényesítésnél, de egyszerűbb a kriptográfiai ellenőrzésnél. Bemutatja a mélységi védelem elvét: formátum érvényesítés (11 számjegy), üzleti szabály érvényesítés (érvényes típuskódok) és algoritmikus érvényesítés (ellenőrző számjegy).

Nemzetközi üzletfejlesztés: Ha Latin-amerikai piacokra épít rendszereket, a CUIT/CUIL megértése segít megismerni a szomszédos országok hasonló rendszereit. Brazíliában CPF/CNPJ, Chilében RUT, Uruguayban RUT - mind ellenőrző számjegy algoritmusokat használnak. Az itt tanult minták átvihetők ezekre a rendszerekre.

Alternatívák és éles üzemi megfontolások

Míg ez az eszköz jól működik fejlesztésben és tesztelésben, éles üzemi környezetben más követelmények vannak:

Hivatalos kormányzati érvényesítés: Élő alkalmazásoknál az algoritmikus érvényesítés önmagában nem elég - ellenőrizni kell, hogy a CUIT/CUIL ténylegesen regisztrálva van-e a AFIP (Szövetségi Adójövedelmi Igazgatóság)-nál. Az AFIP valós idejű érvényesítéshez webszolgáltatásokat biztosít, bár regisztrálni és hitelesíteni kell magát a hozzáféréshez. A csavar: egy szám matematikailag érvényes lehet, de hivatalosan nem kiosztott, ezért mindig implementálja mindkét érvényesítési réteget éles üzemben.

Könyvtárak és csomagok: Ha CUIT/CUIL érvényesítést épít be a kódbázisába, fontolja meg ezeket a bevált könyvtárakat saját megoldás helyett:

  • JavaScript: validar-cuit npm csomag kezeli az érvényesítést és formázást
  • PHP: afip-php könyvtár biztosít érvényesítést és AFIP webszolgáltatás integrációt
  • Python: py-cuit PyPI-n teljes algoritmust implementál

Karbantartott könyvtárak használata csökkenti a megvalósítási hibák kockázatát, és gyakran tartalmazza azokat a speciális eseteket, amelyeket egyedi kódban könnyen elfelejtenének.

Manuális számítás: Tanulási célokra vagy hibakeresésre, az algoritmus kézi végigvezetése segít a megértésben. Fogjon egy kalkulátort és egy CUIT/CUIL mintát, majd kövesse lépésről lépésre a súlyozott szorzási folyamatot.

Vállalati érvényesítési szolgáltatások: Nagyméretű alkalmazások előnyére válhatnak harmadik féltől származó érvényesítési API-k, amelyek nemcsak a formátumot ellenőrzik, hanem kereskedelmi adatbázisokkal is kereszthivatkoznak. Ezek a szolgáltatások képesek jelezni inaktív vállalkozásokat, azonosítani szankcionált szervezeteket vagy további metaadatokat biztosítani a CUIT/CUIL tulajdonosáról.

A CUIT/CUIL Rendszer Története

A CUIT/CUIL azonosítási rendszer Argentínában jelentősen fejlődött létrehozása óta:

Eredetek és Bevezetés

A CUIT (Clave Única de Identificación Tributaria) első alkalommal az 1970-es években került bevezetésre Argentínában, mint az adóbeszedési rendszer korszerűsítésének része. A Közigazgatási Adóhivatal (AFIP) vezette be ezt az egyedi azonosítót, hogy hatékonyabban nyomon kövesse 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 specifikusan azonosítsa a munkavállalókat a társadalombiztosítási rendszerben, megteremtve a különbséget az adóazonosítás és a munkaügyi azonosítás között, miközben konzisztens formátumot tart fenn.

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 rendszer további digitalizáláson esett át, és online ellenőrzési rendszereket vezettek be.

A 2000-es évek elején a CUIT/CUIL rendszer integrálódott a különböző digitális kormányzati szolgáltatásokkal, kulcsfontosságú elemmé válva Argentína e-kormányzati kezdeményezéseiben. Ebben az időszakban történt meg a jelenleg is használatos ellenőrzési algoritmus és formátum szabványosítása.

Legutóbbi Fejlemények

Az utóbbi években az AFIP fokozta a CUIT/CUIL számok biztonsági és ellenőrzési folyamatait, kifinomultabb érvényesítési rendszereket vezetve be és más kormányzati adatbázisokkal integrálva azokat. A rendszer most kulcsfontosságú szerepet játszik Argentína adóelkerülés elleni küzdelmében és a gazdaság formalizálásában.

Napjainkban a CUIT/CUIL nemcsak adó- és foglalkoztatási célokra szolgál, hanem széles körben használják banki ügyletekhez, ingatlan-tranzakciókhoz, közüzemi szolgáltatásokhoz és online vásárlásokhoz, így nélkülözhetetlen azonosítóvá vált mind magánszemélyek, mind vállalkozások számára Argentínában.

Megvalósítási szempontok

A CUIT/CUIL érvényesítés saját rendszereiben történő megvalósítása során vegye figyelembe ezeket a technikai aspektusokat:

Algoritmus stabilitása: A jelenlegi CUIT/CUIL ellenőrző algoritmus változatlan maradt a szabványosítás óta az 1990-es években. Az AFIP műszaki dokumentációja szerint a modulo-11 súlyozott ellenőrző számjegy megközelítés a Resolución General 2854/2010 és az azt követő szabályozásokban van rögzítve. Ez a stabilitás azt jelenti, hogy a megvalósítások ritkán igényelnek frissítéseket, de figyelemmel kell kísérnie az AFIP közleményeit az esetleges szabályozási változásokkal kapcsolatban.

Teljesítmény optimalizálás: Az ellenőrző algoritmus számítási szempontból olcsó - mindössze 10 szorzás, egy összeadás és egy modulo művelet. Nagy áteresztőképességű rendszereknél, amelyek másodpercenként ezrével végeznek ellenőrzéseket, a szűk keresztmetszet általában a hálózati késleltetés az AFIP adatbázisával történő ellenőrzéskor, nem maga az algoritmus. Érdemes megfontolni az AFIP ellenőrzési eredmények gyorsítótárazását megfelelő élettartammal (jellemzően 24 óra), hogy egyensúlyba hozzuk a frissességet a teljesítménnyel.

Karakterkódolás: Külső forrásokból (PDF-ek, beszkennelt dokumentumok, webes adatgyűjtés) érkező CUIT/CUIL adatok feldolgozásakor figyeljen a karakterkódolási problémákra. A kötőjel megjelenhet em dash (U+2014), en dash (U+2013) vagy mínusz jel (U+2212) formájában is a szabványos kötőjel-mínusz (U+002D) helyett. Normalizálja ezeket az ellenőrzés előtt a hamis negatívok elkerülése érdekében.

Internacionalizáció: Ha alkalmazása több latin-amerikai piacot is kiszolgál, vegye figyelembe, hogy Argentína CUIT/CUIL-ja modulo-11-et használ specifikus súlyokkal, míg Chile RUT-ja modulo-11-et más súlyokkal, Brazília CPF/CNPJ-je pedig modulo-11-et ismét más mintázattal. Ne feltételezze, hogy az algoritmusok azonosak - minden ország rendszere eltérő szabályokkal rendelkezik. A ellenőrző számjegy algoritmusok mélyebb megértéséhez tekintse meg a ISO/IEC 7064 szabványt, amely formalizálja a különböző modulo-alapú ellenőrzési sémákat.

Adatbázis tárolás: Tárolja a CUIT/CUIL számokat kötőjelek nélkül fix hosszúságú CHAR(11) mezőben vagy BIGINT-ként, ha az adatbázisa támogatja a 11 számjegyű egészeket pontosságvesztés nélkül. Adjon hozzá ellenőrző kényszerítést, amely érvényesíti az ellenőrző számjegyet adatbázis szinten, védekezve a sérült adatok ellen. Hozzon létre indexeket ezen a mezőn a hatékony kereséshez, amikor a felhasználók CUIT/CUIL alapján keresnek.

Kódpéldák

Python

1def calculate_verification_digit(type_code, dni):
2    # Átalakítás karakterlánccá és DNI 8 számjegyűre kiegészítése nullákkal
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Típuskód és DNI kombinálása
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    # Szorzatok összegének kiszámítása
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Ellenőrző számjegy kiszámítása
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Speciális 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ípuskó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ípuskód. A következők egyikének kell lennie: {valid_type_codes}")
34    
35    # Véletlenszerű DNI generálása, ha nem lett megadva
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Ellenőrző számjegy kiszámítása
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # CUIT/CUIL formázása
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Kötőjelek eltávolítása, ha vannak
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Alapvető formátum ellenőrzése
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Érvénytelen formátum"
52    
53    # Részek kibontása
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    # Típuskód érvényesítése
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ípuskód"
62    
63    # Ellenőrző számjegy kiszámítása és összehasonlítása
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-vel
72print(generate_cuit_cuil(27))  # Generálás véletlenszerű DNI-vel
73print(validate_cuit_cuil("20-12345678-9"))  # CUIT/CUIL érvényesítése
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Átalakítás karakterlánccá és DNI 8 számjegyűre kiegészítése nullákkal
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Típuskód és DNI kombinálása
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  // Szorzatok összegének kiszámítása
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Ellenőrző számjegy kiszámítása
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Speciális 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ípuskódok
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Érvénytelen típuskód. A következők egyikének kell lennie: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Véletlenszerű DNI generálása, ha nem lett megadva
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Ellenőrző számjegy kiszámítása
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // CUIT/CUIL formázása
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Kötőjelek eltávolítása, ha vannak
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Alapvető formátum ellenőrzése
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Érvénytelen formátum' };
58  }
59  
60  // Részek kibontása
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  // Típuskód érvényesítése
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Érvénytelen típuskód' };
69  }
70  
71  // Ellenőrző számjegy kiszámítása és összehasonlítása
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-vel
82console.log(generateCuitCuil(27)); // Generálás véletlenszerű DNI-vel
83console.log(validateCuitCuil("20-12345678-9")); // CUIT/CUIL érvényesítése
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        // Átalakítás karakterlánccá és DNI 8 számjegyűre kiegészítése nullákkal
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Típuskód és DNI kombinálása
15        String digits = typeCodeStr + dniStr;
16        
17        // Szorzatok összegének kiszámítása
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Ellenőrző számjegy kiszámítása
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Speciális 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ípuskód. A következők egyikének kell lennie: " + VALID_TYPE_CODES);
39        }
40        
41        // Véletlenszerű DNI generálása, ha nem lett megadva
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Ellenőrző számjegy kiszámítása
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // CUIT/CUIL formázása
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Kötőjelek eltávolítása, ha vannak
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Alapvető formátum ellenőrzése
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Érvénytelen formátum");
61        }
62        
63        // Részek kibontása
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        // Típuskód érvényesítése
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Érvénytelen típuskód");
71        }
72        
73        // Ellenőrző számjegy kiszámítása és összehasonlítása
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-vel
103        System.out.println(generateCuitCuil(27, null)); // Generálás véletlenszerű DNI-vel
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // CUIT/CUIL érvényesítése
105    }
106}
107

PHP

<?php function calculateVerificationDigit($typeCode, $dni) { // Átalakítás karakterlánccá és DNI 8 számjegyűre kiegészítése nullákkal $typeCodeStr = (string)$typeCode; $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT); // Típuskód és DNI kombinálása $digits = $typeCodeStr . $dniStr; // Súlyok minden pozícióhoz $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]; // Szorzatok összegének kiszámítása $sumProducts = 0; for ($i = 0; $i < 10; $i++) { $sumProducts += (int)$digits[$i] * $weights[$i]; } // Ellenőrző számjegy kiszámítása $verificationDigit = 11 - ($sumProducts % 11); // Speciális esetek if ($verificationDigit == 11) { $verificationDigit = 0; } else if ($verificationDigit == 10) { $verificationDigit = 9; } return $verificationDigit; } function generateCuitCuil($typeCode, $dni = null) { // Érvényes típuskódok $validTypeCodes = [20, 23, 24, 27, 30, 33, 34]; if (!in_array($typeCode, $validTypeCodes)) { throw new Exception("Érvénytelen típuskód. A következők egyikének kell lennie: " . implode(', ', $validTypeCodes)); } // Véletlenszerű DNI generálása, ha nem lett megadva if ($dni === null) { $dni = rand(10000000, 99999999); } // Ellenőrző számjegy kiszámítása $verificationDigit = calculateVerificationDigit($typeCode, $dni); // CUIT/CUIL formázása return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit); } function validateCuitCuil($cuitCuil) { // Kötőjelek eltávolítása, ha vannak $cuitCuilClean = str_replace('-', '', $cuitCuil); // Alapvető formátum ellenőrzése if (!preg_match('/^\d{11}$/', $cuitCuilClean)) { return ['isValid' => false, 'errorMessage' => 'Érvénytelen formátum']; } ## Gyakran Ismételt Kérdések ### Mi a különbség a CUIT és a CUIL között? Íme a gyakorlati megkülönböztetés: A **CUIT** (Clave Única de Identificación Tributaria) adózókat azonosít - mind magánszemélyeket, mind vállalkozásokat, akik adót vallanak be az AFIP-nál. A **CUIL** (Clave Única de Identificación Laboral) munkavállalókat azonosít a társadalombiztosítási rendszerben foglalkoztatási és nyugdíjcélokra. A gyakorlatban sok egyén rendelkezik mind CUIL-lel (első munkahelyétől), és később kaphat CUIT-et (ha önállóvá válik vagy vállalkozást indít). A számok azonos formázást és számítási szabályokat használnak, így validálási szempontból ugyanúgy kell kezelni őket. A megkülönböztetés adminisztratív célokból fontos: a bérszámfejtési rendszerek általában CUIL-lel, míg a számlázási és adórendszerek CUIT-tel dolgoznak. ### Milyen típuskódokat használnak magánszemélyeknél és cégeknél? Magánszemélyeknél: - 20, 23, 24: Férfi magánszemélyek (CUIL) - 27: Női magánszemélyek (CUIL) Cégeknél és szervezeteknél: - 30: Vállalatok (CUIT) - 33: Civil szervezetek (CUIT) - 34: Alapítványok (CUIT) ### Hogyan számítják a ellenőrző számjegyet? Az algoritmus súlyozott szorzást használ: vegye az első 10 számjegyet, szorozza meg a **5, 4, 3, 2, 7, 6, 5, 4, 3, 2** súlyokkal, adja össze a szorzatokat, majd számítsa ki 11nusz (összeg modulo 11). Két speciális eset zavarja meg az embereket: ha a számítás 11-et eredményez, használjon 0-t ellenőrző számjegyként; ha 10-et eredményez, használjon 9-et. Ezek a speciális esetek azért léteznek, mert az ellenőrző számjegynek egyetlen számjegynek kell lennie (0-9). Ez egy modulo-11 ellenőrző számjegy algoritmus, hasonló az ISBN-10 kódoknál és más azonosítási rendszereknél világszerte használtakhoz. ### Használhatom ezt az eszközt valódi, hivatalos CUIT/CUIL számok generálásához? Nem - ez az eszköz matematikailag érvényes tesztadatokat generál, de a számok nem hivatalosan regisztráltak az AFIP-nál. Gondoljon rá úgy, mint egy érvényes hitelkártyaszám generálására a Luhn algoritmussal: átmegy a formátum ellenőrzésen, de nem kapcsolódik valós fiókhoz. Hivatalos CUIT/CUIL regisztrációhoz magánszemélyeknek fel kell keresniük az AFIP-ot DNI-jükkel, míg a vállalkozásoknak végre kell hajtaniuk a vállalati regisztrációs eljárásokat. Az eszköz kizárólag fejlesztési, tesztelési és oktatási célokra szolgál, ahol érvényesnek tűnő adatokra van szükség, amelyek nemütköznek valós azonosító számokkal. [A fordítás folytatódik a további részekkel...] ## Hivatkozások 1. AFIP (Közigazgatási Adóhivatal). "CUIT/CUIL/CDI." Hivatalos honlap. [https://www.afip.gob.ar/](https://www.afip.gob.ar/) 2. Munka-, Foglalkoztatási és Szociális Biztonsági Minisztérium. "CUIL - Munkaügyi Egyedi Azonosító Kód." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo) 3. ANSES (Nemzeti Szociális Biztonsági Igazgatóság). "CUIL lekérése." [https://www.anses.gob.ar/](https://www.anses.gob.ar/) 4. Argentín Köztársaság Hivatalos Közlönye. "AFIP Általános Rendelet 2854/2010: Eljárás. Adóazonosító Egységes Kód (C.U.I.T.)." 5. Argentín Köztársaság Adótörvénykönyve. "Adózók Azonosítása és Nyilvántartása." --- Akár számlázási rendszert épít, alkalmazotti belépési folyamatokat tesztel, vagy algoritmus-érvényesítéseket tanulmányoz, ez az eszköz biztosítja a CUIT/CUIL generáláshoz és érvényesítéshez szükséges funkciókat. Generáljon tesztadatokat, amelyek átmennek az algoritmikus ellenőrzésen, ellenőrizze a számokat adatbázisba kerülés előtt, vagy fedezze fel, hogyan működik a ellenőrző számjegy algoritmus a gyakorlatban.