Pereiti prie turinio
🛠️
Whiz Tools

CUIT/CUIL Generatorius ir Tikrintuvas | Argentinos Mokesčių ID Įrankis

Generuokite galiojančius Argentinos CUIT/CUIL bandomuosius numerius arba tikrinkite esamus. Nemokamas internetinis įrankis kūrėjams, testuojantiems mokesčių ID ir algalapių sistemas su AFIP patvirtintu tikrinimu.

CUIT/CUIL generatorius

Įveskite 8 skaitmenų DNI numerį arba naudokite atsitiktinį generatorių

Sugeneruotas CUIT/CUIL
20-51948347-6

Naudojamas atsitiktinai sugeneruotas DNI

Įkrovimo skaičiuotuvas...
📚

Dokumentacija

Argentinos CUIT/CUIL generatorius ir tikrintujasvas

translate the rest of the content,, please.

:

apologize for the incomplete response. Could you clarify which specific Markdown content you would like me to translate to Lithuanian? Please provide the full You markdown content you you translated.

Įvadas

Argentinos mokesčių ir darbo sistemose nuolat sutinkate du kritinius identifikatorius: CUIT (Clave Única de Identificación Tributaria) ir CUIL (Clave Única de Identificación Laboral). Galvokite apie CUIT kaip apie mokesčių ID verslams ir asmenims, mokantiems mokesčius, o CUIL identifikuoja darbuotojus socialinio draudimo sistemoje. Abu naudoja tą patį 11 skaitmenų formatą ir patikros algoritmą, kas daro ypač svarbiu testų rašymą programose, kurios tvarko šiuos numerius.

Kuriant programinę įrangą Argentinos rinkai, jums reikia galiojančių bandomųjų duomenų. Būtent tam ir skirtas šis įrankis. Galite generuoti matematiškai teisingus CUIT/CUIL numerius testavimui nenaudojant tikrų asmens duomenų arba patikrinti esamus numerius, kad įsitikintumėte, jog jie atitinka oficialų AFIP algoritmą. Ypač naudinga tai, kad įrankis apima tiek generavimo pusę (sukuriant galiojančius numerius pagal poreikį), tiek ir patikros pusę (aptinkant formato klaidas, neteisingus tipo kodus ir neteisingus patikros skaitmenis dar prieš jiems sukeliant problemas gamyboje).

CUIT/CUIL Struktūra ir Skaičiavimas

Formato Supratimas

Galiojantis CUIT/CUIL numeris susideda iš 11 skaitmenų, paprastai rodomas formatu XX-XXXXXXXX-X. Štai kaip jis išskaidomas:

  1. Tipo Kodas (pirmieji 2 skaitmenys): Identifikuoja subjekto tipą

    • 20, 23, 24: Vyriškosios lyties asmenys (CUIL)
    • 27: Moteriškosios lyties asmenys (CUIL)
    • 30, 33, 34: Įmonės ir organizacijos (CUIT)

  2. DNI Numeris (viduriniai 8 skaitmenys): Asmenims, tai jų nacionalinio tapatybės dokumento numeris (DNI). Dažna klaida: jei faktinis DNI turi mažiau nei 8 skaitmenis, reikia pridėti nulius iš kairės. Pavyzdžiui, DNI 1234567 tampa 01234567 CUIT/CUIL. Įmonės gauna unikalų priskirtą numerį.

  3. Patikros Skaitmuo (paskutinis skaitmuo): Šis kontrolinis skaitmuo patvirtina visą numerį naudojant svertinį algoritmą. Jei šis skaitmuo nesutampa su skaičiavimu, visas CUIT/CUIL yra netinkamas - tai dažnai sutrikdo kūrėjus, kai jie rankiniu būdu konstruoja testavimo duomenis.

Patikros Skaitmens Skaičiavimas

Patikros skaitmuo naudoja modulo-11 svertinį algoritmą. Štai kaip tai veikia:

  1. Paimti pirmuosius 10 CUIT/CUIL skaitmenų (tipo kodas + DNI)
  2. Padauginti kiekvieną skaitmenį iš jo atitinkamo svorio: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. Sudėti visus sandaugos rezultatus
  4. Apskaičiuoti: 11 minus (suma modulo 11)
  5. Tvarkyti kraštines sąlygas: jei rezultatas yra 11, naudoti 0; jei 10, naudoti 9

Dažniausiai žmonės suklysta ties šiomis kraštinėmis sąlygomis 5 žingsnyje. Testuojant kartais gaunamas 10 ar 11 rezultatas, ir pamiršus juos susieti su 9 ir 0 atitinkamai, sukelia patikros klaidas, kurias sunku diagnozuoti, jei nežinote šios taisyklės.

Matematiškai tai gali būti išreikšta:

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

