Vérification de la validité des codes siret et siren

Soyez le premier à donner votre avis sur cette source.

Snippet vu 60 037 fois - Téléchargée 18 fois

Contenu du snippet

Après plusieurs recherches sur internet, je n'ai pas trouvé d'exemple en java pour tester la validité d'un code SIRET ou SIREN.
Je poste donc une petite class "SiretSiren.java" ainsi qu'une class de test pour ceux qui comme moi cherchent encore ;-), vos commentaires sont les bienvenues.

Je me suis inspiré du code javascript de "cgone" présent sur ce site à l'adresse "http://www.javascriptfr.com/codes/VERIFICATION-VALIDITE-CODES-SIRET-SIREN-ALGO-LUHN_16330.aspx"
et de la définition du CNRS que vous trouverez à l'adresse suivante "http://www.dsi.cnrs.fr/bureau_qualite/admindonnees/documents/siren.pdf"

Source / Exemple :


package com.compufirst.util;

/**

  • @author COL - 27/05/2007
  • numéro SIREN
  • Il est composé de 8 chiffres, plus un chiffre de contrôle qui permet de vérifier la validité du numéro.
  • La clé de contrôle utilisée pour vérifier de l'exactitude d'un identifiant est une clé "1-2". Le principe est
  • le suivant : on multiplie les chiffres de rang impair à partir de la droite par 1, ceux de rang pair par 2 ; la
  • somme des chiffres obtenus doit être un multiple de 10.
  • exemple : soit le SIREN 732 829 320
  • pour vérifier : 7 3 2 8 2 9 3 2 0
  • rang pair x 2 : 6 16 18 4
  • rang impair x 1 : 7 2 2 3 0
  • ----------------------
  • somme : 7+6+2+1+6+2+1+8+3+4+0 = 40
  • Le numéro est exact.
*
  • numéro SIRET
  • Le numéro d'identité d'établissement est articulé en deux parties : la première est le n° SIREN de la
  • personne à laquelle appartient l'unité SIRET ; la seconde est un numéro d'ordre à 4 chiffres attribué à
  • l'établissement suivi d'un chiffre de contrôle, qui permet de vérifier la validité de l'ensemble du numéro
  • SIRET. Cette seconde partie est habituellement appelée NIC (numéro interne de classement).
  • Méthode de vérification :
  • Un SIRET est le résultat de la concaténation d'un numéro SIREN à 9 chiffres (dont la clé doit être
  • vérifiée à part) et d'un numéro interne de classement (NIC) complété éventuellement à gauche par des
  • zéros de façon que sa longueur soit de 4 chiffres. Le dernier et 14ème chiffre est une clé (1-2) qui
  • porte sur les 13 premiers chiffres.
  • On multiplie les chiffres de rang impair à partir de la droite par 1, ceux de rang pair par 2 ; la somme
  • des chiffres obtenus est un multiple de 10.
  • Exemple :
  • pour vérifier : 7 3 2 8 2 9 3 2 0 0 0 0 7 4
  • rang pair x 2 : 14 4 4 6 0 0 14
  • rang impair x 1 : 3 8 9 2 0 0 4
  • -----------------------------------
  • somme : 1+4+3+4+8+4+9+6+2+0+0+0+0+1+4+4=50
  • Le numéro est exact. Il correspond au SIRET du 7ème établissement immatriculé par l'entreprise.
*
  • /
public class SiretSiren { public static final String SIREN = "SIREN"; public static final String SIRET = "SIRET"; public static final String WRONGNUMBER = "WRONGNUMBER"; public static final String NOTANUMBER = "NOTANUMBER"; private String siretsiren; private String type; public SiretSiren(){ } public SiretSiren(String siretsiren){ this.setSiretsiren(siretsiren); } private boolean isSirenSyntaxValide(String siren){ int total = 0; int digit = 0; for (int i = 0; i<siren.length(); i++) { /** Recherche les positions paires : 2ème, 4ème, 6ème et 8ème chiffre que l'on multiplie par 2
  • petite différence avec la définition ci-dessus car ici on travail de gauche à droite */
