સામગ્રી પર જાઓ

CUIT/CUIL જનરેટર & વેલિડેટર | આર્જેન્ટાઇન ટૅક્સ ID ટૂલ

માન્ય આર્જેન્ટાઇન CUIT/CUIL પરીક્ષણ નંબર જનરેટ કરો અથવા વિद્યમાન નંબરોની ચકાસણી કરો. વિકાસકો માટે AFIP-અનુરૂપ ચકાસણી સાથે ટૅક્સ ID અને પગાર સિસ્ટમ પરીક્ષણ માટે મફત ઓનલાઇન ટૂલ.

CUIT/CUIL જનરેટર

8 અંકનો DNI નંબર દાખલ કરો અથવા રેન્ડમ જનરેટર વાપરો

જનરેટ થયેલ CUIT/CUIL
20-83121385-0

રેન્ડમ જનરેટ થયેલ DNI વાપરી રહ્યા છીએ

લોડિંગ કેલ્ક્યુલેટર...
📚

દસ્તાવેજીકરણ

અર્જેન્ટાઇન CUIT/CUIL જનરેટર અને વેલિડેટર

પરિચય

અર્જેન્ટિનાના કર અને શ્રમ સિસ્ટમમાં, તમે સતત બે મહત્વપૂર્ણ ઓળખકર્તાઓનો સામનો કરશો: CUIT (Clave Única de Identificación Tributaria) અને CUIL (Clave Única de Identificación Laboral). CUIT ને વ્યવસાયો અને વ્યક્તિઓ માટે કર ID તરીકે ગણવામાં આવે છે, જ્યારે CUIL સામાજિક સુરક્ષા સિસ્ટમમાં કાર્યકર્તાઓની ઓળખ કરે છે. બંને 11 અંકના ફૉર્મેટ અને ચકાસણી એલ્ગોરિધમનો ઉપયોગ કરે છે, જે આ નંબરો સંભાળતી એપ્લિકેશન્સ પરીક્ષણ કરવાને ખાસ મહત્વપૂર્ણ બનાવે છે.

અર્જેન્ટિનન બજારમાં સૉફ્ટવેર વિકસાવતી વખતે, તમને માન્ય પરીક્ષણ ડેટાની જરૂર હોય છે. અહીં આ સાધન આવે છે. તમે વાસ્તવિક વ્યક્તિગત માહિતીનો ઉપયોગ કર્યા વિના, પરીક્ષણ માટે ગણિતીય રીતે સાચા CUIT/CUIL નંબર બનાવી શકો છો, અથવા અસ્તિત્વમાં રહેલા નંબરોની ચકાસણી કરી શકો છો જે AFIP ના ઔપચારિક એલ્ગોરિધમને અનુરૂપ છે. ખાસ ઉપયોગી બાબત એ છે કે સાધન ઉત્પાદન પક્ષને (માંગ પર માન્ય નંબર બનાવવા) અને ચકાસણી પક્ષને (ફૉર્મેટ ત્રુટિઓ, અમાન્ય પ્રકાર કોડ, અને ગલત ચકાસણી અંકોને પકડવા) સંભાળે છે.

CUIT/CUIL ની સંરચના અને ગણતરી

ફૉર્મેટ સમજવું

એક માન્ય CUIT/CUIL નંબર 11 અંકોનો બનેલો હોય છે, જે સામાન્ય રીતે XX-XXXXXXXX-X ફૉર્મેટમાં દર્શાવવામાં આવે છે. આ રીતે તે વિભાજિત થાય છે:

  1. પ્રકાર કોડ (પ્રથમ 2 અંક): સંસ્થાના પ્રકારને ઓળખે છે

    • 20, 23, 24: પુરુષ વ્યક્તિઓ (CUIL)
    • 27: સ્ત્રી વ્યક્તિઓ (CUIL)
    • 30, 33, 34: કંપનીઓ અને સંસ્થાઓ (CUIT)
  2. DNI નંબર (મધ્ય 8 અંક): વ્યક્તિઓ માટે, આ તેમના રાષ્ટ્રીય ઓળખ દસ્તાવેજ નંબર (DNI) છે. એક સામાન્ય ગૂંચવણ: જો વાસ્તવિક DNI 8 કરતા ઓછા અંકોનો હોય, તો તેને આગળના શૂન્ય વડે પૂરવાનો રહે. ઉદાહરણ તરીકે, DNI 1234567 CUIT/CUIL માં 01234567 બને. કંપનીઓને બદલે એક અનન્ય સોંપાયેલ નંબર મળે.

  3. ચકાસણી અંક (છેલ્લો અંક): આ ચેક અંક પૂરા નંબરને વેઇટેડ એલ્ગોરિધમ વડે ચકાસે છે. જો આ અંક ગણતરી સાથે મેળ ખાતો નથી, તો આખો CUIT/CUIL અમાન્ય ગણાય—જે વિકાસકોને પરીક્ષણ ડેટા બનાવતી વખતે વારંવાર ગૂંચવે.

