source: ether_megapoli/trunk/service/implementation/com/medias/integration/validation/Validation.java @ 488

/*
 * 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;
}