Diferencia entre revisiones de «Clave Única de Identificación Tributaria»
m Agregado código en Visual FoxPro Etiqueta: posibles pruebas |
|||
Línea 329: | Línea 329: | ||
RETURN @ResultVar |
RETURN @ResultVar |
||
--CLF_GT |
|||
END |
END |
Revisión del 22:42 15 ene 2018
La Clave Única de Identificación Tributaria (CUIT) es una clave que se utiliza en el sistema tributario de la República Argentina para poder identificar inequívocamente a las personas físicas o jurídicas autónomas, susceptibles de tributar. Las claves son asignadas por la Administración Federal de Ingresos Públicos (AFIP), para poder confeccionar el registro o censo de las mismas, para efectos administrativos y tributarios.
Composición
Consta de un total de once (11) cifras: dos dígitos iniciales que indican el tipo global, seguido por ocho dígitos que corresponden, en el caso de personas físicas, al número de Documento Nacional de Identidad, y en el caso de empresas a un número de sociedad asignado por la AFIP, y finalmente un dígito verificador.
Otros nombres
Para quienes trabajan en relación de dependencia, el mismo código toma el nombre de Código Único de Identificación Laboral (CUIL).
Quienes necesitan realizar operaciones que implican el pago de tributos (tal como varios tipos de compraventas registradas), pero que no clasifican como empleados o trabajadores autónomos, también pueden obtener de la misma agencia una "Clave de Identificación" (CDI).
La CUIT como dato personal de carácter público
La Clave Única de Identificación Tributaria de las personas físicas es un dato personal, en la medida que vincula a una persona con su identificación tributaria. No obstante, conforme la legislación argentina en materia de datos personales, en particular el artículo 5 de la Ley 25.326 de Protección de Datos Personales, la CUIT es unos de los datos de carácter personal que no requieren el consentimiento de su titular para su tratamiento.[1] Al mismo tiempo, la CUIT de los contribuyentes es un dato de acceso público, que de hecho es publicada por la Administración Federal de Ingresos Públicos a través del Padrón de Personas Físicas y Jurídicas.
Procedimiento para obtener la CUIT
La CUIT se obtiene en la Administración Federal de Ingresos Públicos, existiendo un trámite para las personas físicas y otro para las personas jurídicas que se describen en el sitio oficial del citado organismo recaudador.[2] El trámite debe realizarse ante la Agencia de la AFIP que corresponda al domicilio de la persona o entidad solicitante.
Procedimiento para obtener el dígito verificador
Tanto la CUIT (Clave Única de Identificación Tributaria) como el CUIL (Código Único de Identificación Laboral) constan de tres partes separados por guion:
- el tipo,
- el número y
- el dígito verificador.
En el siguiente ejemplo se toma como CUIT el número ##-12345678-X
, donde ##
es el tipo, 12345678
es el número de DNI o número de sociedad y X
es el dígito verificador.
Tipos:
- 20, 23, 24 y 27 para Personas Físicas
- 30, 33 y 34 para Empresas.
El dígito verificador se calcula usando el algoritmo Módulo 11. Para obtenerlo si no lo conocemos o si queremos calcularlo:
- Se procede a tomar el número de 10 dígitos compuesto por los 2 primeros mas los 8 dígitos siguientes, de derecha a izquierda, multiplicando cada dígito por los números que componen la serie numérica 2,3,4,5,6,7; y sumando el resultado de estos productos, como se muestra a continuación (si se ha aplicado la serie hasta el 7 y quedan dígitos por multiplicar, se comienza la serie nuevamente):
En el ejemplo:
8 × 2 = 16 7 × 3 = 21 6 × 4 = 24 5 × 5 = 25 4 × 6 = 24 3 × 7 = 21 2 × 2 = 4 1 × 3 = 3 0 × 4 = 0 2 × 5 = 10
entonces la suma de los productos es:
16+21+24+25+24+21+4+3+0+10 = SUMA_P
- Al número obtenido por la suma del producto de cada dígito por la serie ya mencionada, se le aplica módulo 11, o sea, se divide por 11 y se determina el resto de la división.
En el ejemplo:
SUMA_MOD11 = SUMA_P modulo 11
Queda en SUMA_MOD11 el resto de dividir por 11
- Ahora se hace 11 menos SUMA_MOD11
ONCEMENOS = 11 - SUMA_MOD11
- Si el resultado es 11, el dígito verificador será 0.
- Si el resultado es 10, no existe, es un error. Se debe cambiar el tipo a 23 o 33 y recalcular. Algunos algoritmos verifican erróneamente con 9 sin cambiar el tipo, lo cual es una falla de implementación.
Tipo original | Nuevo tipo | Dígito verificador |
---|---|---|
20 (Hombre) | 23 | 9 |
27 (Mujer) | 23 | 4 |
24 (Repetido) | 23 | 3 |
30 (Empresa) | 33 | 9 |
34 (Repetida) | 33 | 3 |
- En otro caso el resultado será el dígito verificador.
Ejemplo Macro en Visual Basic MS Excel
Public Function ValidarCuit(ByVal Cuit As String) As Boolean If Len(Cuit) = 11 Then Dim Ponderador As Integer Dim Acumulado As Integer Dim Digito As Integer Dim Posicion As Integer Ponderador = 2 Acumulado = 0 'Recorro la cadena de atrás para adelante For Posicion = 10 To 1 Step -1 'Sumo las multiplicaciones de cada dígito x su ponderador Acumulado = Acumulado + Val(Mid$(Cuit, Posicion, 1)) * Ponderador Ponderador = Ponderador + 1 If Ponderador > 7 Then Ponderador = 2 Next Digito = 11 - (Acumulado Mod 11) If Digito = 11 Then Digito = 0 ValidarCuit = (Digito = Right(Cuit, 1)) Else ValidarCuit = False End If End Function
Código Java
private boolean validarCuit(String cuit) {
//Eliminamos todos los caracteres que no son números
cuit = cuit.replaceAll("[^\\d]", "");
//Controlamos si son 11 números los que quedaron, si no es el caso, ya devuelve falso
if (cuit.length() != 11){
return false;
}
//Convertimos la cadena que quedó en una matriz de caracteres
char[] cuitArray = cuit.toCharArray();
//Inicializamos una matriz por la cual se multiplicarán cada uno de los dígitos
Integer[] serie = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
//Creamos una variable auxiliar donde guardaremos los resultados del cálculo del número validador
Integer aux = 0;
//Recorremos las matrices de forma simultanea, sumando los productos de la serie por el número en la misma posición
for (int i=0; i<10; i++){
aux += Character.getNumericValue(cuitArray[i]) * serie[i];
}
//Hacemos como se especifica: 11 menos el resto de de la división de la suma de productos anterior por 11
aux = 11 - (aux % 11);
//Si el resultado anterior es 11 el código es 0
if (aux == 11){
aux = 0;
}
//Si el resultado anterior es 10 el código no tiene que validar, cosa que de todas formas pasa
//en la siguiente comparación.
//Devuelve verdadero si son iguales, falso si no lo son
//(Esta forma esta dada para prevenir errores, en java 6 se puede usar: return aux.equals(Character.getNumericValue(cuitArray[10]));)
return Objects.equals(Character.getNumericValue(cuitArray[10]), aux);
}
Código Javascript
function validarCuit(cuit) {
if(cuit.length != 11) {
return false;
}
var acumulado = 0;
var digitos = cuit.split("");
var digito = digitos.pop();
for(var i = 0; i < digitos.length; i++) {
acumulado += digitos[9 - i] * (2 + (i % 6));
}
var verif = 11 - (acumulado % 11);
if(verif == 11) {
verif = 0;
}
return digito == verif;
}
Código Python
def esCUITValida(cuit):
cuit = str(cuit)
cuit = cuit.replace("-", "")
cuit = cuit.replace(" ", "")
cuit = cuit.replace(".", "")
if len(cuit) != 11:
return False
if not cuit.isdigit():
return False
base = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
aux = 0
for i in xrange(10):
aux += int(cuit[i]) * base[i]
aux = 11 - (aux % 11)
if aux == 11:
aux = 0
if int(cuit[10]) == aux:
return True
else:
return False
Código PHP
public function validarCuit( $cuit ){
$cuit = preg_replace( '/[^\d]/', '', (string) $cuit );
if( strlen( $cuit ) != 11 ){
return false;
}
$acumulado = 0;
$digitos = str_split( $cuit );
$digito = array_pop( $digitos );
for( $i = 0; $i < count( $digitos ); $i++ ){
$acumulado += $digitos[ 9 - $i ] * ( 2 + ( $i % 6 ) );
}
$verif = 11 - ( $acumulado % 11 );
$verif = $verif == 11? 0 : $verif;
return $digito == $verif;
}
Código PL/SQL
PROCEDURE CALCULAR_DV (i_cuit number) AS
v_dv number;
v_cuit number;
begin
VALIDAR_CUIT(i_cuit,10);
select mod(substr(i_cuit,1,1)*5+
substr(i_cuit,2,1)*4+
substr(i_cuit,3,1)*3+
substr(i_cuit,4,1)*2+
substr(i_cuit,5,1)*7+
substr(i_cuit,6,1)*6+
substr(i_cuit,7,1)*5+
substr(i_cuit,8,1)*4+
substr(i_cuit,9,1)*3+
substr(i_cuit,10,1)*2,11)
into v_dv
from dual;
case when (11-v_dv) between 1 and 9 then
v_cuit := i_cuit || (11-v_dv);
when v_dv = 1 then
CASE WHEN substr(i_cuit,1,2) = 27 then
v_cuit := 23||substr(i_cuit,3,8)||4;
WHEN substr(i_cuit,1,2) = 20 then
v_cuit := 23||substr(i_cuit,3,8)||9;
WHEN substr(i_cuit,1,2) = 24 then
v_cuit := 23||substr(i_cuit,3,8)||3;
WHEN substr(i_cuit,1,2) = 30 then
v_cuit := 33||substr(i_cuit,3,8)||9;
WHEN substr(i_cuit,1,2) = 34 then
v_cuit := 33||substr(i_cuit,3,8)||3;
ELSE
dbms_output.put_line('El CUIT no se pudo calcular correctamente');
END CASE;
else
v_cuit := i_cuit||0;
end case;
dbms_output.put_line('El CUIT completo con DV es: ' || v_cuit);
EXCEPTION WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Error desconocido: '||SUBSTR(SQLERRM, 1, 200));
END;
PROCEDURE VALIDAR_CUIT(i_cuit number,cant number) AS
BEGIN
CASE WHEN length(i_cuit) <> cant THEN
DBMS_OUTPUT.PUT_LINE('El cuit enviado se espera que tenga ' || cant || ' digitos');
END CASE;
END;
Código T-SQL
CREATE FUNCTION U_FU_ValidaCUITL
(
@Cuitl varchar(50)
)
RETURNS int
AS
BEGIN
DECLARE @ResultVar int,
@TempCuitl varchar(50),
@factmult varchar(6) ='234567',
@i int ,
@j int,
@suma int
/*
Codigo Valor
0 Error
1 OK
*/
set @ResultVar=0
if len(@Cuitl)>13
begin
set @ResultVar=0
end
else
begin
if len(substring(@Cuitl,1,CHARINDEX('-',@Cuitl)-1))>2
begin
set @ResultVar=0
end
else
begin
if len(substring(reverse(@Cuitl),1,CHARINDEX('-',reverse(@Cuitl))-1))>1
begin
set @ResultVar=0
end
else
begin
set @TempCuitl =reverse(substring(reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)),1,CHARINDEX('-',reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)))-1)+ substring(reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)),charindex('-',reverse(substring(reverse(@Cuitl), charindex('-',REVERSE(@Cuitl))+1,50)))+1,50))
set @i=1
set @j=1
set @suma =0
while @i<=len (@TempCuitl)
begin
set @suma =@suma+ Cast((substring(@TempCuitl,@i,1)) as int) *Cast((substring(@factmult,@j,1)) as int)
set @i=@i+1
set @j=@j+1
if @j>6
set @j=1
end
end
end
end
if Cast(substring(reverse(@Cuitl),1,CHARINDEX('-',reverse(@Cuitl))-1) as int) =11-(@suma % 11)
set @ResultVar=1
RETURN @ResultVar
--CLF_GT
END
Código Visual FoxPro
FUNCTION ValidarCUIT(tcCUIT)
LOCAL lnSuma, llRet
IF EMPTY(tcCuit)
llRet = .T.
ELSE
IF TYPE('tcCuit') = 'C' AND LEN(tcCuit) = 13
lnSuma = VAL(SUBS(tcCUIT,11,1)) * 2 + ;
VAL(SUBS(tcCUIT,10,1)) * 3 + ;
VAL(SUBS(tcCUIT,9,1)) * 4 + ;
VAL(SUBS(tcCUIT,8,1)) * 5 + ;
VAL(SUBS(tcCUIT,7,1)) * 6 + ;
VAL(SUBS(tcCUIT,6,1)) * 7 + ;
VAL(SUBS(tcCUIT,5,1)) * 2 + ;
VAL(SUBS(tcCUIT,4,1)) * 3 + ;
VAL(SUBS(tcCUIT,2,1)) * 4 + ;
VAL(SUBS(tcCUIT,1,1)) * 5
llRet = VAL(SUBS(tcCUIT,13,1)) = ;
IIF(MOD(lnSuma,11) = 0, 0, 11-MOD(lnSuma,11))
ELSE
*-- No es Char o no tiene el largo correcto
llRet = .F.
ENDIF
ENDIF
RETURN llRet
ENDFUNC
Referencias
- ↑ «Art. 5, Ley 25.326 de Protección de Datos Personales». Consultado el 11 de septiembre de 2012.
- ↑ Administración Federal de Ingresos Públicos. «Guía de Trámites de la Administración Federal de Ingresos Públicos». Consultado el 11 de septiembre de 2012.