ચકાસણી અંક ગણતરી

ચકાસણી અંક મોડ્યુલો-11 વેઇટેડ એલ્ગોરિધમનો ઉપયોગ કરે છે. આ રીતે કામ કરે:

  1. CUIT/CUIL ના પ્રથમ 10 અંક લો (પ્રકાર કોડ + DNI)
  2. દરેક અંકને તેના સંબંધિત વેઇટ વડે ગુણાકાર કરો: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. બધા ગુણાકારોનો સરવાળો કરો
  4. ગણો: 11 માંથી (સરવાળો મોડ 11)
  5. કિનારાના કિસ્સાઓ સંભાળો: જો પરિણામ 11 હોય, 0 વાપરો; જો 10 હોય, 9 વાપરો

લોકો સૌથી વધુ ભૂંઠા પડે છે તે 5 માં કિનારાના કિસ્સાઓ. પરીક્ષણ કરતી વખતે, તમને ક્યારેક 10 કે 11 નું પરિણામ મળશે, અને 9 અને 0 પર માપવાનું ભૂલી જવાથી ચકાસણી નિષ્ફળ જાય, જે ડિબગ કરવા માટે કठિન હોઈ શકે.

ગાણિતિક રીતે, આને આ રીતે વ્યક્ત કરી શકાય:

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

જ્યાં:

  • VDVD ચકાસણી અંક
  • did_i પ્રથમ 10 અંકોનો ii-મો અંક
  • wiw_i [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] અનુક્રમનો સંબંધિત વેઇટ
  • વિશેષ કિસ્સાઓ: જો VD=11VD = 11 તો VD=0VD = 0, જો VD=10VD = 10 તો VD=9VD = 9

પગલાં-વાર માર્ગદર્શિકા

જનરેટર વાપરવો

  1. ટૂલ ઇન્ટરફેસના ટોચ પર "જનરેટર" ટૅબ પસંદ કરો.

  2. ડ્રૉપડાઉન મેનૂમાંથી પ્રકાર કોડ પસંદ કરો:

    • 20: પુરુષ (CUIL)
    • 23: વ્યવસાય (CUIT)
    • 24: અસ્થાયી વ્યવસાય (CUIT)
    • 27: મહિલા (CUIL)
    • 30: કૉર્પોરેશન (CUIT)
    • 33: નાગરિક સંગઠન (CUIT)
    • 34: ફાઉન્ડેશન (CUIT)
  3. DNI નંબર દાખલ કરો (વૈકલ્પિક):

    • પૂરા પાડેલ ક્ષેત્રમાં 8 અંકનો DNI નંબર દાખલ કરો
    • ખાલી રાખવામાં આવે તો, ટૂલ રૅન્ડમ જનરેટ કરેલ DNI વાપરશે
    • 8 કરતાં ઓછા અંક દાખલ કરશો તો, સિસ્ટમ આગળ શૂન્ય ઉમેરશે
  4. રૅન્ડમ DNI જનરેટ કરો (વૈકલ્પિક):

    • 8 અંકનો રૅન્ડમ DNI નંબર જનરેટ કરવા "રૅન્ડમ" બટન પર ક્લિક કરો
  5. જનરેટ કરેલ CUIT/CUIL જુઓ:

    • ટૂલ આપોઆપ તમારા ઇનપુટ પર આધારિત માન્ય CUIT/CUIL પ્રદર્શિત કરશે
    • ફૉર્મેટ XX-XXXXXXXX-X હશે, યોગ્ય ચકાસણી અંક સાથે
  6. પરિણામ કૉપી કરો:

    • CUIT/CUIL ને ક્લિપબૉર્ડ પર કૉપી કરવા કૉપી આઇકન પર ક્લિક કરો
    • સફળતાપૂર્વક કૉપી થઈ જાય ત્યારે પુષ્ટિકરણ સંદેશ દેખાશે

વૈલિડેટર વાપરવો

  1. ટૂલ ઇન્ટરફેસના ટોચ પર "વૈલિડેટર" ટૅબ પસંદ કરો.

  2. ચકાસવા માટે CUIT/CUIL દાખલ કરો:

    • CUIT/CUIL ને XX-XXXXXXXX-X ફૉર્મેટમાં દાખલ કરો
    • ટૂલ આપોઆપ તમારા ઇનપુટને હાઇફન્સ સાથે ફૉર્મેટ કરશે
    • તમે બિનહાઇફન્સ (XXXXXXXXXXX) નંબર પણ દાખલ કરી શકો
  3. "ચકાસો" બટન પર ક્લિક કરો:

    • ટૂલ ફૉર્મેટ, પ્રકાર કોડ અને ચકાસણી અંકની તપાસ કરશે
  4. ચકાસણી પરિણામ જુઓ:

    • માન્ય CUIT/CUIL નંબર માટે, લીલો સફળતા સંદેશ દેખાશે
    • અમાન્ય નંબર માટે, લાલ ત્રુટિ સંદેશ સમસ્યા સમજાવશે:
      • અમાન્ય ફૉર્મેટ (XX-XXXXXXXX-X હોવું જ જોઈએ)
      • અમાન્ય પ્રકાર કોડ (20, 23, 24, 27, 30, 33, 34 માંથી કોઈ)
      • અમાન્ય ચકાસણી અંક
  5. વધારાની માહિતી:

    • માન્ય નંબર માટે, ટૂલ ઘટકોનો વિભાગ પ્રદર્શિત કરશે:
      • પ્રકાર કોડ અને તેનો અર્થ
      • DNI નંબર
      • ચકાસણી અંક

