Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/exceptions/XMLException.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/exceptions/XMLException.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/exceptions/XMLException.java	(revision 488)
@@ -0,0 +1,32 @@
+/*
+ * Created on 23 Janvier. 2007
+ */
+package com.medias.integration.exceptions;
+
+/**
+ * @author 
+ *
+ * Exception XML
+ */
+public class XMLException
+        extends Exception {
+    /**
+     * Construit une XMLException.
+     */
+    public XMLException( Exception e ) {
+        super(e);
+    }
+
+    /**
+     * Construit une XMLException.
+     * @param message Message de l'exception.
+     */
+    public XMLException( String message ) {
+        super(message);
+    }
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1L;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/hibernate/HibernateSessionFactory.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/hibernate/HibernateSessionFactory.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/hibernate/HibernateSessionFactory.java	(revision 488)
@@ -0,0 +1,84 @@
+package com.medias.integration.hibernate;
+
+import org.hibernate.HibernateException;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+
+/**
+ * Configures and provides access to Hibernate sessions, tied to the
+ * current thread of execution.  Follows the Thread Local Session
+ * pattern, see {@link http://hibernate.org/42.html}.
+ */
+public class HibernateSessionFactory
+{
+    /**
+     * Default constructor.
+     */
+    private HibernateSessionFactory() {
+    }
+
+    /**
+     * Returns the ThreadLocal Session instance.  Lazy initialize
+     * the <code>SessionFactory</code> if needed.
+     *
+     *  @return Session
+     *  @throws org.hibernate.HibernateException
+     */
+    public static Session currentSession() throws HibernateException {
+        Session session = (Session) threadLocal.get();
+
+        if (session == null) {
+            if (sessionFactory == null) {
+                try {
+                    cfg.configure(CONFIG_FILE_LOCATION);
+                    sessionFactory = cfg.buildSessionFactory();
+                }
+                catch (Exception e) {
+                    System.err.println("%%%% Error Creating SessionFactory %%%%");
+                    e.printStackTrace();
+                }
+            }
+            session = sessionFactory.openSession();
+            threadLocal.set(session);
+        }
+
+        return session;
+    }
+
+    /**
+     *  Close the single hibernate session instance.
+     *
+     *  @throws org.hibernate.HibernateException
+     */
+    public static void closeSession() throws HibernateException {
+        Session session = (Session) threadLocal.get();
+        threadLocal.set(null);
+
+        if (session != null) {
+            session.close();
+        }
+    }
+
+    /** 
+     * Location of hibernate.cfg.xml file.
+     * NOTICE: Location should be on the classpath as Hibernate uses
+     * #resourceAsStream style lookup for its configuration file. That
+     * is place the config file in a Java package - the default location
+     * is the default Java package.<br><br>
+     * Examples: <br>
+     * <code>CONFIG_FILE_LOCATION = "/hibernate.conf.xml". 
+     * CONFIG_FILE_LOCATION = "/com/foo/bar/myhiberstuff.conf.xml".</code> 
+     */
+    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
+
+    /** Holds a single instance of Session */
+    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
+
+    /** The single instance of hibernate configuration */
+    private static final Configuration cfg = new Configuration();
+
+    /** The single instance of hibernate SessionFactory */
+    private static SessionFactory sessionFactory;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/insertion/Insertion.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/insertion/Insertion.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/insertion/Insertion.java	(revision 488)
@@ -0,0 +1,928 @@
+/**
+ * Created on 24 Janvier. 2006
+ *  @author 
+ */
+
+package com.medias.integration.insertion;
+
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.database.objects.Adresse;
+import com.medias.database.objects.Bilan;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.CategorieParam;
+import com.medias.database.objects.Commentaire;
+import com.medias.database.objects.DeltaMesure;
+import com.medias.database.objects.Fabriquant;
+import com.medias.database.objects.Fichier;
+import com.medias.database.objects.Flag;
+import com.medias.database.objects.Jeu;
+import com.medias.database.objects.Localisation;
+import com.medias.database.objects.Mesure;
+import com.medias.database.objects.Organisme;
+import com.medias.database.objects.Parametre;
+import com.medias.database.objects.Personne;
+import com.medias.database.objects.Plateforme;
+import com.medias.database.objects.RequeteNbvalsJeu;
+import com.medias.database.objects.RequetePlatLoc;
+import com.medias.database.objects.Sequence;
+import com.medias.database.objects.TypeCapteur;
+import com.medias.database.objects.TypePlateforme;
+import com.medias.database.objects.Unite;
+import com.medias.database.objects.Valeur;
+import com.medias.integration.utils.CommunicationBD;
+import com.medias.integration.utils.Nombre;
+import com.medias.integration.utils.Statiques;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * Classe permettant d'inserer les jeux de donnÃ©es
+ */
+public class Insertion {
+	/**
+	 *  Insertion de la valeur
+	 */
+	public int insererValeur(Valeur valeur) throws Exception {//,int flagValiditeId
+		// on teste si le flag de la valeur est different de null : on l'insere
+		if (valeur.getFlagByValeurFlag() != null) {
+			int flagValeurId = insererFlag(valeur.getFlagByValeurFlag(),0);
+			valeur.getFlagByValeurFlag().setFlagId(flagValeurId);
+		}
+		// on teste si le flag de la validitÃ© est different de null : on l'insere
+		if (valeur.getFlagByValiditeFlag() != null) {
+			flagValidId = insererFlag(valeur.getFlagByValiditeFlag(),0);//flagValiditeId);
+			valeur.getFlagByValiditeFlag().setFlagId(flagValidId);
+		}
+
+		CommunicationBD.save(valeur);
+		return valeur.getValeurId();
+	}
+	
+	/**
+	 *  Insertion de la mesure
+	 */
+	public int insererMesure(Mesure mesure, ArrayList<Localisation> listeLocs) throws Exception {//,int flagId
+		insererLoc(mesure.getLocalisation(),listeLocs, mesure.getPlateforme().getTypePlateforme().getTypePlateformeNom());//,flagId);
+		if (mesure.getDeltaMesure() != null) {
+			insererDelta(mesure.getDeltaMesure());
+		}
+		CommunicationBD.save(mesure);
+		return mesure.getMesureId();
+	}
+	
+	/**
+	 * Insertion des flags 
+	 */
+	public int insererFlag(Flag flag, int flagPrecId) throws Exception {
+		int flagId = 0;
+		if (flagPrecId == 0) {
+			Flag flagExistant = (Flag) CommunicationBD.getObjectByColonne(Flag.class, "flagNom", flag.getFlagNom());
+			// si Le flag n'existe pas : on l'insÃ©re
+			if (flagExistant == null) {
+				CommunicationBD.save(flag);
+				flagId = flag.getFlagId();
+			}
+			// sinon le flag existe : on rÃ©cupÃ©re l'ID
+			else {
+				flagId = flagExistant.getFlagId();
+				flag.setFlagId(flagId);
+			}
+		} else {
+			flagId = flagPrecId;
+		}
+		return flagId;
+	}
+
+	/**
+	* Insertion du commentaire 
+	*/
+	public int insererCommentaire(Commentaire commentaire) throws Exception {
+		List<?> commentaireExistant = CommunicationBD.getList("select c.commentaireId from Commentaire c where commentaire_txt = '"
+				+commentaire.getCommentaireTxt().replaceAll("'", "''")+"'");
+		// Le commentaire existe : on rÃ©cupÃ©re l'ID
+		if (commentaireExistant.size() != 0) {
+			commentaire.setCommentaireId(((Integer)commentaireExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(commentaire);
+		int id = commentaire.getCommentaireId();
+		return id;
+	}	
+
+	/**
+	* Insertion de l'adresse
+	*/
+	public int insererAdresse(Adresse adresse) throws Exception {
+		List<?> adresseExistant = CommunicationBD.getList("select a.adresseId from Adresse a " +
+				"where adresse_rue = '"+adresse.getAdresseRue().replaceAll("'", "''")+"' " +
+				"and adresse_zip = '"+adresse.getAdresseZip().replaceAll("'", "''")+"' " +
+				"and adresse_ville = '"+adresse.getAdresseVille().replaceAll("'", "''")+"' " +
+				"and adresse_pays = '"+adresse.getAdressePays().replaceAll("'", "''")+"'");
+		// si L'adresse existe : on rÃ©cupÃ©re l'ID
+		if (adresseExistant.size() != 0) {
+			adresse.setAdresseId(((Integer)adresseExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(adresse);
+		int adresseId = adresse.getAdresseId();
+		return adresseId;
+	}
+		
+	/**
+	* Insertion de l'organisme 
+	*/
+	public int insererOrganisme(Organisme organisme) throws Exception {
+		// l'adresse de l'organisme n'est pas nul : on l'insere
+		insererAdresse(organisme.getAdresse());
+		// si le commentaire de l'organisme n'est pas null : on l'insere
+		if (organisme.getCommentaire() != null) {
+			insererCommentaire(organisme.getCommentaire());
+		}
+		// on verifie si l'organisme n'existe pas dejÃ© dans la base
+		List<?> organismeExistant = CommunicationBD.getList("select o.organismeId from Organisme o " +
+				"where organisme_nom = '"+organisme.getOrganismeNom().replaceAll("'", "''")+"'");
+		// si l'organisme existe : on rÃ©cupÃ©re l'ID
+		if (organismeExistant.size() != 0) {
+			organisme.setOrganismeId(((Integer)organismeExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(organisme);			
+		int organismeId = organisme.getOrganismeId();
+		return organismeId;
+	}
+	
+	/**
+	* Insertion de la personne
+	*/
+	public int insererPersonne(Personne personne) throws Exception {
+		CommunicationBD.open();
+		insererOrganisme(personne.getOrganisme());
+		if (personne.getCommentaire() != null) {
+			insererCommentaire(personne.getCommentaire());
+		}
+		List<?> personneExistant = CommunicationBD.getList("select p.personneId from Personne p where personne_mail = '"
+				+personne.getPersonneMail().replaceAll("'", "''")+"'");
+		// si la personne existe : on rÃ©cupÃ©re l'ID
+		if (personneExistant.size() != 0) {
+			personne.setPersonneId(((Integer)personneExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(personne);
+		int personneId = personne.getPersonneId();
+		CommunicationBD.close();
+		return personneId;
+	}
+	
+	/**
+	* Insertion du jeu 
+	*/
+	public int insererJeu(Jeu jeu) throws Exception {
+		CommunicationBD.open();
+		// si le commentaire du jeu n'est pas null : on l'insere
+		if (jeu.getCommentaire() != null) {
+			insererCommentaire(jeu.getCommentaire());
+		}
+		// inserer l'organisme du jeu
+		insererOrganisme(jeu.getOrganisme());
+		// On vÃ©rifie que le jeu n'existe pas dÃ©jÃ© dans la base
+		List<?> jeuExistant = CommunicationBD.getList("select j.jeuId, j.jeuAltmax, " +
+				"j.jeuAltmin, j.jeuDated, j.jeuDatef, j.jeuLatmax, j.jeuLatmin, " +
+				"j.jeuLonmax, j.jeuLonmin from Jeu j where jeu_nom = '"+jeu.getJeuNom().replaceAll("'", "''")+"'");
+		
+		// si le jeu existe : on rÃ©cupÃ©re l'ID
+		if (jeuExistant.size() != 0) {
+			Object[] resultats = (Object[])jeuExistant.get(0);
+			jeu.setJeuId(((Integer)resultats[0]).intValue());
+			jeu.setJeuAltmax((Integer)resultats[1]);
+			jeu.setJeuAltmin((Integer)resultats[2]);
+			jeu.setJeuDated((Date)resultats[3]);
+			jeu.setJeuDatef((Date)resultats[4]);
+			jeu.setJeuLatmax((Integer)resultats[5]);
+			jeu.setJeuLatmin((Integer)resultats[6]);
+			jeu.setJeuLonmax((Integer)resultats[7]);
+			jeu.setJeuLonmin((Integer)resultats[8]);
+		}
+		CommunicationBD.save(jeu);
+		int jeuId = jeu.getJeuId();
+		CommunicationBD.close();
+		return jeuId;
+	}
+	
+	/**
+	* Insertion de la categorie (parametre)
+	*/
+	public int insererCategorieParam(CategorieParam categorieParam)throws Exception {
+		List<?> categorieParamExistant = CommunicationBD.getList("select c.categorieParamId from CategorieParam c where categorie_param_nom = '"
+				+categorieParam.getCategorieParamNom().replaceAll("'", "''")+"'");
+		// La categorie du parametre existe : on rÃ©cupÃ©re l'ID
+		if (categorieParamExistant.size() != 0) {
+			categorieParam.setCategorieParamId(((Integer)categorieParamExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(categorieParam);
+		int catId = categorieParam.getCategorieParamId();
+		return catId;
+	}
+
+	/**
+	* Insertion de l'unite (parametre) 
+	*/
+	public int insererUniteParametre(Unite unite) throws Exception {
+		List<?> uniteExistant = CommunicationBD.getList("select u.uniteId from Unite u where unite_code = '"+unite.getUniteCode().replaceAll("'", "''")+"'");
+		// si l'unite existe : on rÃ©cupÃ©re l'ID
+		if (uniteExistant.size() != 0) {
+			unite.setUniteId(((Integer)uniteExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(unite);
+		int uniteId = unite.getUniteId();
+		return uniteId;
+	}
+	
+	/**
+	* Insertion du parametre 
+	*/
+	public int insererParametre(Parametre parametre) throws Exception {
+		CommunicationBD.open();
+		// le commentaire n'est pas null : on l'insere
+		if (parametre.getCommentaire() != null) {
+			insererCommentaire(parametre.getCommentaire());
+		}
+		insererCategorieParam(parametre.getCategorieParam());
+		insererUniteParametre(parametre.getUnite());
+		List<?> parametreExistant = CommunicationBD.getList("select p.parametreId from Parametre p " +
+		"where parametre_code = '"+parametre.getParametreCode().replaceAll("'", "''")+"'");
+		// Le parametre existe : on rÃ©cupÃ©re l'ID et les jeux associÃ©s
+		if (parametreExistant.size() != 0) {
+			parametre.setParametreId(((Integer)parametreExistant.get(0)).intValue());
+			List<?> jeusParam = CommunicationBD.getList("select p.jeus from Parametre p where p.parametreId = "+parametre.getParametreId());
+			for (int numJeu=0; numJeu < jeusParam.size(); numJeu++)			 {
+				parametre.getJeus().add((Jeu)jeusParam.get(numJeu));
+			}
+		}
+		CommunicationBD.save(parametre);
+		int parametreId = parametre.getParametreId();
+		CommunicationBD.close();
+		return parametreId;
+	}
+	
+	/**
+	* Insertion du fabriquant du capteur 
+	*/
+	public int insererFabriquant(Fabriquant fabriquant) throws Exception {
+		List<?> fabriquantExistant = CommunicationBD.getList("select f.fabriquantId from Fabriquant f " +
+				"where fabriquant_nom = '"+fabriquant.getFabriquantNom().replaceAll("'", "''")+"'");
+		// Le fabriquant existe : on rÃ©cupÃ©re l'ID
+		if (fabriquantExistant.size() != 0) {
+			fabriquant.setFabriquantId(((Integer)fabriquantExistant.get(0)).intValue());
+		}
+		CommunicationBD.save(fabriquant);
+		int fabriquantId = fabriquant.getFabriquantId();
+		return fabriquantId;
+	}
+		
+	/**
+	* Insertion du type de capteur 
+	*/
+	public int insererTypeCapteur(TypeCapteur typeCapteur) throws Exception {
+		// si le commentaire n est pas null : on insere le commentaire du type du capteur 
+		if (typeCapteur.getCommentaire() != null) {
+			insererCommentaire(typeCapteur.getCommentaire());
+		}
+		List<?> typeCapteurExistant = CommunicationBD.getList("select t.typeCapteurId from TypeCapteur t " +
+				"where type_capteur_nom = '"+typeCapteur.getTypeCapteurNom().replaceAll("'", "''")+"'");
+		// Le typeCapteur existe : on rÃ©cupÃ©re l'ID
+		if (typeCapteurExistant.size() != 0) {
+			typeCapteur.setTypeCapteurId( ( (Integer) typeCapteurExistant.get( 0 ) ).intValue() );
+		}
+		CommunicationBD.save(typeCapteur);
+		int typeCapteurId = typeCapteur.getTypeCapteurId();
+		return typeCapteurId;
+	}
+	
+	/**
+	 * Insertion du capteur 
+	 */
+	public int insererCapteur(Capteur capteur, ArrayList<Parametre> parametres) throws Exception {
+		CommunicationBD.open();
+		// On parcourt la liste des paramÃ©tres du capteur
+		for (Parametre paramCapt : capteur.getParametres()) {
+			// On parcourt la liste des paramÃ©tres du jeu
+			for (Parametre parametre : parametres) {
+				// On complÃ©te les identifiants des paramÃ©tres
+				if (parametre.getParametreCode().equals(paramCapt.getParametreCode())) {
+					paramCapt.setParametreId(parametre.getParametreId());
+					break;
+				}
+			}
+		}
+		// insertion du fabriquant du capteur
+		insererFabriquant(capteur.getFabriquant());
+		// insertion du type du capteur
+		insererTypeCapteur(capteur.getTypeCapteur());
+		// insertion du commentaire s'il existe
+		if (capteur.getCommentaire() != null) {
+			insererCommentaire(capteur.getCommentaire());
+		}
+		// On vÃ©rifie si le capteur existe dÃ©jÃ©
+		List<?> capteursExistants = CommunicationBD.getList("select c.capteurId from Capteur c "
+						+ "where capteur_modele = '" + capteur.getCapteurModele().replaceAll("'", "''")+"' "
+						+ "and capteur_numserie = '" + capteur.getCapteurNumserie().replaceAll("'", "''") + "' "
+						+ "and c.fabriquant.fabriquantNom = '"+capteur.getFabriquant().getFabriquantNom().replaceAll("'", "''")+"' "
+						+ "and c.typeCapteur.typeCapteurNom = '"+capteur.getTypeCapteur().getTypeCapteurNom().replaceAll("'", "''")+"'");
+		// si Le capteur existe : on rÃ©cupÃ©re l'ID et les jeux/paramÃ©tres associÃ©s
+		if (capteursExistants.size() != 0) {
+			capteur.setCapteurId(((Integer)capteursExistants.get(0)).intValue());
+			List<?> jeusCapt = CommunicationBD.getList("select c.jeus from Capteur c where c.capteurId = "+capteur.getCapteurId());
+			for (int numJeu=0; numJeu < jeusCapt.size(); numJeu++) {
+				capteur.getJeus().add((Jeu)jeusCapt.get(numJeu));
+			}
+			List<?> paramsCapt = CommunicationBD.getList("select c.parametres from Capteur c where c.capteurId = "+capteur.getCapteurId());
+			Parametre paramCapt;
+			boolean paramPresent;
+			for (int numParam=0; numParam < paramsCapt.size(); numParam++) {
+				paramCapt = (Parametre)paramsCapt.get(numParam);
+				paramPresent = false;
+				for (Parametre paramCapt2 : capteur.getParametres()) {
+					if (paramCapt2.getParametreCode().equals(paramCapt.getParametreCode())){
+						paramPresent = true;
+						break;
+					}
+				}
+				if (!paramPresent) capteur.getParametres().add(paramCapt);
+			}
+		}
+		CommunicationBD.save(capteur);
+		int capteurId = capteur.getCapteurId();
+		CommunicationBD.close();
+		return capteurId;
+	}
+
+	/**
+	* Insertion du type de plateforme 
+	*/
+	public int insererTypePlateforme(TypePlateforme typePlateforme) throws Exception {
+		if (typePlateforme.getTypePlateformeNom().equals( Constantes.typePlatFix))
+			typePlateforme.setTypePlateformeId(Constantes.typePlatFixID);
+		else
+			typePlateforme.setTypePlateformeId(Constantes.typePlatMobID);
+		return typePlateforme.getTypePlateformeId();
+	}
+	
+	/**
+	* Insertion de la plateforme 
+	 * @param parametres 
+	 * @param capteurs 
+	*/
+	public int insererPlateforme(Plateforme plateforme, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) throws Exception {
+		CommunicationBD.open();
+		// On parcourt la liste des capteurs de la plateforme
+		for (Capteur captPlat : plateforme.getCapteurs()) {
+			// On parcourt la liste des capteurs du jeu
+			for (Capteur capteur : capteurs) {
+				// On complÃ©te les identifiants des capteurs
+				if (capteur.getCapteurModele().equals(captPlat.getCapteurModele())
+						&& capteur.getCapteurNumserie().equals(captPlat.getCapteurNumserie())
+						&& capteur.getTypeCapteur().getTypeCapteurNom().equals(captPlat.getTypeCapteur().getTypeCapteurNom())
+						&& capteur.getFabriquant().getFabriquantNom().equals(captPlat.getFabriquant().getFabriquantNom())) {
+					captPlat.setCapteurId(capteur.getCapteurId());
+					break;
+				}
+			}
+		}
+		// On parcourt la liste des paramÃ©tres de la plateforme
+		for (Parametre paramPlat : plateforme.getParametres()) {
+			// On parcourt la liste des paramÃ©tres du jeu
+			for (Parametre parametre : parametres) {
+				// On complÃ©te les identifiants des paramÃ©tres
+				if (parametre.getParametreCode().equals(paramPlat.getParametreCode())) {
+					paramPlat.setParametreId(parametre.getParametreId());
+					break;
+				}
+			}
+		}
+		// On associe le jeu Ã© la plateforme
+//		for (Jeu jeuPlat : plateforme.getJeus()) {
+//			if (jeuPlat.getJeuNom().equals(jeu.getJeuNom())) {
+//				jeuPlat.setJeuId(jeu.getJeuId());
+//				break;
+//			}
+//		}
+		insererTypePlateforme(plateforme.getTypePlateforme());
+		// insertion du commentaire s'il esxiste
+		if (plateforme.getCommentaire() != null) {
+			insererCommentaire(plateforme.getCommentaire());
+		}
+		// On vÃ©rifie si la plateforme existe dÃ©jÃ©
+//		Plateforme plateformeExistant = (Plateforme) CommunicationBD.getObjectByColonne(Plateforme.class, "plateformeNom",
+//				plateforme.getPlateformeNom().replaceAll("'", "''"));
+		List<?> plateformeExistant = CommunicationBD.getList("select p.plateformeId from Plateforme p "
+						+ "where plateforme_nom = '" + plateforme.getPlateformeNom().replaceAll("'", "''")+"'");
+		// si la plateforme existe : on rÃ©cupÃ©re l'ID et les jeux associÃ©s
+		if (plateformeExistant.size() != 0) {
+			plateforme.setPlateformeId(((Integer)plateformeExistant.get(0)).intValue());
+			List<?> captsPlat = CommunicationBD.getList("select p.capteurs from Plateforme p where p.plateformeId = "+plateforme.getPlateformeId());
+			Capteur capteur;
+			boolean isPresent;
+			for (int numCapt=0; numCapt < captsPlat.size(); numCapt++) {
+				capteur = (Capteur)captsPlat.get(numCapt);
+				isPresent = false;
+				for (Capteur capt: plateforme.getCapteurs()) {
+					if (capteur.getCapteurModele().equals(capt.getCapteurModele())
+							&& capteur.getCapteurNumserie().equals(capt.getCapteurNumserie())
+							&& capteur.getTypeCapteur().getTypeCapteurNom().equals(capt.getTypeCapteur().getTypeCapteurNom())
+							&& capteur.getFabriquant().getFabriquantNom().equals(capt.getFabriquant().getFabriquantNom())) {
+						isPresent = true;
+					}
+				}
+				if (!isPresent) {
+					Capteur c = new Capteur(capteur.getCapteurId(), 
+							new Fabriquant(capteur.getFabriquant().getFabriquantId(), capteur.getFabriquant().getFabriquantNom()), 
+							new TypeCapteur(capteur.getTypeCapteur().getTypeCapteurId(), capteur.getTypeCapteur().getTypeCapteurNom()), 
+							null, capteur.getCapteurModele(), capteur.getCapteurNumserie(), capteur.getCapteurEtalonnage(), null, null, null, null, null);
+					plateforme.getCapteurs().add(c);
+				}
+			}
+			List<?> paramsPlat = CommunicationBD.getList("select p.parametres from Plateforme p where p.plateformeId = "+plateforme.getPlateformeId());
+			Parametre parametre;
+			for (int numParam=0; numParam < paramsPlat.size(); numParam++) {
+				parametre = (Parametre)paramsPlat.get(numParam);
+				isPresent = false;
+				for (Parametre param: plateforme.getParametres()) {
+					if (parametre.getParametreCode().equals(param.getParametreCode())) {
+						isPresent = true;
+					}
+				}
+				if (!isPresent) {
+					Parametre p = new Parametre(parametre.getParametreId(), null, null, null, parametre.getParametreNom(), parametre.getParametreCode(),
+							null, null, null, null, null);
+					plateforme.getParametres().add(p);
+				}
+			}
+			List<?> jeusPlat = CommunicationBD.getList("select p.jeus from Plateforme p where p.plateformeId = "+plateforme.getPlateformeId());
+			for (int numJeu=0; numJeu < jeusPlat.size(); numJeu++) {
+				plateforme.getJeus().add((Jeu)jeusPlat.get(numJeu));
+			}
+		}
+		CommunicationBD.save(plateforme);
+		int plateformeId = plateforme.getPlateformeId();
+		// On insÃ©re les positions de la plateforme
+		for (RequetePlatLoc requetePlatLoc : plateforme.getRequetePlatLocs()) {
+			requetePlatLoc.setPlateforme(plateforme);
+			requetePlatLoc.setPlateformeId(plateformeId);
+			CommunicationBD.save(requetePlatLoc);
+		}
+		CommunicationBD.close();
+		return plateformeId;
+	}
+	
+	/**
+	* Insertion du fichier 
+	*/
+	public int insererFichier(Fichier fichier) throws Exception {
+		List<?> fichiersExistants = CommunicationBD.getList("select f.fichierId from Fichier f " +
+				"where jeu_id = "+fichier.getJeu().getJeuId()+" and fichier_nom = '"+fichier.getFichierNom().replaceAll("'", "''")+"'");
+		// si Le fichier n'existe pas : on l'insÃ©re
+		if (fichiersExistants.size() == 0) {
+			fichierExiste = false;
+		}
+		// sinon Le fichier existe : on rÃ©cupÃ©re l'ID
+		else {
+			fichierExiste = true;
+			fichier.setFichierId( ( (Integer) fichiersExistants.get( 0 ) ).intValue() );
+		}
+		CommunicationBD.save(fichier);
+		int fichierId = fichier.getFichierId();
+		return fichierId;
+	}
+	
+	/**
+	* Insertion de la localisation 
+	*/
+	public int insererLoc(Localisation localisation, ArrayList<Localisation> listeLocs, String typePlat) throws Exception {//, int flagId
+		int id = findLoc( listeLocs, localisation );
+		if (id == -1) {
+			if (typePlat.equals(Constantes.typePlatFix)) {
+				List<?> localisationsExistants = CommunicationBD.getList("select l.localisationId from Localisation l" +
+						" where localisation_lat  = "+localisation.getLocalisationLat()+
+						" and localisation_lon = "+localisation.getLocalisationLon()+ 
+						" and localisation_alt = "+localisation.getLocalisationAlt());
+				// si La localisation n'existe pas : on l'insÃ©re
+				if (localisationsExistants.size() == 0) {
+				// si le flag de longitude n est pas null : on l'insere
+				}
+				// sinon La localisation existe : on rÃ©cupÃ©re l'ID
+				else {
+					localisation.setLocalisationId(((Integer)localisationsExistants.get(0)).intValue());
+				}
+			}
+			CommunicationBD.save(localisation);
+			listeLocs.add(new Localisation(localisation.getLocalisationId(), localisation.getLocalisationLat(), localisation.getLocalisationLon(), localisation.getLocalisationAlt()));
+		} else {
+			localisation.setLocalisationId(id);
+		}
+		int localisationId = localisation.getLocalisationId();
+		return localisationId;
+	}
+	
+	/**
+	 * VÃ©rifie si la localisation donnÃ©e figure dans la liste de localisations
+	 * Si oui, retourne l'ID de la localisation trouvÃ©e dans la liste
+	 * Si non, retourne -1
+	 */
+	public int findLoc(ArrayList<Localisation> listeLocs, Localisation loc) {
+		for (Localisation l : listeLocs) {
+			if (l.getLocalisationLat() == loc.getLocalisationLat() 
+					&& l.getLocalisationLon() == loc.getLocalisationLon()
+					&& l.getLocalisationAlt() == loc.getLocalisationAlt())
+				return l.getLocalisationId();
+		}
+		return -1;
+	}
+	
+	/**
+	* Insertion du delta 
+	*/
+	public int insererDelta(DeltaMesure deltaMesure) throws Exception {
+		List<?> deltasExistants = CommunicationBD.getList("select d.deltaId from Delta d " +
+				"where delta_mesure_date = "+deltaMesure.getDeltaMesureDate()+" " +
+				"and delta_mesure_lat = "+deltaMesure.getDeltaMesureLat()+" " +
+				"and  delta_mesure_lon = "+deltaMesure.getDeltaMesureLon()+" " + 
+				"and delta_mesure_alt = "+deltaMesure.getDeltaMesureLon());
+		// si le delta existe : on rÃ©cupÃ©re l'ID
+		if (deltasExistants.size() != 0) {
+			deltaMesure.setDeltaMesureId( ( (Integer) deltasExistants.get( 0 ) ).intValue() );
+		}
+		CommunicationBD.save( deltaMesure );
+		int deltaId = deltaMesure.getDeltaMesureId();
+		return deltaId;
+	}
+	
+	/**
+	* Insertion de la sequence 
+	*/
+	public int insererSequence(Sequence sequence) throws Exception {
+		List<?> sequencesExistants = CommunicationBD
+				.getList( "select s.sequenceId from Sequence s "
+                        + "where jeu_id  = " + sequence.getJeu().getJeuId()
+                        + " and sequence_dated = '" + DateTime.dateToString( sequence.getSequenceDated(), Constantes.formatDateJJMMAAAAHHMMSS )
+                        + "' and sequence_datef = '" + DateTime.dateToString( sequence.getSequenceDatef(), Constantes.formatDateJJMMAAAAHHMMSS ) + "'" );
+		int sequenceId ;
+	
+		// La sequence n'existe pas : on l'insÃ©re
+		if (sequencesExistants.size() == 0) {
+			 // inserer le commentaire s'il existe
+			if (sequence.getCommentaire() != null) {
+				insererCommentaire(sequence.getCommentaire());
+			}
+			CommunicationBD.save(sequence);
+			sequenceId = sequence.getSequenceId();
+		}
+		// La sequence existe : on rÃ©cupÃ©re l'ID
+		else {
+			sequenceId = ((Integer) sequencesExistants.get(0)).intValue();
+			sequence.setSequenceId(sequenceId);
+			/**test sur lr commentaire de la sequence*/
+			if (sequence.getCommentaire() != null) {
+				sequence.getCommentaire().setCommentaireId(sequence.getCommentaire().getCommentaireId());
+			}
+			sequence.getJeu().setJeuAltmax(Statiques.altMaxJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.altMinJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.latMaxJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.latMinJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.lonMaxJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.lonMinJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.hsMaxJeu);
+			sequence.getJeu().setJeuAltmax(Statiques.hsMinJeu);
+			sequence.getJeu().setJeuDated(Statiques.dateMaxJeu);
+			sequence.getJeu().setJeuDatef(Statiques.dateMinJeu);
+		}
+		return sequenceId;
+	}
+	
+	 /**
+	 * Insertion de la table  bilan 
+	 */
+	public void insererBilan(Jeu jeu, ArrayList<Plateforme> plateformes, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) throws Exception {
+		Bilan bilan;
+		List<?> bilansExistants;
+		// On parcourt les plateformes du jeu
+		for (Plateforme plateforme: plateformes) {
+			// On parcourt les capteurs du jeu
+			for (Capteur capteur: capteurs) {
+				// On parcourt les capteurs liÃ©s Ã© la plateforme
+				for (Capteur capteurPlat: plateforme.getCapteurs()) {
+					if (capteurPlat.getCapteurModele().equals(capteur.getCapteurModele())
+							&& capteurPlat.getCapteurNumserie().equals(capteur.getCapteurNumserie())
+							&& capteurPlat.getFabriquant().getFabriquantNom().equals(capteur.getFabriquant().getFabriquantNom())
+							&& capteurPlat.getTypeCapteur().getTypeCapteurNom().equals(capteur.getTypeCapteur().getTypeCapteurNom())) {
+						// S'il y a correspondance sur un capteur...
+						// On parcourt les paramÃ©tres du jeu
+						for (Parametre parametre: parametres) {
+							// On parcourt les paramÃ©tres liÃ©s au capteur
+							for (Parametre parametreCapt: capteur.getParametres()) {
+								if (parametreCapt.getParametreCode().equals(parametre.getParametreCode())) {
+									// S'il y a correspondance sur un paramÃ©tre...
+									// On vÃ©rifie que le bilan n'existe pas dÃ©jÃ© dans la base
+									bilansExistants = CommunicationBD.getList("from Bilan b where" 
+											+ " plateforme_id = " + plateforme.getPlateformeId()
+											+ " and capteur_id = " + capteur.getCapteurId()
+											+ " and jeu_id = " + jeu.getJeuId()
+											+ " and parametre_id = " + parametre.getParametreId());
+									// si Le bilan n'existe pas : on l'insÃ©re
+									if (bilansExistants.size() == 0) {
+										bilan = new Bilan();
+										bilan.setPlateforme(plateforme);
+										bilan.setCapteur(capteur);
+										bilan.setJeu(jeu);
+										bilan.setParametre(parametre);
+										CommunicationBD.save(bilan);
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+		
+	/**
+	 * Mise Ã© jour des mesures
+	 */
+	public void mettreAjourMesure(Sequence sequence) throws Exception {
+		// faire un select sur la base de donnee afin de rÃ©cuperer les mesures
+		List<?> mesures = CommunicationBD.getList("from Mesure m "
+				+ "where fichier_id in " 
+				+ "(select f.fichierId from Fichier f where jeu_id = "+sequence.getJeu().getJeuId()+") "
+				+ "and mesure_date >= '" + DateTime.dateToString(sequence.getSequenceDated(),Constantes.formatDateJJMMAAAAHHMMSS)+"' " 
+				+ "and mesure_date <= '" + DateTime.dateToString(sequence.getSequenceDatef(),Constantes.formatDateJJMMAAAAHHMMSS)+"'");
+		
+		Mesure mesure = null;
+		int nbMesures = mesures.size();
+		for(int numMesure = 0; numMesure < nbMesures ; numMesure++){
+			mesure = (Mesure) mesures.get(numMesure);
+			mesure.setSequence(sequence);
+			CommunicationBD.save(mesure);		
+		}
+	}		
+	
+	/**
+	 * Mise Ã© jour du jeu
+	 */	
+	public void mettreAjourJeu(Jeu jeu) throws Exception {
+		if(jeu.getJeuDated() == null || DateTime.plusGrand(jeu.getJeuDated(),Statiques.dateMinJeu)){
+			jeu.setJeuDated(Statiques.dateMinJeu);
+		}
+		if(jeu.getJeuDatef() == null || DateTime.plusGrand( Statiques.dateMaxJeu,jeu.getJeuDatef())){
+			jeu.setJeuDatef(Statiques.dateMaxJeu);	
+		}
+		if(jeu.getJeuLatmax() == null || Statiques.latMaxJeu > jeu.getJeuLatmax()){
+			jeu.setJeuLatmax(Statiques.latMaxJeu);
+		}
+		if(jeu.getJeuLatmin() == null || Statiques.latMinJeu < jeu.getJeuLatmin()){
+			jeu.setJeuLatmin(Statiques.latMinJeu);
+		}
+		if(jeu.getJeuLonmax() == null || Statiques.lonMaxJeu > jeu.getJeuLonmax()){
+			jeu.setJeuLonmax(Statiques.lonMaxJeu);
+		}
+		if(jeu.getJeuLonmin() == null || Statiques.lonMinJeu < jeu.getJeuLonmin()){
+			jeu.setJeuLonmin(Statiques.lonMinJeu);
+		}
+		if(jeu.getJeuAltmax() == null || Statiques.altMaxJeu > jeu.getJeuAltmax()){
+			jeu.setJeuAltmax(Statiques.altMaxJeu);
+		}
+		if(jeu.getJeuAltmin() == null || Statiques.altMinJeu < jeu.getJeuAltmin()){
+			jeu.setJeuAltmin(Statiques.altMinJeu);
+		}
+		if(Statiques.hsMaxJeu.intValue() != Nombre.altDoubleToInt(Double.valueOf(Constantes.hsMoinsInf)).intValue()
+				&& (jeu.getJeuHsmax() == null || Statiques.hsMaxJeu > jeu.getJeuHsmax())){
+			jeu.setJeuHsmax(Statiques.hsMaxJeu);
+		}
+		if(Statiques.hsMinJeu.intValue() != Nombre.altDoubleToInt( new Double( Constantes.hsPlusInf ) ).intValue()
+				&& (jeu.getJeuHsmin() == null || Statiques.hsMinJeu < jeu.getJeuHsmin())){
+			jeu.setJeuHsmin(Statiques.hsMinJeu);
+		}
+		CommunicationBD.save(jeu);
+	}
+	
+	/**
+	 * Mise Ã© jour des liaisons entre les capteurs et les jeux
+	 */
+	public void mettreAJourRequeteCaptJeu(Jeu jeu, ArrayList<Capteur> capteurs) throws Exception {
+		jeu.setCapteurs(new HashSet<Capteur>());
+		for (Capteur capteur: capteurs) {
+			jeu.getCapteurs().add(capteur);
+		}
+		CommunicationBD.save(jeu);
+	}
+	
+	/**
+	 * Mise Ã© jour la liason entre les Parametres et les jeux
+	 */
+	public void mettreAJourRequeteParamJeu(Jeu jeu, ArrayList<Parametre> parametres) throws Exception {
+		jeu.setParametres(new HashSet<Parametre>());
+		for (Parametre parametre: parametres) {
+			jeu.getParametres().add(parametre);
+		}
+		CommunicationBD.save(jeu);
+	}
+	
+	/**
+	 * Mise Ã© jour la liason entre les plateformes et le jeu
+	 */
+	public void mettreAJourRequetePlatJeu(Jeu jeu, ArrayList<Plateforme> plateformes) throws Exception {
+		jeu.setPlateformes(new HashSet<Plateforme>());
+		for (Plateforme plateforme: plateformes) {
+			jeu.getPlateformes().add(plateforme);
+		}
+		CommunicationBD.save(jeu);
+	}
+	
+	/**
+	 * Mise Ã© jour de la liason entre le nbre de valeurs et jeu
+	 */
+	public void mettreAJourRequeteNbValsJeu(Jeu jeu, int nbFichiers, int nbMesures, int nbValeurs) throws Exception {
+		List<?> reqNbValsJeuExistants = CommunicationBD.getList("from RequeteNbvalsJeu r where jeu_id = "+jeu.getJeuId());
+		RequeteNbvalsJeu requeteNbvalsJeu;
+		// si l'objet n'existe pas : on l'insÃ©re
+		if (reqNbValsJeuExistants.size() == 0) {	
+			requeteNbvalsJeu = new RequeteNbvalsJeu();
+			requeteNbvalsJeu.setJeu(jeu);
+			requeteNbvalsJeu.setJeuId(jeu.getJeuId());
+			requeteNbvalsJeu.setNbFichiers(nbFichiers);
+			requeteNbvalsJeu.setNbMesures(nbMesures);
+			requeteNbvalsJeu.setNbValeurs(nbValeurs);
+		}
+		// Sinon on le met Ã© jour
+		else {
+			requeteNbvalsJeu = (RequeteNbvalsJeu) reqNbValsJeuExistants.get(0);
+			if (nbFichiers!=0) {
+				requeteNbvalsJeu.setNbFichiers(nbFichiers);
+				if (nbMesures!=0) {
+					requeteNbvalsJeu.setNbMesures(nbMesures);
+					if (nbValeurs!=0) requeteNbvalsJeu.setNbValeurs(nbValeurs);
+				}
+			}
+		}
+		CommunicationBD.save(requeteNbvalsJeu);
+	}
+	
+	/**
+	 * Mise Ã© jour de la liaison entre les parametres et les capteurs
+	 */
+	public void mettreAJourRequeteParamCapt(ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) throws Exception {
+		// On parcourt la liste des capteurs du jeu
+		for (Capteur capteur: capteurs) {
+			// On parcourt la liste des paramÃ©tres du capteur
+			for (Parametre paramCapt : capteur.getParametres()) {
+				// On parcourt la liste des paramÃ©tres du jeu
+				for (Parametre parametre : parametres) {
+					// On complÃ©te les identifiants des paramÃ©tres
+					if (parametre.getParametreCode().equals(paramCapt.getParametreCode())) {
+						paramCapt.setParametreId(parametre.getParametreId());
+						break;
+					}
+				}
+			}
+			CommunicationBD.save(capteur);
+		}
+		// on vÃ©rifie s'il y a un seul capteur
+	}
+
+	/**
+	 * Mise Ã© jour de la liaison entre les plateformes et les capteurs/paramÃ©tres
+	 */
+	public void mettreAJourRequeteCaptPlatParam(ArrayList<Plateforme> plateformes, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) throws Exception {
+		// On parcourt les plateformes du jeu
+		for (Plateforme plateforme: plateformes) {
+			// On parcourt la liste des capteurs de la plateforme
+			for (Capteur captPlat : plateforme.getCapteurs()) {
+				// On parcourt la liste des capteurs du jeu
+				for (Capteur capteur : capteurs) {
+					// On complÃ©te les identifiants des capteurs
+					if (capteur.getCapteurModele().equals(captPlat.getCapteurModele())
+							&& capteur.getCapteurNumserie().equals(captPlat.getCapteurNumserie())
+							&& capteur.getTypeCapteur().getTypeCapteurNom().equals(captPlat.getTypeCapteur().getTypeCapteurNom())
+							&& capteur.getFabriquant().getFabriquantNom().equals(captPlat.getFabriquant().getFabriquantNom())) {
+						captPlat.setCapteurId(capteur.getCapteurId());
+						break;
+					}
+				}
+			}
+			// On parcourt la liste des paramÃ©tres de la plateforme
+			for (Parametre paramPlat : plateforme.getParametres()) {
+				// On parcourt la liste des paramÃ©tres du jeu
+				for (Parametre parametre : parametres) {
+					// On complÃ©te les identifiants des paramÃ©tres
+					if (parametre.getParametreCode().equals(paramPlat.getParametreCode())) {
+						paramPlat.setParametreId(parametre.getParametreId());
+						break;
+					}
+				}
+			}
+			CommunicationBD.save(plateforme);
+		}
+		// on vÃ©rifie s'il y a une seule plateforme ou plusieurs
+	}
+	
+	/**
+	 * Mise Ã© jour de la liaison entre le bilan
+	 */
+	public void mettreAJourBilan(Jeu jeu) throws Exception {
+		List<?> bilanExistants = CommunicationBD.getList("from Bilan b where jeu_id = " + jeu.getJeuId());
+		Bilan bilan;
+		List<?> valsExistants;
+		Object[] resultats;
+		List<?> datesExistants;
+		List<?> locsExistants;
+		// Pour chaque bilan du jeu...
+		for (int numBilan = 0; numBilan < bilanExistants.size(); numBilan++) {
+			bilan = (Bilan) bilanExistants.get(numBilan);
+			// Mise Ã© jour des valeurs min, max et du nombre de valeurs
+			valsExistants = CommunicationBD.getList("select min(v.valeurVal) as valMin, max(v.valeurVal) as valMax,"
+							+ " count(v.valeurId) as nbVals from Valeur v"
+							+ " where capteur_id = " + bilan.getCapteur().getCapteurId()
+							+ " and parametre_id = " + bilan.getParametre().getParametreId()
+							+ " and v.mesure.plateforme.plateformeId = " + bilan.getPlateforme().getPlateformeId()
+							+ " and v.mesure.fichier.jeu.jeuId = " + jeu.getJeuId());
+			if (valsExistants.size() != 0) {
+				resultats = (Object[]) valsExistants.get(0);
+				bilan.setBilanValmin((Double) resultats[0]);
+				bilan.setBilanValmax((Double) resultats[1]);
+				bilan.setBilanNbval(new Integer(((Long) resultats[2]).intValue()));
+				// Mise Ã© jour des dates dÃ©but et fin
+				datesExistants = CommunicationBD.getList("select min(m.mesureDate) as dateMin, max(m.mesureDate) as dateMax"
+						 + " from Mesure m where plateforme_id = " + bilan.getPlateforme().getPlateformeId()
+						 + " and m.fichier.jeu.jeuId = " + jeu.getJeuId()
+						 + " and mesure_id in (select v.mesure.mesureId from Valeur v" 
+						 + " where capteur_id = " + bilan.getCapteur().getCapteurId()
+						 + " and parametre_id = " + bilan.getParametre().getParametreId()+")");
+				if (datesExistants.size() != 0) {
+					resultats = (Object[])datesExistants.get(0);
+					bilan.setBilanDated((Date) resultats[0]);
+					bilan.setBilanDatef((Date) resultats[1]);
+					// Mise Ã© jour des localisations
+					locsExistants = CommunicationBD.getList( "select min(l.localisationLat) as latMin,"
+                            + " max(l.localisationLat) as latMax, min(l.localisationLon) as lonMin,"
+                            + " max(l.localisationLon) as lonMax, min(l.localisationAlt) as altMin,"
+                            + " max(l.localisationAlt) as altMax, min(l.localisationHs) as hsMin,"
+                            + " max(l.localisationHs) as hsMax from Localisation l where localisation_id" +
+                            " in (SELECT m.localisation.localisationId FROM Mesure m"
+                            + " where plateforme_id = " + bilan.getPlateforme().getPlateformeId()
+                            + " and m.fichier.jeu.jeuId = " + jeu.getJeuId()
+                            + " and mesure_id IN (SELECT v.mesure.mesureId FROM Valeur v"
+                            + " WHERE capteur_id = " + bilan.getCapteur().getCapteurId()
+                            + " and parametre_id = " + bilan.getParametre().getParametreId() + "))" );
+					if (locsExistants.size() != 0) {
+						resultats = (Object[])locsExistants.get(0);
+						bilan.setBilanLatmin((Integer) resultats[0]);
+						bilan.setBilanLatmax((Integer) resultats[1]);
+						bilan.setBilanLonmin((Integer) resultats[2]);
+						bilan.setBilanLonmax((Integer) resultats[3]);
+						bilan.setBilanAltmin((Integer) resultats[4]);
+						bilan.setBilanAltmax((Integer) resultats[5]);
+						if(resultats[6] != null){
+							bilan.setBilanHsmin((Integer) resultats[6]);
+						}
+						if(resultats[7] != null){
+							bilan.setBilanHsmax((Integer) resultats[7]);
+						}
+						/**********traitement de la frÃ©quence*****************/
+					}
+				}
+				// on sauvegarde le bilan
+				CommunicationBD.save(bilan);
+			}
+		} 	
+	}
+	
+	public boolean isFichierExiste() {
+		return fichierExiste;
+	}
+
+	public void setFichierExiste(boolean fichierExiste) {
+		this.fichierExiste = fichierExiste;
+	}
+
+	public int getFlagLocId() {
+		return flagLocId;
+	}
+
+	public void setFlagLocId(int flagLocId) {
+		this.flagLocId = flagLocId;
+	}
+
+	public int getFlagValidId() {
+		return flagValidId;
+	}
+
+	public void setFlagValidId(int flagValidId) {
+		this.flagValidId = flagValidId;
+	}
+	 
+	/**               
+	 * Insertion de la valeur
+	 */
+	private int flagValidId = 0;
+	private int flagLocId = 0;
+	private boolean fichierExiste = false;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureCapteurs.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureCapteurs.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureCapteurs.java	(revision 488)
@@ -0,0 +1,163 @@
+/*
+ * Created on 29 Jan. 2007
+ */
+/**
+ * @author 
+ * 
+ * 
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LectureCapteurs {
+	public LectureCapteurs() {
+	}
+
+	public void lireFichier() {
+		String nomFichierCapt = Constantes.cheminListes + "/" + Constantes.nomListeCapteurs;
+		File fichier = new File(nomFichierCapt);
+		if (fichier.exists()) {
+			// Etape ou l' on crÃ©e le Workbook
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			// Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			// Etape d'initialisation des listes.
+			numerosCapt = new ArrayList<String>();
+			typesCapt = new ArrayList<String>();
+			fabriquantsCapt = new ArrayList<String>();
+			modelesCapt = new ArrayList<String>();
+			numsSeriesCapt = new ArrayList<String>();
+			etalonnagesCapt = new ArrayList<String>();
+			nomsCaptFromFile = new ArrayList<String>();
+//			descriptionsCapt = new ArrayList<String>();
+//			descriptionsTypeCapt = new ArrayList<String>();
+			numsParametresCapt = new ArrayList<ArrayList<String>>();
+
+			int nbCapteurs = sheet.getRows() - 1;//Constantes.nbCapteurs;
+		
+			String numsParametres, numParametre, paramDer;
+			int paramCourant;
+			ArrayList<String> numsParametresLigne;
+			// Etape de lecture des cellules
+			for (int numCapt = 0; numCapt < nbCapteurs; numCapt++) {
+				numerosCapt.add(sheet.getCell(0, numCapt + 1).getContents());
+				typesCapt.add(sheet.getCell(1, numCapt + 1).getContents());
+				fabriquantsCapt.add(sheet.getCell(2, numCapt + 1).getContents());
+				modelesCapt.add(sheet.getCell(3, numCapt + 1).getContents());
+				numsSeriesCapt.add(sheet.getCell(4, numCapt + 1).getContents());
+				etalonnagesCapt.add(sheet.getCell(5, numCapt + 1).getContents());
+				//descriptionsCapt.add(sheet.getCell(4, numCapt + 1).getContents());
+				//descriptionsTypeCapt.add(sheet.getCell(6, numCapt + 1).getContents());
+				numsParametres = sheet.getCell(6, numCapt + 1).getContents();
+				numsParametresLigne = new ArrayList<String>();
+				while (numsParametres.indexOf(Constantes.delimiteurXLS) != -1) {
+					// On rÃ©cupÃ©re la 1Ã©re donnÃ©e de la mesure avant le dÃ©limiteur
+					numParametre = numsParametres.substring(0, numsParametres.indexOf(Constantes.delimiteurXLS)).trim();
+					// On rÃ©cupÃ©re la mesure restante aprÃ©s le dÃ©limiteur
+					numsParametres = numsParametres.substring(numsParametres.indexOf(Constantes.delimiteurXLS)+1).trim();
+					if (numParametre.equals("..")) {
+						if (numsParametres.indexOf(Constantes.delimiteurXLS) != -1)
+							paramDer = numsParametres.substring(0, numsParametres.indexOf(Constantes.delimiteurXLS)).trim();
+						else
+							paramDer = numsParametres.trim();
+						paramCourant = Integer.parseInt(numsParametresLigne.get(numsParametresLigne.size()-1));
+						while (paramCourant < Integer.parseInt(paramDer)-1) {
+							paramCourant++;
+							numsParametresLigne.add(String.valueOf(paramCourant));
+						}
+					} else {
+						numsParametresLigne.add(numParametre);
+					}
+				}
+				numParametre = numsParametres;
+				numsParametresLigne.add(numParametre);
+				numsParametresCapt.add(numsParametresLigne);
+				nomsCaptFromFile.add(sheet.getCell(7, numCapt + 1).getContents());
+			}
+			// Etape de fermeture du flux
+			workbook.close();
+		}
+	}
+
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosCapt.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosCapt.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+
+	public ArrayList<String> getNumerosCapt() {
+		return numerosCapt;
+	}
+
+	public ArrayList<String> getDescriptionsCapt() {
+		return descriptionsCapt;
+	}
+
+	public ArrayList<String> getEtalonnagesCapt() {
+		return etalonnagesCapt;
+	}
+
+	public ArrayList<String> getFabriquantsCapt() {
+		return fabriquantsCapt;
+	}
+
+	public ArrayList<String> getModelesCapt() {
+		return modelesCapt;
+	}
+
+	public ArrayList<String> getNumsSeriesCapt() {
+		return numsSeriesCapt;
+	}
+	
+	public ArrayList<ArrayList<String>> getNumsParametresCapt() {
+		return numsParametresCapt;
+	}
+
+	public ArrayList<String> getTypesCapt() {
+		return typesCapt;
+	}
+
+	public ArrayList<String> getDescriptionsTypeCapt() {
+		return descriptionsTypeCapt;
+	}
+
+	public ArrayList<String> getNomsCaptFromFile() {
+		return nomsCaptFromFile;
+	}
+
+	private ArrayList<String> numerosCapt;
+	private ArrayList<String> typesCapt;
+	private ArrayList<String> fabriquantsCapt;
+	private ArrayList<String> modelesCapt;
+	private ArrayList<String> numsSeriesCapt;
+	private ArrayList<String> etalonnagesCapt;
+	private ArrayList<ArrayList<String>> numsParametresCapt;
+	private ArrayList<String> nomsCaptFromFile;
+	private ArrayList<String> descriptionsCapt;
+	private ArrayList<String> descriptionsTypeCapt;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureModeleXML.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureModeleXML.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureModeleXML.java	(revision 488)
@@ -0,0 +1,172 @@
+/**
+ * Created on 17 Jan. 2007
+ * * @author
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import com.medias.EcritureLog;
+import com.medias.integration.vues.ParametreModele;
+import integration.exceptions.XMLException;
+import org.jdom.Element;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+/**
+ * Lecture et dÃ©chiffrrage d'un modÃ©le XML dÃ©crivant la structure d'un fichier
+ * de donnÃ©es correspondant Ã© un jeu donnÃ©.
+ */
+public class LectureModeleXML {
+	public LectureModeleXML(String categorie, String jeu) {
+		this.categorie = categorie;
+		this.jeu = jeu;
+	}
+
+	public void lireModele() {
+		//	Chemin du modÃ©le xml Ã© manipuler
+		String modele = Constantes.cheminModeles + "/" + categorie + "/" + jeu + "_modele.xml";
+		//	Etape de Construction du "parser XML"
+		XMLParser builder = new XMLParser();
+		File f = new File(modele);
+		if (f.exists()) {
+			try {
+				builder.readXml(modele);
+				//	EcritureLog.ecrire("******* ModÃ©le du jeu de donnÃ©es : "+ f.getName() + " *******", "out");
+			} catch (XMLException e) {
+				e.printStackTrace();
+			}
+		} else {
+			EcritureLog.ecrire( "Fichier " + f.getName() + " non trouvÃ© !", "err" );
+		}
+		root = builder.getRoot();
+	}
+	
+	//	Partie des donnÃ©es Ã© manimpuler
+	/**
+	 * Renvoie les paramÃ©tres avec leurs caractÃ©ristiques dans une liste.
+	 * 
+	 * @return La liste de tous les paramÃ©tres et leurs caractÃ©ristiques.
+	 */
+	public ArrayList<ParametreModele> getParametres() {
+		ArrayList<ParametreModele> infosParam = new ArrayList<ParametreModele>();
+		Iterator<?> it = root.getChild("donnees").getChildren("parametre").iterator();
+		while (it.hasNext()) {
+			Element child = (Element) it.next();
+			infosParam.add(new ParametreModele(child.getAttributeValue("nom"),
+					child.getAttributeValue("type"), child.getAttributeValue("fonction"), 
+					child.getAttributeValue("unite"), child.getAttributeValue("delta"), 
+					child.getAttributeValue("numero"),child.getAttributeValue("format"),child.getAttributeValue("lod")));
+		}
+		return infosParam;
+	}
+
+	/**
+	 * Renvoie les paramÃ©tres associÃ©s Ã© une valeur avec leurs caractÃ©ristiques dans une liste.
+	 * 
+	 * @return La liste de tous les paramÃ©tres associÃ©s et leurs caractÃ©ristiques.
+	 */
+	public ArrayList<ParametreModele> getParametresValeur() {
+		ArrayList<ParametreModele> infosParam = new ArrayList<ParametreModele>();
+		Iterator<?> it = root.getChild("donnees").getChildren("parametre").iterator();
+		String fonction;
+		while (it.hasNext()) {
+			Element child = (Element) it.next();
+			fonction = child.getAttributeValue("fonction");
+			if (fonction.equals(Constantes.nomFonctionInsererVal)) {
+				infosParam.add(new ParametreModele(child.getAttributeValue("nom"),
+						child.getAttributeValue("type"), fonction, 
+						child.getAttributeValue("unite"), child.getAttributeValue("delta"), 
+						child.getAttributeValue("numero"), child.getAttributeValue("format"),child.getAttributeValue("lod")));
+			}
+		}
+		return infosParam;
+	}
+	
+	/**
+	 * Renvoie des numÃ©ros correspondant aux plateformes et leur rÃ©fÃ©rences.
+	 */
+	//	Liste des plateformes Ã© manipuler
+	public ArrayList<String> getNumsPlateforme() {
+		ArrayList<String> numPlats = new ArrayList<String>();
+		Iterator<?> it = root.getChild("donnees").getChildren("plateforme").iterator();
+		Element child;
+		while (it.hasNext()) {
+			child = (Element) it.next();
+			numPlats.add(child.getAttributeValue("numero"));
+		}
+		return numPlats;
+	}
+
+	/**
+	 * Renvoie des numÃ©ros correspondant aux capteurs et leur rÃ©fÃ©rences.
+	 */
+	//	Liste des capteurs Ã© manipuler
+	public ArrayList<String> getNumsCapteur() {
+		ArrayList<String> numCapts = new ArrayList<String>();
+		Iterator<?> it = root.getChild("donnees").getChildren("capteur").iterator();
+		Element child;
+		while (it.hasNext()) {
+			child = (Element) it.next();
+			numCapts.add(child.getAttributeValue("numero"));
+		}
+		return numCapts;
+	}
+
+	//	Partie faisant rÃ©fÃ©rence Ã© l'entÃ©te
+	public String getNomCategorie() {
+		return root.getChild("entete").getAttributeValue("categorie");
+	}
+
+	//	RÃ©fÃ©rences relatives au jeu
+	public String getNomJeu() {
+		return root.getChild("entete").getAttributeValue("jeu");
+	}
+
+	//	Description du jeu en question
+	public String getDescriptionJeu() {
+		return root.getChild("entete").getAttributeValue("description");
+	}
+
+	//	Valeur absente
+	public String getValeurAbsente() {
+		return root.getChild("entete").getAttributeValue("valeur_absente");
+	}
+
+	//	Noms relatifs aux organismes
+	public String getNumOrganismeJeu() {
+		return root.getChild("entete").getAttributeValue("organisme");
+	}
+
+	//	Delimiteur du modÃ©le
+	public String getDelimiteur() {
+		return root.getChild( "entete" ).getAttributeValue("delimiteur");
+	}
+
+	//	Subdivision ou non
+	public String getSubdiviser() {
+		return root.getChild( "entete" ).getAttributeValue("subdiviser");
+	}
+	
+	//	CoordonnÃ©es de la personne "pi"
+	public String getNumeroPi() {
+		return root.getChild("entete").getChild("pi").getAttributeValue(
+				"numero");
+	}
+
+	//	CoordonnÃ©es de la personne "contact"
+	public String getNumeroContact() {
+		return root.getChild("entete").getChild("contact").getAttributeValue("numero");
+	}
+
+	//	CoordonnÃ©es de la personne "integrateur"
+	public String getNumeroIntegrateur() {
+		return root.getChild("entete").getChild("integrateur").getAttributeValue("numero");
+	}
+
+	private Element root;
+
+	private String categorie;
+
+	private String jeu;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureOrganismes.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureOrganismes.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureOrganismes.java	(revision 488)
@@ -0,0 +1,131 @@
+
+/*
+ * Created on 29 Jan. 2007
+ */
+/**
+ * @author 
+ * 
+ * 
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LectureOrganismes {
+	public LectureOrganismes() {
+	}
+
+	public void lireFichier() {
+		String nomFichierOrg = Constantes.cheminListes + "/" + Constantes.nomListeOrganismes;
+		File fichier = new File(nomFichierOrg);
+		if (fichier.exists()) {
+			// Etape ou l' on crÃ©e le Workbook
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				//ws.setEncoding("OS2-850");//ISO-8859-1
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			// Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			
+            //initialisation des listes.
+			numerosOrg = new ArrayList<String>();
+			nomsOrg = new ArrayList<String>();
+			descriptionsOrg = new ArrayList<String>();
+			mailsOrg = new ArrayList<String>();
+			urlsOrg = new ArrayList<String>();
+			ruesOrg = new ArrayList<String>();
+			codesPostalsOrg = new ArrayList<String>();
+			villesOrg = new ArrayList<String>();
+			paysOrg = new ArrayList<String>();
+			int nbOrganismes = sheet.getRows() - 1;//Constantes.nbOrganismes;
+			// Etape de lecture des cellules
+			for (int numOrg = 0; numOrg < nbOrganismes; numOrg++) {
+				numerosOrg.add(sheet.getCell(0, numOrg + 1).getContents());
+				nomsOrg.add(sheet.getCell(1, numOrg + 1).getContents());
+				descriptionsOrg.add(sheet.getCell(2, numOrg + 1).getContents());
+				mailsOrg.add(sheet.getCell(3, numOrg + 1).getContents());
+				urlsOrg.add(sheet.getCell(4, numOrg + 1).getContents());
+				ruesOrg.add(sheet.getCell(5, numOrg + 1).getContents());
+				codesPostalsOrg.add(sheet.getCell(6, numOrg + 1).getContents());
+				villesOrg.add(sheet.getCell(7, numOrg + 1).getContents());
+				paysOrg.add(sheet.getCell(8, numOrg + 1).getContents());
+			}
+			// Etape de fermeture du flux
+			workbook.close();
+		}
+	}
+	
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosOrg.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosOrg.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+
+	public ArrayList<String> getNumerosOrg() {
+		return numerosOrg;
+	}
+
+	public ArrayList<String> getNomsOrg() {
+		return nomsOrg;
+	}
+
+	public ArrayList<String> getMailsOrg() {
+		return mailsOrg;
+	}
+
+	public ArrayList<String> getDescriptionsOrg() {
+		return descriptionsOrg;
+	}
+
+	public ArrayList<String> getRuesOrg() {
+		return ruesOrg;
+	}
+
+	public ArrayList<String> getCodesPostalsOrg() {
+		return codesPostalsOrg;
+	}
+
+	public ArrayList<String> getVillesOrg() {
+		return villesOrg;
+	}
+
+	public ArrayList<String> getPaysOrg() {
+		return paysOrg;
+	}
+
+	public ArrayList<String> getUrlsOrg() {
+		return urlsOrg;
+	}
+
+	private ArrayList<String> numerosOrg;
+	private ArrayList<String> nomsOrg;
+	private ArrayList<String> mailsOrg;
+	private ArrayList<String> descriptionsOrg;
+	private ArrayList<String> ruesOrg;
+	private ArrayList<String> codesPostalsOrg;
+	private ArrayList<String> villesOrg;
+	private ArrayList<String> paysOrg;
+	private ArrayList<String> urlsOrg;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureParametres.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureParametres.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureParametres.java	(revision 488)
@@ -0,0 +1,121 @@
+/**
+ * Created on 26 Jan. 2007
+ */
+
+/**
+ * @author 
+ * 
+ * 
+ */
+
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import com.medias.EcritureLog;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LectureParametres {
+	public LectureParametres() {
+	}
+
+	public void lireFichier() {
+		//	Etape d'accÃ©s au chemin du modÃ©le xml Ã© amanipuler
+		String nomFichierParam = Constantes.cheminListes + "/" + Constantes.nomListeParametres;
+		File fichier = new File(nomFichierParam);
+		if (fichier.exists()) {
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			//	Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			
+			//	Initialisation des listes.
+			numerosParam = new ArrayList<String>();
+			nomsParam = new ArrayList<String>();
+			codesMegapoliParam = new ArrayList<String>();
+			numsUnitesParam = new ArrayList<String>();
+			//descriptionsParam = new ArrayList<String>();
+			categoriesParam = new ArrayList<String>();
+			nomsParamFromFile = new ArrayList<String>();
+			//	Etape de lecture des cellules
+			int nbParams = sheet.getRows() - 1;//Constantes.nbParametres
+			for (int numParam = 0; numParam < nbParams; numParam++) {
+				numerosParam.add(sheet.getCell(0, numParam + 1).getContents());
+				nomsParam.add(sheet.getCell(1, numParam + 1).getContents());
+				codesMegapoliParam.add(sheet.getCell(2, numParam + 1).getContents());
+				categoriesParam.add(sheet.getCell(3, numParam + 1).getContents());
+				numsUnitesParam.add(sheet.getCell(4, numParam + 1).getContents());
+				nomsParamFromFile.add(sheet.getCell(5, numParam + 1).getContents());
+				//descriptionsParam.add(sheet.getCell(4, numParam + 1).getContents());
+			}
+			//	Etape de fermeture du flux
+			workbook.close();
+		} else {
+			EcritureLog.ecrire(
+                    "Fichier " + fichier.getName() + " non trouvÃ© !", "err" );
+		}
+	}
+
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosParam.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosParam.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+	
+	public ArrayList<String> getNumerosParam() {
+		return numerosParam;
+	}
+
+	public ArrayList<String> getNomsParam() {
+		return nomsParam;
+	}
+
+	public ArrayList<String> getCodesMegapoliParam() {
+		return codesMegapoliParam;
+	}
+
+	public ArrayList<String> getNumsUnitesParam() {
+		return numsUnitesParam;
+	}
+
+	public ArrayList<String> getDescriptionsParam() {
+		return descriptionsParam;
+	}
+
+	public ArrayList<String> getCategoriesParam() {
+		return categoriesParam;
+	}
+
+	public ArrayList<String> getNomsParamFromFile() {
+		return nomsParamFromFile;
+	}
+
+	private ArrayList<String> numerosParam;
+	private ArrayList<String> nomsParam;
+	private ArrayList<String> codesMegapoliParam;
+	private ArrayList<String> categoriesParam;
+	private ArrayList<String> numsUnitesParam;
+	private ArrayList<String> descriptionsParam;
+	private ArrayList<String> nomsParamFromFile;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePersonnes.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePersonnes.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePersonnes.java	(revision 488)
@@ -0,0 +1,116 @@
+/*
+ * Created on 29 Jan. 2007
+ */
+/**
+ * @author 
+ * 
+ * 
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LecturePersonnes {
+	public LecturePersonnes() {
+	}
+
+	public void lireFichier() {
+		String nomFichierPers = Constantes.cheminListes + "/" + Constantes.nomListePersonnes;
+		File fichier = new File(nomFichierPers);
+		if (fichier.exists()) {
+			// Etape ou l' on crÃ©e le Workbook
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			// Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			
+			// Erape d'initialisisations des listes
+			numerosPers = new ArrayList<String>();
+			nomsPers = new ArrayList<String>();
+			prenomsPers = new ArrayList<String>();
+			mailsPers = new ArrayList<String>();
+			descriptionsPers = new ArrayList<String>();
+			numOrgsPers = new ArrayList<String>();
+
+			nbPersonnes = sheet.getRows() - 1;//Constantes.nbPersonnes;
+			// Etape de lecture des cellules
+			for (int numPers = 0; numPers < nbPersonnes; numPers++) {
+				numerosPers.add(sheet.getCell(0, numPers + 1).getContents());
+				nomsPers.add(sheet.getCell(1, numPers + 1).getContents());
+				prenomsPers.add(sheet.getCell(2, numPers + 1).getContents());
+				mailsPers.add(sheet.getCell(3, numPers + 1).getContents());
+				descriptionsPers.add(sheet.getCell(4, numPers + 1).getContents());
+				numOrgsPers.add(sheet.getCell(5, numPers + 1).getContents());
+			}
+			// Etape de fermeture du flux
+			workbook.close();
+		}
+	}
+	
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosPers.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosPers.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+
+	public ArrayList<String> getNumerosPers() {
+		return numerosPers;
+	}
+
+	public ArrayList<String> getNomsPers() {
+		return nomsPers;
+	}
+
+	public ArrayList<String> getPrenomsPers() {
+		return prenomsPers;
+	}
+
+	public ArrayList<String> getMailsPers() {
+		return mailsPers;
+	}
+
+	public ArrayList<String> getDescriptionsPers() {
+		return descriptionsPers;
+	}
+
+	public ArrayList<String> getNumOrgsPers() {
+		return numOrgsPers;
+	}
+
+	private ArrayList<String> numerosPers;
+
+	private ArrayList<String> nomsPers;
+
+	private ArrayList<String> prenomsPers;
+
+	private ArrayList<String> mailsPers;
+
+	private ArrayList<String> descriptionsPers;
+
+	private ArrayList<String> numOrgsPers;
+
+	private int nbPersonnes;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePlateformes.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePlateformes.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LecturePlateformes.java	(revision 488)
@@ -0,0 +1,199 @@
+/*
+ * Created on 29 Jan. 2007
+ */
+/**
+ * @author 
+ * 
+ * 
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LecturePlateformes {
+	public LecturePlateformes() {
+	}
+
+	public void lireFichier() {
+		String nomFichierPlat = Constantes.cheminListes + "/" + Constantes.nomListePlateformes;
+		File fichier = new File(nomFichierPlat);
+		if (fichier.exists()) {
+			// Etape ou l' on crÃ©e le Workbook
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			// Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			
+			// initialisation des listes.
+			numerosPlat = new ArrayList<String>();
+			nomsPlat = new ArrayList<String>();
+			typesPlat = new ArrayList<String>();
+			descriptionsPlat = new ArrayList<String>();
+			latMinsPlat = new ArrayList<String>();
+			latMaxsPlat = new ArrayList<String>();
+			longMinsPlat = new ArrayList<String>();
+			longMaxsPlat = new ArrayList<String>();
+			altMinsPlat = new ArrayList<String>();
+			altMaxsPlat = new ArrayList<String>();
+			//hautSolMinsPlat = new ArrayList<String>();
+			//hautSolMaxsPlat = new ArrayList<String>();
+			numsCaptPLat = new ArrayList<ArrayList<String>>();
+			
+			
+			nbPlateformes = sheet.getRows() - 1;//Constantes.nbPlateformes;
+			String numsCapteurs, numCapteur, captDer;
+			int captCourant;
+			ArrayList<String> numsCapteursLigne;
+			// Etape de lecture des cellules
+			for (int numPlat = 0; numPlat < nbPlateformes; numPlat++) {
+				numerosPlat.add(sheet.getCell(0, numPlat + 1).getContents());
+				nomsPlat.add(sheet.getCell(1, numPlat + 1).getContents());
+				descriptionsPlat.add(sheet.getCell(2, numPlat + 1).getContents());
+				typesPlat.add(sheet.getCell(3, numPlat + 1).getContents());
+				latMinsPlat.add(sheet.getCell(4, numPlat + 1).getContents().replaceAll(",", "."));
+				latMaxsPlat.add(sheet.getCell(5, numPlat + 1).getContents().replaceAll(",", "."));
+				longMinsPlat.add(sheet.getCell(6, numPlat + 1).getContents().replaceAll(",", "."));
+				longMaxsPlat.add(sheet.getCell(7, numPlat + 1).getContents().replaceAll(",", "."));
+				altMinsPlat.add(sheet.getCell(8, numPlat + 1).getContents().replaceAll(",", "."));
+				altMaxsPlat.add(sheet.getCell(9, numPlat + 1).getContents().replaceAll(",", "."));
+				//hautSolMinsPlat.add(sheet.getCell(10, numPlat + 1).getContents());
+				//hautSolMaxsPlat.add(sheet.getCell(11, numPlat + 1).getContents());
+				
+				numsCapteurs = sheet.getCell(10, numPlat + 1).getContents();
+				numsCapteursLigne = new ArrayList<String>();
+				while (numsCapteurs.indexOf(Constantes.delimiteurXLS) != -1) {
+					// On rÃ©cupÃ©re la 1Ã©re donnÃ©e de la mesure avant le dÃ©limiteur
+					numCapteur = numsCapteurs.substring(0, numsCapteurs.indexOf(Constantes.delimiteurXLS)).trim();
+					// On rÃ©cupÃ©re la mesure restante aprÃ©s le dÃ©limiteur
+					numsCapteurs = numsCapteurs.substring(numsCapteurs.indexOf(Constantes.delimiteurXLS)+1).trim();
+					if (numCapteur.equals("..")) {
+						if (numsCapteurs.indexOf(Constantes.delimiteurXLS) != -1)
+							captDer = numsCapteurs.substring(0, numsCapteurs.indexOf(Constantes.delimiteurXLS)).trim();
+						else
+							captDer = numsCapteurs.trim();
+						captCourant = Integer.parseInt(numsCapteursLigne.get(numsCapteursLigne.size()-1));
+						while (captCourant < Integer.parseInt(captDer)-1) {
+							captCourant++;
+							numsCapteursLigne.add(String.valueOf(captCourant));
+						}
+					} else {
+						numsCapteursLigne.add(numCapteur);
+					}
+				}
+				numCapteur = numsCapteurs;
+				numsCapteursLigne.add(numsCapteurs);
+				numsCaptPLat.add(numsCapteursLigne);
+			// Etape de fermeture du flux
+			}
+			workbook.close();
+		}
+	}
+
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosPlat.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosPlat.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+
+	public ArrayList<String> getNumerosPlat() {
+		return numerosPlat;
+	}
+
+	public ArrayList<String> getNomsPLat() {
+		return nomsPlat;
+	}
+
+	public ArrayList<String> getTypesPlat() {
+		return typesPlat;
+	}
+
+	public ArrayList<String> getDescriptionsPLat() {
+		return descriptionsPlat;
+	}
+
+	public ArrayList<String> getLatMinsPLat() {
+		return latMinsPlat;
+	}
+
+	public ArrayList<String> getLatMaxsPLat() {
+		return latMaxsPlat;
+	}
+
+	public ArrayList<String> getLongMinsPLat() {
+		return longMinsPlat;
+	}
+
+	public ArrayList<String> getLongMaxsPLat() {
+		return longMaxsPlat;
+	}
+
+	public ArrayList<String> getAltMinsPLat() {
+		return altMinsPlat;
+	}
+
+	public ArrayList<String> getAltMaxsPLat() {
+		return altMaxsPlat;
+	}
+
+	public ArrayList<String> getHautSolMinsPlat() {
+		return hautSolMinsPlat;
+	}
+
+	public ArrayList<String> getHautSolMaxsPlat() {
+		return hautSolMaxsPlat;
+	}
+
+	public ArrayList<ArrayList<String>> getNumsCaptPlat() {
+		return numsCaptPLat;
+	}
+	
+	 ArrayList<ArrayList<String>> numsCaptPLat;
+	private ArrayList<String> numerosPlat;
+
+	private ArrayList<String> nomsPlat;
+
+	private ArrayList<String> typesPlat;
+
+	private ArrayList<String> descriptionsPlat;
+
+	private ArrayList<String> latMinsPlat;
+
+	private ArrayList<String> latMaxsPlat;
+
+	private ArrayList<String> longMinsPlat;
+
+	private ArrayList<String> longMaxsPlat;
+
+	private ArrayList<String> altMinsPlat;
+
+	private ArrayList<String> altMaxsPlat;
+
+	private ArrayList<String> hautSolMinsPlat;
+
+	private ArrayList<String> hautSolMaxsPlat;
+
+	private int nbPlateformes;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureUnites.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureUnites.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/LectureUnites.java	(revision 488)
@@ -0,0 +1,94 @@
+/*
+ * Created on 29 Jan. 2007
+ */
+/**
+ * @author 
+ * 
+ * 
+ */
+package com.medias.integration.lecture_ecriture;
+
+import com.medias.Constantes;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.WorkbookSettings;
+import jxl.read.biff.BiffException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class LectureUnites {
+	public LectureUnites() {
+	}
+
+	public void lireFichier() {
+		String nomFichierUni = Constantes.cheminListes + "/" + Constantes.nomListeUnites;
+		File fichier = new File(nomFichierUni);
+		if (fichier.exists()) {
+			// Etape ou l' on crÃ©e le Workbook
+			Workbook workbook = null;
+			try {
+				WorkbookSettings ws = new WorkbookSettings();
+				ws.setEncoding(Constantes.encodageDefaut);
+				workbook = Workbook.getWorkbook(fichier, ws);
+			} catch (BiffException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			// Etape ou l'on rÃ©cupÃ©re les donnÃ©es de la 1Ã©re page du classeur
+			Sheet sheet = workbook.getSheet(0);
+			// Etape d'initialisation des listes.
+			numerosUni = new ArrayList<String>();
+			codesUni = new ArrayList<String>();
+			nomsUni = new ArrayList<String>();
+			typesUni = new ArrayList<String>();
+			
+			int nbUnites = sheet.getRows() - 1;//Constantes.nbUnites;
+			// Etape de lecture des cellules
+			for (int numUni = 0; numUni < nbUnites; numUni++) {
+				numerosUni.add(sheet.getCell(0, numUni + 1).getContents());
+				codesUni.add(sheet.getCell(1, numUni + 1).getContents());
+				nomsUni.add(sheet.getCell(2, numUni + 1).getContents());
+				typesUni.add(sheet.getCell(3, numUni + 1).getContents());
+			}
+			// Etape de fermeture du flux
+			workbook.close();
+		}
+	}
+
+	public int getIndice(int numero) {
+		int indice = -1;
+		int numeroCourant;
+		for (int indiceListe = 0; indiceListe < numerosUni.size(); indiceListe++) {
+			numeroCourant = Integer.parseInt((String)numerosUni.get(indiceListe));
+			if (numeroCourant == numero) {
+				indice = indiceListe;
+				return indice;
+			}
+		}
+		return indice;
+	}
+
+	public ArrayList<String> getCodesUni() {
+		return codesUni;
+	}
+
+	public ArrayList<String> getNumerosUni() {
+		return numerosUni;
+	}
+
+	public ArrayList<String> getNomsUni() {
+		return nomsUni;
+	}
+
+	public ArrayList<String> getTypesUni() {
+		return typesUni;
+	}
+
+	private ArrayList<String> numerosUni;
+	private ArrayList<String> codesUni;
+	private ArrayList<String> nomsUni;
+	private ArrayList<String> typesUni;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/XMLParser.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/XMLParser.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/lecture_ecriture/XMLParser.java	(revision 488)
@@ -0,0 +1,134 @@
+/**
+ * Created on 24 Janvier. 2006
+ *  @author 
+ */
+package com.medias.integration.lecture_ecriture;
+
+
+import com.medias.EcritureLog;
+import integration.exceptions.XMLException;
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jdom.input.SAXBuilder;
+import org.jdom.output.XMLOutputter;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * 
+ * Classe permettant de lire, Ã©crire ou modifier des fichiers XML.
+ */
+
+public class XMLParser {
+    /**
+     * Ajoute un Ã©lÃ©ment Ã© une racine.
+     * @param root ElÃ©ment racine.
+     * @param element ElÃ©ment Ã© ajouter.
+     */
+    public void createXMLRepresentation(Element root, Element element) {
+        root.addContent(element);
+    }
+
+    /**
+     * Ajoute un Ã©lÃ©ment Ã© une racine.
+     * @param root ElÃ©ment racine.
+     * @param name Nom de l'Ã©lÃ©ment.
+     * @param value Valeur de l'Ã©lÃ©ment.
+     */
+    public void createXMLRepresentation(Element root, String name, String value) {
+        Element element = new Element(name);
+        element.setText(value);
+        root.addContent(element);
+    }
+
+    /**
+     * Renvoie l'Ã©lÃ©ment enfant d'un Ã©lÃ©ment enfant de la racine du document.
+     * @param parent Nom de l'Ã©lÃ©ment parent de l'Ã©lÃ©ment Ã© renvoyer.
+     * @param child Nom de l'Ã©lÃ©ment Ã© renvoyer.
+     * @return L'Ã©lÃ©ment recherchÃ©.
+     */
+    public Element getRootElement(String parent, String child) {
+        Element el = doc.getRootElement();
+        return el.getChild(parent).getChild(child);
+    }
+
+    /**
+     * Ecrit un document JDOM dans un fichier XML.
+     * @param xmlFilename Nom du fichier XML Ã© crÃ©er.
+     */
+    public void writeXml(String xmlFilename) {
+        try {
+            XMLOutputter outputter = new XMLOutputter();
+            FileOutputStream output = new FileOutputStream(xmlFilename);
+            outputter.output(doc, output);
+            output.close();
+        } catch (IOException ex) {
+            ex.printStackTrace();
+            EcritureLog.ecrire( "Le fichier XML n'a pas pu Ã©tre crÃ©Ã©.", "err" );
+        }
+    }
+
+    /**
+     * Ecrit un document JDOM dans un fichier XML.
+     * @param xmlFilename Nom du fichier XML Ã© crÃ©er.
+     * @param codage Codage Ã© utiliser.
+     */
+    public void writeXml(String xmlFilename, String codage) {
+        try {
+            XMLOutputter outputter = new XMLOutputter();
+            FileOutputStream output = new FileOutputStream(xmlFilename);
+            outputter.getFormat().setEncoding(codage);
+            outputter.output(doc, output);
+            output.close();
+        } catch (IOException ex) {
+            ex.printStackTrace();
+            EcritureLog.ecrire("Le fichier XML n'a pas pu Ã©tre crÃ©Ã©.","err");
+        }
+    }
+
+    /**
+     * Renvoie un document Ã© partir d'un fichier XML.
+     * @param xmlFilename Nom du fichier XML.
+     */
+    public void readXml(String xmlFilename) throws XMLException
+    {
+        SAXBuilder builder = new SAXBuilder();
+        try {
+        	FileInputStream fic = new FileInputStream(xmlFilename);
+            doc = builder.build(fic);
+            fic.close();
+        } catch (Exception e) {
+            throw new XMLException(e);
+        }
+    }
+
+    /**
+     * CrÃ©e un Ã©lÃ©ment JDOM.
+     * @param name Nom de l'Ã©lÃ©ment.
+     * @return ElÃ©ment crÃ©Ã©.
+     */
+    public Element createElement(String name) {
+        return new Element(name);
+    }
+
+    /**
+     * Met Ã© jour le document JDOM courant du builder.
+     * @param doc Nouveau document.
+     */
+    public void setDocument(Document doc) {
+        this.doc = doc;
+    }
+
+    /**
+     * Renvoie l'Ã©lÃ©ment root du document courant.
+     * @return Element root.
+     */
+    public Element getRoot() {
+        return doc.getRootElement();
+    }
+
+    /** Document JDOM reprÃ©sentant le fichier XML manipulÃ©. **/
+    private Document doc;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidation.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidation.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidation.java	(revision 488)
@@ -0,0 +1,221 @@
+/*
+ * Created on 16 Janvier. 2006
+ */
+
+package com.medias.integration.prevalidation;
+
+import com.medias.EcritureLog;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.Parametre;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.vues.ParametreModele;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+/**
+ * @author
+ * 
+ * Classe permettant de Prevalider un ensemble de fichier d'un jeu donnÃ©
+ */
+
+public class PreValidation {
+	public PreValidation(File fichier) {
+		this.fichier = fichier;
+		entete = new ArrayList<String>();
+		mesures = new ArrayList<String>();
+	}
+
+	public void prevalider(LectureParametres lectureParametres, LectureUnites lectureUnites, LectureCapteurs lectureCapteurs
+			, ArrayList<Parametre> parametres, ArrayList<Capteur> capteurs, String nomJeu) {
+		// Fichier constituÃ© d'un entÃ©te de type METEO
+		if ((nomJeu.equals("METEO-SIRTA") || nomJeu.equals("weather SIRTA")) && fichier.getName().endsWith(".txt")) {
+			PreValidationMETEOFILE prevalidationMETEOFILE = new PreValidationMETEOFILE(fichier);
+			prevalidationMETEOFILE.lireFichier(lectureParametres,lectureUnites,lectureCapteurs,parametres,capteurs);
+			this.setEntete(prevalidationMETEOFILE.getEntete());
+			this.setMesures(prevalidationMETEOFILE.getMesures());
+			this.setNbParams(prevalidationMETEOFILE.getNbParams());
+			this.setInfoParams(prevalidationMETEOFILE.getInfoParams());
+			prevalidationMETEOFILE = null;
+		}
+		// Fichier constituÃ© d'un entÃ©te NASA AMES
+		else if (fichier.getName().endsWith(".na") || fichier.getName().endsWith(".txt") || fichier.getName().endsWith(".ames") || fichier.getName().endsWith(".nas") || fichier.getName().endsWith(".ict")) {
+			int formatFichierNASAAMES = 0;
+			try {
+				BufferedReader buf = new BufferedReader(new FileReader(fichier));
+				String ligne = buf.readLine();
+				if (ligne != null) {
+					formatFichierNASAAMES = Integer.parseInt(ligne.substring(ligne.indexOf(" ")+1).trim());
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			if (formatFichierNASAAMES == 1001) {
+				PreValidationNASAAMES1001 preValidationNASAAMES1001 = new PreValidationNASAAMES1001(fichier);
+				preValidationNASAAMES1001.lireFichier(lectureParametres,lectureUnites,lectureCapteurs,parametres,capteurs);
+				this.setEntete(preValidationNASAAMES1001.getEntete());
+				this.setMesures(preValidationNASAAMES1001.getMesures());
+				this.setNbParams(preValidationNASAAMES1001.getNbParams());
+				this.setInfoParams(preValidationNASAAMES1001.getInfoParams());
+				preValidationNASAAMES1001 = null;
+			}
+		}
+		else {
+			EcritureLog.ecrire("\nErreur sur l'extension du fichier : Les extensions valides sont na, ames, txt, ict ou nas","err");
+		}
+	}
+
+	public void vider() {
+		fichier = null;
+		mesures = null;
+		entete = null;
+		infoParams = null;
+	}
+	
+	/**
+	 *  On retrouve les indices de capteurs correspondant aux noms de capteurs
+	 *  apparaissant dans le fichier de donnÃ©es
+	 */
+	protected ArrayList<Integer> findIndicesCaptInFile(LectureCapteurs lectureCapteurs, ArrayList<Capteur> capteurs) {
+		ArrayList<Integer> numsCapt = new ArrayList<Integer>();
+		Capteur capt;
+		String nomFromFile, modele, numserie, fabriquant, type;
+		int captTrouve;
+		for (int numCapt = 0; numCapt < lectureCapteurs.getTypesCapt().size(); numCapt++) {
+			nomFromFile = lectureCapteurs.getNomsCaptFromFile().get(numCapt);
+			captTrouve = -1;
+			for (String ligne: infoSup) {
+				if (captTrouve == -1 && ligne.indexOf(nomFromFile) != -1) {
+					// On a trouvÃ© un nom de capteur dans le fichier qui correspond au capteur numCapt de la liste des capteurs
+					modele = lectureCapteurs.getModelesCapt().get(numCapt);
+					numserie = lectureCapteurs.getNumsSeriesCapt().get(numCapt);
+					fabriquant = lectureCapteurs.getFabriquantsCapt().get(numCapt);
+					type = lectureCapteurs.getTypesCapt().get(numCapt);
+					for (int numC = 0; numC < capteurs.size(); numC++) {
+						capt = capteurs.get(numC);
+						if ((type.equals("") || capt.getTypeCapteur().getTypeCapteurNom().equals(type))
+								&& (fabriquant.equals("") || capt.getFabriquant().getFabriquantNom().equals(fabriquant))
+								&& (modele.equals("") || capt.getCapteurModele().equals(modele))
+								&& (numserie.equals("") || capt.getCapteurNumserie().equals(numserie))) {
+							// On a fait le lien entre le capteur numCapt de la liste XLS et le capteur numC de la liste d'objets
+							captTrouve = numC;
+//							numsCapt.add(new Integer(numC));
+							break;
+						}
+					}
+				}
+			}
+			if (captTrouve != -1) numsCapt.add(new Integer(captTrouve));
+		}
+		return numsCapt;
+	}
+	
+	/**
+	 * A partir du nom d'unitÃ©, va chercher dans le tableau des unitÃ©s et rÃ©cupÃ©re le type et le code de l'unitÃ©
+	 */
+	protected String[] findUnite(String nomUnite, LectureUnites lectureUnites) {
+		String code, nom, type = null;
+		String[] res = new String[2];
+		for (int indiceUnite = 0; indiceUnite < lectureUnites.getCodesUni().size(); indiceUnite++) {
+			code = lectureUnites.getCodesUni().get(indiceUnite);
+			nom = lectureUnites.getNomsUni().get(indiceUnite);
+			if (code.trim().equals(nomUnite) || nom.trim().equals(nomUnite)) {
+				type = lectureUnites.getTypesUni().get(indiceUnite);
+				res[0] = code;
+				res[1] = type;
+				break;
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * A partir du nom de paramÃ©tre du fichier, va chercher dans le tableau des paramÃ©tres, rÃ©cupÃ©re le code du paramÃ©tre
+	 * puis renvoie l'indice Ã© lequel est situÃ© le paramÃ©tre correspondant dans la liste des paramÃ©tres du jeu
+	 */
+	protected int findIndiceParam(String nomParam, LectureParametres lectureParametres, ArrayList<Parametre> parametres) {
+		if (parametres.size() == 1) return 0;
+		String nomInFile, code;
+		for (int indiceP = 0; indiceP < lectureParametres.getNomsParam().size(); indiceP++) {
+			nomInFile = lectureParametres.getNomsParamFromFile().get(indiceP);
+			if (nomInFile.trim().equals(nomParam)) {
+				code = lectureParametres.getCodesMegapoliParam().get(indiceP);
+				for (int numP = 0; numP < parametres.size(); numP++) {
+					if (parametres.get(numP).getParametreCode().equals(code)) return numP;
+				}
+			}
+		}
+		return -1;
+	}
+	
+	/**
+	 * Retrouve l'indice du capteur correspondant au code de paramÃ©tre donnÃ©
+	 */
+	protected int findIndiceCapt(String codeParam, ArrayList<Integer> indicesCapteur, ArrayList<Capteur> capteurs) {
+		if (capteurs.size() == 1) return 0;
+		Capteur capt;
+		for (Integer indice: indicesCapteur) {
+			capt = capteurs.get(indice.intValue());
+			for (Parametre param : capt.getParametres()) {
+				if (param.getParametreCode().equals(codeParam)) {
+					return indice.intValue();
+				}
+			}
+		}
+		return -1;
+	}
+
+	public ArrayList<String> getEntete() {
+		return entete;
+	}
+
+	public void setEntete(ArrayList<String> entete) {
+		this.entete = entete;
+	}
+
+	public ArrayList<String> getMesures() {
+		return mesures;
+	}
+
+	public void setMesures(ArrayList<String> mesures) {
+		this.mesures = mesures;
+	}
+
+	public File getFichier() {
+		return fichier;
+	}
+
+	public void setFichier(File fichier) {
+		this.fichier = fichier;
+	}
+	
+	public int getNbParams() {
+		return nbParams;
+	}
+
+	public void setNbParams(int nbParams) {
+		this.nbParams = nbParams;
+	}
+
+	public ArrayList<ParametreModele> getInfoParams() {
+		return infoParams;
+	}
+
+	public void setInfoParams(ArrayList<ParametreModele> infoParams) {
+		this.infoParams = infoParams;
+	}
+
+//	private String jeu;
+
+	protected File fichier;
+	protected ArrayList<String> entete;
+	protected ArrayList<String> mesures;
+	protected int nbParams;
+	protected ArrayList<ParametreModele> infoParams;
+	protected ArrayList<String> infoSup;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationMETEOFILE.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationMETEOFILE.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationMETEOFILE.java	(revision 488)
@@ -0,0 +1,147 @@
+package com.medias.integration.prevalidation;
+
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.Parametre;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.vues.ParametreModele;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * PrÃ©validation d'un jeu ayant des donnÃ©es de type METEO
+ *
+ */
+public class PreValidationMETEOFILE extends PreValidation
+{
+	public PreValidationMETEOFILE(File fichier) {
+		super(fichier);
+	}
+
+	/**
+	 * MÃ©thode de prÃ©validation permmettent de distinguer l'entÃ©te et les donnÃ©es d'un fichier METEO
+	 * NB: La premiÃ©re ligne ne commenÃ©ant pas par # indique la ligne Ã© laquelle commence la sÃ©rie de donnÃ©es
+	 * @return 
+	 */
+
+	public void lireFichier(LectureParametres lectureParametres, LectureUnites lectureUnites, LectureCapteurs lectureCapteurs
+			, ArrayList<Parametre> parametres, ArrayList<Capteur> capteurs) {
+		try {
+			//**************************************************************************************
+			// On rÃ©cupÃ©re le contenu du fichier pour le lire.
+			//****************************************************************************************
+			FileInputStream fis = new FileInputStream(fichier);
+			InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
+			BufferedReader buf = new BufferedReader(isr);
+			// Lecture du fichier ligne aprÃ©s ligne
+			String ligne = buf.readLine();
+			while (ligne != null) {
+				if (!ligne.startsWith("#")) {
+					mesures.add(ligne);					 
+				} else {
+					entete.add(ligne);
+				}
+				ligne = buf.readLine();
+			}
+			// RÃ©cupÃ©ration des informations de l'entÃ©te
+			// Dates de dÃ©but et de fin
+			int nbLignesMesures = mesures.size();
+			Date dateDeb = DateTime.stringToDate( mesures.get( 0 ).substring( 0, 10 ).trim(), "yyyy MM dd" );
+			Date dateFin = DateTime.stringToDate(mesures.get(nbLignesMesures-1).substring(0,10).trim(), "yyyy MM dd");
+//			System.out.println("deb="+dateDeb+", fin="+dateFin);
+			// Infos supplÃ©mentaires (pour trouver les capteurs)
+			infoSup = new ArrayList<String>();
+			infoSup.add(entete.get(1));
+			// On recherche les capteurs apparaissant dans les infos supplÃ©mentaires du fichier
+			ArrayList<Integer> indicesCaptInFile = findIndicesCaptInFile(lectureCapteurs,capteurs);
+			// Infos sur les paramÃ©tres et la valeur absente
+			infoParams = new ArrayList<ParametreModele>();
+			ParametreModele infoParam;
+			int nbLignesEntete = entete.size();
+			int diff;
+			String ligneEntete, nombre1, nombre2, valAbs = null;
+			ArrayList<String> lignesParam = new ArrayList<String>();
+			for(int numL=0; numL < nbLignesEntete;numL++){
+				ligneEntete = entete.get(numL).trim();
+				// Recherche des lignes de description des paramÃ©tres
+				if(ligneEntete.toLowerCase().startsWith("# col.")){
+					if (ligneEntete.indexOf("->") == -1) {
+						lignesParam.add(ligneEntete);
+						nbParams++;
+					} else {
+						nombre1 = ligneEntete.substring(ligneEntete.indexOf("ol.")+3,ligneEntete.indexOf("->")).trim();
+						nombre2 = ligneEntete.substring(ligneEntete.indexOf("->")+2, ligneEntete.indexOf(":")).trim();
+						diff = Integer.parseInt(nombre2)-Integer.parseInt(nombre1)+1;
+						nbParams += diff;
+						for (int i = 0; i < diff; i++) {
+							lignesParam.add("# col. x : none (no unit)");
+						}
+					}
+				}
+				// Recherche de la ligne oÃ© est indiquÃ©e la valeur absente
+				else if (ligneEntete.indexOf("corresponds to missed data") != -1){
+					valAbs = ligneEntete.substring(ligneEntete.indexOf("\"")+1, ligneEntete.lastIndexOf("\""));
+				}
+			}
+			String nomParam, nomUnite, codeParam;
+			String[] unite;
+			int indiceParam, indiceCapt;
+			for (int numParam = 0; numParam < nbParams; numParam++) {
+				infoParam = new ParametreModele();
+				nomParam = lignesParam.get(numParam);
+				nomUnite = nomParam.substring(nomParam.indexOf("(")+1,nomParam.indexOf(")")).trim();
+				nomParam = nomParam.substring(nomParam.indexOf(":")+1,nomParam.indexOf("(")).trim();
+				infoParam.setNom(nomParam);
+				infoParam.setValAbsente(valAbs);
+				infoParam.setCoef("1");
+				unite = findUnite(nomUnite, lectureUnites);
+				infoParam.setNomUnite(unite[0]);
+				infoParam.setType(unite[1]);
+				if (nomParam.toLowerCase().equals( Constantes.nomParametreLatitude) || nomParam.toLowerCase().equals(Constantes.nomParametreLongitude)
+						|| nomParam.toLowerCase().equals(Constantes.nomParametreAltitude) || nomParam.toLowerCase().equals("height")) {
+					infoParam.setFonction(Constantes.nomFonctionInsererLoc);
+				} else if (nomParam.startsWith("none") || nomParam.startsWith("Altitude") || nomParam.startsWith("QF")
+						|| nomParam.startsWith("Quality")) {
+					infoParam.setFonction(Constantes.nomFonctionNone);
+				} else if (nomParam.startsWith("Year") || nomParam.startsWith("Month") || nomParam.startsWith("Day") 
+						|| nomParam.startsWith("Hour") || nomParam.startsWith("Minute") || nomParam.startsWith("Second")) {
+					infoParam.setDateDeb(dateDeb);
+					infoParam.setDateFin(dateFin);
+					infoParam.setDateSince(null);
+					infoParam.setFonction(Constantes.nomFonctionDate);
+					infoParam.setFormat(nomUnite);
+					infoParam.setType(nomParam);
+				} else {
+					infoParam.setFonction(Constantes.nomFonctionInsererVal);
+					// Nom des paramÃ©tres correspondant aux variables primaires
+					indiceParam = findIndiceParam(nomParam,lectureParametres,parametres);
+					infoParam.setIndiceParam(indiceParam);
+					if (indiceParam == -1) {
+						codeParam = "???";
+						EcritureLog.ecrire("\nErreur : le paramÃ©tre '"+nomParam+"' n'a pas Ã©tÃ© trouvÃ©","err");
+					} else {
+						codeParam = parametres.get(indiceParam).getParametreCode();
+						infoParam.setDelta(parametres.get(indiceParam).getDelta());
+						infoParam.setLod(parametres.get(indiceParam).getLod());
+					}
+					indiceCapt = findIndiceCapt(codeParam,indicesCaptInFile,capteurs);
+					infoParam.setIndiceCapt(indiceCapt);
+				}
+//				EcritureLog.ecrire("param="+infoParam.getNom()+", format="+infoParam.getFormat()+", fct="+infoParam.getFonction()+", type="+infoParam.getType()+", unite="+infoParam.getNomUnite(), "out");
+				infoParams.add(infoParam);
+			}
+		} catch (IOException e) {
+			System.out.println(e.getMessage()+ "\nErreur dans la lecture du fichier "+ fichier.getName() + " !");
+		}
+	}
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationNASAAMES1001.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationNASAAMES1001.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/prevalidation/PreValidationNASAAMES1001.java	(revision 488)
@@ -0,0 +1,201 @@
+/**
+ * Created on 16 Jan. 2007
+ * @author 
+ */
+
+package com.medias.integration.prevalidation;
+
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.Parametre;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.vues.ParametreModele;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * PrÃ©validation d'un jeu ayant des donnÃ©es de type NASA-AMES 1001
+ *
+ */
+
+public class PreValidationNASAAMES1001 extends PreValidation
+{
+	public PreValidationNASAAMES1001(File fichier) {
+		super(fichier);
+	}
+
+	/**
+	 * MÃ©thode de prÃ©validation permmettent de distinguer l'entÃ©te et les donnÃ©es d'un fichier NASA-AMES 1001
+	 * NB: Le 1er nombre indiquÃ© sur la 1Ã©re ligne indique la ligne Ã© laquelle commence la sÃ©rie de donnÃ©es
+	 * @return 
+	 */
+	
+	public void lireFichier(LectureParametres lectureParametres, LectureUnites lectureUnites, LectureCapteurs lectureCapteurs
+			, ArrayList<Parametre> parametres, ArrayList<Capteur> capteurs) {
+		try {
+			//**************************************************************************************
+			// On rÃ©cupÃ©re le contenu du fichier pour le lire.
+			//****************************************************************************************
+			FileInputStream fis = new FileInputStream(fichier);
+			InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
+			BufferedReader buf = new BufferedReader(isr);//new FileReader(fichier));
+			boolean isEntete = true;
+			// Lecture du fichier ligne aprÃ©s ligne
+			String ligne = buf.readLine();
+			int nbLignesEntete = 0;
+			if (ligne != null) {
+				nbLignesEntete = Integer.parseInt(ligne.substring(0,ligne.indexOf(" ")));
+			}
+			while (ligne != null) {
+				if (isEntete == false) {
+					mesures.add(ligne);
+				} else {
+					entete.add(ligne);
+				}
+				// Si le dÃ©compte des lignes d'entÃ©te est terminÃ©, on arrive aux lignes de donnÃ©es
+				if (nbLignesEntete == 1) {
+					isEntete = false;
+				}
+				ligne = buf.readLine();
+				nbLignesEntete--;
+			}
+			// RÃ©cupÃ©ration des informations de l'entÃ©te
+			// Dates de dÃ©but et de fin
+			String dates = entete.get(6).trim();
+			Date dateDeb = DateTime.stringToDate( dates.substring( 0, 10 ).trim(), "yyyy MM dd" );
+			Date dateFin = DateTime.stringToDate(dates.substring(dates.length()-10).trim(), "yyyy MM dd");
+			//System.out.println("dates="+dates+", deb="+dateDeb+", fin="+dateFin);
+			// Nom du paramÃ©tre de la 1Ã©re colonne (variable temporelle)
+			String nomParamInd = entete.get(8).trim();
+			String unitInd = nomParamInd.substring(nomParamInd.indexOf("(")+1,nomParamInd.indexOf(")")).trim();
+			// Date Ã© partir de laquelle dÃ©marre la variable temporelle
+			Date dateSince = null;
+			String typeTime, formatTime;
+			if (nomParamInd.indexOf("since ") != -1) {
+				String dateSinceStr = unitInd.substring(unitInd.indexOf("since ")+6).trim();
+				dateSinceStr = dateSinceStr.replaceAll("\\+", "GMT\\+");
+				dateSince = DateTime.stringToDate(dateSinceStr, Constantes.formatDateDefault);
+				if (unitInd.toLowerCase().startsWith("hours")) {
+					typeTime = "HoursSince";
+				} else if (unitInd.toLowerCase().startsWith("seconds")) {
+					typeTime = "SecondsSince";
+				} else if (unitInd.toLowerCase().startsWith("year")) {
+					typeTime = "YearsSince";
+				} else {
+					typeTime = "DaysSince";
+				}
+				formatTime = null;
+			} else {
+				formatTime = unitInd;
+				if (nomParamInd.startsWith("Year")) {
+					typeTime = "Year";
+				} else {
+					typeTime = "Date";
+				}				
+			}
+			// Nb de colonnes de donnÃ©es = nb de variables primaires + 1 (variable temporelle)
+			nbParams = Integer.parseInt(entete.get(9).trim()) + 1;
+			// Coefficients
+			String[] coefficients = entete.get(10).trim().split(" ");
+			ArrayList<String> coefs = new ArrayList<String>();
+			for (String co : coefficients) {
+				if (!co.equals("")) coefs.add(co.trim());
+			}
+			// Valeurs absentes
+			String[] valAbsentes = entete.get(11).trim().split(" ");
+			ArrayList<String> valAbs = new ArrayList<String>();
+			for (String va : valAbsentes) {
+				if (!va.equals("")) valAbs.add(va.trim());
+			}
+			// Infos supplÃ©mentaires (pour trouver les capteurs)
+			infoSup = new ArrayList<String>();
+			infoSup.add(entete.get(3));
+			int nbLignesSup = Integer.parseInt(entete.get(11+nbParams).trim());
+			for (int numSup = 0; numSup < nbLignesSup; numSup++) {
+				infoSup.add(entete.get(12+nbParams+numSup));
+			}
+			// On recherche les capteurs apparaissant dans les infos supplÃ©mentaires du fichier
+			ArrayList<Integer> indicesCaptInFile = findIndicesCaptInFile(lectureCapteurs,capteurs);
+			// Infos sur les paramÃ©tres
+			infoParams = new ArrayList<ParametreModele>();
+			ParametreModele infoParam = new ParametreModele();
+			infoParam.setNom(nomParamInd);
+			infoParam.setDateDeb(dateDeb);
+			infoParam.setDateFin(dateFin);
+			infoParam.setDateSince(dateSince);
+			infoParam.setFonction(Constantes.nomFonctionDate);
+			infoParam.setType(typeTime);
+			infoParam.setFormat(formatTime);
+			infoParams.add(infoParam);
+			String nomParam, nomUnite, codeParam;
+			String[] unite;
+			int indiceParam, indiceCapt;
+			for (int numParam = 0; numParam < nbParams - 1; numParam++) {
+				infoParam = new ParametreModele();
+				nomParam = entete.get(12+numParam).trim();
+				nomUnite = nomParam.substring(nomParam.indexOf("(")+1,nomParam.indexOf(")")).trim();
+				nomParam = nomParam.substring(0,nomParam.indexOf("(")).trim();
+				infoParam.setNom(nomParam);
+				infoParam.setValAbsente(valAbs.get(numParam));
+				infoParam.setCoef(coefs.get(numParam));
+				unite = findUnite(nomUnite, lectureUnites);
+				infoParam.setNomUnite(unite[0]);
+				infoParam.setType(unite[1]);
+				if (nomParam.toLowerCase().equals(Constantes.nomParametreLatitude) || nomParam.toLowerCase().equals(Constantes.nomParametreLongitude)
+						|| nomParam.toLowerCase().equals(Constantes.nomParametreAltitude) || nomParam.toLowerCase().equals(Constantes.nomParametreHauteurSol)) {
+					infoParam.setFonction(Constantes.nomFonctionInsererLoc);
+				} else if (nomParam.startsWith("time") || nomParam.startsWith("end_time") || nomParam.startsWith("event_marker")
+						|| nomParam.startsWith("number of DMA") || nomParam.startsWith("numflag") || nomParam.startsWith("platform")) {
+					infoParam.setFonction(Constantes.nomFonctionNone);
+				} else if (nomParam.startsWith("Month") || nomParam.startsWith("Day") 
+						|| nomParam.startsWith("Hour") || nomParam.startsWith("Minute") || nomParam.startsWith("Second")) {
+					infoParam.setDateDeb(dateDeb);
+					infoParam.setDateFin(dateFin);
+					infoParam.setDateSince(dateSince);
+					infoParam.setFonction(Constantes.nomFonctionDate);
+					infoParam.setFormat(nomUnite);
+					infoParam.setType(nomParam);
+				} else {
+					infoParam.setFonction(Constantes.nomFonctionInsererVal);
+					// Nom des paramÃ©tres correspondant aux variables primaires
+					indiceParam = findIndiceParam(nomParam,lectureParametres,parametres);
+					infoParam.setIndiceParam(indiceParam);
+					if (indiceParam == -1) {
+						codeParam = "???";
+						EcritureLog.ecrire("\nErreur : le paramÃ©tre '"+nomParam+"' n'a pas Ã©tÃ© trouvÃ©","err");
+					} else {
+						codeParam = parametres.get(indiceParam).getParametreCode();
+						infoParam.setDelta(parametres.get(indiceParam).getDelta());
+						infoParam.setLod(parametres.get(indiceParam).getLod());
+					}
+					indiceCapt = findIndiceCapt(codeParam,indicesCaptInFile,capteurs);
+					infoParam.setIndiceCapt(indiceCapt);
+				}
+				infoParams.add(infoParam);
+			}
+//			System.out.println("\n\ndate="+DateTime.dateToString(dateDeb,"dd/MM/yyyy")+" to "+DateTime.dateToString(dateFin,"dd/MM/yyyy")+" since "+DateTime.dateToString(dateSince,"dd/MM/yyyy HH:mm:ss")+"\n");
+//			System.out.println("\n\nligne entete 1="+entete.get(0));
+//			System.out.println("ligne entete 2="+entete.get(1));
+//			System.out.println("ligne entete 3="+entete.get(2));
+//			System.out.println("ligne entete avder="+entete.get(entete.size()-2));
+//			System.out.println("ligne entete der="+entete.get(entete.size()-1));
+//			System.out.println("\nligne data 1="+mesures.get(0));
+//			System.out.println("ligne data 2="+mesures.get(1));
+//			System.out.println("ligne data 3="+mesures.get(2));
+//			System.out.println("ligne data avder="+mesures.get(mesures.size()-2));
+//			System.out.println("ligne data der="+mesures.get(mesures.size()-1)+"\n");
+		} catch (IOException e) {
+			System.out.println(e.getMessage()+ "\nErreur dans la lecture du fichier "+ fichier.getName() + " !");
+		}
+	}
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Principal.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Principal.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Principal.java	(revision 488)
@@ -0,0 +1,351 @@
+package com.medias.integration.principal;
+
+import com.medias.Chrono;
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.Fichier;
+import com.medias.database.objects.Jeu;
+import com.medias.database.objects.Localisation;
+import com.medias.database.objects.Mesure;
+import com.medias.database.objects.Parametre;
+import com.medias.database.objects.Personne;
+import com.medias.database.objects.Plateforme;
+import com.medias.database.objects.Valeur;
+import com.medias.integration.insertion.Insertion;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureModeleXML;
+import com.medias.integration.lecture_ecriture.LectureOrganismes;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LecturePlateformes;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.lecture_ecriture.LecturePersonnes;
+import com.medias.integration.prevalidation.PreValidation;
+import com.medias.integration.repartition.Repartition;
+import com.medias.integration.utils.CommunicationBD;
+import com.medias.integration.utils.Nombre;
+import com.medias.integration.utils.Statiques;
+import com.medias.integration.validation.Validation;
+import com.medias.integration.vues.MesureModele;
+import com.medias.integration.vues.ParametreModele;
+import com.medias.integration.vues.ValeurModele;
+import com.medias.integration.vues.PlateformeModele;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Properties;
+
+/**
+ * Created on 24 Jan. 2007
+ *
+ */
+
+/**
+ * @author *******************************************************************************************************************
+ *         Classe permettant de prevalider, valider, rÃ©partir et inserer un ensemble de fichier d'un jeu donnÃ©. 			 *
+ *         *******************************************************************************************************************
+ */
+
+public class Principal
+{
+    public static void main( String[] args )
+    {
+        // Argument 0 : LE NOM DE LA CATEGORIE
+        String nomCategorie = args[0];
+        // Argument 1 : LE NOM DU JEU
+        String nomJeu = args[1];
+        // Argument 2 : LE NUMERO DE VERSION
+        String numVersion = args[2];
+
+        /**
+         * Lancement du chronomÃ©tre
+         */
+        Chrono chrono = new Chrono();
+        chrono.start();
+        // Attribution des constantes
+//		String fichierProp = new File("megapoli.properties").getAbsolutePath();
+        String emplacementProp = Principal.class.getResource( "" ).getPath();
+        emplacementProp = emplacementProp.substring( 0, emplacementProp.lastIndexOf( "/" ) ) + "/../../../";
+        String fichierProp = emplacementProp + "megapoli.properties";
+        Properties prop = new Properties();
+        try
+        {
+            prop.load( new FileInputStream( fichierProp ) );
+        }
+        catch( FileNotFoundException e )
+        {
+            e.printStackTrace();
+        }
+        catch( IOException e )
+        {
+            e.printStackTrace();
+        }
+        Constantes.cheminFichierSortie = prop.getProperty( "data.output" );
+        Constantes.cheminDonnees = prop.getProperty( "data.upload" );
+        Constantes.cheminListes = prop.getProperty( "data.metadata" );
+        Constantes.cheminModeles = prop.getProperty( "data.model" );
+        Constantes.cheminDonneesSortie = prop.getProperty( "data.download" );
+        // Fichier de log
+        EcritureLog.init( nomJeu, nomCategorie );
+        // ***********************************************
+        // ************ On recherche les fichiers du jeu *
+        // ***********************************************
+        String cheminJeu = Constantes.cheminDonnees + "/" + nomCategorie + "/" + nomJeu + "/";
+        String cheminJeuSortie = Constantes.cheminDonneesSortie + "/" + nomCategorie + "/" + nomJeu + "/";
+        //	On rÃ©cupÃ©re tous les fichiers du rÃ©pertoire
+        File fileCourant = new File( cheminJeu );
+        // CrÃ©ation du rÃ©pertoire de sortie
+        File fileDest = new File( cheminJeuSortie );
+        if( !fileDest.exists() ) fileDest.mkdir();
+        String[] listeFics = fileCourant.list();
+        ArrayList<String> listeFichiers = new ArrayList<String>();
+        // On enlÃ©ve de la liste les fichiers inutiles
+        for( String fic : listeFics )
+        {
+            if( !fic.endsWith( ".xml" ) && !fic.endsWith( ".svn" ) )
+            {
+                listeFichiers.add( fic );
+            }
+        }
+        //	S'il y a au moins un fichier dans le jeu
+        if( listeFichiers.size() != 0 )
+        {
+            Chrono chronoMeta = new Chrono();
+            chronoMeta.start();
+            //	Trier les fichiers par ordre alphabÃ©tique
+            Collections.sort( listeFichiers );
+            //	Etape 1 : On lit le modÃ©le XML du jeu
+            LectureModeleXML lectureModeleXML = new LectureModeleXML( nomCategorie, nomJeu );
+            lectureModeleXML.lireModele();
+            //	Etape 2 : On lit les listes EXCEL de capteurs, paramÃ©tres, plateformes, ...
+            LectureUnites lectureUnites = new LectureUnites();
+            lectureUnites.lireFichier();
+            LectureParametres lectureParametres = new LectureParametres();
+            lectureParametres.lireFichier();
+            LectureCapteurs lectureCapteurs = new LectureCapteurs();
+            lectureCapteurs.lireFichier();
+            LecturePlateformes lecturePlateformes = new LecturePlateformes();
+            lecturePlateformes.lireFichier();
+            LectureOrganismes lectureOrganismes = new LectureOrganismes();
+            lectureOrganismes.lireFichier();
+            LecturePersonnes lecturePersonnes = new LecturePersonnes();
+            lecturePersonnes.lireFichier();
+
+            //	Etape 3 : RÃ©partition des mÃ©tadonnÃ©es du jeu
+            Repartition repartition = new Repartition( lectureModeleXML, lectureCapteurs,
+                    lecturePlateformes, lectureParametres, lecturePersonnes, lectureUnites, lectureOrganismes );
+            ArrayList<Personne> personnes = repartition.repartirPersonnes();
+            Jeu jeu = repartition.repartirJeu( personnes, numVersion );
+            Statiques.plateformesModele = new ArrayList<PlateformeModele>();
+            ArrayList<Parametre> parametres = repartition.repartirParametres();
+            ArrayList<Capteur> capteurs = repartition.repartirCapteurs( parametres );
+            ArrayList<Plateforme> plateformes = repartition.repartirPlateformes( jeu.getOrganisme().getAdresse().getAdressePays(), capteurs, parametres );
+
+            //	Etape 4 : Insertion des mÃ©tadonnÃ©es du jeu
+            Insertion insertion = new Insertion();
+            try
+            {
+                synchronized( Principal.class )
+                {
+                    //	Insertion des personnes (PI, contact, intÃ©grateur)
+                    insertion.insererPersonne( jeu.getPersonneByIntegrateurId() );
+                    insertion.insererPersonne( jeu.getPersonneByContactId() );
+                    // on teste si le pi n est pas null : on l'insere
+                    if( jeu.getPersonneByPiId() != null )
+                        insertion.insererPersonne( jeu.getPersonneByPiId() );
+                    //	Insertion du jeu
+                    insertion.insererJeu( jeu );
+                    // Insertion des parametres
+                    for( Parametre parametre : parametres )
+                        insertion.insererParametre( parametre );
+                    //	Insertion des capteurs
+                    for( Capteur capteur : capteurs )
+                        insertion.insererCapteur( capteur, parametres );
+                    //	Insertion des plateformes
+                    for( Plateforme plateforme : plateformes )
+                        insertion.insererPlateforme( plateforme, capteurs, parametres );
+                    //	On ouvre la connexion
+                    CommunicationBD.open();
+                    //	Mise Ã© jour des liaisons capteurs/jeu
+                    insertion.mettreAJourRequeteCaptJeu( jeu, capteurs );
+                    //	Mise Ã© jour des liaisons parametres/jeu
+                    insertion.mettreAJourRequeteParamJeu( jeu, parametres );
+                    //	Mise Ã© jour des liaisons plateformes/jeu
+                    insertion.mettreAJourRequetePlatJeu( jeu, plateformes );
+                    //	Mise Ã© jour des liaisons paramÃ©tres/capteurs
+                    insertion.mettreAJourRequeteParamCapt( capteurs, parametres );
+                    //	Mise Ã© jour des liaisons capteurs/plateformes et paramÃ©tres/plateformes
+                    insertion.mettreAJourRequeteCaptPlatParam( plateformes, capteurs, parametres );
+                    //	Insertion de la table bilan
+                    insertion.insererBilan( jeu, plateformes, capteurs, parametres );
+                    //	On ferme la connexion
+                    CommunicationBD.close();
+                    chronoMeta.stop();
+                    chronoMeta.afficheChrono( "METADONNEES" );
+
+                    // Etape 5 : Traitement des fichiers de donnÃ©es
+                    /*****************************************************************************************************
+                     * On parcourt les fichiers du jeu																	 *
+                     ******************************************************************************************************
+                     */
+                    //	Initialisations
+                    //	Initialialisation des :  altitude,latitude, longitude et hauteur sol. On convertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
+                    //	altitude du jeu
+                    Statiques.altMaxJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.altitudeMoinsInf ) );
+                    Statiques.altMinJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.altitudePlusInf ) );
+                    //	latitude du jeu
+                    Statiques.latMaxJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.latitudeMoinsInf ) );
+                    Statiques.latMinJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.latitudePlusInf ) );
+                    //	longitude du jeu
+                    Statiques.lonMaxJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.longitudeMoinsInf ) );
+                    Statiques.lonMinJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.longitudePlusInf ) );
+                    //	hauteur sol du jeu
+                    Statiques.hsMaxJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.hsMoinsInf ) );
+                    Statiques.hsMinJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.hsPlusInf ) );
+                    // Dates
+                    Statiques.dateMinJeu = DateTime.stringToDate( Constantes.datePlusInf, Constantes.formatDateJJMMAAAAHHMMSS );
+                    Statiques.dateMaxJeu = DateTime.stringToDate( Constantes.dateMoinsInf, Constantes.formatDateJJMMAAAAHHMMSS );
+
+                    ArrayList<ArrayList<String>> listeDonnees;
+                    PreValidation preValidation;
+                    Validation validation;
+                    String cheminFichier, cheminFichierSortie;
+                    Chrono chronoFichier;
+                    Fichier fichier;
+                    MesureModele mesureModele;
+                    Mesure mesure;
+                    ArrayList<Localisation> listeLocs = new ArrayList<Localisation>();
+                    ArrayList<ParametreModele> paramsMesure, paramsValeur;
+                    ParametreModele parametreModele;
+                    Parametre parametre;
+                    Capteur capteur;
+                    ArrayList<ValeurModele> valeursMesure;
+                    ValeurModele valeurModele;
+                    Valeur valeur;
+                    int nbMesures = 0, nbValeurs = 0, nbErreurs = 0, numFichier = 0;
+                    int nbFichiers = listeFichiers.size();// - 1; // On enlÃ©ve le fichier de mÃ©tadonnÃ©es xml
+                    // Pour chaque fichier de donnÃ©es...
+                    for( int numFic = 0; numFic < nbFichiers; numFic++ )
+                    {
+                        cheminFichier = cheminJeu + listeFichiers.get( numFic );
+                        fileCourant = new File( cheminFichier );
+                        //	Si le fichier existe et n'est pas vide
+                        if( fileCourant.exists() && !cheminFichier.endsWith( "metadata.xml" ) && !cheminFichier.endsWith( ".svn" ) )
+                        {
+                            numFichier++;
+                            chronoFichier = new Chrono();
+                            chronoFichier.start();
+                            EcritureLog.ecrire( "\n- [" + numFichier + "/" + nbFichiers + "] Fichier " + fileCourant.getName(), "out-ln" );
+                            //	Etape 6 : prÃ©validation : On prÃ©valide le fichier
+                            preValidation = new PreValidation( fileCourant );
+                            preValidation.prevalider( lectureParametres, lectureUnites, lectureCapteurs, parametres, capteurs, nomJeu );
+                            EcritureLog.ecrire( " -> PrÃ©validation OK", "out-ln" );
+                            //	Etape 7 : validation : On valide le fichier
+                            validation = new Validation( preValidation );
+                            listeDonnees = validation.valider( lectureModeleXML, fileCourant.getName() );
+                            preValidation.vider();
+                            validation.vider();
+
+                            int nbErreursValidation = validation.getNbErreursTotales();
+                            nbErreurs += nbErreursValidation;
+                            if( nbErreursValidation == 0 )
+                            {
+                                EcritureLog.ecrire( " -> Validation OK", "out-ln" );
+                                //	Etape 8 : rÃ©partition du fichier
+                                fichier = repartition.repartirFichier( jeu, fileCourant );
+                                //	On ouvre la connexion
+                                CommunicationBD.open();
+                                // Etape 9 : insertion du fichier
+                                insertion.insererFichier( fichier );
+                                nbMesures += listeDonnees.size();
+                                paramsMesure = validation.getListeParams();
+                                //	Pour chaque mesure...
+                                for( ArrayList<String> donneesMesure : listeDonnees )
+                                {
+                                    //	Etape 10 : Rangement des donnÃ©es sur la ligne et rÃ©partition des sÃ©quences
+                                    mesureModele = repartition.repartirDonnees( donneesMesure, paramsMesure );//,numSeqPrecedent,parametresModele,indiceNiv);
+                                    paramsValeur = mesureModele.getParamsValeur();
+                                    //	Etape 11 : repartition de la mesure
+                                    mesure = repartition.repartirMesure( mesureModele, fichier, plateformes );
+                                    //	Etape 12 : Insertion de la mesure
+                                    insertion.insererMesure( mesure, listeLocs );//,flagLocId);
+                                    valeursMesure = mesureModele.getValeursMesure();
+                                    //	Pour chaque valeur...
+                                    for( int numValeur = 0; numValeur < valeursMesure.size(); numValeur++ )
+                                    {
+                                        valeurModele = valeursMesure.get( numValeur );
+                                        // On rÃ©cupÃ©re les infos du paramÃ©tre associÃ© Ã© la valeur
+                                        parametreModele = paramsValeur.get( numValeur );
+                                        parametre = parametres.get( parametreModele.getIndiceParam() );
+                                        capteur = capteurs.get( parametreModele.getIndiceCapt() );
+                                        //	Etape 13 : repartition de la valeur
+                                        valeur = repartition.repartirValeur( mesure, valeurModele, parametreModele, parametre, capteur );
+
+                                        //	Etape 14 : insertion de la valeur
+                                        if( valeur != null )
+                                        {
+                                            insertion.insererValeur( valeur );//,flagValidId);
+                                            nbValeurs++;
+                                        }
+                                    }
+//							}
+                                }
+                                //	On ferme la connexion
+                                CommunicationBD.close();
+                                EcritureLog.ecrire( " -> Insertion OK", "out-ln" );
+                                // Le fichier est validÃ© et ses donnÃ©es sont insÃ©rÃ©es: on dÃ©place le fichier dans le rÃ©pertoire "download"
+                                cheminFichierSortie = cheminJeuSortie + listeFichiers.get( numFic );
+                                fileDest = new File( cheminFichierSortie );
+                                if( !fileDest.exists() )
+                                {
+                                    fileCourant.renameTo( fileDest );
+                                }
+                            }
+                            chronoFichier.stop();
+                            chronoFichier.afficheChrono( " -> FICHIER" );
+                        }
+                        else if( !cheminFichier.endsWith( "metadata.xml" ) && !cheminFichier.endsWith( ".svn" ) )
+                        {
+                            EcritureLog.ecrire( "- Fichier " + fileCourant.getName() + " non trouvÃ© !", "err" );
+                        }
+                    }
+                    if( nbErreurs != 0 )
+                    {
+                        EcritureLog.ecrire( "\n-> Il y a au total " + nbErreurs + " erreur(s) dans les fichiers du jeu " + nomJeu + "\n", "err" );
+                    }
+                    Chrono chronoFin = new Chrono();
+                    chronoFin.start();
+                    //	On ouvre la connexion
+                    CommunicationBD.open();
+                    //	Mise Ã© jour du jeu
+                    insertion.mettreAjourJeu( jeu );
+                    //	Mise Ã© jour des infos sur la quantitÃ© de donnÃ©es insÃ©rÃ©e
+                    insertion.mettreAJourRequeteNbValsJeu( jeu, nbFichiers, nbMesures, nbValeurs );
+                    //	Mise Ã© jour du bilan
+                    insertion.mettreAJourBilan( jeu );
+                    //	On ferme la connexion
+                    CommunicationBD.close();
+                    //	Fin du chrono
+                    chronoFin.stop();
+                    chronoFin.afficheChrono( "FINALISATION" );
+                }// Fin synchronized
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+        else
+        {
+            EcritureLog.ecrire( "Pas de fichiers Ã© valider dans le jeu " + nomJeu, "err" );
+        }
+        /** ArrÃ©t du chronomÃ©tre */
+        chrono.stop();
+        chrono.afficheChrono( "TOTAL" );
+    }
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Test.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Test.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Test.java	(revision 488)
@@ -0,0 +1,1751 @@
+//TODO
+package com.medias.integration.principal;
+
+import com.medias.Chrono;
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.integration.insertion.Insertion;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureOrganismes;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LecturePersonnes;
+import com.medias.integration.lecture_ecriture.LecturePlateformes;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.lecture_ecriture.LectureModeleXML;
+import com.medias.integration.prevalidation.PreValidation;
+import com.medias.integration.repartition.Repartition;
+import com.medias.integration.utils.Nombre;
+import com.medias.integration.utils.Statiques;
+import com.medias.integration.validation.Validation;
+import com.medias.integration.vues.ParametreModele;
+import com.medias.integration.vues.SequenceModele;
+import com.medias.integration.vues.MesureModele;
+import com.medias.integration.vues.PlateformeModele;
+import com.medias.integration.vues.ValeurModele;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+
+/**
+ * Created on 24 Jan. 2007
+ * 
+ */
+
+/**
+ * 
+ * @author
+ * 
+ * *******************************************************************************************************************
+ * Classe permettant de prevalider, valider, rÃ©partir et inserer un ensemble de fichier d'un jeu donnÃ©. 			 *
+ * *******************************************************************************************************************
+ */
+
+public class Test {
+	/**
+	 * LibÃ©rer la mÃ©moire aprÃ©s la repartition d'un fichier donnÃ©.
+	 *
+	 */
+	/**---private static void viderRepartition(ArrayList<ArrayList<String>> listeDonnees) {
+		listeDonnees = null;
+	}*/
+
+	/**
+	 * LibÃ©rer la mÃ©moire aprÃ©s la validation d'un fichier donnÃ©.
+	 * 
+	 */
+	private static void viderValidation(Validation validation,
+			ArrayList<String> listeMesures) {
+		validation = null;
+		listeMesures = null;
+	}
+	
+	/**
+	 * LibÃ©rer la mÃ©moire aprÃ©s la prÃ©validation d'un fichier donnÃ©.
+	 * 
+	 */
+	private static void viderPrevalidation(PreValidation preValidation,
+			File fichier) {
+		preValidation = null;
+		fichier = null;
+	}
+
+	public static void main(String[] args) {
+		// Argument 0 : LE NOM DE LA CATEGORIE
+		String nomCategorie = args[0];
+		// Argument 1 : LE NOM DU JEU
+		String nomJeu = args[1];
+
+		/**
+		 * Lancement du chronomÃ©tre
+		 * 
+		*/ 
+		
+		Chrono chrono = new Chrono();
+		Chrono chronoFichier;
+		Chrono chronoMeta;
+		Chrono chronoFin;
+		chrono.start();
+		// Fichier de log
+		EcritureLog.init(nomJeu, nomCategorie);
+		// ************ On recherche les fichiers du jeu
+		// ************************
+		String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/" + nomJeu
+				+ "/";
+		String cheminFichier;
+		PreValidation preValidation;
+		Validation validation;
+		ArrayList<String> listeMesures = null;
+		ArrayList<ArrayList<String>> listeDonnees = null;
+		int nbErreursValidation;
+//		Fichier fichier;
+		MesureModele mesureModele;
+//		ValeurModele valeurModele = null;
+//		Valeur valeur = null;
+		ArrayList<ValeurModele> valeursMesure = null;
+		ArrayList<String> donneesMesure = null;
+//		Mesure mesure = null;
+//		String numSeqPrecedent = null;
+		//Bilan bilan = null;
+//		int flagLocId;
+		//int flagValId;
+//		int flagValidId;
+		// On rÃ©cupÃ©re tous les fichiers du rÃ©pertoire
+		File fileCourant = new File(cheminJeu);
+		String[] listeFichiers = fileCourant.list();
+		// S'il y a au moins un fichier dans le jeu
+		if (listeFichiers.length != 0) {
+			chronoMeta = new Chrono();
+			chronoMeta.start();
+			// Trier les fichiers par ordre alphabÃ©tique
+			Arrays.sort(listeFichiers);
+			// Etape 3 : On lit le modÃ©le XML du jeu
+			LectureModeleXML lectureModeleXML = new LectureModeleXML(nomCategorie,nomJeu);
+			lectureModeleXML.lireModele();
+			ArrayList<ParametreModele> parametresModele = lectureModeleXML.getParametres();
+//			ArrayList<ParametreModele> parametresValeur = lectureModeleXML.getParametresValeur();
+			// Etape 4 : On lit les listes EXCEL de capteurs, paramÃ©tres, plateformes, ...
+			LectureCapteurs lectureCapteurs = new LectureCapteurs();
+			lectureCapteurs.lireFichier();
+			LecturePlateformes lecturePlateformes = new LecturePlateformes();
+			lecturePlateformes.lireFichier();
+			LectureParametres lectureParametres = new LectureParametres();
+			lectureParametres.lireFichier();
+			LecturePersonnes lecturePersonnes = new LecturePersonnes();
+			lecturePersonnes.lireFichier();
+			LectureUnites lectureUnites = new LectureUnites();
+			lectureUnites.lireFichier();
+//			ArrayList<String> codesUnite = lectureUnites.getCodesUni();
+			LectureOrganismes lectureOrganismes = new LectureOrganismes();
+			lectureOrganismes.lireFichier();			
+			// Etape 5 : RÃ©partition des mÃ©tadonnÃ©es du jeu
+			Statiques.plateformesModele = new ArrayList<PlateformeModele>();
+			Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs, lecturePlateformes, lectureParametres, lecturePersonnes, lectureUnites,lectureOrganismes);
+//			ArrayList<Personne> personnes = repartition.repartirPersonnes();
+//			Jeu jeu = repartition.repartirJeu(personnes);
+//			ArrayList<Parametre> parametres = repartition.repartirParametres(jeu);
+//			ArrayList<Capteur> capteurs = repartition.repartirCapteurs(parametres);
+//			ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
+			// Etape 10 : Insertion des mÃ©tadonnÃ©es du jeu
+			/**---
+			 * 
+			 * */
+//			--------
+			Insertion insertion = new Insertion();
+			try {
+				synchronized ( Principal.class) {
+//					
+//				// On ouvre la connexion
+//					//------------
+					//--------
+//					CommunicationBD.open();
+//				//System.out.println("---ouvert----");
+//				// insertion du jeu
+//				//------
+//				////--------
+//					insertion.insererJeu(jeu);
+//				//System.out.println("----"+jeu);
+//				// Insertion des parametres
+//				
+//				/**--*/
+//				/*
+//				 * 
+//				 */
+//					Parametre parametre ;
+/**				for(int numParam = 0; numParam < parametres.size(); numParam++){
+					parametre = parametres.get(numParam);
+//					//--------
+					insertion.insererParametre(parametre);
+//					System.out.println("par="+parametre.getParametreNom());
+				}*/
+//				
+//				// Insertion des capteurs
+//			Capteur capteur = null;
+/**				for(int numCapt = 0; numCapt < capteurs.size(); numCapt++){
+					capteur = capteurs.get(numCapt);
+					//--------
+					insertion.insererCapteur(capteur,parametres);
+//	
+//					
+				}*/
+//				
+//				// Insertion des plateformes
+//				/**
+//				 * 
+//				 */
+/**				Plateforme plateforme = null;
+				for(int numPlat = 0; numPlat < plateformes.size(); numPlat++){
+					plateforme = plateformes.get(numPlat);
+//					
+					////--------
+					insertion.insererPlateforme(plateforme,capteurs);
+//					
+//					//--System.out.println("PLAT="+plateforme.getPlateformeNom());
+				}/**/
+//				// On ferme la connexion
+//				////--------
+//				CommunicationBD.close();
+				
+				chronoMeta.stop();
+				chronoMeta.afficheChrono("METADONNEES");
+				
+//				/*****************************************************************************************************
+//				* On parcourt les fichiers du jeu																	 *
+//				******************************************************************************************************
+//				*/
+//				// Initialisations
+				/*****************************/
+				
+				Statiques.sequencesModeles = new ArrayList<SequenceModele>();
+
+				Statiques.dateMinJeu = DateTime.stringToDate( Constantes.datePlusInf, Constantes.formatDateJJMMAAAAHHMMSS );
+				Statiques.dateMaxJeu = DateTime.stringToDate(Constantes.dateMoinsInf,Constantes.formatDateJJMMAAAAHHMMSS);
+				// Initialialisation des :  altitude,latitude, longitude et hauteur sol. 
+				// On onvertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
+				// altitude du jeu
+				Statiques.altMaxJeu = Nombre.altDoubleToInt(Double.valueOf(Constantes.altitudeMoinsInf));
+				Statiques.altMinJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.altitudePlusInf ) );
+				// latitude du jeu
+				Statiques.latMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudeMoinsInf));
+				Statiques.latMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudePlusInf));
+				// longitude du jeu
+				Statiques.lonMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudeMoinsInf));
+				Statiques.lonMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudePlusInf));
+				// hauteur sol du jeu
+				Statiques.hsMaxJeu =  Nombre.altDoubleToInt(Double.valueOf(Constantes.hsMoinsInf));
+				Statiques.hsMinJeu = Nombre.altDoubleToInt(Double.valueOf(Constantes.hsPlusInf));
+		
+				int nbFichiers = 0;
+//				int nbMesures = 0;
+//				int nbValeurs = 0;
+				int indiceNiv = -1;
+//				int nbNiv;
+//				int indiceParam = 0;
+//				int cptNiv, cptParam;
+				nbFichiers = listeFichiers.length;
+				for (int numFic = 0; numFic < nbFichiers; numFic++) {
+					chronoFichier = new Chrono();
+					chronoFichier.start();
+					cheminFichier = cheminJeu + listeFichiers[numFic];
+					fileCourant = new File(cheminFichier);
+					// Si le fichier existe et n'est pas vide
+					if (fileCourant.exists()) {
+						EcritureLog.ecrire("Fichier " + fileCourant.getName(), "out-ln");
+						// Etape 1 : prÃ©validation : On prÃ©valide le fichier
+						preValidation = new PreValidation(fileCourant);
+						preValidation.prevalider(null,null,null,null,null,nomJeu);
+						viderPrevalidation(preValidation, fileCourant);
+						EcritureLog.ecrire( "  -> PrÃ©validation OK", "out-ln" );
+						//System.out.println("\n");
+						//for(int numListM = /*listeMesures.size()-2*/0; numListM < /*listeMesures.size()*/2; numListM++){
+							//System.out.println(listeMesures.get(numListM));
+						//}
+						// Etape 2 : validation : On valide le fichier
+
+						
+						//-----------traitement de la validation 
+						validation = new Validation(preValidation);
+							listeDonnees = validation.valider(lectureModeleXML,fileCourant.getName());
+							indiceNiv = validation.getIndiceNiv();
+							nbErreursValidation = validation
+									.getNbErreursTotales();
+							viderValidation(validation, listeMesures);
+							if (nbErreursValidation == 0) {
+								EcritureLog.ecrire("  -> Validation OK",
+										"out-ln");
+								System.out.println("\n");
+							}
+
+							
+							  /**ArrayList<String> donnees; for(int numListD = 0;
+							  *numListD < listeDonnees.size(); numListD++){ donnees =
+							  *listeDonnees.get(numListD); for(int numDonnee =
+							  *0; numDonnee < /*donnees.size()*///37; numDonnee++){
+							  /*System.out.print(" *** "+donnees.get(numDonnee)); }
+							  *System.out.println(); }*/
+							 
+							// traitement de la repartion
+							// Etape 5 : rÃ©partition du fichier
+//							fichier = repartition.repartirFichier(jeu,fileCourant);
+							//System.out.println("***********"+fileCourant);
+							// On ouvre la connexion
+							////--------
+//							CommunicationBD.open();
+							// Etape 10 : insertion du fichier
+							//--------
+//							insertion.insererFichier(fichier);
+//
+							// Pour chaque mesure...
+							// /***
+//							nbMesures += listeDonnees.size();
+							for (int numMesure = 0; numMesure < 2/*listeDonnees
+									.size()*/; numMesure++) {
+//								////--------
+//								//flagLocId = insertion.getFlagLocId();
+								donneesMesure = listeDonnees.get(numMesure);
+								
+								// Etape 6 : Rangement des donnÃ©es sur la ligne
+								// et rÃ©partition des sÃ©quences
+								//mesureModele = repartition.repartirDonnees(donneesMesure, numSeqPrecedent,parametresModele, indiceNiv);
+								//
+								//numSeqPrecedent = mesureModele.getNumSequence();
+								//mesureModele = repartition.repartirDonnees(donneesMesure, numSeqPrecedent, parametresModele, indiceNiv);
+								mesureModele = repartition.repartirDonnees(donneesMesure,parametresModele);
+//								numSeqPrecedent = mesureModele.getNumSequence();
+								// Etape 7 : repartition de la mesure
+//								mesure = repartition.repartirMesure(mesureModele, fichier, plateformes);
+//System.out.println("mesure="+DateTime.dateToString(mesure.getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
+//System.out.println("mesure pos="+Nombre.altIntToFloat(mesure.getLocalisation().getLocalisationAlt()));
+								// Si le fichier n'existe pas encore, on insÃ©re
+								// les mesures et les valeurs
+								// --
+								if (!insertion.isFichierExiste()) {
+								// Etape 11 : Insertion de la mesure
+								////--------
+								//
+								//insertion.insererMesure(mesure, flagLocId);
+								valeursMesure = mesureModele.getValeursMesure();
+								// Pour chaque valeur...
+//								nbValeurs += valeursMesure.size();
+//								nbNiv = valeursMesure.size() / parametres.size();
+//								cptNiv = 0;
+//								cptParam = 0;
+								for (int numValeur = 0; numValeur < valeursMesure.size(); numValeur++) {
+//									////--------
+//									//flagValId = insertion.getFlagValId();
+//								//	flagValidId = insertion.getFlagValidId();
+//									valeurModele = valeursMesure.get(numValeur);
+									// Si pas subdivision
+									if (indiceNiv == -1) {
+//										indiceParam = numValeur;										
+									}
+//									}
+//									// Si subdivision
+									else {
+//										cptNiv++;
+									}
+//										// Cas oÃ© on arrive Ã© la derniÃ©re donnÃ©e du paramÃ©tre courant
+//										if (cptNiv > nbNiv) {
+//											cptParam++;
+//											cptNiv = 1;
+//										}
+//										indiceParam = cptParam;
+									}
+									// Etape 9 : repartition de la valeur
+//									valeur = repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),
+//										valeurModele, capteurs, parametres.get(indiceParam), parametres.get(indiceParam).getUnite()
+//											.getUniteCode(),parametresValeur.get(indiceParam),codesUnite);
+									// Etape 12 : insertion de la valeur
+									////--------
+									//System.out.println("------00-------");
+									//insertion.insererValeur(valeur, /*flagValId*/flagValidId);
+									//System.out.println("-------------");
+								}
+							}
+						}
+
+						// On ferme la connexion
+						////--------
+							//**
+					//		CommunicationBD.close();
+
+//						EcritureLog.ecrire("  -> RÃ©partition-Insertion OK","out");
+					} // ---*/
+					/** ---viderRepartition(listeDonnees);-- */
+//
+//					else { EcritureLog.ecrire("Fichier " +
+//					  fileCourant.getName()+ " non trouvÃ© !", "err");
+//					}
+//					 
+//					
+//					  chronoFichier.stop(); chronoFichier.afficheChrono(" -> FICHIER");
+//					 
+//					 }
+					chronoFin = new Chrono();
+					chronoFin.start();
+					// Etape 8 : rÃ©partition de la derniÃ©re sÃ©quence
+					////--------
+//					repartition.repartirDerniereSequence();
+					// Etape 13 : rÃ©partition et insertion des sÃ©quences
+//					SequenceModele sequenceModele;
+//					Sequence sequence;
+
+					// On ouvre la connexion
+					// ---
+	//				CommunicationBD.open();
+					for (int numSeq = 0; numSeq < Statiques.sequencesModeles
+							.size(); numSeq++) {
+//						sequenceModele = Statiques.sequencesModeles.get(numSeq);
+		//				sequence = repartition.repartirSequence(jeu,sequenceModele);
+						////--------
+		//				insertion.insererSequence(sequence);
+						// insertion.insererSequence(sequence, numSeq);
+						// Mettre Ã© jour les mesures
+						// Mise Ã© jour des mesures appartenant Ã© la sÃ©quence
+						// ---
+			//			insertion.mettreAjourMesure(sequence);
+					}
+					/**
+					 * ---EcritureLog.ecrire(" 0 Mesure : mise Ã© jour -> Ok",
+					 * "out"); EcritureLog.ecrire("SÃ©quences mises Ã© jour",
+					 * "out"); // Mettre Ã© jour le jeu
+					 * insertion.mettreAjourJeu(jeu); EcritureLog.ecrire(" 1 Jeu
+					 * mis Ã© jour : jeu -> OK", "out"); // Mettre Ã© jour les
+					 * tables requetes capteurs du jeu
+					 * insertion.mettreAJourRequeteCapteurJeu(jeu, capteurs);
+					 * EcritureLog.ecrire(" 2 Liaisons entre : jeu/capteurs ->
+					 * OK", "out"); // Mettre Ã© jour les les tables requetes des
+					 * parametres du jeu
+					 * insertion.mettreAJourRequeteParametreJeu(jeu,
+					 * parametres); EcritureLog.ecrire(" 3 Liaisons entre :
+					 * jeu/parametres -> OK", "out"); // Mettre Ã© jour les les
+					 * tables requetes des plateformes du jeu
+					 * insertion.mettreAJourRequetePlateformeJeu(jeu,
+					 * plateformes); EcritureLog.ecrire(" 4 Liaisons entre :
+					 * jeu/plateformes -> OK", "out"); // Mettre Ã© jour les les
+					 * tables requetes nbvals
+					 * insertion.mettreAJourRequeteNbValsJeu(jeu,nbFichiers,nbMesures,
+					 * nbValeurs); EcritureLog.ecrire(" 5 Liaisons entre :
+					 * jeu/nbFichiers/nbMesures/nbValeurs -> OK", "out"); //
+					 * Mettre Ã© jour les tables requetes des parametres des
+					 * plateformes
+					 * insertion.mettreAJourRequeteParametreCapteur(capteurs,
+					 * parametres); EcritureLog.ecrire(" 6 Liaisons entre :
+					 * capteurs/parametres -> OK", "out"); // Mettre Ã© jour les
+					 * tables requetes des plateformes des capteurs
+					 * insertion.mettreAJourRequeteCapteurPlateforme(plateformes,
+					 * capteurs); EcritureLog.ecrire(" 7 Liaisons entre :
+					 * plateformes/capteurs -> OK", "out"); // Mettre Ã© jour de
+					 * la liaison entre les plateformes et les parametres.
+					 * insertion.mettreAJourRequeteParametrePlateforme(plateformes,parametres);
+					 * EcritureLog.ecrire(" 8 Liaisons entre :
+					 * plateformes/paramÃ©tres -> OK", "out"); // Mise Ã© jour de
+					 * la liaison entre les plateformes et les localisations.
+					 * insertion.mettreAJourRequeteLocalisationsPlateforme(plateformes);
+					 * EcritureLog.ecrire(" 9 Liaisons localisations/plateformes ->
+					 * OK", "out"); CommunicationBD.close();
+					 * CommunicationBD.open(); // Insertion de la table bilan
+					 * insertion.insererBilan(jeu, plateformes, capteurs,
+					 * parametres); EcritureLog.ecrire(" 10 Insertion : bilan ->
+					 * Ok", "out"); // Mettre Ã© jour de la liaison entre le
+					 * bilan. insertion.mettreAJourBilan(jeu);
+					 * EcritureLog.ecrire(" 11 Bilan mis Ã© jour", "out"); // On
+					 * ferme la connexion CommunicationBD.close();
+					 * EcritureLog.ecrire(" 12 Insertion du jeu terminÃ©e",
+					 * "out");---
+					 */
+					// Fin du chrono
+					chronoFin.stop();
+					System.out.println("\n");
+					chronoFin.afficheChrono("FINAL");
+
+					/**************************** */
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		} else {
+			//EcritureLog.ecrire("Pas de fichiers Ã© valider dans le jeu "+ Constantes.nomJeuAMDAR, "err");
+			EcritureLog.ecrire("Pas de fichiers Ã© valider dans le jeu ", "err");
+		}
+		/**
+		 * ArrÃ©t du chronomÃ©tre
+		 * 
+		 */
+		chrono.stop();
+		chrono.afficheChrono("TOTAL");
+	}
+}
+
+/*************************************************************************************/
+///*
+// * Created on 30 Jan. 2007
+// */
+///**
+// * @author 
+// * 
+// * 
+// */
+//package integration.principal;
+//
+//import java.io.File;
+//// import java.math.BigDecimal;
+//import java.util.ArrayList;
+//import java.util.Arrays;
+//
+////import org.hibernate.type.IntegerType;
+//// import java.util.Iterator;
+//// import java.util.List;
+//
+//// import EDU.oswego.cs.dl.util.concurrent.FJTask.Seq;
+//
+//// import integration.hibernate.Adresse;
+//import integration.hibernate.Capteur;
+//// import integration.hibernate.Categorie;
+//// import integration.hibernate.Commentaire;
+//// import integration.hibernate.DeltaMesure;
+//import integration.hibernate.Fichier;
+//import integration.hibernate.Jeu;
+//// import integration.hibernate.Langue;
+//// import integration.hibernate.Localisation;
+//import integration.hibernate.Mesure;
+//import integration.hibernate.Parametre;
+//import integration.hibernate.Personne;
+//import integration.hibernate.Plateforme;
+//import integration.hibernate.Sequence;
+//import integration.hibernate.Valeur;
+//import integration.insertion.Insertion;
+//import integration.lecture_ecriture.EcritureLog;
+//import integration.lecture_ecriture.LectureCapteurs;
+//import integration.lecture_ecriture.LectureModeleXML;
+//import integration.lecture_ecriture.LectureOrganismes;
+//import integration.lecture_ecriture.LectureParametres;
+//import integration.lecture_ecriture.LecturePersonnes;
+//import integration.lecture_ecriture.LecturePlateformes;
+//import integration.lecture_ecriture.LectureUnites;
+//import integration.prevalidation.PreValidation;
+//import integration.repartition.Repartition;
+//import integration.utils.Chrono;
+//import integration.utils.CommunicationBD;
+//import integration.utils.Constantes;
+//import integration.utils.DateTime;
+//import integration.utils.Nombre;
+//// import integration.utils.DateTime;
+//// import integration.utils.Nombre;
+//import integration.utils.Statiques;
+//import integration.validation.Validation;
+//import integration.vues.MesureModele;
+//import integration.vues.ParametreModele;
+//import integration.vues.SequenceModele;
+//import integration.vues.ValeurModele;
+//
+//public class Test {
+//
+//	/**
+//	 * @param args
+//	 */
+//	// **********************************************************************************
+//	// ****************************TestCapteurs******************************************
+//	// **********************************************************************************
+//	// public static void main(String[] args) {
+//	// LectureCapteurs lectureCapteurs = new LectureCapteurs();
+//	// lectureCapteurs.lireFichier();
+//	// for (int num=0; num< Constantes.nbCapteurs; num++){
+//	// System.out.print(lectureCapteurs.getNumerosCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getModelesCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getEtalonnagesCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getNumsSeriesCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getTypesCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getDescriptionsCapt().get(num));
+//	// System.out.print(" * "+lectureCapteurs.getFabriquantsCapt().get(num));
+//	// System.out.print(" * ");
+//	// for (int num2=0;
+//	// num2<lectureCapteurs.getParametresCapt().get(num).size(); num2++){
+//	// System.out.print(" #
+//	// "+lectureCapteurs.getParametresCapt().get(num).get(num2));
+//	// }
+//	// System.out.println();
+//	// }
+//	//	
+//	// }
+//
+//	public static void main(String[] args) {
+//		// Argument 0 : LE NOM DE LA CATEGORIE
+//		String nomCategorie = args[0];
+//		// Argument 1 : LE NOM DU JEU
+//		String nomJeu = args[1];
+//		// ******************************Lancement du chronomÃ©tre
+//		// **********************************
+//		// Chrono chrono = new Chrono();
+//		// chrono.start();
+//		Chrono chrono = new Chrono();
+//		Chrono chronoFichier;
+//		Chrono chronoMeta;
+//		Chrono chronoFin;
+//		chrono.start();
+//		// Fichier de log
+//		EcritureLog.init(nomJeu, nomCategorie);
+//		// ************ On recherche les fichiers du jeu
+//		// ************************
+//		String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/"
+//				+ nomJeu + "/";
+//		/**
+//		 * boolean fichierExiste = false; String cheminFichier; PreValidation
+//		 * preValidation; Validation validation; ArrayList<String>
+//		 * listeMesures; ArrayList<ArrayList<String>> listeDonnees = null; int
+//		 * nbErreursValidation; Fichier fichier = new Fichier(); Localisation
+//		 * localisation = new Localisation(); MesureModele mesureModele;
+//		 * ValeurModele valeurModele = null; Valeur valeur = null; ArrayList<ValeurModele>
+//		 * valeursMesure = null; ArrayList<String> donneesMesure = null; Mesure
+//		 * mesure = null; String numSeqPrecedent = null; File fileCourant = new
+//		 * File(cheminJeu); String[] listeFichiers = fileCourant.list(); int
+//		 * flagLocId; int flagValId;
+//		 */
+//		String cheminFichier;
+//		PreValidation preValidation;
+//		Validation validation;
+//		ArrayList<String> listeMesures;
+//		ArrayList<ArrayList<String>> listeDonnees = null;
+//		int nbErreursValidation;
+//		Fichier fichier;
+//		MesureModele mesureModele;
+//		ValeurModele valeurModele = null;
+//		Valeur valeur = null;
+//		ArrayList<ValeurModele> valeursMesure = null;
+//		ArrayList<String> donneesMesure = null;
+//		Mesure mesure = null;
+//		String numSeqPrecedent = null;
+//		int flagLocId;
+//		int flagValId;
+//		// On rÃ©cupÃ©re tous les fichiers du rÃ©pertoire
+//		File fileCourant = new File(cheminJeu);
+//		String[] listeFichiers = fileCourant.list();
+//		// S'il y a au moins un fichier dans le jeu
+//		if (listeFichiers.length != 0) {
+//			chronoMeta = new Chrono();
+//			chronoMeta.start();
+//			// Trier les fichiers par ordre alphabÃ©tique
+//			Arrays.sort(listeFichiers);
+//			// Etape 3 : On lit le modÃ©le XML du jeu
+//			LectureModeleXML lectureModeleXML = new LectureModeleXML(
+//					nomCategorie, nomJeu);
+//			lectureModeleXML.lireModele();
+//			ArrayList<ParametreModele> parametresModele = lectureModeleXML
+//					.getParametres();
+//			ArrayList<ParametreModele> parametresValeur = lectureModeleXML
+//					.getParametresValeur();
+//			// Etape 4 : On lit les listes EXCEL de capteurs, paramÃ©tres,
+//			// plateformes, ...
+//			LectureCapteurs lectureCapteurs = new LectureCapteurs();
+//			lectureCapteurs.lireFichier();
+//			LecturePlateformes lecturePlateformes = new LecturePlateformes();
+//			lecturePlateformes.lireFichier();
+//			LectureParametres lectureParametres = new LectureParametres();
+//			lectureParametres.lireFichier();
+//			LecturePersonnes lecturePersonnes = new LecturePersonnes();
+//			lecturePersonnes.lireFichier();
+//			LectureUnites lectureUnites = new LectureUnites();
+//			lectureUnites.lireFichier();
+//			ArrayList<String> codesUnite = lectureUnites.getCodesUni();
+//			LectureOrganismes lectureOrganismes = new LectureOrganismes();
+//			lectureOrganismes.lireFichier();
+//
+//			// Etape 5 : RÃ©partition des mÃ©tadonnÃ©es du jeu
+//			Repartition repartition = new Repartition(lectureModeleXML,
+//					lectureCapteurs, lecturePlateformes, lectureParametres,
+//					lecturePersonnes, lectureUnites, lectureOrganismes);
+//			ArrayList<Personne> personnes = repartition.repartirPersonnes();
+//			Jeu jeu = repartition.repartirJeu(personnes);
+//			ArrayList<Parametre> parametres = repartition.repartirParametres();
+//			ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
+//			ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
+//					
+//
+//			// Etape 10 : Insertion des mÃ©tadonnÃ©es du jeu
+//			Insertion insertion = new Insertion();
+//			try {
+//				synchronized (Principal.class) {
+//					// On ouvre la connexion
+//					CommunicationBD.open();
+//					// On insÃ©re le jeu
+//					insertion.insererJeu(jeu);
+//					// CommunicationBD.close();
+//					// insertion des parametres
+//					// CommunicationBD.open();
+//					// insertion des parametres
+//					Parametre parametre;
+//					for (int numParam = 0; numParam < parametres.size(); numParam++) {
+//						parametre = parametres.get(numParam);
+//						insertion.insererParametre(parametre);
+//					}
+//					// insertion des capteurs
+//					Capteur capteur;
+//					for (int numCapt = 0; numCapt < capteurs.size(); numCapt++) {
+//						capteur = capteurs.get(numCapt);
+//			//			insertion.insererCapteur(capteur);
+//					}
+//					// insererPlateforme
+//					Plateforme plateforme;
+//					for (int numPlat = 0; numPlat < plateformes.size(); numPlat++) {
+//						plateforme = plateformes.get(numPlat);
+//			//			insertion.insererPlateforme(plateforme);
+//					}
+//					//On ferme la connexion
+//					CommunicationBD.close();
+//					chronoMeta.stop();
+//					System.out.println("TEST DEMARRÃ©");
+//					chronoMeta.afficheChrono("METADONNEES");
+//			
+//					// insertion fichier
+//					// **************************************************************************************************
+//					// On parcourt les fichiers du jeu
+//					// ****************************************************************************************************
+//					// Statiques.sequencesModeles = new
+//					// ArrayList<SequenceModele>();
+//					// for (int numFic = 0; numFic < 1/*listeFichiers.length*/;
+//					// numFic++) {
+//					/**
+//					 * cheminFichier = cheminJeu + listeFichiers[numFic];
+//					 * fileCourant = new File(cheminFichier); // Si le fichier
+//					 * existe et n'est pas vide if (fileCourant.exists()) {
+//					 * EcritureLog .ecrire("Fichier " + fileCourant.getName(),
+//					 * "out-ln"); // Etape 1 : prÃ©validation : On prÃ©valide le
+//					 * fichier preValidation = new PreValidation(nomJeu,
+//					 * fileCourant); listeMesures = preValidation.prevalider();
+//					 * viderPrevalidation(preValidation, fileCourant);
+//					 * EcritureLog.ecrire(" -> PrÃ©validation OK", "out-ln");
+//					 * //insertion // Etape 2 : validation : On valide le
+//					 * fichier validation = new Validation(listeMesures);
+//					 * listeDonnees = validation.valider(lectureModeleXML);
+//					 * nbErreursValidation = validation.getNbErreursTotales();
+//					 * viderValidation(validation, listeMesures); if
+//					 * (nbErreursValidation == 0) { EcritureLog.ecrire(" ->
+//					 * Validation OK", "out-ln"); // Etape 5 : rÃ©partition du
+//					 * fichier fichier =
+//					 * repartition.repartirFichier(jeu,fileCourant); //boolean
+//					 * fichierExiste = false; fichierExiste =
+//					 * insertion.insererFichier(fichier); //if (fichierExiste =
+//					 * false) { }
+//					 */
+//					// **************************************************************************************************
+//					// On parcourt les fichiers du jeu
+//					// ****************************************************************************************************
+//					// initialisations des dates.
+//					Statiques.sequencesModeles = new ArrayList<SequenceModele>();
+//					//les mettre ds constantes
+//					Statiques.dateMinJeu = DateTime.stringToDate(Constantes.datePlusInf,Constantes.formatDateJJMMAAAAHHMMSS);
+//					Statiques.dateMaxJeu = DateTime.stringToDate(Constantes.dateMoinsInf,Constantes.formatDateJJMMAAAAHHMMSS);
+//					// initialialisation des :  altitude,latitude, longitude et hauteur sol. 
+//					// On onvertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
+//					// altitude du jeu
+//					Statiques.altMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.altitudeMoinsInf));
+//					Statiques.altMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.altitudePlusInf));
+//					// latitude du jeu
+//					Statiques.latMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudeMoinsInf));
+//					Statiques.latMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.latitudePlusInf));
+//					// longitude du jeu
+//					Statiques.lonMaxJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudeMoinsInf));
+//					Statiques.lonMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.longitudePlusInf));
+//					// hauteur sol du jeu
+//					Statiques.hsMaxJeu =  Nombre.latDoubleToInt(Double.valueOf(Constantes.hsMoinsInf));
+//					Statiques.hsMinJeu = Nombre.latDoubleToInt(Double.valueOf(Constantes.hsPlusInf));
+//					for (int numFic = 0; numFic < listeFichiers.length; numFic++) {
+//						chronoFichier = new Chrono();
+//						chronoFichier.start();
+//						cheminFichier = cheminJeu + listeFichiers[numFic];
+//						fileCourant = new File(cheminFichier);
+//						// Si le fichier existe et n'est pas vide
+//						if (fileCourant.exists()) {
+//							EcritureLog.ecrire("Fichier "
+//									+ fileCourant.getName(), "out-ln");
+//							// Etape 1 : prÃ©validation : On prÃ©valide le fichier
+//							preValidation = new PreValidation(nomJeu,
+//									fileCourant);
+//							listeMesures = preValidation.prevalider();
+//							viderPrevalidation(preValidation, fileCourant);
+//							EcritureLog.ecrire("  -> PrÃ©validation OK",
+//									"out-ln");
+//							// Etape 2 : validation : On valide le fichier
+//							validation = new Validation(listeMesures);
+//							listeDonnees = validation.valider(lectureModeleXML);
+//							nbErreursValidation = validation
+//									.getNbErreursTotales();
+//							viderValidation(validation, listeMesures);
+//							if (nbErreursValidation == 0) {
+//								EcritureLog.ecrire("  -> Validation OK",
+//										"out-ln");
+//								// Etape 5 : rÃ©partition du fichier
+//								fichier = repartition.repartirFichier(jeu,
+//										fileCourant);
+//								// On ouvre la connexion
+//								CommunicationBD.open();
+//								// Etape 10 : insertion du fichier
+//								insertion.insererFichier(fichier);
+//								// for (int numMesure = 0; numMesure <
+//								// listeDonnees.size(); numMesure++) {
+//								//								
+//								// donneesMesure = listeDonnees.get(numMesure);
+//								// mesureModele =
+//								// repartition.repartirDonnees(donneesMesure,
+//								// numSeqPrecedent,parametresModele);
+//								// numSeqPrecedent =
+//								// mesureModele.getNumSequence();
+//								// mesure =
+//								// repartition.repartirMesure(mesureModele,
+//								// fichier, plateformes);
+//								//								
+//								// if (!fichierExiste) {
+//								// // Insertion de la mesure
+//								// insertion.insererMesure(mesure);
+//								//								
+//								// valeursMesure =
+//								// mesureModele.getValeursMesure();
+//								// // Pour chaque valeur...
+//								// for(int numValeur = 0; numValeur <
+//								// valeursMesure.size() ; numValeur++){
+//								// valeurModele = valeursMesure.get(numValeur);
+//								// // Etape 9 : repartition de la valeur
+//								// valeur =
+//								// repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),valeurModele,capteurs,parametres.get(numValeur),parametresValeur.get(numValeur),codesUnite);
+//								// // insertion de la valeur
+//								// insertion.insererValeur(valeur);
+//								//										
+//								// }
+//								// Pour chaque mesure...
+//								for (int numMesure = 0; numMesure < listeDonnees
+//										.size(); numMesure++) {
+//									flagLocId = insertion.getFlagLocId();
+//									donneesMesure = listeDonnees.get(numMesure);
+//									// Etape 6 : Rangement des donnÃ©es sur la
+//									// ligne et rÃ©partition des sÃ©quences
+//									mesureModele = repartition.repartirDonnees(
+//											donneesMesure, numSeqPrecedent,
+//											parametresModele);
+//									numSeqPrecedent = mesureModele
+//											.getNumSequence();
+//									// Etape 7 : repartition de la mesure
+//									mesure = repartition.repartirMesure(
+//											mesureModele, fichier, plateformes);
+//									// Si le fichier n'existe pas encore, on
+//									// insÃ©re les mesures et les valeurs
+//									if (!insertion.isFichierExiste()) {
+//										// Etape 11 : Insertion de la mesure
+//										insertion.insererMesure(mesure,
+//												flagLocId);
+//										valeursMesure = mesureModele
+//												.getValeursMesure();
+//										// Pour chaque valeur...
+//										for (int numValeur = 0; numValeur < valeursMesure
+//												.size(); numValeur++) {
+//											flagValId = insertion
+//													.getFlagValId();
+//											valeurModele = valeursMesure
+//													.get(numValeur);
+//											// Etape 9 : repartition de la
+//											// valeur
+//											valeur = repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),
+//															valeurModele,capteurs,parametres.get(numValeur),
+//															parametres.get(numValeur).getUnite().getUniteCode(),
+//															parametresValeur.get(numValeur),codesUnite);
+//											// Etape 12 : insertion de la valeur
+//											insertion.insererValeur(valeur,flagValId);
+//										}
+//									}
+//
+//									// valeursMesure =
+//									// mesureModele.getValeursMesure();
+//									// insertion.insererLoc(localisation);
+//
+//								}
+//
+//								// On ferme la connexion
+//								CommunicationBD.close();
+//
+//								EcritureLog.ecrire(
+//										"  -> RÃ©partition-Insertion OK",
+//										"out-ln");
+//							}
+//							viderRepartition(listeDonnees);
+//						} else {
+//							EcritureLog.ecrire("Fichier "
+//									+ fileCourant.getName() + " non trouvÃ© !",
+//									"err");
+//						}
+//						chronoFichier.stop();
+//						chronoFichier.afficheChrono("  -> FICHIER");
+//					}
+//					chronoFin = new Chrono();
+//					chronoFin.start();
+//					// Etape 8 : rÃ©partition de la derniÃ©re sÃ©quence
+//					repartition.repartirDerniereSequence();
+//					// Etape 13 : rÃ©partition et insertion des sÃ©quences
+//					SequenceModele sequenceModele;
+//					Sequence sequence;
+//					// On ouvre la connexion
+//					CommunicationBD.open();
+//					//int nbMesures;
+//					for (int numSeq = 0; numSeq < Statiques.sequencesModeles
+//							.size(); numSeq++) {
+//						sequenceModele = Statiques.sequencesModeles.get(numSeq);
+//						sequence = repartition.repartirSequence(jeu,
+//								sequenceModele);
+//						 insertion.insererSequence(sequence);
+//						// Mise Ã© jour des mesures appartenant Ã© la sÃ©quence
+//						 insertion.mettreAjourMesure(sequence);
+//					}
+//					// Mettre Ã© jour le jeu
+//					insertion.mettreAjourJeu(jeu);
+//					// Mettre Ã© jour les tables requetes
+//					// insertion.mettreAjourRequete();
+//					// Mettre Ã© jour la table bilan
+//                    /**insertion.insererBilan();*/
+//					// On ferme la connexion
+//					CommunicationBD.close();
+//					chronoFin.stop();
+//					chronoFin.afficheChrono("FINAL");
+//
+//				}
+//			} catch (Exception e) {
+//				e.printStackTrace();
+//			}
+//
+//		} else {
+//			EcritureLog.ecrire("Pas de fichiers Ã© valider dans le jeu "
+//					+ Constantes.nomJeuAMDAR, "err");
+//		}
+//		// ******************************ArrÃ©t du chronomÃ©tre
+//		chrono.stop();
+//		chrono.afficheChrono("TOTAL");
+//	}
+//
+//	/**
+//	 * LibÃ©rer la mÃ©moire aprÃ©s la repartition d'un fichier donnÃ©.
+//	 * 
+//	 */
+//	private static void viderRepartition(
+//			ArrayList<ArrayList<String>> listeDonnees) {
+//		listeDonnees = null;
+//	}
+//
+//	/**
+//	 * LibÃ©rer la mÃ©moire aprÃ©s la validation d'un fichier donnÃ©.
+//	 * 
+//	 */
+//	private static void viderValidation(Validation validation,
+//			ArrayList<String> listeMesures) {
+//		validation = null;
+//		listeMesures = null;
+//	}
+//
+//	/**
+//	 * LibÃ©rer la mÃ©moire aprÃ©s la prÃ©validation d'un fichier donnÃ©.
+//	 * 
+//	 */
+//	private static void viderPrevalidation(PreValidation preValidation,
+//			File fichier) {
+//		preValidation = null;
+//		fichier = null;
+//	}
+//
+//}
+//
+///*******************************************************************************
+// * } }
+// * 
+// * //insertion sequences //repartition.repartirDerniereSequence(); //boucler
+// * pour inserer tte les sequences modÃ©les
+// *  // Sequence sequence = repartition.repartirSequence(jeu, sequenceModele); //
+// * //insertion.insererSequence(sequence); //
+// * 
+// *  // Pour chaque mesure...
+// * 
+// * //DeltaMesure deltaMesure = null; //insertion. insererDelta(deltaMesure); //
+// *  //
+// *  // On ferme la connexion CommunicationBD.close(); } } catch (Exception e) {
+// * e.printStackTrace(); } } }
+// ******************************************************************************/
+//
+///**
+// * LibÃ©rer la mÃ©moire aprÃ©s la repartition d'un fichier donnÃ©.
+// * 
+// */
+//// private static void viderRepartition(ArrayList<ArrayList<String>>
+//// listeDonnees) {
+//// listeDonnees = null;
+//// }
+///**
+// * LibÃ©rer la mÃ©moire aprÃ©s la validation d'un fichier donnÃ©.
+// * 
+// */
+//// private static void viderValidation(Validation validation,
+//// ArrayList<String> listeMesures) {
+//// validation = null;
+//// listeMesures = null;
+//// }
+///**
+// * LibÃ©rer la mÃ©moire aprÃ©s la prÃ©validation d'un fichier donnÃ©.
+// * 
+// */
+//// private static void viderPrevalidation(PreValidation preValidation,
+//// File fichier) {
+//// preValidation = null;
+//// fichier = null;
+//// }
+//// }
+//// ***********************************************//
+//// categorie
+//// try {
+//// CommunicationBD.open();
+//// List cats = CommunicationBD.getAllList(Categorie.class);
+//// Categorie cat;
+//// for (int i=0; i<cats.size(); i++) {
+//// cat = (Categorie) cats.get(i);
+//// System.out.println("cat="+cat.getCategorieNom());
+//// }
+//// CommunicationBD.close();
+//// } catch (Exception e) {
+//// TODO Auto-generated catch block
+//// e.printStackTrace();
+//// }
+//// commentaire
+//// try {
+//// CommunicationBD.open();
+//// List coms = CommunicationBD.getAllList(Commentaire.class);
+//// Commentaire com;
+//// for (int i=0; i<coms.size(); i++) {
+//// com = (Commentaire) coms.get(i);
+//// System.out.println("\ncommentaire = " + com.getCommentaireTxt());
+//// }
+//// CommunicationBD.close();
+//// } catch (Exception e) {
+//// // TODO Auto-generated catch block
+//// e.printStackTrace();
+//// }
+//// adresses
+//// try {
+//// CommunicationBD.open();
+//// List adrs = CommunicationBD.getAllList(Adresse.class);
+//// Adresse adr;
+//// for (int i=0; i<adrs.size(); i++) {
+//// adr = (Adresse) adrs.get(i);
+//// System.out.println("\nAdresseId = " + adr.getAdresseId());
+//// System.out.println("\nAdressePays= " + adr.getAdressePays());
+//// System.out.println("\nAdresseRue = " + adr.getAdresseRue());
+//// System.out.println("\nAdresseVille = " + adr.getAdresseVille());
+//// System.out.println("\nAdresseZip = " + adr.getAdresseZip());
+//// }
+//// CommunicationBD.close();
+//// } catch (Exception e) {
+//// // TODO Auto-generated catch block
+//// e.printStackTrace();
+//// }
+////		
+//// try {
+//// CommunicationBD.open();
+//// List plats = CommunicationBD.getAllList(Plateforme.class);
+//// Plateforme plat;
+//// for (int i=0; i<plats.size(); i++) {
+//// plat = (Plateforme) plats.get(i);
+//// System.out.println("\nPlateformesId = " + plat.getPlateformeNom());
+////				
+//// }
+//// CommunicationBD.close();
+//// } catch (Exception e) {
+//// // TODO Auto-generated catch block
+//// e.printStackTrace();
+//// }
+//
+//// // Argument 0 : LE NOM DE LA CATEGORIE
+//// String nomCategorie = args[0];
+//// // Argument 1 : LE NOM DU JEU
+//// String nomJeu = args[1];
+////
+//// // ******************************Lancement du chronomÃ©tre
+//// // **********************************
+//// Chrono chrono = new Chrono();
+//// chrono.start();
+//// // Fichier de log
+//// EcritureLog.init(nomJeu, nomCategorie);
+//// // ************ On recherche les fichiers du jeu
+//// // ************************
+//// String cheminJeu = Constantes.cheminDonnees + nomCategorie + "/" + nomJeu
+//// + "/";
+//// String cheminFichier;
+//// PreValidation preValidation;
+//// Validation validation;
+//// ArrayList<String> listeMesures;
+//// ArrayList<ArrayList<String>> listeDonnees = null;
+//// int nbErreursValidation;
+//// Fichier fichier;
+//// MesureModele mesureModele;
+//// ValeurModele valeurModele = null;
+//// Valeur valeur = null;
+//// ArrayList<ValeurModele> valeursMesure = null;
+//// ArrayList<String> donneesMesure = null;
+//// Mesure mesure = null;
+//// String numSeqPrecedent = null;
+////				
+//// // On rÃ©cupÃ©re tous les fichiers du rÃ©pertoire
+//// File fileCourant = new File(cheminJeu);
+//// String[] listeFichiers = fileCourant.list();
+//// // S'il y a au moins un fichier dans le jeu
+//// if (listeFichiers.length != 0) {
+//// // Trier les fichiers par ordre alphabÃ©tique
+//// Arrays.sort(listeFichiers);
+//// // Etape 3 : On lit le modÃ©le XML du jeu
+//// LectureModeleXML lectureModeleXML = new LectureModeleXML(nomCategorie,
+//// nomJeu);
+//// lectureModeleXML.lireModele();
+//// ArrayList<ParametreModele> parametresModele =
+//// lectureModeleXML.getParametres();
+//// ArrayList<ParametreModele> parametresValeur =
+//// lectureModeleXML.getParametresValeur();
+//// // Etape 4 : On lit les listes EXCEL de capteurs, paramÃ©tres, plateformes,
+//// ...
+//// LectureCapteurs lectureCapteurs = new LectureCapteurs();
+//// lectureCapteurs.lireFichier();
+//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
+//// lecturePlateformes.lireFichier();
+//// LectureParametres lectureParametres = new LectureParametres();
+//// lectureParametres.lireFichier();
+//// LecturePersonnes lecturePersonnes = new LecturePersonnes();
+//// lecturePersonnes.lireFichier();
+//// LectureUnites lectureUnites = new LectureUnites();
+//// lectureUnites.lireFichier();
+//// ArrayList<String> codesUnite = lectureUnites.getCodesUni();
+//// LectureOrganismes lectureOrganismes = new LectureOrganismes();
+//// lectureOrganismes.lireFichier();
+//// // Etape 5 : RÃ©partition des mÃ©tadonnÃ©es du jeu
+//// Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs,
+//// lecturePlateformes, lectureParametres,
+//// lecturePersonnes, lectureUnites,
+//// lectureOrganismes);
+//// ArrayList<Personne> personnes = repartition.repartirPersonnes();
+//// Jeu jeu = repartition.repartirJeu(personnes);
+//// ArrayList<Parametre> parametres = repartition.repartirParametres();
+//// ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
+//// ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
+//// Statiques.sequencesModeles = new ArrayList<SequenceModele>();
+////					
+//// //
+//// **************************************************************************************************
+//// // On parcourt les fichiers du jeu
+//// //
+//// ****************************************************************************************************
+//// for (int numFic = 0; numFic < 2; numFic++) {
+//// cheminFichier = cheminJeu + listeFichiers[numFic];
+//// fileCourant = new File(cheminFichier);
+//// // Si le fichier existe et n'est pas vide
+//// if (fileCourant.exists()) {
+//// EcritureLog.ecrire("Fichier " + fileCourant.getName(), "out-ln");
+//// // Etape 1 : prÃ©validation : On prÃ©valide le fichier
+//// preValidation = new PreValidation(nomJeu, fileCourant);
+//// listeMesures = preValidation.prevalider();
+//// viderPrevalidation(preValidation, fileCourant);
+//// EcritureLog.ecrire(" -> PrÃ©validation OK", "out-ln");
+////
+//// // Etape 2 : validation : On valide le fichier
+//// validation = new Validation(listeMesures);
+//// listeDonnees = validation.valider(lectureModeleXML);
+//// nbErreursValidation = validation.getNbErreursTotales();
+//// viderValidation(validation, listeMesures);
+//// if (nbErreursValidation == 0) {
+//// EcritureLog.ecrire(" -> Validation OK", "out-ln");
+////
+//// // Etape 5 : rÃ©partition du fichier
+//// fichier = repartition.repartirFichier(jeu,fileCourant);
+////								
+//// // TESTS 1
+//// // System.out.println("\nCHEMIN = " + fichier.getFichierChemin());
+//// // System.out.println("Nom = " + fichier.getFichierNom());
+//// // System.out.println("TAILLE = " + fichier.getFichierTaille()+" ko");
+//// // System.out.println("Jeu = " + fichier.getJeu().getJeuNom());
+////								
+////								
+//// // Pour chaque mesure...
+//// for(int numMesure = 0; numMesure < listeDonnees.size() ; numMesure++){
+//// donneesMesure = listeDonnees.get(numMesure);
+//// // Etape 6 : Rangement des donnÃ©es sur la ligne et rÃ©partition des sÃ©quences
+//// mesureModele =
+//// repartition.repartirDonnees(donneesMesure,numSeqPrecedent,parametresModele);
+//// numSeqPrecedent = mesureModele.getNumSequence();
+//// // Etape 7 : repartition de la mesure
+//// mesure = repartition.repartirMesure(mesureModele, fichier, plateformes);
+//////
+////									
+//// // TESTS 2
+//// //System.out.println("\n Nom Fichier = " +
+//// mesure.getFichier().getFichierNom());
+//// //System.out.println(" Date Mesure = " +
+//// DateTime.dateToString(mesure.getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
+//// //System.out.println(" Nom PLateForme = " +
+//// mesure.getPlateforme().getPlateformeNom());
+//// //System.out.println(" Type PLateForme = " +
+//// mesure.getPlateforme().getTypePlateforme().getTypePlateformeNom());
+//// //System.out.println("lat="+Nombre.latIntToFloat(new
+//// Integer(mesure.getLocalisation().getLocalisationLat())));
+//// //System.out.println("lon="+Nombre.latIntToFloat(new
+//// Integer(mesure.getLocalisation().getLocalisationLon())));
+//// //System.out.println("alt="+Nombre.altIntToFloat(new
+//// Integer(mesure.getLocalisation().getLocalisationAlt())));
+//// valeursMesure = mesureModele.getValeursMesure();
+//// // Pour chaque valeur...
+//// for(int numValeur = 0; numValeur < valeursMesure.size() ; numValeur++){
+//// valeurModele = valeursMesure.get(numValeur);
+//// // Etape 9 : repartition de la valeur
+//// valeur =
+//// repartition.repartirValeur(mesure,mesureModele.getFlagValidite(),valeurModele,capteurs,parametres.get(numValeur),parametresValeur.get(numValeur),codesUnite);
+////
+//// // TESTS 3
+//// // System.out.println("\n\n date = " +
+//// DateTime.dateToString(valeur.getMesure().getMesureDate(),Constantes.formatDateJJMMAAAAHHMMSS));
+//// // System.out.println(" param code = " +
+//// valeur.getParametre().getParametreCode());
+//// // System.out.println(" param nom = " +
+//// valeur.getParametre().getParametreNom());
+//// // System.out.println(" cat param = " +
+//// valeur.getParametre().getCategorieParam().getCategorieParamNom());
+//// // System.out.println(" unite = " +
+//// valeur.getParametre().getUnite().getUniteCode());
+//// // System.out.println(" valeurVAL = " + valeur.getValeurVal());
+//// // System.out.println(" capteur mod= " +
+//// valeur.getCapteur().getCapteurModele());
+//// // System.out.println(" capteur num= " +
+//// valeur.getCapteur().getCapteurNumserie());
+//// // System.out.println(" capteur fab= " +
+//// valeur.getCapteur().getFabriquant().getFabriquantNom());
+//// // System.out.println(" flagVALIDITE = " +
+//// valeur.getFlagByValiditeFlag().getFlagNom());
+//// // System.out.println(" Valeur Delta = " + valeur.getValeurDelta());
+////										
+////										
+////										
+//// }
+//// //EcritureLog.ecrire(" -> RÃ©partition OK", "out-ln");
+//// }
+//// EcritureLog.ecrire(" -> RÃ©partition OK", "out");
+//// }
+//// viderRepartition(listeDonnees);
+//// } else {
+//// EcritureLog.ecrire("Fichier " + fileCourant.getName()
+//// + " non trouvÃ© !", "err");
+//// }
+//// }
+//// // Etape 8 : rÃ©partition de la derniÃ©re sÃ©quence
+//// repartition.repartirDerniereSequence();
+//// TESTS 4
+//// for (int i = 0; i < Statiques.sequencesModeles.size(); i++) {
+//// SequenceModele sequenceModele = Statiques.sequencesModeles.get(i);
+//// EcritureLog.ecrire(" DESCRIPTION = " +
+//// sequenceModele.getDescription(),"out");
+//// EcritureLog.ecrire(" nbMESURES = " + sequenceModele.getNbMesures(),"out");
+//// EcritureLog.ecrire(" DTE_SEQ_MIN = " +
+//// DateTime.dateToString(sequenceModele.getDateMinSeq(),Constantes.formatDateJJMMAAAAHHMMSS),"out");
+//// EcritureLog.ecrire(" DTE_SEQ_MAX = " +
+//// DateTime.dateToString(sequenceModele.getDateMaxSeq(),Constantes.formatDateJJMMAAAAHHMMSS),"out");
+//// EcritureLog.ecrire(" ALTITUDE_SEQ_MIN = " + Nombre.altIntToFloat(new
+//// Integer(sequenceModele.getAltMinSeq())),"out");
+//// EcritureLog.ecrire(" ALTITUDE_SEQ_MAX = " + Nombre.altIntToFloat(new
+//// Integer(sequenceModele.getAltMaxSeq())),"out");
+//// EcritureLog.ecrire(" LAT_SEQ_MIN = " + Nombre.latIntToFloat(new
+//// Integer(sequenceModele.getLatMinSeq())),"out");
+//// EcritureLog.ecrire(" LAT_SEQ_MAX = " + Nombre.latIntToFloat(new
+//// Integer(sequenceModele.getLatMaxSeq())),"out");
+//// EcritureLog.ecrire(" LONG_SEQ_MIN = " + Nombre.latIntToFloat(new
+//// Integer(sequenceModele.getLonMinSeq())),"out");
+//// EcritureLog.ecrire(" LONG_SEQ_MAX = " + Nombre.latIntToFloat(new
+//// Integer(sequenceModele.getLonMaxSeq())),"out");
+//// EcritureLog.ecrire("","out");
+////
+////						
+//// }
+//
+////					
+//// } else {
+//// EcritureLog.ecrire("Pas de fichiers Ã© valider dans le jeu "
+//// + Constantes.nomJeuAMDAR, "err");
+//// }
+//// // ******************************ArrÃ©t du chronomÃ©tre
+//// // **********************************
+//// chrono.stop();
+//// chrono.afficheChrono();
+//// }
+//// /**
+//// * LibÃ©rer la mÃ©moire aprÃ©s la repartition d'un fichier donnÃ©.
+//// *
+//// */
+//// private static void viderRepartition(ArrayList<ArrayList<String>>
+//// listeDonnees) {
+//// listeDonnees = null;
+//// }
+////
+//// /**
+//// * LibÃ©rer la mÃ©moire aprÃ©s la validation d'un fichier donnÃ©.
+//// *
+//// */
+//// private static void viderValidation(Validation validation,
+//// ArrayList<String> listeMesures) {
+//// validation = null;
+//// listeMesures = null;
+//// }
+////
+//// /**
+//// * LibÃ©rer la mÃ©moire aprÃ©s la prÃ©validation d'un fichier donnÃ©.
+//// *
+//// */
+//// private static void viderPrevalidation(PreValidation preValidation,
+//// File fichier) {
+//// preValidation = null;
+//// fichier = null;
+//// }
+////		 
+//
+//// String s = "machin";
+//// String t = null;
+//// System.out.println("res="+(.equals(t)));
+//// ArrayList<ValeurModele> liste=new ArrayList<ValeurModele>();
+//// ValeurModele val;
+//// for (int i=0; i< 3; i++){
+//// val = new ValeurModele();
+//// val.setValeurVal("0");
+//// liste.add(val);
+//// }
+////		 
+//// ValeurModele val2 = liste.get(1);
+//// val2.setValeurVal("1");
+//// //liste.get(1).setValeurVal("1");
+////		 
+//// for (int i=0; i< liste.size(); i++){
+//// System.out.println(liste.get(i).getValeurVal());
+//// }
+//// ArrayList<ArrayList<String>> listeDonnees = null;
+//// // On lit le modÃ©le XML du jeu
+//// LectureModeleXML lectureModeleXML = new LectureModeleXML("AVION","AMDAR");
+//// lectureModeleXML.lireModele();
+//// // On lit les listes de capteurs, paramÃ©tres, plateformes, ...
+//// LectureCapteurs lectureCapteurs = new LectureCapteurs();
+//// lectureCapteurs.lireFichier();
+//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
+//// lecturePlateformes.lireFichier();
+//// LectureParametres lectureParametres = new LectureParametres();
+//// lectureParametres.lireFichier();
+//// LecturePersonnes lecturePersonnes = new LecturePersonnes();
+//// lecturePersonnes.lireFichier();
+//// LectureUnites lectureUnites = new LectureUnites();
+//// lectureUnites.lireFichier();
+//// LectureOrganismes lectureOrganismes = new LectureOrganismes();
+//// lectureOrganismes.lireFichier();
+////		
+////		 
+//// Fichier fichier;
+//// MesureModele mesureModele;
+//// ArrayList<String> donneesMesure = null;
+//// // On rÃ©cupÃ©re tous les fichiers du rÃ©pertoire
+//// File fileCourant = null;
+//// String[] listeFichiers = fileCourant.list();
+////	
+//// //
+////			
+////			
+//// Repartition repartition = new Repartition(lectureModeleXML, lectureCapteurs,
+//// lecturePlateformes, lectureParametres,
+//// lecturePersonnes, lectureUnites,
+//// lectureOrganismes);
+//// ArrayList<Personne> personnes = repartition.repartirPersonnes();
+//// Jeu jeu = repartition.repartirJeu(personnes);
+//// ArrayList<Parametre> parametres = repartition.repartirParametres();
+//// ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
+//// ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
+//// fichier = repartition.repartirFichier(jeu,fileCourant);
+//// mesureModele = repartition.repartirDonnees(donneesMesure);
+//// // RÃ©partition des mÃ©tadonnÃ©es du jeu
+//// // Repartition repartition = new Repartition(listeDonnees,
+//// // lectureModeleXML, lectureCapteurs,
+//// // lecturePlateformes, lectureParametres,
+//// // lecturePersonnes, lectureUnites,
+//// // lectureOrganismes);
+//// // ArrayList<Personne> personnes = repartition.repartirPersonnes();
+//// // Jeu jeu = repartition.repartirJeu(personnes);
+//// //
+//// // ArrayList<Parametre> parametres = repartition.repartirParametres();
+//// // ArrayList<Capteur> capteurs = repartition.repartirCapteurs();
+//// // ArrayList<Plateforme> plateformes = repartition.repartirPlateformes();
+//// // mesureModele = repartition.repartirDonnees(donneesMesure);
+////			
+////			
+//// Personne personne;
+//// Capteur capteur;
+//// Parametre parametre;
+//// Plateforme plateforme;
+//// int numCapteur;
+//
+///**
+// * -------------------------------test sur
+// * personnes------------------------------------
+// */
+//
+//// for (int num=0; num< personnes.size(); num++){
+//// personne = personnes.get(num);
+////
+//// System.out.println("Mail ="+ personne.getPersonneMail());
+//// System.out.println("Nom ="+ personne.getPersonneNom());
+//// System.out.println("PrÃ©nom ="+ personne.getPersonnePrenom());
+//// if (personne.getCommentaire() != null) {
+//// System.out.println("Description ="+
+//// personne.getCommentaire().getCommentaireTxt());
+//// }
+//// System.out.println("nom organisme = "+
+//// personne.getOrganisme().getOrganismeNom());
+//// System.out.println("mail organisme = "+
+//// personne.getOrganisme().getOrganismeMail());
+//// System.out.println(" pyas organisme = "+
+//// personne.getOrganisme().getAdresse().getAdressePays());
+//// System.out.println(" rue organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseRue());
+//// System.out.println(" ville organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseVille());
+//// System.out.println("code organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseZip());
+//// System.out.println();
+////			 
+//// }
+///**
+// * ---------------------------fin test sur
+// * personnes------------------------------------
+// */
+//
+///**
+// * -------------------------------test sur
+// * capteurs------------------------------------
+// */
+//
+//// Iterator<Parametre> it;
+//// // Parametre parametre;
+//// for (int num=0; num< capteurs.size(); num++){
+//// capteur = capteurs.get(num);
+////			 
+//// System.out.println("Etalonnage Capteurs ="+ capteur.getCapteurEtalonnage());
+//// System.out.println("MOdele Capteurs = " + capteur.getCapteurModele());
+//// System.out.println("Nomero Serie Cpateurs = " +
+//// capteur.getCapteurNumserie());
+//// if (capteur.getCommentaire() != null) {
+//// System.out.println("Description Capteurs = " +
+//// capteur.getCommentaire().getCommentaireTxt());
+//// }
+//// System.out.println("Nom Fabriquant Capteurs = " +
+//// capteur.getFabriquant().getFabriquantNom());
+////			 
+//// it = capteur.getParametres().iterator();
+//// while (it.hasNext()) {
+//// parametre = it.next();
+//// System.out.println("Parametres Capteurs = " + parametre.getParametreCode());
+//// }
+////
+//// System.out.println("Noms types Capteurs = " +
+//// capteur.getTypeCapteur().getTypeCapteurNom());
+////						 
+//// System.out.println();
+////		 
+//// }
+///**
+// * ----------------------------fin test sur
+// * capteurs------------------------------------
+// */
+//
+///**
+// * -------------------------------test sur
+// * palteformes------------------------------------
+// */
+//
+////		 
+//// Iterator<Capteur> it;
+//// //Capteur capteur;
+//// for (int num=0; num< plateformes.size(); num++){ plateforme =
+//// plateformes.get(num);
+////			 
+//// System.out.println("Id plateforme = "+ plateforme.getPlateformeId());
+//// System.out.println("Nom plateforme = " + plateforme.getPlateformeNom());
+//// System.out.println("Type plateforme = " +
+//// plateforme.getTypePlateforme().getTypePlateformeNom());
+////			
+////			 
+//// if (plateforme.getCommentaire() != null) {
+//// System.out.println("Description Capteurs = " +
+//// plateforme.getCommentaire().getCommentaireTxt());
+//// }
+////			 
+////			 
+//// it = plateforme.getCapteurs().iterator();
+//// while (it.hasNext()) {
+//// capteur = it.next();
+//// System.out.println("Etalonnage Capteurs de Palateformes = " +
+//// capteur.getCapteurEtalonnage());
+//// System.out.println("Id Capteurs de Palateformes = " +
+//// capteur.getCapteurId());
+//// System.out.println("Modele Capteurs de Palateformes = " +
+//// capteur.getCapteurModele());
+//// System.out.println("Numero de Serie Capt Platformes = " +
+//// capteur.getCapteurNumserie());
+//// if (capteur.getCommentaire() != null) {
+//// System.out.println(" description Capt Plateformes = " +
+//// capteur.getCommentaire().getCommentaireTxt());
+//// }
+//// System.out.println("Id Fabriquant Capt PLateformes = " +
+//// capteur.getFabriquant().getFabriquantId());
+//// System.out.println(" Type capteur palteformes = " +
+//// capteur.getTypeCapteur().getTypeCapteurNom());
+//// }
+//// System.out.println();
+////			 
+//// }
+////		 
+////		 
+//
+///**
+// * ---------------------------fin test sur
+// * palteformes------------------------------------
+// */
+//
+///**
+// * ---------------------------fin test sur
+// * jeux------------------------------------
+// */
+//
+//// for (int num=0; num< personnes.size(); num++){
+//// personne = personnes.get(num);
+////			 
+//// System.out.println("Mail ="+ personne.getPersonneMail());
+//// System.out.println("Nom ="+ personne.getPersonneNom());
+//// System.out.println("PrÃ©nom ="+ personne.getPersonnePrenom());
+//// if (personne.getCommentaire() != null) {
+//// System.out.println("Description ="+
+//// personne.getCommentaire().getCommentaireTxt());
+//// }
+//// System.out.println("nom organisme = "+
+//// personne.getOrganisme().getOrganismeNom());
+//// System.out.println("mail organisme = "+
+//// personne.getOrganisme().getOrganismeMail());
+//// System.out.println(" pyas organisme = "+
+//// personne.getOrganisme().getAdresse().getAdressePays());
+//// System.out.println(" rue organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseRue());
+//// System.out.println(" ville organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseVille());
+//// System.out.println("code organisme = "+
+//// personne.getOrganisme().getAdresse().getAdresseZip());
+//// System.out.println();
+////			 
+//// }
+////		 
+////		 
+////		 
+//// System.out.println("nom jeu = "+ jeu.getJeuId());
+//// System.out.println("nom jeu = "+ jeu.getJeuNom());
+//// System.out.println("Categorie jeu = "+ jeu.getCategorie().getCategorieNom());
+//// System.out.println("Description jeu = "+
+//// jeu.getCommentaire().getCommentaireTxt());//.getJeuNom());
+//// System.out.println("mail organisme jeu = "+
+//// jeu.getOrganisme().getOrganismeMail());
+//// System.out.println("nom Organisme jeu = "+
+//// jeu.getOrganisme().getOrganismeNom());
+//// System.out.println("description organisme jeu = " +
+//// jeu.getOrganisme().getCommentaire().getCommentaireTxt());
+//// System.out.println("contact jeu = " +
+//// jeu.getPersonneByContactId().getPersonneMail());
+//// System.out.println("mail contact jeu = " +
+//// jeu.getPersonneByContactId().getPersonneNom());
+//// System.out.println("nom contact jeu = " +
+//// jeu.getPersonneByContactId().getPersonneNom());
+//// System.out.println("prenom contact jeu = " +
+//// jeu.getPersonneByContactId().getPersonnePrenom());
+//// }
+//
+///** ---------------------------fin test jeu------------------------------------ */
+//
+///** ---------------------------test parametres-------------------------------- */
+//
+//// for (int num=0; num< parametres.size(); num++){
+//// parametre = parametres.get(num);
+////			 
+//// System.out.println("Code parametre = " + parametre.getParametreCode());
+//// System.out.println("Nom parametre = " + parametre.getParametreNom());
+//// System.out.println("Nom Categorie parametre = " +
+//// parametre.getCategorieParam().getCategorieParamNom());
+//// System.out.println("Code Unite parametre = " +
+//// parametre.getUnite().getUniteCode());
+////		 
+////		
+//// if (parametre.getCommentaire() != null) {
+//// System.out.println("Description ="+
+//// parametre.getCommentaire().getCommentaireTxt());
+//// }
+//// System.out.println();
+//// }
+///** -----------------------fin test parametres-------------------------------- */
+//
+//// LecturePlateformes lecturePlateformes = new LecturePlateformes();
+//// lecturePlateformes.lireFichier();
+//// for (int num=0; num< Constantes.nbPlateformes; num++){
+//// System.out.print(lecturePlateformes.getNumerosPlat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getNomsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getTypesPlat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getDescriptionsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getLatMinsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getLatMaxsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getLongMinsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getLongMaxsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getAltMinsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getAltMaxsPLat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getHautSolMinsPlat().get(num));
+//// System.out.print(" * "+lecturePlateformes.getHautSolMaxsPlat().get(num));
+//// System.out.print(" * ");
+//// for (int num2=0; num2<lecturePlateformes.getNumsCaptPlat().get(num).size();
+//// num2++){
+//// System.out.print(" # "+
+//// lecturePlateformes.getNumsCaptPlat().get(num).get(num2));
+//// }
+//// System.out.println();
+//
+//// **********************************************************************************
+//// ****************************TestParametres****************************************
+//// **********************************************************************************
+////	
+//// public static void main(String[] args) {
+//// LectureParametres lectureParametres = new LectureParametres(null);
+//// lectureParametres.lireFichier();
+//// for (int num=0; num< Constantes.nbParametres; num++){
+//// System.out.print(lectureParametres.getNumerosParam().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureParametres.getNomParam().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureParametres.getCodeMegapoliParam().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureParametres.getNumUniteParam().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureParametres.getDescriptionParam().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureParametres.getCategorieParam().get(num));
+////			
+//// System.out.println();
+//// }
+//// }
+////
+//// }
+////	
+//// **********************************************************************************
+//// ****************************TestOrganismes****************************************
+//// **********************************************************************************
+////
+//// public static void main(String[] args) {
+//// LectureOrganismes lectureOrganismes = new LectureOrganismes(null);
+//// lectureOrganismes.lireFichier();
+//// for (int num=0; num< Constantes.nbParametres; num++){
+//// System.out.print(lectureOrganismes.getNumerosOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getNomsOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getMailOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getDescriptionOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getRueOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getCodePostalOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getVilleOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getPaysOrg().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lectureOrganismes.getUrlOrg().get(num));
+////			
+//// System.out.println();
+//// }
+//// }
+////
+//// }
+////	
+//// **********************************************************************************
+//// ***************************TestPersonnes*****************************************
+//// **********************************************************************************
+////
+//// public static void main(String[] args) {
+//// LecturePersonnes lecturePersonnes = new LecturePersonnes(null);
+//// lecturePersonnes.lireFichier();
+//// for (int num=0; num< Constantes.nbPersonnes; num++){
+//// System.out.print(lecturePersonnes.getNumerosPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getNomsPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getPrenomsPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getPrenomsPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getMailPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getDescriptionPes().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePersonnes.getNumOrgPes().get(num));
+////			
+//// System.out.println();
+//// }
+//// }
+////
+//// }
+//// ********************************************************************************
+//// *************************TestPLateformes***************************************
+//// ********************************************************************************
+//// public static void main(String[] args) {
+//// LecturePlateformes lecturePlateformes = new LecturePlateformes(null);
+//// lecturePlateformes.lireFichier();
+//// for (int num=0; num< Constantes.nbPlateformes; num++){
+//// System.out.print(lecturePlateformes.getNumerosPlat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getNomsPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getTypePlat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getDescriptionPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMinPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMaxPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMinPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMaxPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMaxPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMaxPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMinPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getAltMaxPLat().get(num));
+//// System.out.print(" ->>->>->>->>
+//// "+lecturePlateformes.getNumsCaptPlat().get(num));
+//// System.out.println();
+//// }
+//// }
+//// }
+////	
+////
+//// *********************************************************************************
+//// ********************************TestUnites***************************************
+//// *********************************************************************************
+//// public static void main(String[] args) {
+//// LectureUnites lectureUnites = new LectureUnites(null);
+//// lectureUnites.lireFichier();
+//// for (int num = 0; num < Constantes.nbUnites; num++) {
+//// System.out.print(lectureUnites.getNumUni().get(num));
+//// System.out.print(" ->>->>->>->> "
+//// + lectureUnites.getNumUni().get(num));
+//// System.out.print(" ->>->>->>->> "
+//// + lectureUnites.getCodeUni().get(num));
+////
+//// System.out.println();
+//// }
+////}
+/******************************************************************/
+
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/repartition/Repartition.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/repartition/Repartition.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/repartition/Repartition.java	(revision 488)
@@ -0,0 +1,832 @@
+/**
+ * Created on 00 00. 0000
+ *  @author 
+ */
+
+package com.medias.integration.repartition;
+
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.database.objects.Adresse;
+import com.medias.database.objects.Capteur;
+import com.medias.database.objects.Categorie;
+import com.medias.database.objects.CategorieParam;
+import com.medias.database.objects.Commentaire;
+import com.medias.database.objects.Fabriquant;
+import com.medias.database.objects.Fichier;
+import com.medias.database.objects.Flag;
+import com.medias.database.objects.Jeu;
+import com.medias.database.objects.Langue;
+import com.medias.database.objects.Localisation;
+import com.medias.database.objects.Mesure;
+import com.medias.database.objects.Organisme;
+import com.medias.database.objects.Parametre;
+import com.medias.database.objects.Personne;
+import com.medias.database.objects.Plateforme;
+import com.medias.database.objects.RequetePlatLoc;
+import com.medias.database.objects.Sequence;
+import com.medias.database.objects.TypeCapteur;
+import com.medias.database.objects.TypePlateforme;
+import com.medias.database.objects.Unite;
+import com.medias.database.objects.Valeur;
+import com.medias.integration.lecture_ecriture.LectureCapteurs;
+import com.medias.integration.lecture_ecriture.LectureModeleXML;
+import com.medias.integration.lecture_ecriture.LectureOrganismes;
+import com.medias.integration.lecture_ecriture.LecturePersonnes;
+import com.medias.integration.lecture_ecriture.LectureParametres;
+import com.medias.integration.lecture_ecriture.LecturePlateformes;
+import com.medias.integration.lecture_ecriture.LectureUnites;
+import com.medias.integration.utils.Statiques;
+import com.medias.integration.utils.Nombre;
+import com.medias.integration.vues.MesureModele;
+import com.medias.integration.vues.ParametreModele;
+import com.medias.integration.vues.PlateformeModele;
+import com.medias.integration.vues.ValeurModele;
+import com.medias.integration.vues.SequenceModele;
+
+import java.io.File;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Repartition {
+	/**
+	 * Classe permettant de lire et d'Ã©crire dans un fichier
+	 */
+	public Repartition(LectureModeleXML lectureModeleXML, LectureCapteurs lectureCapteurs,
+			LecturePlateformes lecturePlateformes,
+			LectureParametres lectureParametres,
+			LecturePersonnes lecturePersonnes, LectureUnites lectureUnites,
+			LectureOrganismes lectureOrganismes) {
+		this.lectureModeleXML = lectureModeleXML;
+		this.lectureCapteurs = lectureCapteurs;
+		this.lecturePlateformes = lecturePlateformes;
+		this.lectureParametres = lectureParametres;
+		this.lecturePersonnes = lecturePersonnes;
+		this.lectureUnites = lectureUnites;
+		this.lectureOrganismes = lectureOrganismes;
+	}
+
+	/** 
+	 * Traitement des informations personnes 
+	 */
+	public ArrayList<Personne> repartirPersonnes() {
+		ArrayList<Personne> personnes = new ArrayList<Personne>();
+		/** Traitement de personne IntÃ©grateur */
+		String numIntegrateur = lectureModeleXML.getNumeroIntegrateur();
+		if (numIntegrateur == null) {
+			EcritureLog.ecrire( "Erreur : pas d'intÃ©grateur trouvÃ©", "err" );
+		} else {
+			Personne integrateur = repartirPersonne(numIntegrateur);
+			personnes.add(integrateur);
+		}
+
+		/** Traitement de la personne Contact */
+		String numContact = lectureModeleXML.getNumeroContact();
+		if (numContact == null) {
+			EcritureLog.ecrire("Erreur : pas de contact trouvÃ© ", "err");
+		} else {
+			Personne contact = repartirPersonne(numContact);
+			personnes.add(contact);
+		}
+
+		/** Traitement de la personne PI */
+		String numPI = lectureModeleXML.getNumeroPi();
+		if (numPI != null) {
+			Personne pi = repartirPersonne(numPI);
+			personnes.add(pi);
+		}
+		return personnes;
+	}
+	
+	/**
+	 * RÃ©partition d'un objet personne Ã© partir de son numÃ©ro
+	 */
+	public Personne repartirPersonne(String num) {
+		// On va chercher dans la liste des personnes la personne correspondant au numÃ©ro trouvÃ©
+		int indicePers = lecturePersonnes.getIndice(Integer.parseInt(num));
+		String mail = lecturePersonnes.getMailsPers().get(indicePers);
+		String nom = lecturePersonnes.getNomsPers().get(indicePers);
+		String prenom = lecturePersonnes.getPrenomsPers().get(indicePers);
+		String numOrg = lecturePersonnes.getNumOrgsPers().get(indicePers);
+		String role = lecturePersonnes.getDescriptionsPers().get(indicePers);
+		Organisme organisme = null;
+		// On va chercher dans la liste des organismes l'organisme correspondant au numÃ©ro trouvÃ©
+		if (numOrg == null) {
+			EcritureLog.ecrire("Erreur : pas d'organisme trouvÃ© pour "+prenom+" "+nom, "err");
+		} else {
+			organisme = repartirOrganisme(numOrg);
+		}
+		Personne personne = new Personne();
+		Commentaire commentaire = new Commentaire();
+		commentaire.setCommentaireTxt(role);
+		commentaire.setLangue( Constantes.langueEN);
+		personne.setCommentaire(commentaire);
+		personne.setOrganisme(organisme);
+		personne.setPersonneMail(mail);
+		personne.setPersonneNom(nom);
+		personne.setPersonnePrenom(prenom);
+		return personne;
+	}
+
+	/**
+	 * RÃ©partition d'un objet organisme Ã© partir de son numÃ©ro
+	 */
+	public Organisme repartirOrganisme(String num) {
+		int indiceOrg = lectureOrganismes.getIndice(Integer.parseInt(num));
+		String codepostal = lectureOrganismes.getCodesPostalsOrg().get(indiceOrg);
+		String descriptionOrg = lectureOrganismes.getDescriptionsOrg().get(indiceOrg);
+		String mailOrg = lectureOrganismes.getMailsOrg().get(indiceOrg);
+		String nomOrg = lectureOrganismes.getNomsOrg().get(indiceOrg);
+		String pays = lectureOrganismes.getPaysOrg().get(indiceOrg);
+		String rue = lectureOrganismes.getRuesOrg().get(indiceOrg);
+		String urlOrg = lectureOrganismes.getUrlsOrg().get(indiceOrg);
+		String ville = lectureOrganismes.getVillesOrg().get(indiceOrg);
+		Adresse adresse = new Adresse();
+		adresse.setAdressePays(pays);
+		adresse.setAdresseRue(rue);
+		adresse.setAdresseVille(ville);
+		adresse.setAdresseZip(codepostal);
+		Organisme organisme = new Organisme();
+		organisme.setAdresse(adresse);
+		Commentaire commentaire = new Commentaire();
+		commentaire.setCommentaireTxt(descriptionOrg);
+		commentaire.setCommentaireUrl(urlOrg);
+		Langue langue = (pays.equals("France")?Constantes.langueFR:Constantes.langueEN);
+		commentaire.setLangue(langue);
+		organisme.setCommentaire(commentaire);
+		organisme.setOrganismeMail(mailOrg);
+		organisme.setOrganismeNom(nomOrg);
+		return organisme;
+	}
+	
+	/** 
+	 * Traitement des informations Jeu 
+	 */
+	public Jeu repartirJeu(ArrayList<Personne> personnes, String numVersion) {
+		/** On recupere les infos du modÃ©le */
+		String nomCategorie = lectureModeleXML.getNomCategorie();
+		String nomJeu = lectureModeleXML.getNomJeu();
+		String descriptionJeu = lectureModeleXML.getDescriptionJeu();
+		String numOrganisme = lectureModeleXML.getNumOrganismeJeu();
+		Langue langue = Constantes.langueEN;
+		// On va chercher dans la liste des personnes la personne correspondant au numÃ©ro trouvÃ©
+		Jeu jeu = new Jeu();
+		Categorie categorie = new Categorie();
+		categorie.setCategorieId(getCategorieId(nomCategorie));
+		categorie.setCategorieNom(nomCategorie);
+		jeu.setCategorie(categorie);
+		jeu.setJeuDateinser(new Date(System.currentTimeMillis()));
+		jeu.setJeuNom(nomJeu);
+		jeu.setJeuNumversion(numVersion);
+		// On va chercher les infos sur l'organisme du jeu
+		if (numOrganisme == null) {
+			EcritureLog.ecrire("Erreur : pas d'organisme trouvÃ© pour le jeu","err");
+		} else {
+			Organisme organisme = repartirOrganisme(numOrganisme);
+			jeu.setOrganisme(organisme);
+			if (organisme.getAdresse().getAdressePays().equals("France"))
+				langue = Constantes.langueFR;
+		}
+		if (descriptionJeu != null) {
+			Commentaire commentaire = new Commentaire();
+			commentaire.setCommentaireTxt(descriptionJeu);
+			commentaire.setLangue(langue);
+			jeu.setCommentaire(commentaire);
+		}
+		jeu.setPersonneByContactId(personnes.get(Constantes.indiceContact));
+		jeu.setPersonneByIntegrateurId(personnes.get(Constantes.indiceIntegrateur));
+		if (personnes.size() == 3) {
+			jeu.setPersonneByPiId(personnes.get(Constantes.indicePI));
+		}
+		return jeu;
+	}
+
+	/** 
+	 * Traitement des informations Capteurs
+	 */
+	public ArrayList<Capteur> repartirCapteurs(ArrayList<Parametre> parametres) {
+		ArrayList<Capteur> capteurs = new ArrayList<Capteur>();
+		ArrayList<String> numsCapteur = lectureModeleXML.getNumsCapteur();
+		Capteur capteur;
+		String numCapteur;
+		// On retrouve les infos de chaque capteur Ã© partir de son numÃ©ro
+		for (int num = 0; num < numsCapteur.size(); num++) {
+			numCapteur = numsCapteur.get(num);
+			if (numCapteur == null) {
+				EcritureLog.ecrire( "Erreur : pas de capteur trouvÃ©", "err" );
+			} else {
+				capteur = repartirCapteur(numCapteur, parametres);
+				capteurs.add(capteur);
+			}
+		}
+		return capteurs;
+	}
+	
+	public Capteur repartirCapteur(String num, ArrayList<Parametre> parametres) {
+		int indiceCapteur = lectureCapteurs.getIndice(Integer.parseInt(num));
+		String modele = lectureCapteurs.getModelesCapt().get(indiceCapteur);
+		String numSerie = lectureCapteurs.getNumsSeriesCapt().get(indiceCapteur);
+		String etalonnage = lectureCapteurs.getEtalonnagesCapt().get(indiceCapteur);
+//		String descriptionCapt = lectureCapteurs.getDescriptionsCapt().get(indiceCapteur);
+		String nomTypeCapt = lectureCapteurs.getTypesCapt().get(indiceCapteur);
+//		String descriptionTypeCapt = lectureCapteurs.getDescriptionsTypeCapt().get(indiceCapteur);
+		String nomFabriquant = lectureCapteurs.getFabriquantsCapt().get(indiceCapteur);
+		ArrayList<String> numsParametres = lectureCapteurs.getNumsParametresCapt().get(indiceCapteur);
+
+		Capteur capteur = new Capteur();
+		capteur.setCapteurEtalonnage((etalonnage.equals("")?null:etalonnage));
+		capteur.setCapteurModele((modele.equals("")?Constantes.unknown:modele));
+		capteur.setCapteurNumserie((numSerie.equals("")?Constantes.unknown:numSerie));
+
+		Fabriquant fabriquant = new Fabriquant();
+		fabriquant.setFabriquantNom((nomFabriquant.equals("")?Constantes.unknown:nomFabriquant));
+		capteur.setFabriquant(fabriquant);
+		// RÃ©partition des paramÃ©tres du capteur
+		Set<Parametre> parametresCapt = new HashSet<Parametre>();
+		Parametre parametreCapt;
+		for (String numParametre: numsParametres) {
+			if (numParametre != null && !numParametre.equals("")) {
+				parametreCapt = repartirParametre(numParametre);
+				for (Parametre parametre: parametres) {
+					if (parametre.getParametreCode().equals(parametreCapt.getParametreCode())) {
+						parametresCapt.add(parametreCapt);
+						break;
+					}
+				}
+			}
+		}
+		capteur.setParametres(parametresCapt);
+		TypeCapteur typeCapteur = new TypeCapteur();
+		typeCapteur.setTypeCapteurNom(nomTypeCapt);
+		capteur.setTypeCapteur(typeCapteur);
+		return capteur;
+	}
+
+	/** 
+	 * Traitement des informations Parametres 
+	 */
+	public ArrayList<Parametre> repartirParametres() {
+		ArrayList<Parametre> parametres = new ArrayList<Parametre>();
+		ArrayList<ParametreModele> parametresJeu = lectureModeleXML.getParametres();
+		Parametre parametre;
+		String numParametre;
+		// On retrouve les infos de chaque paramÃ©tre Ã© partir de son numÃ©ro
+		for (ParametreModele paramJeu: parametresJeu) {
+			numParametre = paramJeu.getNumero();
+			if (numParametre != null) {
+				parametre = repartirParametre(numParametre);
+				parametre.setDelta(paramJeu.getDelta());
+				parametre.setLod(paramJeu.getLod());
+				parametres.add(parametre);
+			}
+		}
+		return parametres;
+	}
+	
+	public Parametre repartirParametre(String num) {
+		int indiceParametre = lectureParametres.getIndice(Integer.parseInt(num));
+		String nomPar = lectureParametres.getNomsParam().get(indiceParametre);
+		String codeMegapoliPar = lectureParametres.getCodesMegapoliParam().get( indiceParametre );
+		String numUnitePar = lectureParametres.getNumsUnitesParam().get(indiceParametre);
+//		descriptionPar = lectureParametres.getDescriptionsParam().get(indiceParametre);
+		String categoriePar = lectureParametres.getCategoriesParam().get( indiceParametre );
+		Parametre parametre = new Parametre();
+		CategorieParam categorieParam = new CategorieParam();
+		categorieParam.setCategorieParamDomaine(Constantes.domaineCategorieParam);
+		categorieParam.setCategorieParamNom((categoriePar.equals("")?Constantes.unknown:categoriePar));
+		parametre.setCategorieParam(categorieParam);
+		parametre.setParametreCode(codeMegapoliPar);
+		parametre.setParametreNom(nomPar);
+		// on recupere l'unitÃ© du paramÃ©tre
+		if (numUnitePar == null) {
+			EcritureLog.ecrire("Erreur : pas d'unitÃ© trouvÃ©e pour le paramÃ©tre "+nomPar, "err");
+		} else {
+			Unite unite = repartirUnite( numUnitePar );
+			parametre.setUnite( unite );
+		}
+		return parametre;
+	}
+
+	public Unite repartirUnite(String num) {
+		int indiceUnite = lectureUnites.getIndice(Integer.parseInt(num));
+		String codeUnitePar = lectureUnites.getCodesUni().get(indiceUnite);
+		String nomUnitePar = lectureUnites.getNomsUni().get(indiceUnite);
+		Unite unite = new Unite();
+		unite.setUniteCode(codeUnitePar);
+		unite.setUniteNom(nomUnitePar);
+		return unite;
+	}
+	
+	/** 
+	 * Traitement des informations Plateformes 
+	 */
+	public ArrayList<Plateforme> repartirPlateformes(String pays, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) {
+		ArrayList<Plateforme> platesformes = new ArrayList<Plateforme>();
+		ArrayList<String> numsPlateforme = lectureModeleXML.getNumsPlateforme();
+		Plateforme plateforme;
+		String numPlat;
+		// On retrouve les infos de chaque plateforme Ã© partir de son numÃ©ro
+		for (int num = 0; num < numsPlateforme.size(); num++) {
+			numPlat = numsPlateforme.get(num);
+			if (numPlat == null) {
+				EcritureLog.ecrire("Erreur : pas de plateforme trouvÃ©", "err");
+			} else {
+				plateforme = repartirPlateforme(numPlat, pays, capteurs, parametres);
+				platesformes.add(plateforme);
+			}
+		}
+		return platesformes;
+	}
+	
+	public Plateforme repartirPlateforme(String num, String pays, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) {
+		int indicePlat = lecturePlateformes.getIndice(Integer.parseInt(num));
+		String nomPlat = lecturePlateformes.getNomsPLat().get(indicePlat);
+		String nomTypePlat = lecturePlateformes.getTypesPlat().get(indicePlat);
+		String descriptionPlat = lecturePlateformes.getDescriptionsPLat().get(indicePlat);
+		ArrayList<String> numsCapteurs = lecturePlateformes.getNumsCaptPlat().get(indicePlat);
+		String altMaxPLat = lecturePlateformes.getAltMaxsPLat().get(indicePlat);
+		String altMinPLat = lecturePlateformes.getAltMinsPLat().get(indicePlat);
+		String latMaxPLat = lecturePlateformes.getLatMaxsPLat().get(indicePlat);
+		String latMinPLat = lecturePlateformes.getLatMinsPLat().get(indicePlat);
+		String longMaxPLat = lecturePlateformes.getLongMaxsPLat().get(indicePlat);
+		String longMinPLat = lecturePlateformes.getLongMinsPLat().get(indicePlat);
+		// On stocke la plateforme
+		PlateformeModele plateformeModele = new PlateformeModele();
+		plateformeModele.setAltMax(altMaxPLat);
+		plateformeModele.setAltMin(altMinPLat);
+		plateformeModele.setLatMax(latMaxPLat);
+		plateformeModele.setLatMin(latMinPLat);
+		plateformeModele.setLonMax(longMaxPLat);
+		plateformeModele.setLonMin(longMinPLat);
+		plateformeModele.setNom(nomPlat);
+		plateformeModele.setType(nomTypePlat);
+		Statiques.plateformesModele.add(plateformeModele);
+		// On construit la plateforme
+		Plateforme plateforme = new Plateforme();
+		// RÃ©partition des capteurs de la plateforme
+		Set<Capteur> capts = new HashSet<Capteur>();
+		Set<Parametre> params = new HashSet<Parametre>();
+		ArrayList<String> paramsCode = new ArrayList<String>();
+		Capteur capteurPlat;
+		for (String numCapteur: numsCapteurs) {
+			if (numCapteur != null && !numCapteur.equals("")) {
+				capteurPlat = repartirCapteur(numCapteur,parametres);
+				for (Capteur capteur: capteurs) {
+					if (capteur.getCapteurModele().equals(capteurPlat.getCapteurModele())
+							&& capteur.getCapteurNumserie().equals(capteurPlat.getCapteurNumserie())
+							&& capteur.getFabriquant().getFabriquantNom().equals(capteurPlat.getFabriquant().getFabriquantNom())
+							&& capteur.getTypeCapteur().getTypeCapteurNom().equals(capteurPlat.getTypeCapteur().getTypeCapteurNom())) {
+						capts.add(capteurPlat);
+						// RÃ©partition des paramÃ©tres du capteur dans la plateforme
+						for (Parametre parametre : capteurPlat.getParametres()) {
+							if (!paramsCode.contains(parametre.getParametreCode())) {
+								paramsCode.add(parametre.getParametreCode());
+								params.add(parametre);
+							}
+						}
+						break;
+					}
+				}
+			}
+		}
+		plateforme.setCapteurs(capts);
+		plateforme.setParametres(params);
+		// RÃ©partition de la localisation de la plateforme
+		Set<RequetePlatLoc> requetePlatLocs = new HashSet<RequetePlatLoc>();
+		RequetePlatLoc requetePlatLoc = new RequetePlatLoc();
+		requetePlatLoc.setAltMax( Nombre.altDoubleToInt( Double.valueOf( altMaxPLat ) ));
+		requetePlatLoc.setAltMin(Nombre.altDoubleToInt(Double.valueOf(altMinPLat)));
+		requetePlatLoc.setLatMax(Nombre.latDoubleToInt(Double.valueOf(latMaxPLat)));
+		requetePlatLoc.setLatMin(Nombre.latDoubleToInt(Double.valueOf(latMinPLat)));
+		requetePlatLoc.setLonMax(Nombre.latDoubleToInt(Double.valueOf(longMaxPLat)));
+		requetePlatLoc.setLonMin(Nombre.latDoubleToInt(Double.valueOf(longMinPLat)));
+		requetePlatLocs.add(requetePlatLoc);
+		plateforme.setRequetePlatLocs(requetePlatLocs);
+		// RÃ©partition du jeu de la plateforme
+		if (descriptionPlat != null && !descriptionPlat.trim().equals("")) {
+			Commentaire commentaire = new Commentaire();
+			commentaire.setCommentaireTxt(descriptionPlat);
+			Langue langue = (pays.equals("France")?Constantes.langueFR:Constantes.langueEN);
+			commentaire.setLangue(langue);
+			plateforme.setCommentaire(commentaire);
+		}
+		plateforme.setPlateformeNom(nomPlat);
+		TypePlateforme typePlateforme = new TypePlateforme();
+		typePlateforme.setTypePlateformeNom(nomTypePlat);
+		plateforme.setTypePlateforme(typePlateforme);
+		return plateforme;
+	}
+	
+	/** 
+	 * Traitement des informations fichier 
+	 */
+	public Fichier repartirFichier(Jeu jeu, File file) {
+		Fichier fichier = new Fichier();
+		fichier.setFichierNom(file.getName());
+		BigDecimal taille = new BigDecimal(file.length());
+		taille = taille.divide(new BigDecimal(1024),3,BigDecimal.ROUND_HALF_DOWN);
+		fichier.setFichierTaille(taille);
+		fichier.setJeu(jeu);
+		return fichier;
+	}
+
+	/** 
+	 * Traitement des informations des donnÃ©es de la mesure
+	 */
+	public MesureModele repartirDonnees(ArrayList<String> donneesMesure,ArrayList<ParametreModele> parametresModele) {
+		//, String numSequencePrecedent, int indiceNiv) {
+		MesureModele mesureModele = new MesureModele();
+		ArrayList<ParametreModele> paramsValeur = new ArrayList<ParametreModele>();
+		String donnee, fonctionParam, formatDate, nomParam, typeDate, dateStr = "";
+		ParametreModele parametreModele;
+		ValeurModele valeurModele;
+		Date date = null;
+		ArrayList<ValeurModele> valeursMesure = new ArrayList<ValeurModele>();
+
+		// Pour chaque donnÃ©e de la ligne de mesure...
+		for(int numDonnee = 0 ; numDonnee < donneesMesure.size() ; numDonnee++){
+			donnee = donneesMesure.get(numDonnee);
+
+			parametreModele = parametresModele.get(numDonnee);//indiceParam);
+			fonctionParam = parametreModele.getFonction();
+			nomParam = parametreModele.getNom();
+			// Si la donnÃ©e est une date
+			if (fonctionParam.equals(Constantes.nomFonctionDate)){
+				formatDate = parametreModele.getFormat();
+				typeDate = parametreModele.getType();
+				if (formatDate == null) {
+					if (typeDate.equals("HoursSince"))
+						date = DateTime.hoursSinceToDate( Double.parseDouble( donnee.replaceAll( ",", "." ) ), parametreModele.getDateSince() );
+					else if (typeDate.equals("SecondsSince"))
+						date = DateTime.secondsSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
+					else if (typeDate.equals("YearsSince"))
+						date = DateTime.yearsSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
+					else
+						date = DateTime.daysSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
+				} else {
+					formatDate = formatDate.replaceAll("DD", "dd").replaceAll("YYYY", "yyyy").replaceAll(":MM", ":mm").replaceAll(":SS", ":ss");
+					if (typeDate.equals("Date")) {
+						date = DateTime.stringToDate(donnee, formatDate);
+					} else if (typeDate.equals("Year")) {
+						dateStr = donnee;
+					} else if (typeDate.equals("Month")) {
+						dateStr += (donnee.length()==1?"0":"")+donnee;
+					} else if (typeDate.equals("Day")) {
+						dateStr += (donnee.length()==1?"0":"")+donnee;
+					} else if (typeDate.equals("Hour")) {
+						dateStr += (donnee.length()==1?"0":"")+donnee;
+					} else if (typeDate.equals("Minute")) {
+						dateStr += (donnee.length()==1?"0":"")+donnee;
+					} else if (typeDate.equals("Second")) {
+						dateStr += (donnee.length()==1?"0":"")+donnee;
+					}
+					if (/*date == null && */dateStr.length() == 14) {
+						date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHHMMSS);
+					} else if (dateStr.length() == 12) {
+						date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHHMM);
+					} else if (dateStr.length() == 10) {
+						date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHH);
+					}
+				}
+				if (date != null) {
+					mesureModele.setDate(DateTime.dateToString(date, Constantes.formatDateDefault));
+				}
+//				mesureModele.setFormatDate(formatDate);
+			}
+			else if(fonctionParam.equals(Constantes.nomFonctionInsererLoc)) {
+				// Si la donnÃ©e est une latitude
+				if (nomParam.toLowerCase().equals(Constantes.nomParametreLatitude)){
+					mesureModele.setLatitude(donnee);
+				}
+				// Si la donnÃ©e est une longitude
+				else if (nomParam.toLowerCase().equals(Constantes.nomParametreLongitude)){
+					mesureModele.setLongitude(donnee);
+				 }
+				// Si la donnÃ©e est une altitude
+				else if (nomParam.toLowerCase().equals(Constantes.nomParametreAltitude)){
+//					if (!subdiviser){
+						if (donnee.equals(parametreModele.getValAbsente())) {
+							mesureModele.setAltitude("0");
+						} else {
+							mesureModele.setAltitude(donnee);
+						}
+				}
+				// Si la donnÃ©e est une hauteur sol
+				else if (nomParam != null && nomParam.equals(Constantes.nomParametreHauteurSol)){
+					mesureModele.setHauteurSol(donnee);
+				}
+			}
+			// Si la donnÃ©e est une valeur
+			else if(fonctionParam.equals(Constantes.nomFonctionInsererVal)){
+				// 	On vÃ©rifie que la donnÃ©e n'est pas une valeur absente
+				paramsValeur.add(parametreModele);
+				valeurModele = new ValeurModele();
+				valeurModele.setValeurDelta(parametreModele.getDelta());
+				valeurModele.setValeurLod(parametreModele.getLod());
+				valeurModele.setValeurVal(donnee);
+				valeursMesure.add(valeurModele);
+			}
+			mesureModele.setParamsValeur(paramsValeur);
+			mesureModele.setValeursMesure(valeursMesure);
+		}
+		return mesureModele;
+   	}
+	
+	/**
+	 * RÃ©partition de l'objet Mesure
+	 */
+	public Mesure repartirMesure(MesureModele mesureModele, Fichier fichier, ArrayList<Plateforme> plateformes) {
+		Mesure mesure = new Mesure();
+		mesure.setFichier(fichier);
+
+		// Plateforme
+		Plateforme plateforme = null;
+		PlateformeModele plateformeModele = null;
+		// Cas une seule plateforme
+		if (plateformes.size() == 1) {
+			plateforme = plateformes.get(0);
+			plateformeModele = Statiques.plateformesModele.get(0);
+		}
+		// Cas plusieurs plateformes
+		else {
+			for (PlateformeModele platMod: Statiques.plateformesModele){
+				for (Plateforme plat: plateformes){
+					// On cherche la plateforme correspondant au modÃ©le
+					if (plat.getPlateformeNom().equals(platMod.getNom())) {
+						plateforme = plat;
+						break;
+					}
+				}
+				// On cherche la plateforme associÃ©e Ã© la mesure Ã© partir du nom du fichier
+				if (fichier.getFichierNom().toLowerCase().indexOf(platMod.getNom().toLowerCase()) != -1) {
+					plateformeModele = platMod;
+					break;
+				}
+			}
+		}
+		mesure.setPlateforme(plateforme);
+		// Construction de la localisation
+		Localisation localisation = new Localisation();
+		String altitude = mesureModele.getAltitude();
+		String hauteurSol = mesureModele.getHauteurSol();
+		String latitude = mesureModele.getLatitude();
+		String longitude = mesureModele.getLongitude();
+		if (altitude != null) {
+			// Plateforme mobile : une altitude par mesure
+			localisation.setLocalisationAlt(Nombre.altDoubleToInt(Double.valueOf(altitude)).intValue());
+		} else {
+			// Plateforme fixe
+			localisation.setLocalisationAlt(Nombre.altDoubleToInt(Double.valueOf(plateformeModele.getAltMin())).intValue());
+		}
+		if (hauteurSol != null) {
+			// Plateforme mobile : une hauteur sol par mesure
+			localisation.setLocalisationHs(Nombre.altDoubleToInt(Double.valueOf(hauteurSol)).intValue());
+		} else {
+			// Plateforme fixe et la plateforme a une hauteur sol
+			if (plateformeModele.getHsMin() != null && !plateformeModele.getHsMin().trim().equals("")) {
+				localisation.setLocalisationHs(Nombre.altDoubleToInt(Double.valueOf(plateformeModele.getHsMin())).intValue());
+			}
+		}
+		if (latitude != null ) {
+			// Plateforme mobile : une latitude par mesure
+			localisation.setLocalisationLat(Nombre.latDoubleToInt(Double.valueOf(latitude.replaceAll(",","."))).intValue());
+		} else {
+			// Plateforme fixe
+			localisation.setLocalisationLat(Nombre.latDoubleToInt(Double.valueOf(plateformeModele.getLatMin())).intValue());
+		}
+		if (longitude != null) {
+			// Plateforme mobile : une longitude par mesure
+			localisation.setLocalisationLon(Nombre.latDoubleToInt(Double.valueOf(longitude.replaceAll(",","."))).intValue());
+		} else {
+			// Plateforme fixe
+			localisation.setLocalisationLon(Nombre.latDoubleToInt(Double.valueOf(plateformeModele.getLonMin())).intValue());
+		}
+		mesure.setLocalisation(localisation);
+		// Date de la mesure
+		String sdate = mesureModele.getDate();
+		Date date = DateTime.stringToDate(sdate, Constantes.formatDateDefault);//DateTime.convertirFormat(formatDate));
+		mesure.setMesureDate(date);
+		
+		// Mises Ã© jour des extrema: - Dates min et max du jeu
+		if (Statiques.dateMinJeu.getTime() > date.getTime()) {
+        	Statiques.dateMinJeu = date;
+        }
+        if (Statiques.dateMaxJeu.getTime() < date.getTime()) {
+        	Statiques.dateMaxJeu = date;
+        }
+        // On calcule les bornes
+		int lat_j = localisation.getLocalisationLat();
+		int lon_j = localisation.getLocalisationLon();
+		int alt_j = localisation.getLocalisationAlt();
+		Integer hs_j = null;
+		if (localisation.getLocalisationHs() != null) {
+			hs_j = localisation.getLocalisationHs();
+		}
+        // Integer lat = null;
+        if (Statiques.latMinJeu.intValue() > lat_j) {
+        	Statiques.latMinJeu = new Integer(lat_j);
+        }
+        if (Statiques.latMaxJeu.intValue() < lat_j) {
+        	Statiques.latMaxJeu = new Integer(lat_j);
+        }
+        //Integer lon = null;
+        if (Statiques.lonMinJeu.intValue() > lon_j) {
+        	Statiques.lonMinJeu =  new Integer(lon_j);
+        }
+        if (Statiques.lonMaxJeu.intValue() < lon_j) {
+        	Statiques.lonMaxJeu =  new Integer(lon_j);
+        }
+        // Integer alt = null;
+        if (Statiques.altMinJeu.intValue() > alt_j) {
+        	Statiques.altMinJeu =  new Integer(alt_j);
+        }
+        if (Statiques.altMaxJeu.intValue() < alt_j) {
+        	Statiques.altMaxJeu =  new Integer(alt_j);
+        }
+        // Integer hs = null;
+		if (hs_j != null && Statiques.hsMinJeu.intValue() > hs_j.intValue()) {
+        	Statiques.hsMinJeu = hs_j;
+        }
+        if (hs_j != null && Statiques.hsMaxJeu.intValue() < hs_j.intValue()) {
+        	Statiques.hsMaxJeu = hs_j;
+        }
+		return mesure;
+	}
+	
+	/** 
+	 * Traitement des informations valeur 
+	 */
+	public Valeur repartirValeur(Mesure mesure, ValeurModele valeurModele, ParametreModele parametreModele, Parametre parametre, Capteur capteur) {
+		//, String flagValidite, ArrayList<Capteur> capteurs, String codeUnite,ArrayList<String> codesUnite) {
+		Valeur valeur = null;
+		// On vÃ©rifie que la donnÃ©e n'est pas une valeur absente
+		Double valeurVal = Double.valueOf( valeurModele.getValeurVal().replaceAll( ",", "." ) );
+		double valAbs = Double.valueOf(parametreModele.getValAbsente());
+//		System.out.println("val="+valeurVal+", abs="+valAbs+", param="+parametreModele.getNom());
+//		if (!valeurModele.getValeurVal().equals(parametreModele.getValAbsente())) {
+		if (valeurVal.doubleValue() != valAbs) {
+			double coef = 1;
+			if (parametreModele.getCoef() != null) coef = Double.valueOf(parametreModele.getCoef());
+			valeurVal = Nombre.mult(valeurVal, coef);
+			valeur = new Valeur();
+			valeur.setCapteur(capteur);
+			// Flag VALEUR
+			if (valeurModele.getValeurFlag() != null) {
+				Flag flag = new Flag();
+				flag.setFlagNom(valeurModele.getValeurFlag());
+				valeur.setFlagByValeurFlag(flag);
+			}
+			// MESURE
+			valeur.setMesure(mesure);
+
+			// PARAMETRE
+			valeur.setParametre(parametre);
+
+			// DELTA
+			String valeurDelta = valeurModele.getValeurDelta();
+			if (valeurDelta != null) {
+				valeur.setValeurDelta(Double.valueOf(valeurDelta));
+			}
+			// LOD (Limit Of Detection)
+			String valeurLod = valeurModele.getValeurLod();
+			if (valeurLod != null) {
+				valeur.setValeurLod(Double.valueOf(valeurLod));
+			}
+			// VALEUR
+			String codeUniteModele = parametreModele.getNomUnite();
+			// On compare l'unitÃ© du paramÃ©tre insÃ©rÃ© avec l'unitÃ© du paramÃ©tre contenu dans le modÃ©le
+			String codeUniteParam = parametre.getUnite().getUniteCode();
+			// on recupere l'indice de l'unitÃ© du parametre
+			// Si les unitÃ©s sont diffÃ©rentes, il y a une conversion Ã© faire
+			if (!codeUniteParam.equals(codeUniteModele)) {
+				if (codeUniteModele.equals(Constantes.unitePPB) && codeUniteParam.equals(Constantes.unitePPM)) {
+					valeurVal = Nombre.divMille(valeurVal);
+				}
+				else if (codeUniteModele.equals(Constantes.unitePPB) && codeUniteParam.equals(Constantes.unitePPT)) {
+					valeurVal = Nombre.mult(valeurVal,1000);
+				}
+				else if (codeUniteModele.equals(Constantes.unitePPT) && codeUniteParam.equals(Constantes.unitePPB)) {
+					valeurVal = Nombre.divMille(valeurVal);
+				}
+				else if (codeUniteModele.equals(Constantes.uniteKelvin) && codeUniteParam.equals(Constantes.uniteCelsius)) {
+					valeurVal = Nombre.kelvinToCelsius(valeurVal);
+				}
+				else if (codeUniteModele.equals(Constantes.unitekPa) && codeUniteParam.equals(Constantes.unitembar)) {
+					valeurVal = Nombre.mult(valeurVal,10);
+				}
+				else if (codeUniteModele.equals(Constantes.unitepm) && codeUniteParam.equals(Constantes.unitepmm)) {
+					valeurVal = Nombre.divMille(valeurVal);
+				}
+				else if (codeUniteModele.equals(Constantes.unitengm_3) && codeUniteParam.equals(Constantes.uniteugm_3)) {
+					valeurVal = Nombre.divMille(valeurVal);
+				}
+			}
+			valeur.setValeurVal(valeurVal.doubleValue());
+		}
+		return valeur;
+	}
+	
+	/**
+	 * Construction de la derniÃ©re sÃ©quence
+	 */              
+	public void repartirDerniereSequence() {
+		if (Statiques.dateMinSeq != null) {
+			SequenceModele sequenceModele = new SequenceModele();
+			sequenceModele.setAltMaxSeq(Statiques.altMaxSeq);
+			sequenceModele.setAltMinSeq(Statiques.altMinSeq);
+			sequenceModele.setDateMaxSeq(Statiques.dateMaxSeq);
+			sequenceModele.setDateMinSeq(Statiques.dateMinSeq);
+			// SÃ©quence ascendante : 1
+			// SÃ©quence descendante : 0
+			if (Statiques.numSeq.intValue() == Constantes.numSequencesAscendante) {
+				sequenceModele.setDescription(Constantes.descriptionSequencesAscendante);
+			} else if (Statiques.numSeq.intValue() == Constantes.numSequencesDescendante) {
+				sequenceModele.setDescription(Constantes.descriptionSequencesDescendante);
+			}
+			sequenceModele.setHsMaxSeq(Statiques.hsMaxSeq);
+			sequenceModele.setHsMinSeq(Statiques.hsMinSeq);
+			sequenceModele.setLatMaxSeq(Statiques.latMaxSeq);
+			sequenceModele.setLatMinSeq(Statiques.latMinSeq);
+			sequenceModele.setLonMaxSeq(Statiques.lonMaxSeq);
+			sequenceModele.setLonMinSeq(Statiques.lonMinSeq);
+			sequenceModele.setNbMesures(Statiques.nbMesuresSeq);
+			Statiques.sequencesModeles.add(sequenceModele);
+		}
+	}
+	
+	/**
+	 *traitement de la sequence
+	 */
+	public Sequence repartirSequence(Jeu jeu, SequenceModele sequenceModele) {
+		Sequence sequence =  new Sequence();
+		String description = sequenceModele.getDescription();
+		if (description != null) {
+			Commentaire commentaireSeq = new Commentaire();
+			commentaireSeq.setCommentaireTxt(description);
+			commentaireSeq.setLangue(Constantes.langueFR);
+			sequence.setCommentaire(commentaireSeq);
+		}
+		sequence.setJeu(jeu);
+		// sequence Altitude Maximale
+		Integer sequenceAltMax = sequenceModele.getAltMaxSeq();
+		sequence.setSequenceAltf(sequenceAltMax);
+		// sequence Altitude Minimale
+		Integer sequenceAltMin = sequenceModele.getAltMinSeq();
+		sequence.setSequenceAltd(sequenceAltMin);
+		// sequence hauteur Sol Maximale
+		Integer sequenceHsMax = sequenceModele.getHsMaxSeq();
+		if (sequenceHsMax != null) {
+			sequence.setSequenceHsf(sequenceHsMax);
+		}
+
+		// sequence hauteur Sol Minimale
+		Integer sequenceHsMin = sequenceModele.getHsMinSeq();
+		if (sequenceHsMin != null) {
+			sequence.setSequenceHsd(sequenceHsMin);
+		}
+		// repartir date max
+		Date sequenceDatef = sequenceModele.getDateMaxSeq();		
+		sequence.setSequenceDatef(sequenceDatef);
+		// rÃ©partir date min
+		Date sequenceDated = sequenceModele.getDateMinSeq();		
+		sequence.setSequenceDated(sequenceDated);
+		
+		// sequence Latitude Minimale
+		Integer sequenceLatd = sequenceModele.getLatMinSeq();
+		sequence.setSequenceLatd(sequenceLatd);
+		// sequence Latitude Maximale
+		Integer sequenceLatf = sequenceModele.getLatMaxSeq();
+		sequence.setSequenceLatf(sequenceLatf);
+		// sequence Longitude Minimale
+		Integer sequenceLond = sequenceModele.getLonMinSeq();
+		sequence.setSequenceLond(sequenceLond);
+		// sequence Longitude Maximale
+		Integer sequenceLonf = sequenceModele.getLonMaxSeq();
+		sequence.setSequenceLonf(sequenceLonf);	
+		
+		return sequence;
+	}
+	
+	public int getCategorieId(String nomCat) {
+		if (nomCat.equals(Constantes.nomCatAVION)) {
+			return Constantes.numCatAVION;
+		} else if  (nomCat.equals(Constantes.nomCatSURF_FIXE)) {
+			return Constantes.numCatSURF_FIXE;
+		} else {
+			return Constantes.numCatSURF_MOBILE;
+		}
+	}
+
+	private LectureModeleXML lectureModeleXML;
+	private LectureCapteurs lectureCapteurs;
+	private LecturePlateformes lecturePlateformes;
+	private LectureParametres lectureParametres;
+	private LecturePersonnes lecturePersonnes;
+	private LectureUnites lectureUnites;
+	private LectureOrganismes lectureOrganismes;
+}
+	
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/CommunicationBD.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/CommunicationBD.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/CommunicationBD.java	(revision 488)
@@ -0,0 +1,320 @@
+/**
+ * Created on 17 Jan. 2007
+  * @author 
+ */
+
+package com.medias.integration.utils;
+import java.io.Serializable;
+import java.util.List;
+import org.hibernate.*;
+import org.hibernate.criterion.*;
+import integration.hibernate.HibernateSessionFactory;
+
+/**
+ * 
+ * AccÃ©s et Ã©changes avec la base de donnÃ©es
+ */
+
+public class CommunicationBD {
+    /**
+     * Ouverture de la session
+     */
+    public static void open() throws Exception {
+        try {
+            session =  HibernateSessionFactory.currentSession();
+            tx = session.beginTransaction();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+    }
+    
+    /**
+     * Fermeture de la session
+     */   
+    public static void close() throws Exception {
+        try {
+        	tx.commit();
+            HibernateSessionFactory.closeSession();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+    }
+ 
+    /**
+     * RequÃ©te de sÃ©lection sur une table
+     * SELECT * FROM table;
+     * Renvoie la liste des tuples de la table
+     */
+    public static List<?> getAllList(Class<?> aClass) throws Exception {
+        List<?> results = null;
+        try {
+        	//tx = session.beginTransaction();
+            results = session.createCriteria(aClass).list();
+            //tx.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+        return results;
+    }
+
+    /**
+     * RequÃ©te de sÃ©lection ordonnÃ©e sur une table
+     * SELECT * FROM table ORDER BY colonne;
+     * Renvoie la liste des tuples de la table
+     */
+    public static List<?> getOrderedList(Class<?> aClass, String column)
+    throws Exception {
+        List<?> results = null;
+        try {
+        	//tx = session.beginTransaction();
+            results = session.createCriteria(aClass).addOrder(Order.asc(column)).list();
+            //tx.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+        return results;
+    }
+
+    /**
+     * RequÃ©te de sÃ©lection HQL (Hibernate Query Language)
+     * Renvoie la liste des tuples rÃ©sultants
+     */
+    public static List<?> getList(String requete)
+    throws Exception {
+        List<?> results = null;
+        try {
+        	//tx = session.beginTransaction();
+            results = session.createQuery( requete ).list();
+            //tx.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+        return results;
+    }
+
+    public static void getSQL(String requete)
+    throws Exception {
+        try {
+        	//tx = session.beginTransaction();
+            session.createSQLQuery(requete).uniqueResult();
+            //tx.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw (e);
+        }
+    }
+    
+    /**
+     * RequÃ©te de sÃ©lection d'un objet issu d'une table Ã© partir de contraintes
+     * SELECT * FROM table WHERE nomColonne=...
+     * Renvoie le tuple recherchÃ© sous forme d'objet
+     */
+    public static Object getObjectByColonne(Class<?> c,String nomColonne,Object valeur) 
+    {
+        Object object =null;
+        try
+        {
+        	//tx = session.beginTransaction();
+            object = session.createCriteria(c)
+                .add( Restrictions.eq( nomColonne, valeur ) )
+                .uniqueResult();
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            return null;
+        }
+        return object;
+    }
+
+    /**
+     * RequÃ©te de sÃ©lection d'un objet issu d'une table Ã© partir de contraintes
+     * SELECT * FROM table WHERE nomColonne1=... AND nomColonne2=...
+     * Renvoie le tuple recherchÃ© sous forme d'objet
+     */
+    public static Object getObjectBy2Colonne(Class<?> c,String nomColonne,Object valeur,String nomColonne2,Object valeur2) 
+    {
+        Object object =null;
+        try
+        {
+        	//tx = session.beginTransaction();
+            object  = session.createCriteria(c)
+                .add(Restrictions.eq(nomColonne, valeur))
+                .add(Restrictions.eq(nomColonne2, valeur2))
+                .uniqueResult();
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            return null;
+        }
+        return object;
+    }
+    
+    /**
+     * RequÃ©te de sÃ©lection d'un objet issu d'une table Ã© partir de son identifiant
+     * SELECT * FROM table WHERE table_id=...
+     * Renvoie le tuple recherchÃ© sous forme d'objet
+     */
+    public static Object getObjectById(Class<?> c,Integer id) 
+    {
+        Object object =null;
+        try
+        {
+        	//tx = session.beginTransaction();
+            object  = session.get( c, id );
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            return null;
+        }
+        return object;
+    }
+    
+    /**
+     * Insertion ou mise Ã© jour d'un objet (<=> tuple)
+     * INSERT INTO table VALUES (...)
+     * UPDATE table SET ...
+     */
+    public static void save(Object o) throws Exception
+    {
+        try
+        {
+        	//tx = session.beginTransaction();
+        	session.saveOrUpdate(o);
+        	//tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+
+    /**
+     * Insertion d'un objet Ã© un identifiant donnÃ©
+     * @throws Exception 
+     */
+    public static void save(Object o,Serializable id) throws Exception {
+        try
+        {
+        	//tx = session.beginTransaction();
+            id = session.save(o);
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+    
+    /**
+     * Insertion ou mise Ã© jour d'un objet (<=> tuple)
+     * INSERT INTO table VALUES (...)
+     */
+    public static void saveOnly(Object o) throws Exception
+    {
+        try
+        {
+        	//tx = session.beginTransaction();
+        	session.save( o );
+        	//tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+    
+    /**
+     * Suppression d'un objet (<=> tuple)
+     * DELETE FROM table WHERE (...)
+     */
+    public static void delete(Object o) throws Exception
+    {
+        try
+        {
+        	//tx = session.beginTransaction();
+            session.delete( o );
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+    
+    /**
+     * Mise Ã© jour d'un objet Ã© un identifiant donnÃ©
+     * @throws Exception 
+     */
+    public static void update(Object o) throws Exception {
+        try
+        {
+        	//tx = session.beginTransaction();
+            session.update( o );
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+
+    /**
+     * Nettoyage de la session
+     * @throws Exception 
+     */
+    public static void clear() throws Exception {
+        try
+        {
+        	//tx = session.beginTransaction();
+            session.clear();
+            //tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+    
+    /**
+     * Sauvegarde de la base de donnÃ©es
+     */
+    public static void commit() throws Exception
+    {
+        try
+        {
+            tx.commit();
+        }
+        catch(Exception e) 
+        {
+            e.printStackTrace();
+            throw(e);
+        }
+    }
+    
+    /**
+     * VÃ©rifie si un objet est dÃ©jÃ© dans la session
+     */
+    public static void flush() {
+    	session.flush();
+    }
+
+    private static Transaction tx = null;
+    private static Session session = null;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Nombre.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Nombre.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Nombre.java	(revision 488)
@@ -0,0 +1,245 @@
+/**
+ * Created on 24 Jan. 2007
+ * @author 
+ */
+package com.medias.integration.utils;
+
+import java.math.BigDecimal;
+
+/**
+ *
+ * Fournit des opÃ©rations sur les nombres.
+ */
+
+public class Nombre {
+    /**
+     * VÃ©rifie qu'une donnÃ©e est un entier.
+     * @param nb Nombre Ã© vÃ©rifier.
+     * @return Vrai si la donnÃ©e est un entier.
+     */
+    public static boolean isInteger(String nb) {
+        try {
+            Integer.parseInt(nb);
+            return true;
+        } catch(NumberFormatException e) {
+            return false;
+        }
+    }
+
+    public static boolean isIntegerPositif(String nb) {
+        try {
+        	if (nb.endsWith(".0")) nb = nb.replaceAll("\\.0", "");
+        	int integer = Integer.parseInt(nb);
+            if(integer < 0) {
+                return false;
+            }
+            return true;
+        } catch(NumberFormatException nfe) {
+            return false;
+        }
+    }
+    
+    /**
+     * VÃ©rifie qu'une donnÃ©e est un entier long.
+     * @param nb Nombre Ã© vÃ©rifier.
+     * @return Vrai si la donnÃ©e est un entier long.
+     */
+    public static boolean isLong(String nb) {
+        try {
+            Long.parseLong(nb);
+            return true;
+        } catch(NumberFormatException e) {
+            return false;
+        }
+    }
+    
+    /**
+     * Verifie qu'une donnÃ©e est un double.
+     * @param nb Nombre Ã© vÃ©rifier.
+     * @return Vrai si la donnÃ©e est un double.
+     */
+    public static boolean isDouble(String nb) {
+        try {
+            Double.parseDouble(nb.replaceAll(",", "."));
+            return true;
+        } catch(NumberFormatException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Verifie qu'un double est positif
+     * @param nb Nombre Ã© vÃ©rifier.
+     * @return Vrai si la donnÃ©e est dans l'intervalle.
+     */
+    public static boolean isDoublePositif(String nb) {
+        try {
+            double temp = new Double(nb.replaceAll(",", ".")).doubleValue();
+            if(temp < 0) {
+                return false;
+            }
+            return true;
+        } catch(NumberFormatException nfe) {
+            return false;
+        }
+    }
+    
+    /**
+     * Verifie qu'un double est dans un intervalle.
+     * @param nb Nombre Ã© vÃ©rifier.
+     * @param min Borne infÃ©rieure de l'intervalle.
+     * @param max Borne supÃ©rieure de l'intervalle.
+     * @return Vrai si la donnÃ©e est dans l'intervalle.
+     */
+    public static boolean isDoubleInInterval(String nb, double min, double max) {
+        try {
+            double temp = new Double(nb.replaceAll(",", ".")).doubleValue();
+            if(temp > max || temp < min) {
+                return false;
+            }
+            return true;
+        } catch(NumberFormatException nfe) {
+            return false;
+        }
+    }
+
+    /**
+     * Transforme un chaine en double.
+     * @param str Chaine Ã© transformer.
+     * @return Double gÃ©nÃ©rÃ©, null si ce n'est pas un double.
+     */
+    public static Double getDouble(String str) {
+        if(str.length() == 0 || str == null) {
+            return null;
+        }
+        try {
+            return new Double(str.replaceAll(",", "."));
+        } catch(NumberFormatException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Transforme un chaine en double et le met en valeur absolue.
+     * @param str Chaine Ã© transformer.
+     * @return Double en valeur absolue gÃ©nÃ©rÃ©, null si ce n'est pas un double.
+     */
+    public static Double getAbsDouble(String str) {
+        if(str.length() == 0 || str == null) {
+            return null;
+        }
+        try {
+            Double db = new Double(str.replaceAll(",", "."));
+            return new Double(Math.abs(db.doubleValue()));
+        } catch(NumberFormatException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Transforme un chaine en integer.
+     * @param str Chaine Ã© transformer.
+     * @return Integer gÃ©nÃ©rÃ©, null si ce n'est pas un integer.
+     */
+    public static Integer getInteger(String str) {
+        if(str.length() == 0 || str == null) {
+            return null;
+        }
+        try {
+            return new Integer(str);
+        } catch(NumberFormatException e) {
+            return null;
+        }
+    }
+    
+    /**
+     * Convertit une latitude ou longitude de Double vers Integer.
+     * @param val Double  convertir.
+     * @return Valeur convertie en Integer.
+     */
+    public static Integer latDoubleToInt(Double val) {
+        return new Integer((int)((val.doubleValue() + 0.0005) * 10000.0));
+    }
+
+    /**
+     * Convertit une latitude ou longitude de Integer vers Float.
+     * @param val Integer  convertir.
+     * @return Valeur convertie en Float.
+     */
+    public static Float latIntToFloat(Integer val) {
+        return new Float(((val.intValue() / 10000.0) - 0.0005));
+    }
+
+    /**
+     * Convertit une altitude ou une hauteur sol de Double vers Integer.
+     * @param val Double  convertir.
+     * @return Valeur convertie en Integer.
+     */
+    public static Integer altDoubleToInt(Double val) {
+        return new Integer((int)((val.doubleValue() + 0.05) * 100.0));
+    }
+
+    /**
+     * Convertit une altitude de Integer vers Float.
+     * @param val Integer  convertir.
+     * @return Valeur convertie en Float.
+     */
+    public static Float altIntToFloat(Integer val) {
+        return new Float(((val.intValue() / 100.0) - 0.05));
+    }
+    
+    /**
+     * Convertit une tempÃ©rature exprimÃ©e en degrÃ©s Kelvin en degrÃ©s Celsius.
+     * @param val Integer  convertir.
+     * @return Valeur convertie en Float.
+     */
+    public static Double kelvinToCelsius(Double kelvin) {
+        return new Double(kelvin.doubleValue() - 273.16);
+    }
+
+    /**
+     * Divise par 1000 la valeur
+     */
+    public static Double divMille(Double val) {
+    	BigDecimal bd = new BigDecimal(val.doubleValue());
+    	bd = bd.divide(new BigDecimal(1000),10,BigDecimal.ROUND_HALF_EVEN);
+    	Double d = new Double(bd.toString());
+        return d;
+    }
+    
+    /**
+     * Multiplie par multi la valeur
+     */
+    public static Double mult(Double val,int multi) {
+    	BigDecimal bd = new BigDecimal(val.doubleValue());
+    	bd = bd.multiply(new BigDecimal(multi));
+    	Double d = new Double(bd.toString());
+        return d;
+    }
+  
+    public static Double mult(Double val,double multi) {
+    	BigDecimal bd = new BigDecimal(val.doubleValue());
+    	bd = bd.multiply(new BigDecimal(multi));
+    	Double d = new Double(bd.toString());
+        return d;
+    }
+    
+    /**
+     * Convertit une altitude gÃ©opotentielle en altitude en mÃ©tres
+     */
+    public static Double geopToAltitude(Double geop) {
+        return new Double(geop.doubleValue() / 9.8);
+    }
+
+    public static Double getAbDouble(String str) {
+        if(str.length() == 0 || str == null) {
+            return null;
+        }
+        try {
+            Double db = new Double(str.replaceAll("--", "."));
+            return new Double(Math.abs(db.doubleValue()));
+        } catch(NumberFormatException e) {
+            return null;
+        }
+    }
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Statiques.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Statiques.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Statiques.java	(revision 488)
@@ -0,0 +1,81 @@
+/**
+ * Created on 24 Jan. 2007
+ * @author 
+ */
+
+package com.medias.integration.utils;
+
+import com.medias.integration.vues.SequenceModele;
+import com.medias.integration.vues.PlateformeModele;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Set;
+
+/** 
+ * Classe regroupant les attributs statiques utilisÃ©s
+ */
+
+public class Statiques {
+	/**
+	 * Convertit un ensemble d'Ã©lÃ©ments de type Set en ArrayList
+	 */ 
+	public static ArrayList<?> convertSetToArrayList(Set<?> set) {
+		ArrayList<Object> arrayList = new ArrayList<Object>();
+		if (set != null) {
+			Iterator<?> it = set.iterator();
+			Object obj = null;
+			while (it.hasNext()) {
+				obj = it.next();
+				arrayList.add(obj);
+			}
+		}
+		return arrayList;
+	}
+
+	/**dates du jeu*/
+	public static Date dateMinJeu = null;
+	public static Date dateMaxJeu = null;
+	/**public static Date jeuDateinser = null;
+	public static Date jeuDatemodif = null;*/
+	public static Integer latMinJeu = null;
+	public static Integer latMaxJeu = null;
+	public static Integer lonMinJeu = null;
+	public static Integer lonMaxJeu = null;
+	public static Integer altMinJeu = null;
+	public static Integer altMaxJeu = null;
+	public static Integer hsMinJeu = null;
+	public static Integer hsMaxJeu = null;
+	/**bilan*/
+	public static Date dateMinBilan = null;
+	public static Date dateMaxBilan = null;
+	public static Integer latMinBilan = null;
+	public static Integer latMaxBilan = null;
+	public static Integer lonMinBilan = null;
+	public static Integer lonMaxBilan = null;
+	public static Integer altMinBilan = null;
+	public static Integer altMaxBilan = null;
+	public static Integer hsMinBilan = null;
+	public static Integer hsMaxBilan = null;
+	public static double valMinBilan = 0.0;
+	public static double valMaxBilan = 0.0;
+	public static Integer nbValBilan = null;
+	
+	/**dates des sequences*/
+	public static Date dateMinSeq = null;
+	public static Date dateMaxSeq = null;
+	public static Integer latMinSeq = null;
+	public static Integer latMaxSeq = null;
+	public static Integer lonMinSeq = null;
+	public static Integer lonMaxSeq = null;
+	public static Integer altMinSeq = null;
+	public static Integer altMaxSeq = null;
+	public static Integer hsMinSeq = null;
+	public static Integer hsMaxSeq = null;
+	public static ArrayList<SequenceModele> sequencesModeles = null;
+	public static int nbMesuresSeq = 0;
+	public static Integer numSeq = null;
+	
+	public static ArrayList<PlateformeModele> plateformesModele = null;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/ControleurType.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/ControleurType.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/ControleurType.java	(revision 488)
@@ -0,0 +1,623 @@
+/*
+ * Created on 25 Jan. 2007
+ */
+package com.medias.integration.validation;
+
+import com.medias.DateTime;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+/**
+ * @author 
+ *
+ * Fournit les mÃ©thodes de test des donnÃ©es des fichiers fournis pour intÃ©gration dans la base.
+ */
+public class ControleurType {
+    /**
+     * Teste si une chaine est une date au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+	@SuppressWarnings("unchecked")
+	public static Message testerDate(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        String formatDateReel = format.replaceAll("DD", "dd").replaceAll("YYYY", "yyyy").replaceAll(":MM", ":mm").replaceAll(":SS", ":ss");
+//        String formatDateReel = DateTime.convertirFormat(format);
+        Date date = DateTime.stringToDate( str, formatDateReel );
+        boolean dateBonne = true;
+        if(date == null) {
+            dateBonne = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une date au format "+format);
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	// On rajoute 1 jour Ã© la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	c.add(Calendar.DAY_OF_YEAR, +1);
+        	dateEnd = c.getTime();
+        	if (date.getTime() < dateBegin.getTime()) {
+        		dateBonne = false;
+        		mes.setMessage("TROUVE: '" + str +
+        				", ATTENDU: une date supÃ©rieure Ã© la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
+        	} else if (date.getTime() >= dateEnd.getTime()) {
+        		dateBonne = false;
+        		mes.setMessage("TROUVE: '" + str +
+        				", ATTENDU: une date infÃ©rieure Ã© la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
+        	}
+        }
+        mes.setValid(dateBonne);
+        return mes;
+    }
+
+    /**
+     * Teste si une chaine est une annÃ©e au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    @SuppressWarnings("unchecked")
+    public static Message testerYear(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        String formatDateReel = format.replaceAll("YYYY", "yyyy");
+        Date date = DateTime.stringToDate( str, formatDateReel );
+        boolean anneeBonne = true;
+        if(date == null) {
+        	anneeBonne = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une annÃ©e au format "+format);
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	int yearEnd = c.get(Calendar.YEAR);
+        	c = Calendar.getInstance();
+        	c.setTime(dateBegin);
+        	int yearBegin = c.get(Calendar.YEAR);
+        	c = Calendar.getInstance();
+        	c.setTime(date);
+        	int year = c.get(Calendar.YEAR);
+        	if (year < yearBegin) {
+        		anneeBonne = false;
+        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: une annÃ©e supÃ©rieure ou Ã©gale Ã© "+yearBegin);
+        	} else if (year > yearEnd) {
+        		anneeBonne = false;
+        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: une annÃ©e infÃ©rieure ou Ã©gale Ã© "+yearEnd);
+        	}
+        }
+        mes.setValid(anneeBonne);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un mois au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    @SuppressWarnings("unchecked")
+    public static Message testerMonth(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        if (str.length() == 1) str = "0"+str;
+        Date date = DateTime.stringToDate( str, format );
+        boolean moisBon = true;
+        if(date == null) {
+        	moisBon = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un mois au format "+format);
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	int monthEnd = c.get(Calendar.MONTH);
+        	c = Calendar.getInstance();
+        	c.setTime(dateBegin);
+        	int monthBegin = c.get(Calendar.MONTH);
+        	c = Calendar.getInstance();
+        	c.setTime(date);
+        	int month = c.get(Calendar.MONTH);
+        	if (month < monthBegin) {
+        		moisBon = false;
+        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: un mois supÃ©rieur ou Ã©gal Ã© "+(monthBegin+1));
+        	} else if (month > monthEnd) {
+        		moisBon = false;
+        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: un mois infÃ©rieur ou Ã©gal Ã© "+(monthEnd+1));
+        	}
+        }
+        mes.setValid(moisBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un jour au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    @SuppressWarnings("unchecked")
+    public static Message testerDay(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        String formatDateReel = format.replaceAll("DD", "dd");
+        if (str.length() == 1) str = "0"+str;
+        Date date = DateTime.stringToDate( str, formatDateReel );
+        boolean jourBon = true;
+        if(date == null) {
+        	jourBon = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un jour au format "+format);
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	int dayEnd = c.get(Calendar.DAY_OF_MONTH);
+        	int monthEnd = c.get(Calendar.MONTH)+1;
+        	c = Calendar.getInstance();
+        	c.setTime(dateBegin);
+        	int dayBegin = c.get(Calendar.DAY_OF_MONTH);
+        	int monthBegin = c.get(Calendar.MONTH)+1;
+        	c = Calendar.getInstance();
+        	c.setTime(date);
+        	int day = c.get(Calendar.DAY_OF_MONTH);
+        	if (monthBegin == monthEnd) {
+        		if (day < dayBegin) {
+        			jourBon = false;
+        			mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour supÃ©rieur ou Ã©gal Ã© "+dayBegin);
+        		} else if (day > dayEnd) {
+        			jourBon = false;
+        			mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour infÃ©rieur ou Ã©gal Ã© "+dayEnd);
+        		}
+        	} else {
+        		if (day < 1) {
+	        		jourBon = false;
+	        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour supÃ©rieur ou Ã©gal Ã© 1");
+	        	} else if (day > 31) {
+	        		jourBon = false;
+	        		mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour infÃ©rieur ou Ã©gal Ã© 31");
+	        	}
+        	}
+        }
+        mes.setValid(jourBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est une heure au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerHour(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        if (str.length() == 1) str = "0"+str;
+        Date date = DateTime.stringToDate( str, format );
+        boolean heureBonne = true;
+        if(date == null) {
+        	heureBonne = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une heure au format "+format);
+        }
+        mes.setValid(heureBonne);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est une minute au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerMinute(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        String formatDateReel = format.replaceAll("MM", "mm");
+        if (str.length() == 1) str = "0"+str;
+        Date date = DateTime.stringToDate( str, formatDateReel );
+        boolean minuteBonne = true;
+        if(date == null) {
+        	minuteBonne = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une minute au format "+format);
+        }
+        mes.setValid(minuteBonne);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est une seconde au format de date indiquÃ©.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerSecond(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        String format = (String) obj;
+        String formatDateReel = format.replaceAll("SS", "ss");
+        if (str.length() == 1) str = "0"+str;
+        Date date = DateTime.stringToDate( str, formatDateReel );
+        boolean secondeBonne = true;
+        if(date == null) {
+        	secondeBonne = false;
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une seconde au format "+format);
+        }
+        mes.setValid(secondeBonne);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un RÃ©el positif indiquant le nombre de secondes depuis une date donnÃ©e,
+     * la date obtenue doit Ã©tre comprise entre les dates de dÃ©but et de fin fournies en paramÃ©tres
+     */
+    @SuppressWarnings("unchecked")
+    public static Message testerSecondsSince(String str, Object obj, Object obj2) {
+    	String str2 = str.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoublePositif(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el positif");
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateSince = dates.get(0);
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	double val = Double.parseDouble(str2);
+        	if (dateSince != null) {
+        		Date date = DateTime.secondsSinceToDate(val, dateSince);
+        		// On rajoute 1 jour Ã© la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
+        		Calendar c = Calendar.getInstance();
+        		c.setTime(dateEnd);
+        		c.add(Calendar.DAY_OF_YEAR, +1);
+        		dateEnd = c.getTime();
+//        		EcritureLog.ecrire("\ndateDeb="+DateTime.dateToString(dateBegin, Constantes.formatDateDefault)
+//        				+", dateFin="+DateTime.dateToString(dateEnd, Constantes.formatDateDefault)
+//        				+", dateSince="+DateTime.dateToString(dateSince, Constantes.formatDateDefault)
+//        				+", val="+val
+//        				+", date="+DateTime.dateToString(date, Constantes.formatDateDefault),"err");
+        		if (date.getTime() < dateBegin.getTime()) {
+        			doubleBon = false;
+        			mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        					", ATTENDU: un nombre de secondes supÃ©rieur Ã© la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
+        		} else if (date.getTime() >= dateEnd.getTime()) {
+        			doubleBon = false;
+        			mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        					", ATTENDU: un nombre de secondes infÃ©rieur Ã© la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
+        		}
+        	}
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+	
+    /**
+     * Teste si une chaine est un RÃ©el positif indiquant le nombre d'heures depuis une date donnÃ©e,
+     * la date obtenue doit Ã©tre comprise entre les dates de dÃ©but et de fin fournies en paramÃ©tres
+     */
+    @SuppressWarnings("unchecked")
+	public static Message testerHoursSince(String str, Object obj, Object obj2) {
+    	String str2 = str.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoublePositif(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el positif");
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateSince = dates.get(0);
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	double val = Double.parseDouble(str2);
+        	Date date = DateTime.hoursSinceToDate(val, dateSince);
+        	// On rajoute 1 jour Ã© la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	c.add(Calendar.DAY_OF_YEAR, +1);
+        	dateEnd = c.getTime();
+        	if (date.getTime() < dateBegin.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre d'heures supÃ©rieur Ã© la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
+        	} else if (date.getTime() >= dateEnd.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre d'heures infÃ©rieur Ã© la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
+        	}
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un RÃ©el positif indiquant le nombre de jours depuis une date donnÃ©e,
+     * la date obtenue doit Ã©tre comprise entre les dates de dÃ©but et de fin fournies en paramÃ©tres
+     */
+    @SuppressWarnings("unchecked")
+	public static Message testerDaysSince(String str, Object obj, Object obj2) {
+    	String str2 = str.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoublePositif(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el positif");
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateSince = dates.get(0);
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	double val = Double.parseDouble(str2);
+        	Date date = DateTime.daysSinceToDate(val, dateSince);
+        	// On rajoute 1 jour Ã© la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	c.add(Calendar.DAY_OF_YEAR, +1);
+        	dateEnd = c.getTime();
+        	if (date.getTime() < dateBegin.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre de jours supÃ©rieur Ã© la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
+        	} else if (date.getTime() >= dateEnd.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre de jours infÃ©rieur Ã© la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
+        	}
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+	
+    /**
+     * Teste si une chaine est un RÃ©el positif indiquant le nombre d'annÃ©e depuis une date donnÃ©e,
+     * la date obtenue doit Ã©tre comprise entre les dates de dÃ©but et de fin fournies en paramÃ©tres
+     */
+    @SuppressWarnings("unchecked")
+	public static Message testerYearsSince(String str, Object obj, Object obj2) {
+    	String str2 = str.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoublePositif(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el positif");
+        } else {
+        	ArrayList<Date> dates = (ArrayList<Date>) obj2;
+        	Date dateSince = dates.get(0);
+        	Date dateBegin = dates.get(1);
+        	Date dateEnd = dates.get(2);
+        	double val = Double.parseDouble(str2);
+        	Date date = DateTime.yearsSinceToDate(val, dateSince);
+        	// On rajoute 1 jour Ã© la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
+        	Calendar c = Calendar.getInstance();
+        	c.setTime(dateEnd);
+        	c.add(Calendar.DAY_OF_YEAR, +1);
+        	dateEnd = c.getTime();
+        	if (date.getTime() < dateBegin.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre d'annÃ©es supÃ©rieur Ã© la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
+        	} else if (date.getTime() >= dateEnd.getTime()) {
+        		doubleBon = false;
+        		mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
+        				", ATTENDU: un nombre d'annÃ©es infÃ©rieur Ã© la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
+        	}
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est valide.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerString(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        mes.setValid(true);
+        return mes;
+    }
+
+    /**
+     * Teste si une chaine est un RÃ©el.
+     * @param str Chaine Ã© tester.
+     * @param nul BoolÃ©en indiquant si la chaine peut Ã©tre nulle.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerDouble(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDouble(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el");
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+
+    /**
+     * Teste si une chaine est un RÃ©el positif.
+     * @param str Chaine Ã© tester.
+     * @param nul BoolÃ©en indiquant si la chaine peut Ã©tre nulle.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerDoublePositif(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoublePositif(str);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un rÃ©el positif");
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un Integer.
+     * @param str Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerInteger(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean integerBon = Nombre.isInteger(str);
+        
+        if(!integerBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier");
+        }
+        mes.setValid(integerBon);
+        return mes;
+    }
+
+    public static Message testerIntegerPositif(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean integerBon = Nombre.isIntegerPositif(str);
+        
+        if(!integerBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier positif");
+        }
+        mes.setValid(integerBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est un Long.
+     * @param str Chaine Ã© tester.
+     * @param nul BoolÃ©en indiquant si la chaine peut Ã©tre nulle.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerLong(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean longBon = Nombre.isLong(str);
+
+        if(!longBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier long");
+        }
+        mes.setValid(longBon);
+        return mes;
+    }
+    
+    /**
+     * Teste si une chaine est une longitude.
+     * @param str2 Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerLongitude(String str2, Object obj, Object obj2) {
+        String str = str2.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean longitudeBonne = true;
+
+        try {
+			double longitude = Double.parseDouble(str);
+			longitudeBonne = (longitude >= Constantes.longitudeMini && longitude <= Constantes.longitudeMaxi);
+		} catch (NumberFormatException e) {
+			longitudeBonne = false;
+		}
+
+        if(!longitudeBonne) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une longitude en degrÃ©s dÃ©cimaux");
+        }
+        mes.setValid(longitudeBonne);
+        return mes;
+    }
+
+    /**
+     * Teste si une chaine est une latitude.
+     * @param str2 Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerLatitude(String str2, Object obj, Object obj2) {
+        String str = str2.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean latitudeBonne = true;
+
+        try {
+			double latitude = Double.parseDouble(str);
+			latitudeBonne = (latitude >= Constantes.latitudeMini && latitude <= Constantes.latitudeMaxi);
+		} catch (NumberFormatException e) {
+			latitudeBonne = false;
+		}
+
+        if(!latitudeBonne) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une latitude en degrÃ©s dÃ©cimaux");
+        }
+        mes.setValid(latitudeBonne);
+        return mes;
+    }
+
+    /**
+     * Teste si une chaine est une altitude.
+     * @param str2 Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerAltitude(String str2, Object obj, Object obj2) {
+        String str = str2.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean altitudeBonne;
+
+        try {
+			double altitude = Double.parseDouble(str);
+			altitudeBonne = (altitude >= Constantes.altitudeMini && altitude <= Constantes.altitudeMaxi);
+		} catch (NumberFormatException e) {
+			altitudeBonne = false;
+		}
+
+        if(!altitudeBonne) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une altitude");
+        }
+        mes.setValid(altitudeBonne);
+        return mes;
+    }
+
+    /*****************************/
+    /**
+     * Teste si une chaine est une altitude gÃ©opotentiel.
+     * @param str2 Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    
+    public static Message testerAltitudeGeop(String str2, Object obj, Object obj2) {
+        String str = str2.replaceAll(",", ".");
+        Message mes = new Message();
+        boolean altitudeGeopBonne;
+        try {
+			double geop = Double.parseDouble(str);
+			// Si la donnÃ©e est un gÃ©opotentiel, il faut la convertir en altitude en divisant par 9.8
+			double altitude = Nombre.geopToAltitude(new Double(geop)).doubleValue();    
+			altitudeGeopBonne = (altitude >= Constantes.altitudeMini && altitude <= Constantes.altitudeMaxi);
+		} catch (NumberFormatException e) {
+			altitudeGeopBonne = false;
+		}
+
+        if(!altitudeGeopBonne) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une altitude");
+        }
+        mes.setValid(altitudeGeopBonne);
+        return mes;
+    }
+    
+    /****************************/
+    /***************************/
+    /**
+     * Teste si une chaine est un pourcentage rÃ©el.
+     * @param str2 Chaine Ã© tester.
+     * @return Le Message de test associÃ©.
+     */
+    public static Message testerDoublePourcent(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoubleInInterval(str, 0, 100);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un pourcentage rÃ©el");
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+
+    public static Message testerDoubleUn(String str, Object obj, Object obj2) {
+        Message mes = new Message();
+        boolean doubleBon = Nombre.isDoubleInInterval(str, 0, 1);
+
+        if(!doubleBon) {
+            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un nombre rÃ©el compris entre 0 et 1");
+        }
+        mes.setValid(doubleBon);
+        return mes;
+    }
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Message.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Message.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Message.java	(revision 488)
@@ -0,0 +1,50 @@
+/*
+ * Created on 16 Jan. 20057
+ */
+package com.medias.integration.validation;
+
+/**
+ * @author
+ *
+ * Message transmis lors de la validation d'une donnÃ©e.
+ */
+public class Message {
+    /**
+     * Construit un Message.
+     */
+    public Message() {
+
+    }
+
+    /**
+     * Construit un message.
+     * @param valid Vrai si la donnÃ©e est valide.
+     * @param message Message de integration.validation, null si valid est vrai.
+     */
+    public Message(boolean valid, String message) {
+        this.valid = valid;
+        this.message = message;
+    }
+
+    public boolean isValid() {
+        return valid;
+    }
+
+    public void setValid(boolean valid) {
+        this.valid = valid;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    /** Vrai si la donnÃ©e est valide. **/
+    private boolean valid;
+
+    /** Message de integration.validation, null si valid est vrai. **/
+    private String message;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Validation.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Validation.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Validation.java	(revision 488)
@@ -0,0 +1,212 @@
+/*
+ * Created on 26 Jan. 2007
+ */
+package com.medias.integration.validation;
+
+import com.medias.Constantes;
+import com.medias.DateTime;
+import com.medias.EcritureLog;
+import com.medias.integration.lecture_ecriture.LectureModeleXML;
+import com.medias.integration.prevalidation.PreValidation;
+import com.medias.integration.vues.ParametreModele;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * @author 
+ *
+ * Classe permettant de valider un ensemble de fichier d'un jeu donnÃ©
+ */
+public class Validation {
+	public Validation(PreValidation preValidation) {
+		this.listeMesures = preValidation.getMesures();
+		this.nbParams = preValidation.getNbParams();
+		this.listeParams = preValidation.getInfoParams();
+		this.nbLignesEntete = preValidation.getEntete().size();
+	}
+
+	public ArrayList<ArrayList<String>> valider(LectureModeleXML lectureModeleXML, String nomFichier) {
+		// On rÃ©cupÃ©re les paramÃ©tres du modÃ©le
+		// NB: si le dÃ©limiteur est l'espace ou la tabulation,
+		// on testera 2 dÃ©limiteurs par dÃ©faut: espace ET tabulation pour Ã©viter les ambiguitÃ©s
+		String delimiteur = lectureModeleXML.getDelimiteur();
+		boolean isDelim2 = false;
+		String delimiteur2 = delimiteur, delimiteur1 = delimiteur;
+		if (delimiteur.equals( Constantes.delimiteur1) || delimiteur.equals(Constantes.delimiteur2)) {
+			delimiteur2 = Constantes.delimiteur22;
+			isDelim2 = true;
+		}
+		String mesure, donnee, datePrec = "", date;
+		// DÃ©clarations, initialisations
+		int erreurNbParam = 0, erreurType = 0, erreurDate = 0, nbErreursFichier = 0;
+		nbErreursTotales = 0;
+		int nbMesures = listeMesures.size();
+		// On initialise la liste des tableaux de donnÃ©es des fichiers trouvÃ©s
+		ArrayList<ArrayList<String>> listeDonnees = new ArrayList<ArrayList<String>>();
+		ArrayList<String> donnees;
+
+		if (listeParams.get(0).getFormat() == null && listeParams.get(0).getDateSince() == null) {
+			EcritureLog.ecrire( "\nErreur Ã© la ligne 9 : La date doit Ã©tre au format YYYY-MM-DD HH:MM:SS Z", "err" );
+			erreurType++;
+		}
+
+		int indiceDelim, numLigne;
+		// On parcourt les mesures du fichier
+		for (int numMesure=0; numMesure< nbMesures; numMesure++) {
+			mesure = listeMesures.get(numMesure).trim();
+			donnees = new ArrayList<String>();
+			numLigne = nbLignesEntete+numMesure+1;
+			indiceDelim = mesure.indexOf(delimiteur1);
+			if (isDelim2 && indiceDelim==-1) indiceDelim = mesure.indexOf(delimiteur2);
+			// Si la mesure contient au moins un dÃ©limiteur...
+			while (indiceDelim != -1) {
+				// On rÃ©cupÃ©re la 1Ã©re donnÃ©e de la mesure avant le dÃ©limiteur
+				donnee = mesure.substring(0, indiceDelim).trim();
+				donnees.add(donnee);
+				// On rÃ©cupÃ©re la mesure restante aprÃ©s le dÃ©limiteur
+				mesure = mesure.substring(indiceDelim+1).trim();
+				indiceDelim = mesure.indexOf(delimiteur1);
+				if (isDelim2 && indiceDelim==-1) indiceDelim = mesure.indexOf(delimiteur2);
+			}
+			donnee = mesure;
+			donnees.add(donnee);
+			// On compare le nombre de paramÃ©tres du modÃ©le avec le nombre de donnÃ©es de la mesure
+//			if (!subdiviser){
+			if (donnees.size() != nbParams) {
+				EcritureLog.ecrire("\nErreur : le fichier n'a pas le nombre de paramÃ©tres attendus Ã© la ligne "+numLigne+" ! Nb donnÃ©es="+donnees.size()+", nb param attendus="+nbParams,"err");
+				erreurNbParam++;
+			}
+			// On stocke les dates dans une liste
+			if (listeParams.get(0).getType().equals("Year"))
+				date = donnees.get(2)+"/"+donnees.get(1)+"/"+donnees.get(0)+" "+donnees.get(3)+":"+donnees.get(4)+":"+donnees.get(5);
+			else
+				date = donnees.get(0);
+			if (date.equals(datePrec)) {
+				if (listeParams.get(0).getType().equals("Year")) {
+					EcritureLog.ecrire("\nErreur Ã© la ligne "+numLigne+", la date '"+date+"' apparait plusieurs fois dans le fichier !","err");
+				} else {
+					double val = Double.parseDouble(date);
+					Date d = DateTime.hoursSinceToDate( val, listeParams.get( 0 ).getDateSince() );
+					EcritureLog.ecrire("\nErreur Ã© la ligne "+numLigne+", la date '"+date+"' ("+DateTime.dateToString(d, Constantes.formatDateJJMMAAAAHHMMSS)+") apparait plusieurs fois dans le fichier !","err");
+				}
+				erreurDate++;
+			}
+			datePrec = date;
+
+			// Test du type de chaque donnee
+			erreurType = testType(donnees,numLigne);//, indiceNiv, nbNiv);
+			nbErreursTotales += erreurType;
+			nbErreursFichier += erreurType;
+			listeDonnees.add(donnees);
+			donnees = null;
+		}
+		listeMesures = null;
+		if (erreurNbParam > 0 || erreurType > 0 || erreurDate > 0) {
+			EcritureLog.ecrire("\nIl y a " + (erreurNbParam + erreurDate + nbErreursFichier)+ " erreur(s) dans le fichier "+nomFichier,"err");
+		}
+		nbErreursTotales += erreurNbParam + erreurDate;
+		return listeDonnees;
+	}
+	
+	public void vider() {
+		listeMesures = null;
+	}
+
+	/**
+	 * 
+	 * @return
+	 * 
+	 */
+	/**
+	 * Teste si le type de la iÃ©me donnÃ©e de la mesure correspond bien au type
+	 * du paramÃ©tre associÃ©
+	 */
+	
+	private int testType(ArrayList<String> donnees, int numLigne) {//, int indiceNiv, int nbNiv) {
+		int erreurType = 0;
+		String donnee, valeurAbsente, type = null, format = null;
+		ParametreModele parametre;
+		Method appelTest;
+		Class<?>[] paramMethode = { String.class, Object.class , Object.class };
+		ArrayList<Date> dates = null;
+		Message message = null;
+		Object obj, obj2;
+//		int indiceParam, cptNiv = 0, cptParam = 0;
+		for (int numDonnee = 0; numDonnee < donnees.size(); numDonnee++) {
+			donnee = donnees.get(numDonnee);
+
+			if (numDonnee < nbParams) {
+				parametre = listeParams.get(numDonnee);//parametres.get(indiceParam);
+				valeurAbsente = parametre.getValAbsente();
+				type = parametre.getType();
+				dates = new ArrayList<Date>();
+				dates.add(parametre.getDateSince());
+				dates.add(parametre.getDateDeb());
+				dates.add(parametre.getDateFin());
+				format = parametre.getFormat();
+			} else {
+				valeurAbsente = donnee;
+				parametre = new ParametreModele();
+			}
+			// On teste les donnÃ©es n'Ã©tant pas Ã©gales Ã© la valeur absente
+			if (valeurAbsente == null || !donnee.equals(valeurAbsente)) {
+					obj = format;
+					obj2 = dates;
+				Object[] argumentsMethode = {donnee,obj,obj2};
+				try {
+					// CrÃ©ation de la mÃ©thode correspondant au type trouvÃ©
+					appelTest = ControleurType.class.getMethod("tester" + type,	paramMethode);
+					try {
+						// Invocation de la mÃ©thode sur la donnÃ©e
+						message = (Message) appelTest.invoke(null, argumentsMethode);
+					} catch (IllegalAccessException e1) {
+						e1.printStackTrace();
+					} catch (InvocationTargetException e1) {
+						e1.printStackTrace();
+					}
+				} catch (NoSuchMethodException e) {
+					e.printStackTrace();
+				}
+				// On affiche les erreurs Ã©ventuelles
+				if (!message.isValid()) {
+				    EcritureLog.ecrire("\nErreur Ã© la ligne "+numLigne+" : " + message.getMessage(),"err");
+					erreurType++;
+				}
+			}
+			// Si la donnÃ©e est une valeur absente et est une latitude : ERREUR
+			else if (parametre.getNom().toLowerCase().equals(Constantes.nomParametreLatitude)) {
+				EcritureLog.ecrire("\nErreur Ã© la ligne "+numLigne+" : La latitude est une valeur absente ("+donnee+")","err");
+				erreurType++;
+			}
+			// Si la donnÃ©e est une valeur absente et est une longitude : ERREUR
+			else if (parametre.getNom().toLowerCase().equals(Constantes.nomParametreLongitude)) {
+				EcritureLog.ecrire("\nErreur Ã© la ligne "+numLigne+" : La longitude est une valeur absente ("+donnee+")","err");
+				erreurType++;
+			}
+		}
+		return erreurType;
+	}
+
+	public int getIndiceNiv() {
+		return indiceNiv;
+	}
+	
+	public int getNbErreursTotales() {
+		return nbErreursTotales;
+	}
+
+	public ArrayList<ParametreModele> getListeParams() {
+		return listeParams;
+	}
+
+	private ArrayList<String> listeMesures;
+	private int nbParams;
+	private int nbLignesEntete;
+	private ArrayList<ParametreModele> listeParams;
+	// Le nombre d'erreurs totales trouvÃ©es pendant la validation
+	private int nbErreursTotales;
+	private int indiceNiv;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/MesureModele.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/MesureModele.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/MesureModele.java	(revision 488)
@@ -0,0 +1,205 @@
+package com.medias.integration.vues;
+
+import java.util.ArrayList;
+
+public class MesureModele {
+	public ArrayList<String> getAlts() {
+		return alts;
+	}
+
+	public void setAlts(ArrayList<String> alts) {
+		this.alts = alts;
+	}
+
+	public ArrayList<String> getGeops() {
+		return geops;
+	}
+
+	public void setGeops(ArrayList<String> geops) {
+		this.geops = geops;
+	}
+
+	public String getFormatHeure() {
+		return formatHeure;
+	}
+
+	public void setFormatHeure(String formatHeure) {
+		this.formatHeure = formatHeure;
+	}
+
+	public String getHeure() {
+		return heure;
+	}
+
+	public void setHeure(String heure) {
+		this.heure = heure;
+	}
+
+	public String getAltitude() {
+		return altitude;
+	}
+
+	public void setAltitude(String altitude) {
+		this.altitude = altitude;
+	}
+
+	public String getDate() {
+		return date;
+	}
+
+	public void setDate(String date) {
+		this.date = date;
+	}
+
+	public String getFlagValidite() {
+		return flagValidite;
+	}
+
+	public void setFlagValidite(String flagValidite) {
+		this.flagValidite = flagValidite;
+	}
+
+	public String getFormatDate() {
+		return formatDate;
+	}
+
+	public void setFormatDate(String formatDate) {
+		this.formatDate = formatDate;
+	}
+
+	public String getHauteurSol() {
+		return hauteurSol;
+	}
+
+	public void setHauteurSol(String hauteurSol) {
+		this.hauteurSol = hauteurSol;
+	}
+
+	public String getLatitude() {
+		return latitude;
+	}
+
+	public void setLatitude(String latitude) {
+		this.latitude = latitude;
+	}
+
+	public String getLongitude() {
+		return longitude;
+	}
+
+	public void setLongitude(String longitude) {
+		this.longitude = longitude;
+	}
+
+	public String getNumSequence() {
+		return numSequence;
+	}
+
+	public void setNumSequence(String numSequence) {
+		this.numSequence = numSequence;
+	}
+
+	public ArrayList<ValeurModele> getValeursMesure() {
+		return valeursMesure;
+	}
+
+	public void setValeursMesure(ArrayList<ValeurModele> valeursMesure) {
+		this.valeursMesure = valeursMesure;
+	}
+
+	public String getAnnee() {
+		return annee;
+	}
+
+	public void setAnnee(String annee) {
+		this.annee = annee;
+	}
+
+	public String getFormatAnnee() {
+		return formatAnnee;
+	}
+
+	public void setFormatAnnee(String formatAnnee) {
+		this.formatAnnee = formatAnnee;
+	}
+
+	public String getFormatJour() {
+		return formatJour;
+	}
+
+	public void setFormatJour(String formatJour) {
+		this.formatJour = formatJour;
+	}
+
+	public String getFormatMois() {
+		return formatMois;
+	}
+
+	public void setFormatMois(String formatMois) {
+		this.formatMois = formatMois;
+	}
+
+	public String getJour() {
+		return jour;
+	}
+
+	public void setJour(String jour) {
+		this.jour = jour;
+	}
+
+	public String getMois() {
+		return mois;
+	}
+
+	public void setMois(String mois) {
+		this.mois = mois;
+	}
+
+	public String getFormatMinutes() {
+		return formatMinutes;
+	}
+
+	public void setFormatMinutes(String formatMinutes) {
+		this.formatMinutes = formatMinutes;
+	}
+
+	public String getMinutes() {
+		return minutes;
+	}
+
+	public void setMinutes(String minutes) {
+		this.minutes = minutes;
+	}
+
+	public ArrayList<ParametreModele> getParamsValeur() {
+		return paramsValeur;
+	}
+
+	public void setParamsValeur(ArrayList<ParametreModele> paramsValeur) {
+		this.paramsValeur = paramsValeur;
+	}
+
+	ArrayList<ValeurModele> valeursMesure = null;
+	ArrayList<ParametreModele> paramsValeur = null;
+	ArrayList<String> geops = null;
+	ArrayList<String> alts = null;
+
+	private String date = null;
+	private String formatDate = null;
+	private String minutes = null;
+	private String formatMinutes = null;
+	private String heure = null;
+	private String formatHeure = null;
+	private String mois = null;
+	private String formatMois = null;
+	private String jour = null;
+	private String formatJour = null;
+	private String annee = null;
+	private String formatAnnee = null;
+	private String latitude = null;
+	private String longitude = null;
+	private String altitude = null;
+	private String hauteurSol = null;
+	private String flagValidite = null;
+	private String numSequence = null;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ParametreModele.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ParametreModele.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ParametreModele.java	(revision 488)
@@ -0,0 +1,169 @@
+/*
+ * Created on 25 Jan. 2007
+ */
+package com.medias.integration.vues;
+
+import java.util.Date;
+
+/**
+ * @author 
+ *
+ * ReprÃ©sente les caractÃ©ristiques d'un paramÃ©tre d'un modÃ©le de jeu de donnÃ©es.
+ */
+public class ParametreModele {
+	public ParametreModele() {
+		nom = "";
+	}
+	
+	public ParametreModele(String nom, String type, String fonction,
+			String unite, String delta, String numero, String format, String lod) {
+		this.nom = nom;
+		this.type = type;
+		this.fonction = fonction;
+		this.nomUnite = unite;
+		this.delta = ((delta!=null && !delta.equals(""))?delta:null);
+		this.numero = numero;
+		this.format = format;
+		this.lod = ((lod!=null && !lod.equals(""))?lod:null);
+	}
+
+	public String toString() {
+		return "Param="+nom+", fonction="+fonction+", unite="+nomUnite+", type="+type+", format="+format+", valAbsente="+valAbsente;
+	}
+
+	public String getDelta() {
+		return delta;
+	}
+
+	public void setDelta(String delta) {
+		this.delta = delta;
+	}
+
+	public String getFonction() {
+		return fonction;
+	}
+
+	public void setFonction(String fonction) {
+		this.fonction = fonction;
+	}
+
+	public String getFormat() {
+		return format;
+	}
+
+	public void setFormat(String format) {
+		this.format = format;
+	}
+
+	public String getNom() {
+		return nom;
+	}
+
+	public void setNom(String nom) {
+		this.nom = nom;
+	}
+
+	public String getNumero() {
+		return numero;
+	}
+
+	public void setNumero(String numero) {
+		this.numero = numero;
+	}
+
+	public String getNomUnite() {
+		return nomUnite;
+	}
+
+	public void setNomUnite(String nomUnite) {
+		this.nomUnite = nomUnite;
+	}
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	public String getLod() {
+		return lod;
+	}
+
+	public void setLod(String lod) {
+		this.lod = lod;
+	}
+	
+	public String getValAbsente() {
+		return valAbsente;
+	}
+
+	public void setValAbsente(String valAbsente) {
+		this.valAbsente = valAbsente;
+	}
+
+	public Date getDateDeb() {
+		return dateDeb;
+	}
+
+	public void setDateDeb(Date dateDeb) {
+		this.dateDeb = dateDeb;
+	}
+
+	public Date getDateFin() {
+		return dateFin;
+	}
+
+	public void setDateFin(Date dateFin) {
+		this.dateFin = dateFin;
+	}
+
+	public Date getDateSince() {
+		return dateSince;
+	}
+
+	public void setDateSince(Date dateSince) {
+		this.dateSince = dateSince;
+	}
+
+	public int getIndiceParam() {
+		return indiceParam;
+	}
+
+	public void setIndiceParam(int indiceParam) {
+		this.indiceParam = indiceParam;
+	}
+
+	public int getIndiceCapt() {
+		return indiceCapt;
+	}
+
+	public void setIndiceCapt(int indiceCapt) {
+		this.indiceCapt = indiceCapt;
+	}
+
+	public String getCoef() {
+		return coef;
+	}
+
+	public void setCoef(String coef) {
+		this.coef = coef;
+	}
+
+	private String nom;
+	private String type;
+	private String fonction;
+	private String nomUnite;
+	private String delta;
+	private String numero;
+	private String format;
+	private String lod;
+	private String valAbsente = null;
+	private String coef = null;
+	private Date dateDeb;
+	private Date dateFin;
+	private Date dateSince;
+	private int indiceParam;
+	private int indiceCapt;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/PlateformeModele.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/PlateformeModele.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/PlateformeModele.java	(revision 488)
@@ -0,0 +1,102 @@
+/*
+ * Created on 25 Jan. 2007
+ */
+package com.medias.integration.vues;
+
+/**
+ * @author 
+ *
+ * ReprÃ©sente les caractÃ©ristiques d'une plate-forme d'un modÃ©le de jeu de donnÃ©es.
+ */
+public class PlateformeModele {
+	public String getAltMax() {
+		return altMax;
+	}
+
+	public void setAltMax(String altMax) {
+		this.altMax = altMax;
+	}
+
+	public String getAltMin() {
+		return altMin;
+	}
+
+	public void setAltMin(String altMin) {
+		this.altMin = altMin;
+	}
+
+	public String getHsMax() {
+		return hsMax;
+	}
+
+	public void setHsMax(String hsMax) {
+		this.hsMax = hsMax;
+	}
+
+	public String getHsMin() {
+		return hsMin;
+	}
+
+	public void setHsMin(String hsMin) {
+		this.hsMin = hsMin;
+	}
+
+	public String getLatMax() {
+		return latMax;
+	}
+
+	public void setLatMax(String latMax) {
+		this.latMax = latMax;
+	}
+
+	public String getLatMin() {
+		return latMin;
+	}
+
+	public void setLatMin(String latMin) {
+		this.latMin = latMin;
+	}
+
+	public String getLonMax() {
+		return lonMax;
+	}
+
+	public void setLonMax(String lonMax) {
+		this.lonMax = lonMax;
+	}
+
+	public String getLonMin() {
+		return lonMin;
+	}
+
+	public void setLonMin(String lonMin) {
+		this.lonMin = lonMin;
+	}
+
+	public String getNom() {
+		return nom;
+	}
+
+	public void setNom(String nom) {
+		this.nom = nom;
+	}
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	private String nom;
+	private String type;
+	private String latMin;
+	private String latMax;
+	private String lonMin;
+	private String lonMax;
+	private String altMin;
+	private String altMax;
+	private String hsMin = null;
+	private String hsMax = null;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/SequenceModele.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/SequenceModele.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/SequenceModele.java	(revision 488)
@@ -0,0 +1,118 @@
+package com.medias.integration.vues;
+
+import java.util.Date;
+
+public class SequenceModele {
+	public int getNbMesures(int numSeq) {
+		return numSeq;
+	}
+	
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	public int getNbMesures() {
+		return nbMesures;
+	}
+
+	public void setNbMesures(int nbMesures) {
+		this.nbMesures = nbMesures;
+	}
+
+	public Integer getAltMaxSeq() {
+		return altMaxSeq;
+	}
+
+	public void setAltMaxSeq(Integer altMaxSeq) {
+		this.altMaxSeq = altMaxSeq;
+	}
+
+	public Integer getAltMinSeq() {
+		return altMinSeq;
+	}
+
+	public void setAltMinSeq(Integer altMinSeq) {
+		this.altMinSeq = altMinSeq;
+	}
+
+	public Date getDateMaxSeq() {
+		return dateMaxSeq;
+	}
+
+	public void setDateMaxSeq(Date dateMaxSeq) {
+		this.dateMaxSeq = dateMaxSeq;
+	}
+
+	public Date getDateMinSeq() {
+		return dateMinSeq;
+	}
+
+	public void setDateMinSeq(Date dateMinSeq) {
+		this.dateMinSeq = dateMinSeq;
+	}
+
+	public Integer getHsMaxSeq() {
+		return hsMaxSeq;
+	}
+
+	public void setHsMaxSeq(Integer hsMaxSeq) {
+		this.hsMaxSeq = hsMaxSeq;
+	}
+
+	public Integer getHsMinSeq() {
+		return hsMinSeq;
+	}
+
+	public void setHsMinSeq(Integer hsMinSeq) {
+		this.hsMinSeq = hsMinSeq;
+	}
+
+	public Integer getLatMaxSeq() {
+		return latMaxSeq;
+	}
+
+	public void setLatMaxSeq(Integer latMaxSeq) {
+		this.latMaxSeq = latMaxSeq;
+	}
+
+	public Integer getLatMinSeq() {
+		return latMinSeq;
+	}
+
+	public void setLatMinSeq(Integer latMinSeq) {
+		this.latMinSeq = latMinSeq;
+	}
+
+	public Integer getLonMaxSeq() {
+		return lonMaxSeq;
+	}
+
+	public void setLonMaxSeq(Integer lonMaxSeq) {
+		this.lonMaxSeq = lonMaxSeq;
+	}
+
+	public Integer getLonMinSeq() {
+		return lonMinSeq;
+	}
+
+	public void setLonMinSeq(Integer lonMinSeq) {
+		this.lonMinSeq = lonMinSeq;
+	}
+
+	private Date dateMinSeq = null;
+	private Date dateMaxSeq = null;
+	private Integer latMinSeq = null;
+	private Integer latMaxSeq = null;
+	private Integer lonMinSeq = null;
+	private Integer lonMaxSeq = null;
+	private Integer altMinSeq = null;
+	private Integer altMaxSeq = null;
+	private Integer hsMinSeq = null;
+	private Integer hsMaxSeq = null;
+	private String description = null;
+	private int nbMesures = 0;
+}
Index: /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ValeurModele.java
===================================================================
--- /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ValeurModele.java	(revision 488)
+++ /ether_megapoli/trunk/service/implementation/com/medias/integration/vues/ValeurModele.java	(revision 488)
@@ -0,0 +1,60 @@
+package com.medias.integration.vues;
+
+//import java.util.ArrayList;
+
+public class ValeurModele {
+	public String getValeurFlag() {
+		return valeurFlag;
+	}
+
+	public void setValeurFlag(String valeurFlag) {
+		this.valeurFlag = valeurFlag;
+	}
+
+	public String getValeurDelta() {
+		return valeurDelta;
+	}
+
+	public void setValeurDelta(String valeurDelta) {
+		this.valeurDelta = valeurDelta;
+	}
+
+	public String getDelta() {
+		return delta;
+	}
+
+	public void setDelta(String delta) {
+		this.delta = delta;
+	}
+
+	public String getNumUnite() {
+		return numUnite;
+	}
+
+	public void setNumUnite(String numUnite) {
+		this.numUnite = numUnite;
+	}
+
+	public String getValeurVal() {
+		return valeurVal;
+	}
+
+	public void setValeurVal(String valeurVal) {
+		this.valeurVal = valeurVal;
+	}
+
+	public String getValeurLod() {
+		return valeurLod;
+	}
+
+	public void setValeurLod(String valeurLod) {
+		this.valeurLod = valeurLod;
+	}
+
+	private String valeurVal;
+	private String valeurDelta;
+	private String numUnite;
+	private String delta;
+	private String valeurLod;
+	private String valeurFlag;
+}