Kur:

  • VDVD yra patikros skaitmuo
  • did_i yra ii-tasis pirmųjų 10 skaitmenų skaitmuo
  • wiw_i yra atitinkamas svoris iš sekos [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
  • Specialios sąlygos: jei VD=11VD = 11 tada VD=0VD = 0, jei VD=10VD = 10 tada VD=9VD = 9

Žingsnis po žingsnio vadovas

Generatoriaus naudojimas

  1. Pasirinkite "Generatoriaus" skirtuką viršutinėje įrankio sąsajoje.

  2. Pasirinkite Tipo Kodą išskleidžiamajame meniu:

    • 20: Vyras (CUIL)
    • 23: Verslas (CUIT)
    • 24: Laikinas verslas (CUIT)
    • 27: Moteris (CUIL)
    • 30: Korporacija (CUIT)
    • 33: Civilinė asociacija (CUIT)
    • 34: Fondas (CUIT)

  3. Įveskite DNI numerį (neprivaloma):

    • Įveskite 8 skaitmenų DNI numerį nurodytame lauke
    • Jei paliksite tuščią, įrankis naudos atsitiktinai sugeneruotą DNI
    • Jei įvesite mažiau nei 8 skaitmenis, sistema užpildys pradžioje nuliais

  4. Generuoti atsitiktinį DNI (neprivaloma):

    • Spustelėkite mygtuką "Atsitiktinis", kad sugeneruotumėte atsitiktinį 8 skaitmenų DNI numerį

  5. Peržiūrėti sugeneruotą CUIT/CUIL:

    • Įrankis automatiškai rodo galiojantį CUIT/CUIL pagal jūsų įvestus duomenis
    • Formatas bus XX-XXXXXXXX-X su teisingu patikros skaitmeniu

  6. Kopijuoti rezultatą:

    • Spustelėkite kopijavimo piktogramą, kad nukopijuotumėte sugeneruotą CUIT/CUIL į iškarpinę
    • Pasirodys patvirtinimo pranešimas sėkmingai nukopijavus

Validatoriaus naudojimas

  1. Pasirinkite "Validatoriaus" skirtuką viršutinėje įrankio sąsajoje.

  2. Įveskite CUIT/CUIL patikrinimui:

    • Įveskite CUIT/CUIL formatu XX-XXXXXXXX-X
    • Įrankis automatiškai formatuos jūsų įvestį brūkšneliais renkant
    • Taip pat galite įvesti numerį be brūkšnelių (XXXXXXXXXXX)

  3. Spustelėkite mygtuką "Patikrinti":

    • Įrankis patikrins formatą, tipo kodą ir patikros skaitmenį

  4. Peržiūrėti patikrinimo rezultatą:

    • Galiojančių CUIT/CUIL numerių atveju pasirodys žalia sėkmės žinutė
    • Negaliojančių numerių atveju pasirodys raudona klaidos žinutė su paaiškinimu:
      • Netinkamas formatas (turi būti XX-XXXXXXXX-X)
      • Netinkamas tipo kodas (turi būti vienas iš: 20, 23, 24, 27, 30, 33, 34)
      • Netinkamas patikros skaitmuo

  5. Papildoma informacija:

    • Galiojančių numerių atveju įrankis rodo komponentų išskaidymą:
      • Tipo kodas ir jo reikšmė
      • DNI numeris
      • Patikros skaitmuo

Dažniausios klaidos ir geriausios praktikos

Dirbant su CUIT/CUIL patvirtinimu jūsų programėlėse, atkreipkite dėmesį į šias dažnas spąstus:

Nulinių užpildų problemos: Dažniausia klaida, su kuria susidūriau, yra DNI numeriai su priekiniais nuliais. Kai kas nors įveda DNI "1234567", jūsų kodas turi jį apdoroti kaip "01234567" CUIT/CUIL konstravimui. Daugelis realizacijų konvertuoja į sveikuosius skaičius apdorojimui, kas pašalina priekinius nulius. Vietoj to naudokite eilučių operacijas su tinkamu užpildymu.

Tipo kodo painiava: Ne visi dviženkliniai skaičiai yra galiojantys tipo kodai. Veikia tik 20, 23, 24, 27, 30, 33, 34. Mačiau sistemas, kurios priima bet kokį dviženklinį prefiksą, kas lemia "panašiai galiojančius" numerius kaip 21-12345678-X, kurie nepraeis AFIP patvirtinimo. Visada patikrinkite tipo kodą prieš skaičiuodami patikros skaitmenį.

Lyties prielaidos: Tipo kodai 20 (vyras) ir 27 (moteris) nėra sukeičiami. Jei automatiškai generuojate CUIL pagal demografinius duomenis, užtikrinkite, kad jūsų tipo kodas atitiktų faktinę lytį, užregistruotą RENAPER (Argentinos nacionaliniame registre). Neatitikimai lemia atmetimą, kai asmenys bando naudoti šiuos numerius valdžios paslaugoms.

Brūkšnelių tvarkymas: Kai kurios realizacijos reikalauja brūkšnelių, kitos jas atmeta. Geriausia praktika: priimkite abu formatus įvesties laukuose (su ar be brūkšnelių), pašalinkite brūkšnelius prieš patvirtinimą, saugokite duomenų bazėse be brūkšnelių ir pridėkite juos tik rodymo tikslais.

Trūkstamas patvirtinimas: Algoritmo patvirtinimas aptinka formato klaidas, bet nepatvirtina, ar CUIT/CUIL yra užregistruotas. Gamyboje pirmiausia patikrinkite formatą (greitai), tada patikrinkite AFIP duomenų bazėje (lėčiau, bet autoritetingai). Šis dviejų etapų metodas iš karto aptinka spausdinimo klaidas, kartu užtikrindamas, kad numeris yra tikras.

Kraštinių atvejų testavimas: Visada testuokite su 0 ir 9 patikros skaitmenimis - tai atsiranda dėl specialių algoritmo atvejų. Taip pat testuokite DNI, prasidedančius nuliais, kad užtikrintumėte, jog jūsų užpildymo logika veikia teisingai.

Naudojimo Atvejai ir Praktinės Taikymo Sritys

Kūrimas ir Testavimas

Programinės Įrangos Kūrimas: Kuriant programėles Argentinos rinkai, jums reikės testinių duomenų, kurie praeitų patikrinimą nenaudojant tikrų vartotojų informacijos. Štai kur tai tampa kritiška:

  • El. komercijos platformos: Mokėjimų apdorojėjai ir sąskaitų išrašymo sistemos reikalauja galiojančių CUIT/CUIL numerių. Apkrovos testavimo metu gali prireikti tūkstančių galiojančių numerių realistinėms vartotojų registracijoms imituoti.
  • Apskaitos programinė įranga: Mokesčių ataskaitų moduliai patikrina CUIT/CUIL formatą prieš pateikiant AFIP. Šių patvirtinimo taisyklių testavimas reikalauja numerių, kurie praeina kontrolinės sumos algoritmą.
  • Žmogiškųjų išteklių valdymo sistemos: Algų apdorojimas ir socialinio draudimo įmokos priklauso nuo galiojančių CUIL numerių. Įprastas scenarijus: testuojate darbuotojų įdarbinimo srautus ir norite patikrinti, ar netinkami CUIL numeriai sukelia tinkamus klaidų pranešimus.
  • Bankinės programėlės: KYC (Kliento Pažinimo) procesai patvirtina CUIT/CUIL kaip dalį sąskaitos atidarymo. Mano patirtyje, kraštutiniai atvejai, tokie kaip tipo kodo neatitikimai, dažnai iškyla integracijos testavimo metu.

Duomenų Bazės Užpildymas: Pildant testines duomenų bazes, naudojant algoritmiškai galiojančius CUIT/CUIL numerius užtikrinama, kad jūsų duomenų bazės apribojimai ir trigeriai veiktų tinkamai. Tai ypač svarbu testuojant duomenų migracijos scenarijus ar ETL procesus, kurie tikrina identifikacijos numerius.

Formos Patvirtinimo Testavimas: Testuokite tiek sėkmingus, tiek klaidingus scenarijus. Generuokite galiojančius numerius, kad patvirtintumėte sėkmingą pateikimą, tada modifikuokite patvirtinimo skaitmenį, kad užtikrintumėte, jog jūsų priekinės ir galinės dalies patvirtinimas pagauna klaidą prieš pasiekiant duomenų bazę.

API Testavimas: Integraciniai testai turėtų naudoti galiojančius CUIT/CUIL numerius užklausų turinyje. Tai neleidžia atsirasti klaidingiems neigiamiems rezultatams, kur testai nepavyksta dėl netinkamų testinių duomenų, o ne dėl faktinių klaidų jūsų API logikoje.

Kokybės Užtikrinimo Automatizavimas: Parametrizuoti testai naudingi dinamiškai generuojant CUIT/CUIL. Vietoj fiksuotų testinių verčių, kurios gali konfliktuoti tarp testų vykdymų, generuokite naujus galiojančius numerius kiekvienam testo vykdymui.

Švietimo Tikslai

Patvirtinimo Algoritmų Mokymasis: CUIT/CUIL patvirtinimo algoritmas demonstruoja praktinį modulio aritmetikos ir svertinių kontrolinių skaitmenų taikymą. Tas pats modelis pasirodo ir kituose identifikacijos sistemose visame pasaulyje — kredito kortelių numeriai (Luhn algoritmas), ISBN kodai ir Europos PVM numeriai visi naudoja panašius svertinių kontrolinių sumų metodus. Supratimas, kaip veikia CUIT/CUIL patvirtinimas, suteikia įžvalgų, kodėl šie algoritmai egzistuoja: jie pagauna perrašymo klaidas, tokias kaip sukeisti skaitmenys ar vieno skaitmens klaidos.

Duomenų Patvirtinimo Mokymas: Mokant jaunesnius programuotojus apie įvesties patvirtinimą, CUIT/CUIL sistema siūlo realų pavyzdį, kuris yra sudėtingesnis už el. pašto patvirtinimą, bet paprastesnis už kriptografinį patvirtinimą. Jis demonstruoja gynybos gilumoje principą: formato patvirtinimas (11 skaitmenų), verslo taisyklių patvirtinimas (galiojantys tipo kodai) ir algoritminis patvirtinimas (kontrolinis skaitmuo).

Tarptautinis Verslo Plėtojimas: Jei kuriate sistemas Lotynų Amerikos rinkoms, CUIT/CUIL supratimas padeda suvokti panašias sistemas kaimyninėse šalyse. Brazilija turi CPF/CNPJ, Čilė — RUT, o Urugvajus — RUT — visi naudoja kontrolinių skaitmenų algoritmus. Čia išmokti modeliai perkeliami į tas sistemas.

Alternatyvos ir Gamybos Aplinkybės

Nors šis įrankis gerai tinka kūrimui ir testavimui, gamybos aplinkos turi skirtingus reikalavimus:

Oficialus Vyriausybinis Patvirtinimas: Gyvose programėlėse vien algoritminis patvirtinimas nepakankamas — jums reikia patikrinti, ar CUIT/CUIL yra faktiškai registruotas AFIP (Administración Federal de Ingresos Públicos). AFIP teikia realaus laiko patvirtinimo žiniatinklio paslaugas, nors jums reikės užsiregistruoti ir autentifikuotis norint gauti prieigą. Niuansas: numeris gali būti matematiškai galiojantis, bet oficialiai nepriskirtas, todėl visada diekite abu patvirtinimo lygius gamyboje.

Bibliotekos ir Paketai: Jei integruojate CUIT/CUIL patvirtinimą į savo kodą, apsvarstykite šias nusistovėjusias bibliotekas vietoj savos kūrimo:

  • JavaScript: validar-cuit npm teikia patvirtinimą ir formatavimą
  • PHP: afip-php biblioteka teikia ir patvirtinimą, ir AFIP žiniatinklio paslaugų integraciją
  • Python: py-cuit PyPI įgyvendina visą algoritmą

Naudojant palaikomas bibliotekas sumažinamas įgyvendinimo klaidų rizika ir dažnai įtraukiami kraštutiniai atvejai, kurių galėtumėte nepastebėti pasirinktiniame kode.

Rankinis Skaičiavimas: Mokymosi tikslais ar derinant, algoritmo skaičiavimas rankiniu būdu padeda giliau suprasti. Paimkite skaičiuotuvą ir pavyzdinį CUIT/CUIL, tada žingsnis po žingsnio sekite svertinės dauginimo procesą.

Įmonių Patvirtinimo Paslaugos: Didelės apimties programėlės gali pasinaudoti trečiųjų šalių patvirtinimo API, kurios ne tik tikrina formatą, bet ir kryžmiškai tikrina komercines duomenų bazes. Šios paslaugos gali pažymėti neaktyvias įmones, identifikuoti sankcionuotus subjektus ar suteikti papildomos informacijos apie CUIT/CUIL turėtoją.

CUIT/CUIL sistemos istorija

CUIT/CUIL identifikavimo sistema Argentinoje nuo pat pradžių reikšmingai išsivystė:

Kilmė ir įdiegimas

CUIT (Clave Única de Identificación Tributaria) pirmą kartą Argentinoje buvo pristatytas 1970-aisiais kaip dalis pastangų modernizuoti mokesčių surinkimo sistemą. Federalinė viešųjų pajamų administracija (AFIP) įdiegė šį unikalų identifikatorių siekdama efektyviau sekti mokesčių mokėtojus ir sumažinti mokesčių vengimą.

CUIL (Clave Única de Identificación Laboral) vėliau buvo pristatytas specialiai darbuotojams socialinio draudimo sistemoje identifikuoti, sukuriant skirtumą tarp mokestinio ir darbo identifikavimo, tačiau išlaikant nuoseklų formatą.

Evoliucija ir skaitmenizacija

1990-aisiais, kai Argentina patyrė reikšmingas ekonomines reformas, CUIT/CUIL sistema tapo vis svarbesnė sekant ekonominę veiklą. Sistema buvo toliau skaitmenizuota, ir buvo įdiegtos internetinės patikrinimo sistemos.

Ankstyvieji 2000-ieji matė CUIT/CUIL sistemos integraciją su įvairiomis skaitmeninėmis vyriausybės paslaugomis, paverčiant ją esminiu Argentinos e-valdžios iniciatyvų komponentu. Šiuo laikotarpiu taip pat buvo standartizuotas patikrinimo algoritmas ir formatas, kuris naudojamas iki šiol.

Naujausi pokyčiai

Pastaruoju metu AFIP patobulino CUIT/CUIL numerių saugumo ir patikrinimo procesus, diegdama sudėtingesnes patvirtinimo sistemas ir integruodama jas su kitomis vyriausybės duomenų bazėmis. Sistema dabar atlieka esminį vaidmenį Argentinos pastangose kovoti su mokesčių vengimu ir formalizuoti ekonomiką.

Šiandien CUIT/CUIL yra naudojamas ne tik mokesčių ir užimtumo tikslais, bet ir plačiame veiklos spektre, įskaitant bankininkystę, nuosavybės sandorius, komunalines paslaugas ir internetinius pirkimus, todėl tai yra esminis identifikatorius tiek fiziniams, tiek juridiniams asmenims, veikiantiems Argentinoje.

Diegimo Aspektai

Diegiant CUIT/CUIL tikrinimą savo sistemose, atsižvelkite į šiuos techninius aspektus:

Algoritmo Stabilumas: Dabartinis CUIT/CUIL patvirtinimo algoritmas išliko nepakitęs nuo jo standartizavimo 1990-aisiais. Pagal AFIP techninę dokumentaciją, modulo-11 svertinis kontrolinio skaitmens metodas yra kodifikuotas Rezoliucijoje Generale 2854/2010 ir vėlesniuose teisės aktuose. Šis stabilumas reiškia, kad diegimai retai reikalauja atnaujinimų, tačiau turėtumėte stebėti AFIP pranešimus dėl bet kokių reguliavimo pokyčių.

Našumo Optimizavimas: Patvirtinimo algoritmas yra kompiuteriškai pigus — tik 10 daugybų, vienas sudėties veiksmas ir vienas modulo operatorius. Didelės apimties sistemose, apdorojančiose tūkstančius patvirtinimų per sekundę, siauras vietas paprastai sudaro tinklo vėlavimas tikrinant AFIP duomenų bazėje, o ne pats algoritmas. Apsvarstykite AFIP patvirtinimo rezultatų kaupimą tinkamais galiojimo laikais (paprastai 24 valandos), kad subalansuotumėte šviežumą ir našumą.

Simbolių Kodavimas: Apdorojant CUIT/CUIL duomenis iš išorinių šaltinių (PDF, skenuoti dokumentai, interneto duomenų rinkimas), stebėkite simbolių kodavimo problemas. Brūkšnelis gali pasirodyti kaip ilgas brūkšnys (U+2014), trumpas brūkšnys (U+2013) arba minuso ženklas (U+2212) vietoj standartinio brūkšnelio-minuso (U+002D). Normalizuokite juos prieš tikrinimą, kad išvengtumėte klaidingų neigiamų rezultatų.

Internacionalizavimas: Jei jūsų programa aptarnauja kelias Lotynų Amerikos rinkas, atkreipkite dėmesį, kad Argentinos CUIT/CUIL naudoja modulo-11 su specifiniais svoriais, Čilės RUT naudoja modulo-11 su skirtingais svoriais, o Brazilijos CPF/CNPJ naudoja modulo-11 su dar kitu modeliu. Nesumanykit, kad algoritmai yra identiški — kiekvienos šalies sistema turi atskiras taisykles. Išsamesniam kontrolinių skaitmenų algoritmų supratimui žr. ISO/IEC 7064 standartą, kuris formalizuoja įvairias modulo pagrįstas patvirtinimo schemas.

Duomenų Bazės Saugojimas: Saugokite CUIT/CUIL numerius be brūkšnelių kaip fiksuoto ilgio CHAR(11) arba kaip BIGINT, jei jūsų duomenų bazė palaiko 11 skaitmenų sveikuosius skaičius be tikslumo praradimo. Pridėkite patikros apribojimą, kuris patvirtina kontrolinį skaitmenį duomenų bazės lygmenyje kaip apsaugą nuo sugadintų duomenų. Sukurkite indeksus šiame lauke efektyviam paieškai, kai vartotojai ieško pagal CUIT/CUIL.

Kodo Pavyzdžiai

Python

1def calculate_verification_digit(type_code, dni):
2    # Konvertuoti į eilutę ir užtikrinti, kad DNI būtų 8 skaitmenys su priekiniais nuliais
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Sujungti tipo kodą ir DNI
7    digits = type_code_str + dni_str
8    
9    # Svoriai kiekvienai pozicijai
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Apskaičiuoti sandaugų sumą
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Apskaičiuoti patikros skaitmenį
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Specialūs atvejai
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    # Galiojantys tipo kodai
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"Neteisingas tipo kodas. Turi būti vienas iš: {valid_type_codes}")
34    
35    # Sugeneruoti atsitiktinį DNI, jei nepateiktas
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Apskaičiuoti patikros skaitmenį
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Formatuoti CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Pašalinti brūkšnelius, jei yra
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Patikrinti pagrindinį formatą
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Neteisingas formatas"
52    
53    # Ištraukti dalis
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    # Patikrinti tipo kodą
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Neteisingas tipo kodas"
62    
63    # Apskaičiuoti ir palyginti patikros skaitmenį
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Neteisingas patikros skaitmuo"
67    
68    return True, "Galiojantis CUIT/CUIL"
69
70# Naudojimo pavyzdys
71print(generate_cuit_cuil(20, 12345678))  # Generuoti konkrečiam DNI
72print(generate_cuit_cuil(27))  # Generuoti atsitiktiniu DNI
73print(validate_cuit_cuil("20-12345678-9"))  # Patikrinti CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Konvertuoti į eilutę ir užtikrinti, kad DNI būtų 8 skaitmenys su priekiniais nuliais
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Sujungti tipo kodą ir DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Svoriai kiekvienai pozicijai
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Apskaičiuoti sandaugų sumą
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Apskaičiuoti patikros skaitmenį
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Specialūs atvejai
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  // Galiojantys tipo kodai
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Neteisingas tipo kodas. Turi būti vienas iš: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Sugeneruoti atsitiktinį DNI, jei nepateiktas
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Apskaičiuoti patikros skaitmenį
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Formatuoti CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Pašalinti brūkšnelius, jei yra
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Patikrinti pagrindinį formatą
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Neteisingas formatas' };
58  }
59  
60  // Ištraukti dalis
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  // Patikrinti tipo kodą
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Neteisingas tipo kodas' };
69  }
70  
71  // Apskaičiuoti ir palyginti patikros skaitmenį
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Neteisingas patikros skaitmuo' };
75  }
76  
77  return { isValid: true };
78}
79
80// Naudojimo pavyzdys
81console.log(generateCuitCuil(20, 12345678)); // Generuoti konkrečiam DNI
82console.log(generateCuitCuil(27)); // Generuoti atsitiktiniu DNI
83console.log(validateCuitCuil("20-12345678-9")); // Patikrinti 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        // Konvertuoti į eilutę ir užtikrinti, kad DNI būtų 8 skaitmenys su priekiniais nuliais
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Sujungti tipo kodą ir DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Apskaičiuoti sandaugų sumą
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Apskaičiuoti patikros skaitmenį
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Specialūs atvejai
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("Neteisingas tipo kodas. Turi būti vienas iš: " + VALID_TYPE_CODES);
39        }
40        
41        // Sugeneruoti atsitiktinį DNI, jei nepateiktas
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Apskaičiuoti patikros skaitmenį
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Formatuoti CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Pašalinti brūkšnelius, jei yra
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Patikrinti pagrindinį formatą
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Neteisingas formatas");
61        }
62        
63        // Ištraukti dalis
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        // Patikrinti tipo kodą
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Neteisingas tipo kodas");
71        }
72        
73        // Apskaičiuoti ir palyginti patikros skaitmenį
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Neteisingas patikros skaitmuo");
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        // Naudojimo pavyzdys
102        System.out.println(generateCuitCuil(20, 12345678)); // Generuoti konkrečiam DNI
103        System.out.println(generateCuitCuil(27, null)); // Generuoti atsitiktiniu DNI
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Patikrinti CUIT/CUIL
105    }
106}
107