સામાન્ય ભૂલો અને શ્રેષ્ઠ પ્રયાસો

CUIT/CUIL ચકાસણી સાથે તમારી એપ્લિકેશન્સમાં કાર્ય કરતી વખતે, આ સામાન્ય ગોઠવણીઓ પર ધ્યાન આપો:

શૂન્ય-પૅડિંગ સમસ્યાઓ: સૌથી સામાન્ય બગ જે મેં જોઈ છે તે DNI નંબરોમાં આગળનાં શૂન્ય સાથે સંકળાયેલ છે. જ્યારે કોઈ DNI "1234567" દાખલ કરે, ત્યારે તમારા કોડને CUIT/CUIL બનાવવા માટે તેને "01234567" તરીકે સંભાળવાની જરૂર છે. ઘણી અમલીકરણો પ્રક્રિયા માટે પૂર્ણાંકોમાં રૂપાંતરિત કરે, જે આગળનાં શૂન્ય કાઢી નાખે. તેની બદલે યોગ્ય પૅડિંગ સાથે સ્ટ્રિંગ ઓપરેશન્સનો ઉપયોગ કરો.

પ્રકાર કોડ ગૂંચવણ: તમામ બે-અંકના નંબર માન્ય પ્રકાર કોડ નથી. ફક્ત 20, 23, 24, 27, 30, 33, 34 કાર્ય કરે. મેં સિસ્ટમ્સ જોઈ છે જે કોઈપણ બે-અંકના પૂર્વાક્ષરને સ્વીકારે, જેના કારણે "માન્ય-દેખાતા" નંબરો જેવા કે 21-12345678-X AFIP ચકાસણી નિષ્ફળ થાય. વેરિફિકેશન અંક ગણતરી કરતાં પહેલાં હંમેશા પ્રકાર કોડ ચકાસો.

લિંગ ધારણાઓ: પ્રકાર કોડ 20 (પુરુષ) અને 27 (સ્ત્રી) આંતરિક નથી. જો તમે ડેમોગ્રાફિક ડેટાના આધારે CUILs સ્વયંચાલિત રીતે બનાવી રહ્યા છો, તો RENAPER (આર્જેન્ટિનાનો રાષ્ટ્રીય રજીસ્ટ્રી) સાથે રજીસ્ટર્ડ વાસ્તવિક લિંગ સાથે તમારો પ્રકાર કોડ મેળ ખાતો કરો. બેમેળ સરકારી સેવાઓ વાપરતી વ્યક્તિઓને નકારી કાઢે.

હાઇફન સંચાલન: કેટલીક અમલીકરણો હાઇફન્સ માટે જરૂર પાડે, જ્યારે અન્ય તેમને નકારે. શ્રેષ્ઠ પ્રયાસ: ઇનપુટ ક્ષેત્રોમાં બંને ફૉર્મેટ્સ સ્વીકારો (હાઇફન્સ સાથે કે વગર), ચકાસણી પહેલાં હાઇફન્સ કાઢી નાખો, ડેટાબેઝમાં બિન-હાઇફન્ડ સંસ્કરણ સંગ્રહિત કરો, અને ફક્ત પ્રદર્શન હેતુઓ માટે હાઇફન્સ ઉમેરો.

ગેરહાજર વેરિફિકેશન: એલ્ગોરિધમ ચકાસણી ફૉર્મેટ ત્રુટિઓ પકડે, પરંતુ CUIT/CUIL નોંધાયેલ છે તેની ખાતરી કરતી નથી. ઉત્પાદનમાં, પ્રથમ ફૉર્મેટ ચકાસો (ઝડપી), પછી AFIP ડેટાબેઝ સામે ચકાસો (ધીમું પરંતુ સત્તાવાર). આ બે-તબક્કાનો અભિગમ ટાઇપો તરત ઓળખે, જ્યારે સાથે નંબર ખરેખર છે તેની ખાતરી કરે.

