VÉRIFICATION DE LA VALIDITÉ DES CODES SIRET ET SIREN

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);
		
	}

}