PHP

<?php

function calculateVerificationDigit($typeCode, $dni) {
    // Konvertuoti į eilutę ir užtikrinti, kad DNI būtų 8 skaitmenys su priekiniais nuliais
    $typeCodeStr = (string)$typeCode;
    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
    
    // Sujungti tipo kodą ir DNI
    $digits = $typeCodeStr . $dniStr;
    
    // Svoriai kiekvienai pozicijai
    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
    
    // Apskaičiuoti sandaugų sumą
    $sumProducts = 0;
    for ($i = 0; $i < 10; $i++) {
        $sumProducts += (int)$digits[$i] * $weights[$i];
    }
    
    // Apskaičiuoti patikros skaitmenį
    $verificationDigit = 11 - ($sumProducts % 11);
    
    // Specialūs atvejai
    if ($verificationDigit == 11) {
        $verificationDigit = 0;
    } else if ($verificationDigit == 10) {
        $verificationDigit = 9;
    }
    
    return $verificationDigit;
}

function generateCuitCuil($typeCode, $dni = null) {
    // Galiojantys tipo kodai
    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
    
    if (!in_array($typeCode, $validTypeCodes)) {
        throw new Exception("Neteisingas tipo kodas. Turi būti vienas iš: " . implode(', ', $validTypeCodes));
    }
    
    // Sugeneruoti atsitiktinį DNI, jei nepateiktas
    if ($dni === null) {
        $dni = rand(10000000, 99999999);
    }
    
    // Apskaičiuoti patikros skaitmenį
    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
    
    // Formatuoti CUIT/CUIL
    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
}