કિનારાના કેસ પરીક્ષણ: હંમેશા 0 અને 9 ની વેરિફિકેશન અંકો સાથે પરીક્ષણ કરો - આ એલ્ગોરિધમમાં વિશેષ કેસોથી પરિણામ પામે. શૂન્ય સાથે શરૂ થતા DNIs પણ પરીક્ષણ કરો, તમારી પૅડિંગ તર્કક્ષમતા યોગ્ય રીતે કાર્ય કરે.

ઉપયોગ કેસો અને વ્યાવહારિક અનુપ્રયોગો

વિકાસ અને પરીક્ષણ

સૉફ્ટવેર વિકાસ: અર્જેન્ટાઇન બજારમાં એપ્લિકેશન બનાવતી વખતે, તમને એવા પરીક્ષણ ડેટા ની જરૂર પડશે કે જે વૈધ માહિતી વાપરવા વગર ચકાસણી પાસ કરે. અહીં આ કટોકટી પૂર્ણ થાય છે:

  • ઈ-કૉમર્સ પ્લેટફૉર્મ: ચૂકવણી પ્રોસેસર અને ઇન્વૉઇસિંગ સિસ્ટમ્સ માટે વૈધ CUIT/CUIL નંબર જરૂરી છે. લોડ પરીક્ષણ દરમિયાન, તમને હજારો વૈધ નંબર ની જરૂર પડી શકે છે જેથી વાસ્તવિક વપરાશકર્તા નોંધણી ની અનુકૃતિ કરી શકાય.
  • એકાઉન્ટિંગ સૉફ્ટવેર: AFIP ને સબમિટ કરતા પહેલા કર અહેવાલ મૉડ્યૂલ CUIT/CUIL ફૉર્મેટ ની ચકાસણી કરે છે. આ ચકાસણી નિયમોનું પરીક્ષણ કરવા માટે, ચેક અંક એલ્ગોરિધમ પાસ કરતા નંબર ની જરૂર પડે છે.
  • HR મેનેજમેન્ટ સિસ્ટમ્સ: પગાર પ્રક્રિયા અને સામાજિક સુરક્ષા યોગદાન વૈધ CUIL નંબર પર આધાર રાખે છે. સામાન્ય પરિદ્રશ્ય: તમે કર્મચારી ઓનબોર્ડિંગ પ્રવાહનું પરીક્ષણ કરી રહ્યા છો અને ખાતરી કરવા માંગો છો કે અયોગ્ય CUILs યોગ્ય ત્રુટિ સંદેશો ટ્રિગર કરે.
  • બેન્કિંગ એપ્લિકેશન: KYC (ગ્રાહક ઓળખ) પ્રક્રિયાઓ ખાતા ખોલવા ના ભાગ રૂપે CUIT/CUIL ની ચકાસણી કરે છે. મારા અનુભવ પ્રમાણે, પ્રકાર કોડ બેફિટ જેવા કિનારા કેસ ઇન્ટીગ્રેશન પરીક્ષણ દરમિયાન ઉભા થાય છે.

ડેટાબેઝ પોપ્યુલેશન: પરીક્ષણ ડેટાબેઝ ને ભરતી વખતે, એલ્ગોરિધ્મિક રીતે વૈધ CUIT/CUIL નંબર નો ઉપયોગ કરવાથી ખાતરી કરી શકાય છે કે તમારા ડેટાબેઝ પ્રતિબંધો અને ટ્રિગર્સ અપેક્ષા મુજબ કાર્ય કરે છે. આ ખાસ કરીને ડેટા સ્થળાંતર સ્ક્રિપ્ટ્સ અથવા ETL પ્રક્રિયાઓ ની ઓળખ નંબર ની ચકાસણી કરતી વખતે મહત્વનું છે.

ફૉર્મ ચકાસણી પરીક્ષણ: સફળ સબમિશન ની ખાતરી કરવા માટે વૈધ નંબર ઉત્પન્ન કરો, પછી ચકાસણી અંક ને સંશોધિત કરો જેથી ડેટાબેઝ પર પહોંચતા પહેલા તમારા ફ્રન્ટેન્ડ અને બૅકેન્ડ ચકાસણી ત્રુટિ ને પકડે.

API પરીક્ષણ: ઇન્ટીગ્રેશન પરીક્ષણો માં વૈધ CUIT/CUIL નંબર નો ઉપયોગ કરવો. આ ગલત નકારાત્મક ને રોકે છે જ્યાં પરીક્ષણો API તર્ક માં વાસ્તવિક ત્રુટિઓ ને બદલે અયોગ્ય પરીક્ષણ ડેટા ને કારણે નિષ્ફળ થાય.

QA ઓટોમેશન: પૅરામીટરાઇઝ્ડ પરીક્ષણો ગતિશીલ CUIT/CUIL ઉત્પન્ન કરવાથી લાભ પામે છે. પરીક્ષણ ચાલુ કરવા ની દરેક વખતે ટક્કર ખાઈ શકે તેવા હાર્ડકોડેડ ટેસ્ટ મૂલ્યો ને બદલે, તાજેતરના વૈધ નંબર ઉત્પન્ન કરો.