if ((i % 2) == 1) { digit = Integer.parseInt(String.valueOf(siren.charAt(i))) * 2; /** si le résultat est >9 alors il est composé de deux digits tous les digits devant
  • s'additionner et ne pouvant être >19 le calcule devient : 1 + (digit -10) ou : digit - 9 */
if (digit > 9) digit -= 9; } else digit = Integer.parseInt(String.valueOf(siren.charAt(i))); total += digit; } /** Si la somme est un multiple de 10 alors le SIREN est valide */ if ((total % 10) == 0) return true; else return false; } private boolean isSiretSyntaxValide(String siret){ int total = 0; int digit = 0; for (int i = 0; i<siret.length(); i++) { /** Recherche les positions impaires : 1er, 3è, 5è, etc... que l'on multiplie par 2
  • petite différence avec la définition ci-dessus car ici on travail de gauche à droite */
if ((i % 2) == 0) { digit = Integer.parseInt(String.valueOf(siret.charAt(i))) * 2; /** si le résultat est >9 alors il est composé de deux digits tous les digits devant
  • s'additionner et ne pouvant être >19 le calcule devient : 1 + (digit -10) ou : digit - 9 */
if (digit > 9) digit -= 9; } else digit = Integer.parseInt(String.valueOf(siret.charAt(i))); total += digit; } /** Si la somme est un multiple de 10 alors le SIRET est valide */ if ((total % 10) == 0) return true; else return false; } /**
  • Méthode qui vérifie si la chaine passée est un nombre.
  • Si le parse réussi alors c'est un nombre sinon une exception est levée
  • @param aString
  • @return true si c'est un chiffre, false dans le cas contraire
  • /
private boolean isNumber(String aString){ try{ Long.parseLong(aString); return true; } catch(NumberFormatException nfe){ return false; } } public boolean isEqualTo(String siretsiren){ if(this.siretsiren.equals(siretsiren)) return true; else return false; } public boolean isEqualTo(SiretSiren siretsiren){ if(this.siretsiren.equals(siretsiren.getSiretsiren())) return true; else return false; } @Override public int hashCode() { return this.getSiretsiren().hashCode(); } public String getSiretsiren() { return siretsiren; } /**
  • Vérifie si le SIREN/SIRET passé, est un numérique à 9 ou 14 chiffres
  • Identifie si le num passé est un SIREN ou un SIRET
  • @param siretsiren (String)
  • */
public void setSiretsiren(String siretsiren) { this.siretsiren = siretsiren; if(!this.isNumber(siretsiren)){ this.type = SiretSiren.NOTANUMBER; } else{ if(siretsiren.length()!=9 || siretsiren.length()!=14) this.type=SiretSiren.WRONGNUMBER; if(siretsiren.length()==9) { if(isSirenSyntaxValide(siretsiren))this.type = SiretSiren.SIREN; else this.type=SiretSiren.WRONGNUMBER; } if(siretsiren.length()==14){ if(isSiretSyntaxValide(siretsiren)) this.type = SiretSiren.SIRET; else this.type=SiretSiren.WRONGNUMBER; } } } public String getType() { return type; } private void setType(String type) { this.type = type; } } /********************************************************************/ /** class de test ***************************************************/ /********************************************************************/ package com.compufirst.util; public class TestSirenSiret { public static void main(String[] args) { SiretSiren siretSiren = new SiretSiren("732829320"); String type = siretSiren.getType(); System.out.println("SiretSiren = 732829320 getType ="+ type); SiretSiren siretSiren2 = new SiretSiren(); siretSiren2.setSiretsiren("35152822900088"); String type2 = siretSiren2.getType(); System.out.println("SiretSiren = 35152822900088 getType ="+ type2); boolean bool = siretSiren.isEqualTo(siretSiren2); boolean bool1 = siretSiren.isEqualTo(siretSiren2.getSiretsiren()); boolean bool2 = siretSiren.isEqualTo("732829320"); System.out.println("siretSiren = siretSiren2 ? :"+ bool); System.out.println("siretSiren = siretSiren2 ? :"+ bool1); System.out.println("siretSiren = siretSiren2 ? :"+ bool2); } }

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1
Date d'inscription
jeudi 4 novembre 2004
Statut
Membre
Dernière intervention
6 septembre 2010

Salut,

C'est pour te dire que tu as fait un erreur dans ton code concernant la vérification du numéro de SIRET.
Tu as copier/coller la vérification du digit provenant de la méthode isSirenSyntaxValide, elle n'est pas de 9 mais de 14 dans ce cas-là

Je te conseille plutôt de sortir la boucle de tes 2 méthodes et de passer en paramètre la taille de la chaîne
un truc dans ce genre...

private static int computeDigits(String value, int length) {
int digit = 0;
int total = 0;
for (int i = 0; i < length; i++) {
if ((i % 2) == 1) {
digit = Integer.parseInt(String.valueOf(value.charAt(i))) * 2;
if (digit > length) {
digit -= length;
}
} else {
digit = Integer.parseInt(String.valueOf(value.charAt(i)));
}
total += digit;
}
return total;
}
Messages postés
5351
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
17 août 2020
97
Salut,

Neutrino216 tu chipote quand même il n'y a que dans l'exemple d'utilisation qu'il fait ça... mais bon sur le principe c'est pas faux ^^
Messages postés
25
Date d'inscription
mardi 21 février 2006
Statut
Membre
Dernière intervention
12 juillet 2007

Salut,
Concernant le nommage des varaible. C'est mieux de donner des noms parlant par exemple
siern au lieu de s ou type au lieu de t. Et c'est plus lisible.
Messages postés
5351
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
17 août 2020
97
Salut,

Question utilisation je ne vois pas trop ou je pourrais toper l'utilitée de ton code, mais une chose est sur c'est qu'il est propre, commenté aux bon endroits, et tu respectes les règles de nomage.
8/10

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.