function validateCuitCuil($cuitCuil) {
    // Pašalinti brūkšnelius, jei yra
    $cuitCuilClean = str_replace('-', '', $cuitCuil);
    
    // Patikrinti pagrindinį formatą
    if (!preg_match('/^\d{11}

## Dažniausiai užduodami klausimai

### Koks skirtumas tarp CUIT ir CUIL?

Štai praktinis skirtumas: **CUIT** (Clave Única de Identificación Tributaria) identifikuoja mokesčių mokėtojus - tiek fizinius asmenis, tiek įmones, teikiančias mokesčių ataskaitas AFIP. **CUIL** (Clave Única de Identificación Laboral) identifikuoja darbuotojus socialinio draudimo sistemoje įdarbinimo ir pensijų tikslais.

Praktikoje daugelis asmenų turi ir CUIL (nuo pirmos darbo vietos), ir vėliau gali gauti CUIT (jei tampa savarankiškai dirbančiais ar pradeda verslą). Numeriai naudoja identišką formatavimą ir skaičiavimo taisykles, todėl tikrinimo požiūriu juos reikia tvarkyti vienodai. Skirtumas svarbus administraciniais tikslais: algalapių sistemos paprastai dirba su CUIL, o sąskaitų ir mokesčių sistemos naudoja CUIT.

### Kokie tipo kodai naudojami fiziniams asmenims ir įmonėms?

Fiziniams asmenims:
- 20, 23, 24: Vyriški asmenys (CUIL)
- 27: Moteriški asmenys (CUIL)

Įmonėms ir organizacijoms:
- 30: Korporacijos (CUIT)
- 33: Pilietinės asociacijos (CUIT)
- 34: Fondai (CUIT)

### Kaip apskaičiuojamas patikros skaitmuo?

Algoritmas naudoja svertinį daugybos metodą: paimkite pirmuosius 10 skaitmenų, padauginkite iš svorių **5, 4, 3, 2, 7, 6, 5, 4, 3, 2**, sudėkite sandaugas, tada apskaičiuokite 11 minus (suma modulo 11).

Du kraštiniai atvejai gali suklaidinti: kai skaičiavimas duoda 11, naudokite 0 kaip patikros skaitmenį; kai duoda 10, naudokite 9. Šie specialūs atvejai egzistuoja todėl, kad patikros skaitmuo turi būti vienas skaitmuo (0-9). Tai yra modulo-11 patikros skaitmens algoritmas, panašus į naudojamą ISBN-10 kituose identifikavimo sistemose pasaulyje.

### Ar galiu naudoti šį įrankį generuoti tikrus, oficialius CUIT/CUIL numerius?

Ne - šis įrankis generuoja matematiškai teisingus testinių duomenų numerius, tačiau jie nėra oficialiai registruoti AFIP. Galvokite apie tai kaip apie generavimą galiojančio kredito kortelės numerio naudojant Luhn algoritmą: jis praeina formato tikrinimą, bet nėra susietas su tikra paskyra.

Oficialiam CUIT/CUIL registravimui asmenys turi apsilankyti AFIP su savo DNI, o įmonės turi užbaigti korporacinės registracijos procedūras. Įrankis yra skirtas tik kūrimui, testavimui ir švietimui, kur reikia galiojančių duomenų, kurie nesikirstų su tikrais identifikavimo numeriais.

### Kodėl mano CUIT/CUIL tikrinimas nepavyksta, nors formatas atrodo teisingas?

Kai tikrinimas nepavyksta nepaisant teisingo formato, patikrinkite šiuos įprastus kaltininkus:

1. **Neteisingas tipo kodas**: Tik 20, 23, 24, 27, 30, 33, 34 yra galiojantys. Naudojant 21, 25 ar kitus skaitmenis tikrinimas nepavyks.
2. **Neteisingas patikros skaitmuo**: Paskutinis skaitmuo turi sutapti su algoritmo skaičiavimu. Net pakeitus vieną skaitmenį DNI dalyje reikia iš naujo apskaičiuoti patikros skaitmenį.
3. **Formato problemos**: Turi būti tiksliai 11 skaitmenų (XX-XXXXXXXX-X). Saugokitės papildomų tarpų ar trūkstamų pradinių nulių.
4. **Paslėpti simboliai**: Kopijavimas iš PDF ar interneto svetainių kartais įterpia nematomus Unicode simbolius, kurie suardo tikrinimą.

Greitas derinimo patarimas: pašalinkite paskutinį skaitmenį ir apskaičiuokite jį rankiniu būdu. Jei jis nesutampa, tai ir yra kaltininkas.

### Ar brūkšniai yra privalomi CUIT/CUIL numeriuose?

Brūkšniai yra tik ekrano formatavimui - jie nėra svarbūs skaičiavimams. Kai matote **20-12345678-9**, algoritmas rūpinasi tik 11 skaitmenimis: **20123456789**.

Dauguma tikrinimo įgyvendinimų pašalina brūkšnius prieš apdorojimą, todėl mūsų įrankis priima ir **20-12345678-9**, ir **20123456789**. API ir duomenų bazėse paprastai saugomas nebrūkšniuotas variantas ir brūkšniai pridedami tik rodant vartotojams. Šis metodas neleidžia formatavimo neatitikimams sukelti tikrinimo klaidų.

### Ar CUIT/CUIL numeris gali turėti mažiau nei 8 skaitmenis DNI dalyje?

DNI dalis visada turi būti tiksliai 8 skaitmenys - jokių išimčių. Jei asmens DNI turi mažiau skaitmenų (kas būdinga senesniems, mažesniems DNI), reikia papildyti pradiniais nuliais.

Pavyzdžiui, DNI **1234567** tampa **01234567** CUIT/CUIL struktūroje. Tai dažna klaidų priežastis keičiant tarp DNI ir CUIT/CUIL formatų. Esu matęs sistemas, kurių tikrinimas nepavyksta, nes pamiršo papildyti, traktuodamos **1234567** kaip 7 skaitmenų, o ne **01234567**. Visada naudokite nulinį papildymą savo kode vietoj paprastos eilučių jungties.

### Kaip galiu patikrinti, ar CUIT/CUIL yra oficialiai registruotas Argentinoje?

Mūsų įrankis tikrina matematinį teisingumą - formatą, tipo kodą ir patikros skaitmenį. Tačiau jis negali pasakyti, ar numeris iš tikrųjų registruotas AFIP ar priklauso realiam asmeniui ar verslui.

Oficialiam patikrinimui naudokite [AFIP žiniatinklio paslaugas](https://www.afip.gob.ar/) arba jų "Constancia de Inscripción" paieškos įrankį. AFIP siūlo API automatiniam tikrinimui, nors reikės užsiregistruoti kaip kūrėjui ir autentifikuotis. Gamybos aplinkose įdiekite abu lygius: pirma vykdykite algoritmišką tikrinimą (greitas, pagauna spausdinimo klaidas ir formato klaidas), tada patikrinkite AFIP duomenų bazėje (lėčiau, bet patvirtina, kad numeris realus ir aktyvus).

### Ar galiu naudoti šį įrankį savo komerciniame taikyme?

Taip - CUIT/CUIL tikrinimo algoritmas yra viešas standartas, apibrėžtas AFIP, todėl galite laisvai jį įdiegti komerciniuose programiniuose sprendimuose. Čia pateikti kodo pavyzdžiai skirti kaip nuorodų įgyvendinimai.

Gamybos naudojimui atsižvelkite į šias geriausias praktikas: įdiekite tinkamą klaidų valdymą kraštiniams atvejams, pridėkite žurnalų įrašymus tikrinimo klaidų derinimui, tikrinkite pagal oficialią AFIP duomenų bazę (ne tik algoritmiškai), ir sekite, ar AFIP nekeičia taisyklių (nors dabartinis algoritmas yra stabilus jau kelias dešimtis metų).

### Ar įrankis išsaugo sugeneruotus ar patikrintus CUIT/CUIL numerius?

Ne - visas apdorojimas vyksta jūsų naršyklėje (kliento pusėje). Kai generuojate ar tikrinate CUIT/CUIL, skaičiavimas vykdomas lokaliai naudojant JavaScript. Niekas nesiunčiama į mūsų serverius, ir mes nefiksuojame, nesaugome ir nesekame jokių jūsų įvestų ar sugeneruotų numerių.

Šis kliento pusės metodas užtikrina privatumą ir taip pat reiškia, kad įrankis veikia ir be interneto ryšio įkrovus puslapį. Galite tai patikrinti atidarę naršyklės kūrėjų įrankius ir stebėdami tinklo kortelę - pamatysite, kad jokie užklausų nesiunčiama generuojant ar tikrinant numerius.

## Nuorodos

1. AFIP (Federalinė viešųjų pajamų administracija). „CUIT/CUIL/CDI." Oficiali svetainė. [https://www.afip.gob.ar/](https://www.afip.gob.ar/)

2. Darbo, užimtumo ir socialinės apsaugos ministerija. „CUIL - Unikalus darbo identifikacijos kodas." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo)

3. ANSES (Nacionalinė socialinės apsaugos administracija). „Gauti mano CUIL." [https://www.anses.gob.ar/](https://www.anses.gob.ar/)

4. Oficialusis Argentinos Respublikos biuletenis. „AFIP generalinis sprendimas 2854/2010: Procedūra. Unikalus mokestinis identifikacijos kodas (C.U.I.T.)."

5. Argentinos Respublikos mokestinis kodeksas. „Mokesčių mokėtojų identifikavimas ir registracija."

---

Nesvarbu, ar kuriate sąskaitų sistemą, tikrinate darbuotojų įdarbinimo procesus, ar mokotės patvirtinimo algoritmų, šis įrankis suteikia jums reikalingą CUIT/CUIL generavimą ir patvirtinimą. Generuokite testavimo duomenis, kurie praeina algoritmų patvirtinimą, patikrinkite numerius prieš juos įkeliant į duomenų bazę arba išsamiai išnagrinėkite, kaip praktiškai veikia kontrolinio skaitmens algoritmas.