શૈક્ષણિક હેતુઓ

(ટ્રાન્સલેશન ચાલુ...)

CUIT/CUIL સિસ્ટમનો ઇતિહાસ

અર્જેન્ટિનામાં CUIT/CUIL ઓળખ પ્રણાલીનો વિકાસ તેની શરૂઆત પછી નોંધપાત્ર રીતે થયો છે:

મૂળ અને અમલીકરણ

CUIT (ક્લાવ ઉનિકા ડ્ઇડેન્ટિફિકેશન ટ્રિબ્યુટેરિયા) પ્રથમ વખત 1970 ના દાયકામાં અર્જેન્ટિનામાં કર વસૂલી પ્રણાલીને આધુનિક બનાવવાના પ્રયાસોના ભાગ રૂપે રજૂ કરવામાં આવ્યો. ફેડરલ એડમિનિસ્ટ્રેશન ઓફ પબ્લિક રેવન્યુ (AFIP) એ કરદાતાઓને વધુ કાર્યક્ષમ રીતે ટ્રૅક કરવા અને કર ચોરીને ઘટાડવા માટે આ અનન્ય ઓળખકર્તાનું અમલીકરણ કર્યું.

CUIL (ક્લાવ ઉનિકા ડ્ઇડેન્ટિફિકેશન લેબોરલ) પાછળથી સામાજિક સુરક્ષા પ્રણાલીમાં કાર્યકર્તાઓને ઓળખવા માટે રજૂ કરવામાં આવ્યો, કર ઓળખ અને શ્રમ ઓળખ વચ્ચે તફાવત બનાવતા સાથે સુસંગત ફૉર્મેટ જાળવી રાખ્યો.

વિકાસ અને ડિજિટાઇઝેશન

1990 ના દાયકામાં, જ્યારે અર્જેન્ટિના મહત્વપૂર્ણ આર્થિક સુધારાઓમાંથી પસાર થઈ રહ્યું હતું, ત્યારે CUIT/CUIL પ્રણાલી આર્થિક પ્રવૃત્તિને ટ્રૅક કરવા વધુ મહત્વપૂર્ણ બની. પ્રણાલીને વધુ ડિજિટાઇઝ કરવામાં આવી, અને ઓનલાઇન ચકાસણી પ્રણાલીઓ અમલમાં મૂકવામાં આવી.

2000 ના દાયકાની શરૂઆતમાં CUIT/CUIL પ્રણાલીનું વિભિન્ન ડિજિટલ સરકારી સેવાઓ સાથે એકીકરણ થયું, જે અર્જેન્ટિનાની ઇ-સરકાર પહેલનો એક મહત્વપૂર્ણ ઘટક બની. આ સમયગાળામાં ચકાસણી એલ્ગોરિધમ અને ફૉર્મેટનું પણ પ્રમાણીકરણ કરવામાં આવ્યું, જે આજે પણ વપરાય છે.

તાજેતરના વિકાસ

છેલ્લાં વર્ષોમાં, AFIP એ CUIT/CUIL નંબરો માટે સુરક્ષા અને ચકાસણી પ્રક્રિયાઓને વધુ મજબૂત બનાવી, વધુ જટિલ ચકાસણી પ્રણાલીઓ અમલમાં મૂકી અને તેને અન્ય સરકારી ડેટાબેઝ સાથે એકીકૃત કર્યું. પ્રણાલી હવે અર્જેન્ટિનાના કર ચોરી સામે લડવા અને અર્થવ્યવસ્થાને ઔપચારિક બનાવવાના પ્રયાસોમાં મહત્વપૂર્ણ ભૂમિકા ભજવે છે.

આજે, CUIT/CUIL નો ઉપયોગ કર અને રોજગાર ઉદ્દેશ્યો માટે જ નહીં, પરંતુ બેન્કિંગ, સંપત્તિ વ્યવહાર, ઉપયોગિતા સેવાઓ, ઓનલાઇન ખરીદી સહિત વ્યાપક પ્રવૃત્તિઓ માટે પણ કરવામાં આવે છે, જે અર્જેન્ટિનામાં વ્યક્તિઓ અને વ્યવસાયો માટે એક મહત્વપૂર્ણ ઓળખકર્તા બની ગયો છે.

અમલીકરણ પ્રતિપાદન

તમારી પોતાની પ્રણાલીઓમાં CUIT/CUIL ચકાસણી અમલમાં મૂકતી વખતે, આ તાંત્રિક પાસાઓ ધ્યાનમાં રાખો:

