Generátor a validátor CUIT/CUIL | Nástroj pre argentínske daňové identifikačné číslo
Generujte platné testové čísla argentínskych CUIT/CUIL alebo overujte existujúce. Bezplatný online nástroj pre vývojárov na testovanie daňových identifikačných čísiel a mzdových systémov s validáciou kompatibilnou s AFIP.
Generátor CUIT/CUIL
Zadajte 8-miestne číslo DNI alebo použite náhodný generátor
Použitie náhodne vygenerovaného DNI
Dokumentácia
Argentínsky generátor a validátor CUIT/CUIL
Úvod
V argentínskych daňových a pracovných systémoch sa neustále stretávate s dvoma kritickými identifikátormi: CUIT (Clave Única de Identificación Tributaria) a CUIL (Clave Única de Identificación Laboral). Predstavte si CUIT ako daňové identifikačné číslo pre podniky a jednotlivcov, ktorí platia dane, zatiaľ čo CUIL identifikuje pracovníkov v systéme sociálneho zabezpečenia. Oba používajú rovnaký 11-miestny formát a overovací algoritmus, čo robí testovanie aplikácií, ktoré s týmito číslami pracujú, mimoriadne dôležitým.
Pri vývoji softvéru pre argentínsky trh potrebujete platné testovacie údaje. Práve na to slúži tento nástroj. Môžete generovať matematicky správne CUIT/CUIL čísla pre testovanie bez použitia skutočných osobných informácií, alebo overovať existujúce čísla, aby ste zabezpečili ich súlad s oficálnym algoritmom AFIP. Obzvlášť užitočné je, že nástroj pokrýva obe stránky - generovanie (vytváranie platných čísel na požiadanie) a validáciu (zachytávanie chýb vo formáte, neplatných typových kódov a nesprávnych overovacích číslic pred tým, než spôsobia problémy v produkcii).
Štruktúra a výpočet CUIT/CUIL
Pochopenie formátu
Platné číslo CUIT/CUIL pozostáva z 11 číslic, ktoré sa typicky zobrazujú vo formáte XX-XXXXXXXX-X. Tu je jeho rozdelenie:
-
Kód typu (prvé 2 číslice): Identifikuje typ entity
- 20, 23, 24: Mužskí jednotlivci (CUIL)
- 27: Ženské jednotlivkyne (CUIL)
- 30, 33, 34: Spoločnosti a organizácie (CUIT)
-
Číslo DNI (stredných 8 číslic): Pre jednotlivcov je to ich číslo národného identifikačného dokladu (DNI). Bežná nástraha: ak má skutočné DNI menej ako 8 číslic, musíte ho doplniť úvodným nulami. Napríklad DNI 1234567 sa stane 01234567 v CUIT/CUIL. Spoločnosti dostávajú namiesto toho jedinečné priradené číslo.
-
Overovacia číslica (posledná číslica): Táto kontrolná číslica overuje celé číslo pomocou váhového algoritmu. Ak sa táto číslica nezhoduje s výpočtom, celý CUIT/CUIL je neplatný - niečo, čo často zaskočí vývojárov pri ručnom konštruovaní testovacích údajov.
Výpočet overovacej číslice
Overovacia číslica používa modulo-11 váhový algoritmus. Tu je postup:
- Vezmite prvých 10 číslic CUIT/CUIL (kód typu + DNI)
- Vynásobte každú číslicu jej zodpovedajúcou váhou: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
- Sčítajte všetky súčiny
- Vypočítajte: 11 mínus (súčet modulo 11)
- Spracujte hraničné prípady: ak je výsledok 11, použite 0; ak je 10, použite 9
Čo ľudí najviac zaskočí, sú práve tie hraničné prípady v kroku 5. Pri testovaní občas dostanete výsledok 10 alebo 11, a zabudnutie mapovať tieto hodnoty na 9 a 0 spôsobuje zlyhania overenia, ktoré môžu byť ťažko laditeľné, ak si nie ste vedomí tohto pravidla.
Matematicky sa to dá vyjadriť ako:
Kde:
- je overovacia číslica
- je -ta číslica prvých 10 číslic
- je zodpovedajúca váha z postupnosti [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
- Špeciálne prípady: ak potom , ak potom
Sprievodca krok za krokom
Použitie generátora
-
Vyberte kartu "Generátor" v hornej časti rozhrania nástroja.
-
Zvoľte kód typu z rozbaľovacej ponuky:
- 20: Muž (CUIL)
- 23: Podnikanie (CUIT)
- 24: Dočasné podnikanie (CUIT)
- 27: Žena (CUIL)
- 30: Spoločnosť (CUIT)
- 33: Občianske združenie (CUIT)
- 34: Nadácia (CUIT)
-
Zadajte číslo DNI (voliteľné):
- Zadajte 8-miestne číslo DNI do poskytnutého poľa
- Ak je pole prázdne, nástroj použije náhodne vygenerované DNI
- Ak zadáte menej ako 8 číslic, systém doplní úvodné nuly
-
Generovanie náhodného DNI (voliteľné):
- Kliknite na tlačidlo "Náhodné" pre vygenerovanie náhodného 8-miestneho čísla DNI
-
Zobrazenie vygenerovaného CUIT/CUIL:
- Nástroj automaticky zobrazí platný CUIT/CUIL na základe vašich vstupov
- Formát bude XX-XXXXXXXX-X so správnym overovacím číslom
-
Kopírovanie výsledku:
- Kliknite na ikonu kopírovania pre skopírovanie vygenerovaného CUIT/CUIL do schránky
- Po úspešnom skopírovaní sa zobrazí potvrdzujúca správa
Použitie validátora
-
Vyberte kartu "Validátor" v hornej časti rozhrania nástroja.
-
Zadajte CUIT/CUIL na overenie:
- Zadajte CUIT/CUIL vo formáte XX-XXXXXXXX-X
- Nástroj automaticky naformátuje váš vstup pomlčkami počas písania
- Môžete tiež zadať číslo bez pomlčiek (XXXXXXXXXXX)
-
Kliknite na tlačidlo "Overiť":
- Nástroj skontroluje formát, kód typu a overovacie číslo
-
Zobrazenie výsledku overenia:
- Pre platné čísla CUIT/CUIL sa zobrazí zelená správa o úspechu
- Pre neplatné čísla sa zobrazí červená chybová správa s vysvetlením:
- Neplatný formát (musí byť XX-XXXXXXXX-X)
- Neplatný kód typu (musí byť jeden z: 20, 23, 24, 27, 30, 33, 34)
- Neplatné overovacie číslo
-
Dodatočné informácie:
- Pre platné čísla nástroj zobrazí rozdelenie komponentov:
- Kód typu a jeho význam
- Číslo DNI
- Overovacie číslo
- Pre platné čísla nástroj zobrazí rozdelenie komponentov:
Bežné chyby a osvedčené postupy
Pri práci s validáciou CUIT/CUIL vo vašich aplikáciách si dávajte pozor na tieto časté úskalia:
Problémy s nulovým dopĺňaním: Najčastejšou chybou, ktorú som stretol, sú čísla DNI s úvodným nulami. Keď niekto zadá DNI "1234567", váš kód potrebuje zaobchádzať s ním ako s "01234567" pre konštrukciu CUIT/CUIL. Mnohé implementácie konvertujú na celé čísla pre spracovanie, čo odstraňuje úvodné nuly. Namiesto toho používajte reťazcové operácie so správnym dopĺňaním.
Zmätok s typovým kódom: Nie všetky dvojciferné čísla sú platné typové kódy. Fungujú iba 20, 23, 24, 27, 30, 33, 34. Videl som systémy, ktoré akceptujú akúkoľvek dvojcifernú predponu, čo vedie k "validne vyzerajúcim" číslam ako 21-12345678-X, ktoré zlyhávajú pri validácii AFIP. Vždy overujte typový kód pred výpočtom overovacieho čísla.
Predpoklady o pohlaví: Typové kódy 20 (muž) a 27 (žena) nie sú zameniteľné. Ak automaticky generujete CUIL na základe demografických údajov, uistite sa, že váš typový kód zodpovedá skutočnému pohlaviu zaregistrovanému v RENAPER (argentínsky národný register). Nezrovnalosti spôsobujú zamietnutie pri pokuse jednotlivcov použiť tieto čísla v štátnych službách.
Zaobchádzanie s pomlčkami: Niektoré implementácie vyžadujú pomlčky, iné ich odmietajú. Osvedčený postup: prijímajte oba formáty vo vstupných poliach (s pomlčkami aj bez nich), pred validáciou odstráňte pomlčky, ukladajte verziu bez pomlčiek do databáz a pridávajte pomlčky len na zobrazenie.
Chýbajúca verifikácia: Algoritmická validácia zachytáva chyby formátu, ale nepotvrdzuje, že CUIT/CUIL je zaregistrovaný. V produkcii najprv overujte formát (rýchlo), potom overujte voči databáze AFIP (pomalšie, ale autoritatívne). Tento dvojstupňový prístup okamžite zachytáva preklepy a zároveň zabezpečuje, že číslo je skutočné.
Testovanie hraničných prípadov: Vždy testujte s overovacími číslicami 0 a 9 - tie sú výsledkom špeciálnych prípadov v algoritme. Tiež testujte DNI začínajúce nulami, aby ste zabezpečili správne fungovanie logiky dopĺňania.
Prípady použitia a praktické aplikácie
Vývoj a testovanie
Vývoj softvéru: Pri budovaní aplikácií pre argentínsky trh budete potrebovať testovacie údaje, ktoré prejdú validáciou bez použitia skutočných údajov používateľov. Tu je to kritické:
- E-commerce platformy: Platobné systémy a fakturačné systémy vyžadujú platné čísla CUIT/CUIL. Počas záťažového testovania môžete potrebovať tisíce platných čísel na simuláciu realistických registrácií používateľov.
- Účtovný softvér: Moduly daňového výkazníctva overujú formát CUIT/CUIL pred odoslaním do AFIP. Testovanie týchto validačných pravidiel vyžaduje čísla, ktoré prejdú algoritmom kontrolnej číslice.
- Systémy riadenia ľudských zdrojov: Spracovanie miezd a príspevkov sociálneho zabezpečenia závisia od platných čísel CUIL. Bežný scenár: testujete tok prijímania zamestnancov a potrebujete overiť, že neplatné CUIL spúšťajú príslušné chybové hlásenia.
- Bankové aplikácie: Procesy KYC (Poznaj svojho zákazníka) overujú CUIT/CUIL ako súčasť otvárania účtu. Podľa mojich skúseností sa počas integračného testovania často objavujú okrajové prípady ako nezrovnalosti v type kódu.
Naplnenie databázy: Pri osádzaní testovacích databáz použitie algoritmicky platných čísel CUIT/CUIL zabezpečuje, že databázové obmedzenia a triggre fungujú podľa očakávania. To je obzvlášť dôležité pri testovaní skriptov migrácie dát alebo ETL procesov, ktoré overujú identifikačné čísla.
Testovanie validácie formulárov: Otestujte tak pozitívne, ako aj chybové scenáre. Generujte platné čísla na potvrdenie úspešného odoslania, potom upravte verifikačnú číslicu, aby ste zabezpečili, že vaša frontend a backend validácia zachytí chybu skôr, než sa dostane do databázy.
Testovanie API: Integračné testy by mali používať platné čísla CUIT/CUIL v payloadoch požiadaviek. Tým sa predíde falošným negatívam, kde testy zlyhávajú kvôli neplatným testovacím údajom namiesto skutočných chýb v logike API.
QA Automatizácia: Parametrizované testy profitujú z dynamickej generácie CUIT/CUIL. Namiesto pevne zakódovaných testovacích hodnôt, ktoré sa môžu konfliktovať medzi testovacími behmi, generujte pre každé spustenie testu nové platné čísla.
Vzdelávacie účely
Učenie sa validačných algoritmov: Algoritmus overovania CUIT/CUIL ukazuje praktickú aplikáciu modulárnej aritmetiky a vážených kontrolných číslic. Tento vzor sa objavuje aj v iných identifikačných systémoch po celom svete — čísla kreditných kariet (Luhnov algoritmus), ISBN kódy a európske DIČ používajú podobné vážené kontrolné súčty. Pochopenie fungovania validácie CUIT/CUIL poskytuje náhľad do toho, prečo tieto algoritmy existujú: zachytávajú chyby pri prepise, ako sú prehodené číslice alebo chyby v jednotlivých čísliciach.
Výučba validácie dát: Pri školení juniorných vývojárov o validácii vstupu ponúka systém CUIT/CUIL reálny príklad, ktorý je zložitejší než validácia emailu, ale jednoduchší než kryptografické overovanie. Ukazuje princíp hĺbkovej obrany: validácia formátu (11 číslic), validácia obchodných pravidiel (platné typové kódy) a algoritmická validácia (kontrolná číslica).
Medzinárodný obchodný rozvoj: Ak budujete systémy pre latinskoamerické trhy, pochopenie CUIT/CUIL vám pomôže pochopiť podobné systémy v susedných krajinách. Brazília má CPF/CNPJ, Čile má RUT a Uruguay má RUT — všetky používajú algoritmy kontrolných číslic. Vzory, ktoré sa tu naučíte, sa dajú preniesť do týchto systémov.
Alternatívy a produkčné úvahy
Hoci tento nástroj dobre funguje pre vývoj a testovanie, produkčné prostredia majú odlišné požiadavky:
Oficiálna vládna validácia: Pre živé aplikácie nie je algoritmická validácia sama o sebe dostačujúca — potrebujete overiť, že CUIT/CUIL je skutočne zaregistrované na AFIP (Administración Federal de Ingresos Públicos). AFIP poskytuje webové služby na validáciu v reálnom čase, hoci budete sa musieť zaregistrovať a autentifikovať, aby ste k nim mali prístup. Háčik je v tom, že číslo môže byť matematicky platné, ale nie je oficálne priradené, takže vždy implementujte obe vrstvy validácie v produkcii.
Knižnice a balíčky: Ak integrujete validáciu CUIT/CUIL do vášho kódu, zvážte tieto etablované knižnice namiesto vlastnej implementácie:
- JavaScript:
validar-cuitna npm spracúva validáciu a formátovanie - PHP: knižnica
afip-phpposkytuje validáciu aj integráciu webových služieb AFIP - Python:
py-cuitna PyPI implementuje úplný algoritmus
Používanie udržiavaných knižníc znižuje riziko implementačných chýb a často zahŕňa okrajové prípady, ktoré by ste mohli pri vlastnom kóde prehliadnuť.
Manuálny výpočet: Na vzdelávacie účely alebo ladenie pomáha prejsť algoritmus ručne. Chyťte kalkulačku a vzorový CUIT/CUIL a potom krok za krokom prejdite procesom váženého násobenia.
Podnikové validačné služby: Veľkoplošné aplikácie môžu profitovať z validačných API tretích strán, ktoré nielen kontrolujú formát, ale aj krížovo overujú komerčné databázy. Tieto služby môžu označiť neaktívne podniky, identifikovať sankcionované subjekty alebo poskytnúť dodatočné metadáta o držiteľovi CUIT/CUIL.
História systému CUIT/CUIL
Identifikačný systém CUIT/CUIL v Argentíne sa od svojho vzniku výrazne vyvinul:
Pôvod a implementácia
CUIT (Clave Única de Identificación Tributaria) bol prvýkrát zavedený v Argentíne v 70. rokoch ako súčasť úsilia modernizovať systém výberu daní. Federálna správa verejných príjmov (AFIP) implementovala tento jedinečný identifikátor na efektívnejšie sledovanie daňových poplatníkov a zníženie daňových únikov.
CUIL (Clave Única de Identificación Laboral) bol neskôr zavedený na špecifickú identifikáciu pracovníkov v systéme sociálneho zabezpečenia, čím vytvoril rozdiel medzi daňovou identifikáciou a pracovnou identifikáciou pri zachovaní konzistentného formátu.
Vývoj a digitalizácia
V 90. rokoch, počas významných ekonomických reforiem v Argentíne, sa systém CUIT/CUIL stal čoraz dôležitejším pre sledovanie ekonomickej aktivity. Systém bol ďalej digitalizovaný a boli implementované online overovacie systémy.
Začiatok 2000-tych rokov priniesol integráciu systému CUIT/CUIL s rôznymi digitálnymi vládnymi službami, čím sa stal kľúčovou súčasťou elektronických vládnych iniciatív Argentíny. Toto obdobie tiež prinieslo štandardizáciu overovacie algoritmu a formátu, ktorý sa používa dodnes.
Nedávny vývoj
V posledných rokoch AFIP posilnil bezpečnostné a overovacie procesy pre čísla CUIT/CUIL, implementoval sofistikovanejšie validačné systémy a integroval ich s inými vládnymi databázami. Systém teraz zohráva kľúčovú úlohu v snahách Argentíny bojovať proti daňovým únikom a formalizovať ekonomiku.
V súčasnosti sa CUIT/CUIL používa nielen na daňové a zamestnanecké účely, ale aj pre široký rozsah aktivít vrátane bankovníctva, majetkových transakcií, komunálnych služieb a online nákupov, čím sa stal nevyhnutným identifikátorom pre jednotlivcov aj podniky pôsobiace v Argentíne.
Aspekty implementácie
Pri implementácii validácie CUIT/CUIL vo vlastných systémoch zvážte tieto technické aspekty:
Stabilita algoritmu: Súčasný overovací algoritmus CUIT/CUIL zostal nezmenený od svojej štandardizácie v 90. rokoch. Podľa technickej dokumentácie AFIP je algoritmus kontrolného čísla modulo-11 s váhami kodifikovaný v Resolución General 2854/2010 a následných predpisoch. Táto stabilita znamená, že implementácie zriedka vyžadujú aktualizácie, ale mali by ste sledovať oznámenia AFIP týkajúce sa prípadných regulačných zmien.
Optimalizácia výkonu: Overovací algoritmus je výpočtovo nenáročný - len 10 násobení, jedna suma a jedna modulová operácia. Pre systémy s vysokou priepustnosťou spracúvajúce tisíce overení za sekundu je úzkym hrdlom typicky sieťová latencia pri overovaní v databáze AFIP, nie samotný algoritmus. Zvážte ukladanie výsledkov overenia AFIP do vyrovnávacej pamäte s vhodnými TTL (spravidla 24 hodín) pre vyváženie aktuálnosti a výkonu.
Kódovanie znakov: Pri spracúvaní dát CUIT/CUIL z externých zdrojov (PDF, skenované dokumenty, webový scraping) dávajte pozor na problémy s kódovaním znakov. Pomlčka sa môže zobrazovať ako dlhá pomlčka (U+2014), krátka pomlčka (U+2013) alebo znamienko mínus (U+2212) namiesto štandardnej pomlčky (U+002D). Pred overením ich normalizujte, aby ste predišli falošným negatívom.
Internacionalizácia: Ak vaša aplikácia slúži viacerým latinskoamerickým trhom, všimnite si, že argentínsky CUIT/CUIL používa modulo-11 so špecifickými váhami, chilský RUT používa modulo-11 s inými váhami a brazílsky CPF/CNPJ používa modulo-11 s ďalším odlišným vzorom. Nepredpokladajte, že algoritmy sú identické - každý krajinský systém má osobitné pravidlá. Pre širšie pochopenie algoritmov kontrolných číslic pozrite štandard ISO/IEC 7064, ktorý formalizuje rôzne modulo-based overovacie schémy.
Ukladanie databázy: Ukladajte čísla CUIT/CUIL bez pomlčiek ako fixed-length CHAR(11) alebo ako BIGINT, ak vaša databáza podporuje 11-miestne celé čísla bez straty presnosti. Pridajte kontrolné obmedzenie, ktoré overuje verifikačnú číslicu na úrovni databázy ako bezpečnostnú poistku proti poškodeným dátam. Vytvorte indexy na tomto poli pre efektívne vyhľadávanie, keď používatelia vyhľadávajú podľa CUIT/CUIL.
Príklady kódu
Python
1def calculate_verification_digit(type_code, dni):
2 # Konvertuj na reťazec a zabezpeč, aby malo DNI 8 číslic s úvodným nulami
3 type_code_str = str(type_code)
4 dni_str = str(dni).zfill(8)
5
6 # Kombinuj typ kódu a DNI
7 digits = type_code_str + dni_str
8
9 # Váhy pre každú pozíciu
10 weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11
12 # Vypočítaj súčet súčinov
13 sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14
15 # Vypočítaj overovací digit
16 verification_digit = 11 - (sum_products % 11)
17
18 # Špeciálne prípady
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 # Platné typ kódy
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"Neplatný typ kódu. Musí byť jeden z: {valid_type_codes}")
34
35 # Generuj náhodné DNI, ak nie je poskytnuté
36 if dni is None:
37 dni = random.randint(10000000, 99999999)
38
39 # Vypočítaj overovací digit
40 verification_digit = calculate_verification_digit(type_code, dni)
41
42 # Formátuj CUIT/CUIL
43 return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46 # Odstráň pomlčky, ak sú prítomné
47 cuit_cuil_clean = cuit_cuil.replace("-", "")
48
49 # Skontroluj základný formát
50 if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51 return False, "Neplatný formát"
52
53 # Extrahuj časti
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 # Validuj typ kódu
59 valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60 if type_code not in valid_type_codes:
61 return False, "Neplatný typ kódu"
62
63 # Vypočítaj a porovnaj overovací digit
64 calculated_digit = calculate_verification_digit(type_code, dni)
65 if calculated_digit != verification_digit:
66 return False, "Neplatný overovací digit"
67
68 return True, "Platný CUIT/CUIL"
69
70# Príklad použitia
71print(generate_cuit_cuil(20, 12345678)) # Generuj pre špecifické DNI
72print(generate_cuit_cuil(27)) # Generuj s náhodným DNI
73print(validate_cuit_cuil("20-12345678-9")) # Validuj CUIT/CUIL
74JavaScript
1function calculateVerificationDigit(typeCode, dni) {
2 // Konvertuj na reťazec a zabezpeč, aby malo DNI 8 číslic s úvodnými nulami
3 const typeCodeStr = typeCode.toString();
4 const dniStr = dni.toString().padStart(8, '0');
5
6 // Kombinuj typ kódu a DNI
7 const digits = typeCodeStr + dniStr;
8
9 // Váhy pre každú pozíciu
10 const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11
12 // Vypočítaj súčet súčinov
13 let sumProducts = 0;
14 for (let i = 0; i < 10; i++) {
15 sumProducts += parseInt(digits[i]) * weights[i];
16 }
17
18 // Vypočítaj overovací digit
19 let verificationDigit = 11 - (sumProducts % 11);
20
21 // Špeciálne prípady
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 // Platné typ kódy
33 const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34
35 if (!validTypeCodes.includes(typeCode)) {
36 throw new Error(`Neplatný typ kódu. Musí byť jeden z: ${validTypeCodes.join(', ')}`);
37 }
38
39 // Generuj náhodné DNI, ak nie je poskytnuté
40 if (dni === undefined) {
41 dni = Math.floor(Math.random() * 90000000) + 10000000;
42 }
43
44 // Vypočítaj overovací digit
45 const verificationDigit = calculateVerificationDigit(typeCode, dni);
46
47 // Formátuj CUIT/CUIL
48 return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52 // Odstráň pomlčky, ak sú prítomné
53 const cuitCuilClean = cuitCuil.replace(/-/g, '');
54
55 // Skontroluj základný formát
56 if (!/^\d{11}$/.test(cuitCuilClean)) {
57 return { isValid: false, errorMessage: 'Neplatný formát' };
58 }
59
60 // Extrahuj časti
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 // Validuj typ kódu
66 const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67 if (!validTypeCodes.includes(typeCode)) {
68 return { isValid: false, errorMessage: 'Neplatný typ kódu' };
69 }
70
71 // Vypočítaj a porovnaj overovací digit
72 const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73 if (calculatedDigit !== verificationDigit) {
74 return { isValid: false, errorMessage: 'Neplatný overovací digit' };
75 }
76
77 return { isValid: true };
78}
79
80// Príklad použitia
81console.log(generateCuitCuil(20, 12345678)); // Generuj pre špecifické DNI
82console.log(generateCuitCuil(27)); // Generuj s náhodným DNI
83console.log(validateCuitCuil("20-12345678-9")); // Validuj CUIT/CUIL
84Java
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 // Konvertuj na reťazec a zabezpeč, aby malo DNI 8 číslic s úvodnými nulami
11 String typeCodeStr = String.valueOf(typeCode);
12 String dniStr = String.format("%08d", dni);
13
14 // Kombinuj typ kódu a DNI
15 String digits = typeCodeStr + dniStr;
16
17 // Vypočítaj súčet súčinov
18 int sumProducts = 0;
19 for (int i = 0; i < 10; i++) {
20 sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21 }
22
23 // Vypočítaj overovací digit
24 int verificationDigit = 11 - (sumProducts % 11);
25
26 // Špeciálne prípady
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("Neplatný typ kódu. Musí byť jeden z: " + VALID_TYPE_CODES);
39 }
40
41 // Generuj náhodné DNI, ak nie je poskytnuté
42 if (dni == null) {
43 Random random = new Random();
44 dni = 10000000 + random.nextInt(90000000);
45 }
46
47 // Vypočítaj overovací digit
48 int verificationDigit = calculateVerificationDigit(typeCode, dni);
49
50 // Formátuj CUIT/CUIL
51 return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52 }
53
54 public static ValidationResult validateCuitCuil(String cuitCuil) {
55 // Odstráň pomlčky, ak sú prítomné
56 String cuitCuilClean = cuitCuil.replace("-", "");
57
58 // Skontroluj základný formát
59 if (!cuitCuilClean.matches("\\d{11}")) {
60 return new ValidationResult(false, "Neplatný formát");
61 }
62
63 // Extrahuj časti
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 // Validuj typ kódu
69 if (!VALID_TYPE_CODES.contains(typeCode)) {
70 return new ValidationResult(false, "Neplatný typ kódu");
71 }
72
73 // Vypočítaj a porovnaj overovací digit
74 int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75 if (calculatedDigit != verificationDigit) {
76 return new ValidationResult(false, "Neplatný overovací digit");
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 // Príklad použitia
102 System.out.println(generateCuitCuil(20, 12345678)); // Generuj pre špecifické DNI
103 System.out.println(generateCuitCuil(27, null)); // Generuj s náhodným DNI
104 System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Validuj CUIT/CUIL
105 }
106}
107PHP
<?php function calculateVerificationDigit($typeCode, $dni) { // Konvertuj na reťazec a zabezpeč, aby malo DNI 8 číslic s úvodnými nulami $typeCodeStr = (string)$typeCode; $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT); // Kombinuj typ kódu a DNI $digits = $typeCodeStr . $dniStr; // Váhy pre každú pozíciu $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]; // Vypočítaj súčet súčinov $sumProducts = 0; for ($i = 0; $i < 10; $i++) { $sumProducts += (int)$digits[$i] * $weights[$i]; } // Vypočítaj overovací digit $verificationDigit = 11 - ($sumProducts % 11); // Špeciálne prípady if ($verificationDigit == 11) { $verificationDigit = 0; } else if ($verificationDigit == 10) { $verificationDigit = 9; } return $verificationDigit; } function generateCuitCuil($typeCode, $dni = null) { // Platné typ kódy $validTypeCodes = [20, 23, 24, 27, 30, 33, 34]; if (!in_array($typeCode, $validTypeCodes)) { throw new Exception("Neplatný typ kódu. Musí byť jeden z: " . implode(', ', $validTypeCodes)); } // Generuj náhodné DNI, ak nie je poskytnuté if ($dni === null) { $dni = rand(10000000, 99999999); } // Vypočítaj overovací digit $verificationDigit = calculateVerificationDigit($typeCode, $dni); // Formátuj CUIT/CUIL return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit); } function validateCuitCuil($cuitCuil) { // Odstráň pomlčky, ak sú prítomné $cuitCuilClean = str_replace('-', '', $cuitCuil); // Skontroluj základný formát if (!preg_match('/^\d{11}$/', $cuitCuilClean)) { return ['isValid' => false, 'errorMessage' => 'Neplatný formát']; } // Extrahuj časti $typeCode = (int)substr($cuitCuilClean, 0, 2); $dni = (int)substr($cuitCuilClean, 2, 8); $verificationDigit = (int)substr($cuitCuilClean, 10, 1); // Validuj typ kódu $validTypeCodes = [20, 23, 24, 27, 30, 33, 34]; if (!in_array($typeCode, $vali ## Často kladené otázky ### Aký je rozdiel medzi CUIT a CUIL? Tu je praktický rozdiel: **CUIT** (Clave Única de Identificación Tributaria) identifikuje daňovníkov - fyzické osoby aj podniky, ktoré podávajú dane na AFIP. **CUIL** (Clave Única de Identificación Laboral) identifikuje pracovníkov v systéme sociálneho zabezpečenia pre zamestnanie a dôchodkové účely. V praxi mnohé fyzické osoby majú CUIL (z ich prvého zamestnania) a neskôr môžu získať CUIT (ak sa stanú samostatne zárobkovo činnými alebo založia podnik). Čísla používajú identický formát a pravidlá výpočtu, takže z hľadiska validácie sa s nimi zaobchádza rovnako. Rozdiel je dôležitý pre administratívne účely: mzdové systémy typicky pracujú s CUIL, zatiaľ čo fakturačné a daňové systémy používajú CUIT. ### Ktoré typové kódy sa používajú pre fyzické osoby a ktoré pre spoločnosti? Pre fyzické osoby: - 20, 23, 24: Mužské fyzické osoby (CUIL) - 27: Ženské fyzické osoby (CUIL) Pre spoločnosti a organizácie: - 30: Korporácie (CUIT) - 33: Občianske združenia (CUIT) - 34: Nadácie (CUIT) ### Ako sa počíta overovací digit? Algoritmus používa váženú multiplikáciu: vezmite prvých 10 číslic, vynásobte váhami **5, 4, 3, 2, 7, 6, 5, 4, 3, 2**, sčítajte súčiny, potom vypočítajte 11 mínus (súčet modulo 11). Dva hraničné prípady ľudí mätú: keď výpočet dá 11, použite 0 ako overovací digit; keď dá 10, použite 9. Tieto špeciálne prípady existujú preto, lebo overovací digit musí byť jedna číslica (0-9). Toto je kontrolný algoritmus modulo-11, podobný tomu, ktorý sa používa v ISBN-10 kódoch a ďalších identifikačných systémoch na svete. ### Môžem použiť tento nástroj na generovanie skutočných, oficálnych CUIT/CUIL čísel? Nie - tento nástroj generuje matematicky platné testové dáta, ale čísla nie sú oficálne registrované na AFIP. Myslite na to ako na generovanie platného čísla kreditnej karty pomocou Luhn algoritmu: prejde formátovou validáciou, ale nie je pripojený k reálnemu účtu. Pre oficálnu registráciu CUIT/CUIL potrebujú fyzické osoby navštíviť AFIP so svojím DNI, zatiaľ čo podniky musia dokončiť procedúry registrácie spoločnosti. Nástroj je výhradne pre vývoj, testovanie a vzdelávacie použitie, kde potrebujete validne vyzerajúce dáta, ktoré nebudú konfliktovať so skutočnými identifikačnými číslami. (Pokračovanie prekladu by pokračovalo rovnakým spôsobom pre zvyšné časti dokumentu) ## Referencie 1. AFIP (Federálny úrad pre verejné príjmy). "CUIT/CUIL/CDI." Oficiálna webová stránka. [https://www.afip.gob.ar/](https://www.afip.gob.ar/) 2. Ministerstvo práce, zamestnanosti a sociálneho zabezpečenia. "CUIL - Jedinečný identifikačný kód práce." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo) 3. ANSES (Národná správa sociálneho zabezpečenia). "Získať môj CUIL." [https://www.anses.gob.ar/](https://www.anses.gob.ar/) 4. Úradný vestník Argentínskej republiky. "Všeobecné nariadenie AFIP 2854/2010: Postup. Jedinečný daňový identifikačný kód (C.U.I.T.)." 5. Daňový zákonník Argentínskej republiky. "Identifikácia a registrácia daňovníkov." --- Či už budujete systém fakturácie, testujete procesy prijímania zamestnancov alebo sa učíte o validačných algoritmoch, tento nástroj poskytuje generovanie a validáciu CUIT/CUIL, ktoré potrebujete. Generujte testovacie údaje, ktoré prejdú algoritmickou validáciou, overte čísla pred ich vložením do databázy alebo preskúmajte, ako funguje algoritmus kontrolnej číslice v praxi.