ગણતર સ્થિરતા: વર્તમાન CUIT/CUIL ચકાસણી ગણતર 1990 ના દાયકામાં તેની મानકીકરણ પછી અunchanged રહ્યો છે. AFIP ની તાંત્રિક દસ્તાવેજીકરણ મુજબ, મોડ્યૂલો-11 વિભારિત ચેક અંક અભિગમ Resolución General 2854/2010 અને પછીના નિયમોમાં કોડિફાઇ કરવામાં આવ્યો છે. આ સ્થિરતાનો અર્થ એ છે કે અમલીકરણોને ભૂરિભાગે અપડેટની જરૂર નથી, પરંતુ તમારે AFIP ની કોઈપણ નિયમનકારી બદલાવ માટે નિરીક્ષણ કરવું જોઈએ.

કાર્ય-કુશળતા ઓપ્ટિમાઇઝેશન: ચકાસણી ગણતર ગણનાત્મક રીતે સસ્તો છે—માત્ર 10 ગુણાકાર, એક સંયોજન, અને એક મોડ્યૂલો ઓપરેશન. પ્રતિ સેકંડે હજારો ચકાસણી પ્રક્રિયા કરતી ઉચ્ચ-પ્રવાહ પ્રણાલીઓ માટે, ગળતર AFIP ના ડેટાબેઝ સામે ચકાસતી વખતે નેટવર્ક વિલંબ, ગણતર itself. AFIP ચકાસણી પરિણામોને યોગ્ય TTLs (સામાન્ય રીતે 24 કલાક) સાથે કેશ કરવાનું ધ્યાન રાખો.

અક્ષર એન્કોડિંગ: બાહ્ય સ્રોતોમાંથી CUIT/CUIL ડેટા પ્રક્રિયા કરતી વખતે (PDFs, સ્કૅન કરેલા દસ્તાવેજો, વેબ સ્ક્રેપિંગ), અક્ષર એન્કોડિંગ મુદ્દાઓ માટે સાવધાન રહો. હાઇફન એક એમ ડેશ (U+2014), એન ડેશ (U+2013), અથવા માઇનસ સાઇન (U+2212) તરીકે દેખાઈ શકે છે, બદલે સ્ટાન્ડર્ડ હાઇફન-માઇનસ (U+002D). ચકાસણી પહેલાં આને સામાન્ય કરો.

આંતરરાષ્ટ્રીયકરણ: જો તમારી એપ્લિકેશન બહુ-લાતિન અમેરિકન બજારોને સેવા આપે, નોંધો કે અર્જેન્ટિનાનો CUIT/CUIL મોડ્યૂલો-11 ને વિશિષ્ટ વિભાર સાથે વાપરે, જ્યારે ચિલીનો RUT મોડ્યૂલો-11 ને અલગ વિભાર સાથે, અને બ્રાઝિલનો CPF/CNPJ મોડ્યૂલો-11 ને બીજા પેટર્ન સાથે વાપરે. ગણતર સમાન છે એવી ધારણા ન કરો—દરેક દેશની પ્રણાલીને અલગ નિયમો છે. ચેક અંક ગણતરોની વ્યાપક સમજ માટે, ISO/IEC 7064 ધોરણ જુઓ, જે વિવિધ મોડ્યૂલો-આધારિત ચકાસણી યોજનાઓને ઔપચારિક કરે છે.

ડેટાબેઝ સંગ્રહ: CUIT/CUIL નંબરોને હાઇફન વગર CHAR(11) તરીકે અથવા BIGINT તરીકે સંગ્રહ કરો, જો તમારો ડેટાબેઝ 11-અંક ઇન્ટીજર્સને ચોક્કસાઈ ગુમાવ્યા વગર સમર્થન આપે. ભ્રષ્ટ ડેટા સામે સુરક્ષા નેટ તરીકે ડેટાબેઝ સ્તર પર ચકાસણી અંકની ચકાસણી કરતી ચેક conststraint ઉમેરો. CUIT/CUIL દ્વારા વપરાશકર્તાઓ શોધ કરતી વખતે કાર્યક્ષમ શોધ માટે આ ક્ષેત્ર પર ઇન્ડેક્સ બનાવો.

કોડ ઉદાહરણો

પાયથન

1def calculate_verification_digit(type_code, dni):
2    # સ્ટ્રિંગમાં રૂપાંતર કરો અને DNI 8 અંકોની અગાઉથી શૂન્ય સાથે સુનિશ્ચિત કરો
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # type code અને DNI ને મિશ્ર કરો
7    digits = type_code_str + dni_str
8    
9    # દરેક સ્થાન માટે વજન
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # ગુણાકારોનો સરવાળો કરો
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # ચકાસણી અંક ગણો
16    verification_digit = 11 - (sum_products % 11)
17    
18    # વિશેષ કેસો
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    # માન્ય type code
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"અમાન્ય type code. નીચેનામાંથી એક હોવો જોઈએ: {valid_type_codes}")
34    
35    # DNI પ્રદાન કરવામાં ન આવ્યું હોય તો રે‌ન્ડમ DNI બનાવો
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # ચકાસણી અંક ગણો
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # CUIT/CUIL ફૉર્મેટ
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # હાઇફન્સ દૂર કરો
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # મૂળભૂત ફૉર્મેટ ચકાસો
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "અમાન્ય ફૉર્મેટ"
52    
53    # ભાગો કાઢો
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    # type code ચકાસો
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "અમાન્ય type code"
62    
63    # ચકાસણી અંક ગણો અને સરખાવો
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "અમાન્ય ચકાસણી અંક"
67    
68    return True, "માન્ય CUIT/CUIL"
69
70# ઉદાહરણ વાપરાશ
71print(generate_cuit_cuil(20, 12345678))  # ચોક્કસ DNI માટે બનાવો
72print(generate_cuit_cuil(27))  # રે‌ન્ડમ DNI સાથે બનાવો
73print(validate_cuit_cuil("20-12345678-9"))  # CUIT/CUIL ચકાસો
74

જાવાસ્ક્રિપ્ટ

1function calculateVerificationDigit(typeCode, dni) {
2  // સ્ટ્રિંગમાં રૂપાંતર કરો અને DNI 8 અંકોની અગાઉથી શૂન્ય સાથે સુનિશ્ચિત કરો
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // type code અને DNI ને મિશ્ર કરો
7  const digits = typeCodeStr + dniStr;
8  
9  // દરેક સ્થાન માટે વજન
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // ગુણાકારોનો સરવાળો કરો
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // ચકાસણી અંક ગણો
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // વિશેષ કેસો
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  // માન્ય type code
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`અમાન્ય type code. નીચેનામાંથી એક હોવો જોઈએ: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // DNI પ્રદાન કરવામાં ન આવ્યું હોય તો રે‌ન્ડમ DNI બનાવો
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // ચકાસણી અંક ગણો
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // CUIT/CUIL ફૉર્મેટ
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // હાઇફન્સ દૂર કરો
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // મૂળભૂત ફૉર્મેટ ચકાસો
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'અમાન્ય ફૉર્મેટ' };
58  }
59  
60  // ભાગો કાઢો
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  // type code ચકાસો
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'અમાન્ય type code' };
69  }
70  
71  // ચકાસણી અંક ગણો અને સરખાવો
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'અમાન્ય ચકાસણી અંક' };
75  }
76  
77  return { isValid: true };
78}
79
80// ઉદાહરણ વાપરાશ
81console.log(generateCuitCuil(20, 12345678)); // ચોક્કસ DNI માટે બનાવો
82console.log(generateCuitCuil(27)); // રે‌ન્ડમ DNI સાથે બનાવો
83console.log(validateCuitCuil("20-12345678-9")); // CUIT/CUIL ચકાસો
84

જાવા

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        // સ્ટ્રિંગમાં રૂપાંતર કરો અને DNI 8 અંકોની અગાઉથી શૂન્ય સાથે સુનિશ્ચિત કરો
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // type code અને DNI ને મિશ્ર કરો
15        String digits = typeCodeStr + dniStr;
16        
17        // ગુણાકારોનો સરવાળો કરો
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // ચકાસણી અંક ગણો
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // વિશેષ કેસો
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("અમાન્ય type code. નીચેનામાંથી એક હોવો જોઈએ: " + VALID_TYPE_CODES);
39        }
40        
41        // DNI પ્રદાન કરવામાં ન આવ્યું હોય તો રે‌ન્ડમ DNI બનાવો
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // ચકાસણી અંક ગણો
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // CUIT/CUIL ફૉર્મેટ
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // હાઇફન્સ દૂર કરો
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // મૂળભૂત ફૉર્મેટ ચકાસો
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "અમાન્ય ફૉર્મેટ");
61        }
62        
63        // ભાગો કાઢો
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        // type code ચકાસો
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "અમાન્ય type code");
71        }
72        
73        // ચકાસણી અંક ગણો અને સરખાવો
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "અમાન્ય ચકાસણી અંક");
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        // ઉદાહરણ વાપરાશ
102        System.out.println(generateCuitCuil(20, 12345678)); // ચોક્કસ DNI માટે બનાવો
103        System.out.println(generateCuitCuil(27, null)); // રે‌ન્ડમ DNI સાથે બનાવો
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // CUIT/CUIL ચકાસો
105    }
106}
107

PHP

<?php function calculateVerificationDigit($typeCode, $dni) { // સ્ટ્રિંગમાં રૂપાંતર કરો અને DNI 8 અંકોની અગાઉથી શૂન્ય સાથે સુનિશ્ચિત કરો $typeCodeStr = (string)$typeCode; $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT); // type code અને DNI ને મિશ્ર કરો $digits = $typeCodeStr . $dniStr; // દરેક સ્થાન માટે વજન $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, ## વારંવાર પૂછવામાં આવતા પ્રશ્નો ### CUIT અને CUIL વચ્ચે શું તફાવત છે? અહીં વ્યાવહારિક ભેદ છે: **CUIT** (Clave Única de Identificación Tributaria) કર ભરનાર - વ્યક્તિઓ અને વ્યવસાયો કે જેઓ AFIP સાથે કર ભરે છે. **CUIL** (Clave Única de Identificación Laboral) રોજગાર અને નિવૃત્તિ હેતુઓ માટે સામાજિક સુરક્ષા પ્રણાલીમાં કાર્યકર્તાઓની ઓળખ કરે છે. વ્યવહારમાં, ઘણી વ્યક્તિઓ પાસે CUIL (પ્રથમ નોકરીથી) હોઈ શકે છે અને પાછળથી CUIT (જો તેઓ સ્વ-રોજગાર કે વ્યવસાય શરૂ કરે) મેળવી શકે છે. સંખ્યાઓ સમાન ફૉર્મેટિંગ અને ગણતરી નિયમોનો ઉપયોગ કરે છે, તેથી ચકાસણીના સ્તરે, તમે તેમને સમાન રીતે સંભાળો. વહીવટી હેતુઓ માટે ભેદ મહત્વપૂર્ણ છે: પગાર પ્રણાલીઓ સામાન્ય રીતે CUIL સાથે કામ કરે છે, જ્યારે ઇન્વอઇસિંગ અને કર પ્રણાલીઓ CUIT નો ઉપયોગ કરે છે. ### વ્યક્તિઓ અને કંપનીઓ માટે કયા પ્રકારના કોડ વપરાય છે? વ્યક્તિઓ માટે: - 20, 23, 24: પુરુષ વ્યક્તિઓ (CUIL) - 27: સ્ત્રી વ્યક્તિઓ (CUIL) કંપનીઓ અને સંસ્થાઓ માટે: - 30: કૉર્પોરેશન (CUIT) - 33: નાગરિક સંઘ (CUIT) - 34: ફાઉન્ડેશન (CUIT) ### ચકાસણી અંક કેવી રીતે ગણવામાં આવે છે? એલ્ગોરિધમ ભારાંકિત ગુણાકાર વાપરે છે: પ્રથમ 10 અંકોને, **5, 4, 3, 2, 7, 6, 5, 4, 3, 2** ભાર સાથે ગુણાંક, ઉત્પાદનોનો સરવાળો, પછી 11 માંથી (સરવાળો મૉડ્યુલો 11) ગણો. બે કિનારાના કેસ લોકોને ગેરમાર્ગે દોરે છે: જ્યારે ગણતરી 11 આપે, ચકાસણી અંક તરીકે 0 વાપરો; જ્યારે 10 આપે, 9 વાપરો. આ વિશેષ કેસો એટલા માટે છે કે ચકાસણી અંક હંમેશા એક અંક (0-9) હોવો જોઈએ. આ મૉડ્યુલો-11 ચેક અંક એલ્ગોરિધમ છે, ISBN-10 કોડ્સ અને વિશ્વભરની અન્ય ઓળખ પ્રણાલીઓ જેવો. (ટ્રાન્સલેશન ચાલુ...) ## સંદર્ભો 1. AFIP (સાર્વજનિક આવક સંચાલન). "CUIT/CUIL/CDI." ઔપચારિક વેબસાઇટ. [https://www.afip.gob.ar/](https://www.afip.gob.ar/) 2. કામ, રોજગાર અને સામાજિક સુરક્ષા મંત્રાલય. "CUIL - શ્રમ ઓળખ માટેનો એકીકૃત કી." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo) 3. ANSES (રાષ્ટ્રીય સામાજિક સુરક્ષા વહીવટ). "મારો CUIL મેળવો." [https://www.anses.gob.ar/](https://www.anses.gob.ar/) 4. અર્જન્ટીના પ્રજાસત્તાક રાજ્યનું ઔપચારિક બુલેટિન. "AFIP જનરલ ઠરાવ 2854/2010: પ્રક્રિયા. એકીકૃત કર ઓળખ (C.U.I.T.)." 5. અર્જન્ટીના પ્રજાસત્તાક રાજ્યનો નાણાકીય કાયદો. "કરદાતાઓની ઓળખ અને નોંધણી." --- તમે ઇન્વॉઇસિંગ સિસ્ટમ બનાઈ રહ્યા છો, કર્મચારી ઓનબોર્ડિંગ પ્રવાહનું પરીક્ષણ કરી રહ્યા છો, અથવા ચકાસણી એલ્ગોરિધમ વિશે શીખી રહ્યા છો, આ ટૂલ CUIT/CUIL જનરેશન અને ચકાસણી પ્રદાન કરે છે. એલ્ગોરિધમિક ચકાસણી પાસ કરતા પરીક્ષણ ડેટા જનરેટ કરો, ડેટાબેઝમાં જતા પહેલાં નંબરોની ચકાસણી કરો, અથવા ચેક અંક એલ્ગોરિધમ કેવી રીતે કાર્ય કરે છે તેનો અભ્યાસ કરો.