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

Last change on this file since 482 was 482, checked in by vmipsl, 12 years ago

BO insertion données _ insertion code medias package insertion
  • Property svn:executable set to *
File size: 10.1 KB
Line 
1/*
2 * Created on 26 Jan. 2007
3 */
4package integration.validation;
5import integration.lecture_ecriture.LectureModeleXML;
6import integration.lecture_ecriture.EcritureLog;
7import integration.prevalidation.PreValidation;
8import integration.utils.Constantes;
9import integration.utils.DateTime;
10import integration.vues.ParametreModele;
11
12import java.lang.reflect.InvocationTargetException;
13import java.lang.reflect.Method;
14import java.util.ArrayList;
15import java.util.Date;
16
17/**
18 * @author
19 *
20 * Classe permettant de valider un ensemble de fichier d'un jeu donné
21 */
22public class Validation {
23
24        private ArrayList<String> listeMesures;
25        private int nbParams;
26        private int nbLignesEntete;
27        private ArrayList<ParametreModele> listeParams;
28        // Le nombre d'erreurs totales trouvées pendant la validation
29        private int nbErreursTotales;
30        private int indiceNiv;
31       
32        public Validation(PreValidation preValidation) {
33                this.listeMesures = preValidation.getMesures();
34                this.nbParams = preValidation.getNbParams();
35                this.listeParams = preValidation.getInfoParams();
36                this.nbLignesEntete = preValidation.getEntete().size();
37        }
38
39        public ArrayList<ArrayList<String>> valider(LectureModeleXML lectureModeleXML, String nomFichier) {
40                // On récupére les paramétres du modéle
41//              ArrayList<ParametreModele> parametres = lectureModeleXML.getParametres();
42//              int nbParametres = parametres.size();
43                // NB: si le délimiteur est l'espace ou la tabulation,
44                // on testera 2 délimiteurs par défaut: espace ET tabulation pour éviter les ambiguités
45                String delimiteur = lectureModeleXML.getDelimiteur();
46                boolean isDelim2 = false;
47                String delimiteur2 = delimiteur, delimiteur1 = delimiteur;
48                if (delimiteur.equals(Constantes.delimiteur1) || delimiteur.equals(Constantes.delimiteur2)) {
49                        delimiteur2 = Constantes.delimiteur22;
50                        isDelim2 = true;
51                }
52//              String valeurAbsente = lectureModeleXML.getValeurAbsente();
53//              boolean subdiviser = Boolean.parseBoolean(lectureModeleXML.getSubdiviser());
54                String mesure, donnee, datePrec = "", date;
55                // Déclarations, initialisations
56                int erreurNbParam = 0, erreurType = 0, erreurDate = 0, nbErreursFichier = 0;
57                nbErreursTotales = 0;
58                int nbMesures = listeMesures.size();
59                // On initialise la liste des tableaux de données des fichiers trouvés
60                ArrayList<ArrayList<String>> listeDonnees = new ArrayList<ArrayList<String>>();
61                ArrayList<String> donnees;
62                // On cherche si une subdivision est nécessaire
63//              indiceNiv = -1;
64//              int nbNiv = 0;
65//              if (subdiviser) {
66//                      indiceNiv = chercherIndiceSubdivision(parametres);
67//              }
68
69                if (listeParams.get(0).getFormat() == null && listeParams.get(0).getDateSince() == null) {
70                        EcritureLog.ecrire("\nErreur é la ligne 9 : La date doit étre au format YYYY-MM-DD HH:MM:SS Z","err");
71                        erreurType++;
72                }
73
74                int indiceDelim, numLigne;
75                // On parcourt les mesures du fichier
76                for (int numMesure=0; numMesure< nbMesures; numMesure++) {
77                        mesure = listeMesures.get(numMesure).trim();
78                        donnees = new ArrayList<String>();
79                        numLigne = nbLignesEntete+numMesure+1;
80                        indiceDelim = mesure.indexOf(delimiteur1);
81                        if (isDelim2 && indiceDelim==-1) indiceDelim = mesure.indexOf(delimiteur2);
82                        // Si la mesure contient au moins un délimiteur...
83                        while (indiceDelim != -1) {
84                                // On récupére la 1ére donnée de la mesure avant le délimiteur
85                                donnee = mesure.substring(0, indiceDelim).trim();
86                                donnees.add(donnee);
87                                // On récupére la mesure restante aprés le délimiteur
88                                mesure = mesure.substring(indiceDelim+1).trim();
89                                indiceDelim = mesure.indexOf(delimiteur1);
90                                if (isDelim2 && indiceDelim==-1) indiceDelim = mesure.indexOf(delimiteur2);
91                        }
92                        donnee = mesure;
93                        donnees.add(donnee);
94                        // On compare le nombre de paramétres du modéle avec le nombre de données de la mesure
95//                      if (!subdiviser){
96                        if (donnees.size() != nbParams) {
97                                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");
98                                erreurNbParam++;
99                        }
100                        // On stocke les dates dans une liste
101                        if (listeParams.get(0).getType().equals("Year"))
102                                date = donnees.get(2)+"/"+donnees.get(1)+"/"+donnees.get(0)+" "+donnees.get(3)+":"+donnees.get(4)+":"+donnees.get(5);
103                        else
104                                date = donnees.get(0);
105                        if (date.equals(datePrec)) {
106                                if (listeParams.get(0).getType().equals("Year")) {
107                                        EcritureLog.ecrire("\nErreur é la ligne "+numLigne+", la date '"+date+"' apparait plusieurs fois dans le fichier !","err");
108                                } else {
109                                        double val = Double.parseDouble(date);
110                                        Date d = DateTime.hoursSinceToDate(val, listeParams.get(0).getDateSince());
111                                        EcritureLog.ecrire("\nErreur é la ligne "+numLigne+", la date '"+date+"' ("+DateTime.dateToString(d, Constantes.formatDateJJMMAAAAHHMMSS)+") apparait plusieurs fois dans le fichier !","err");
112                                }
113                                erreurDate++;
114                        }
115                        datePrec = date;
116//                      } else {
117                                // Cas oé il y a une subdivision
118//                              nbNiv = Integer.parseInt(donnees.get(indiceNiv));
119//                              int nbParametresSubdivises = indiceNiv + 1;
120//                              nbParametresSubdivises += nbNiv * (nbParametres - nbParametresSubdivises);
121//                              if (donnees.size() != nbParametresSubdivises) {
122//                                      EcritureLog.ecrire("\nErreur : le fichier n'a pas le nombre de paramétres attendus é la mesure "+ (numMesure + 1) + " ! Nb données="+donnees.size()+", nb param attendus="+nbParametresSubdivises,"err");
123//                                      erreurNbParam++;
124//                              }
125//                      }
126
127                        // Test du type de chaque donnee
128                        erreurType = testType(donnees,numLigne);//, indiceNiv, nbNiv);
129                        nbErreursTotales += erreurType;
130                        nbErreursFichier += erreurType;
131                        listeDonnees.add(donnees);
132                        donnees = null;
133                }
134                listeMesures = null;
135                if (erreurNbParam > 0 || erreurType > 0 || erreurDate > 0) {
136                        EcritureLog.ecrire("\nIl y a " + (erreurNbParam + erreurDate + nbErreursFichier)+ " erreur(s) dans le fichier "+nomFichier,"err");
137                }
138                nbErreursTotales += erreurNbParam + erreurDate;
139                return listeDonnees;
140        }
141
142        /**
143         * Vérifie si les mesures du fichier doivent étre subdivisées
144         * Renvoie -1 s'il n'y a pas de subdivision é faire
145         * Sinon renvoie l'indice du paramétre de subdivision
146         */
147//      private int chercherIndiceSubdivision(ArrayList<ParametreModele> parametres) {
148//              int indNiv = -1;
149//              for (int numParam=0; numParam<parametres.size(); numParam++) {
150//                      if (parametres.get(numParam).getFonction().equals(Constantes.fonctionSubdiviser)){
151//                              indNiv = numParam;
152//                              break;
153//                      }
154//              }
155//              return indNiv;
156//      }
157       
158        public int getIndiceNiv() {
159                return indiceNiv;
160        }
161
162        /**
163         *
164         * @return
165         *
166         */
167        /**
168         * Teste si le type de la iéme donnée de la mesure correspond bien au type
169         * du paramétre associé
170         */
171       
172        private int testType(ArrayList<String> donnees, int numLigne) {//, int indiceNiv, int nbNiv) {
173                int erreurType = 0;
174                String donnee, valeurAbsente, type = null, format = null;
175                ParametreModele parametre;
176                Method appelTest;
177                Class<?>[] paramMethode = { String.class, Object.class , Object.class };
178                ArrayList<Date> dates = null;
179                Message message = null;
180                Object obj, obj2;
181//              int indiceParam, cptNiv = 0, cptParam = 0;
182                for (int numDonnee = 0; numDonnee < donnees.size(); numDonnee++) {
183                        donnee = donnees.get(numDonnee);
184                       
185                        // On recherche le paramétre associé é la donnée
186                        // Cas oé il n'y a pas de subdivision
187//                      if (indiceNiv == -1) {
188//                              indiceParam = numDonnee;
189//                      }
190                        // Cas oé il y a subdivision
191//                      else {
192                                // Cas oé la donnée est avant la donnée de subdivision
193//                              if (numDonnee <= indiceNiv) {
194//                                      indiceParam = numDonnee;
195//                                      cptParam++;
196//                              }
197                                // Cas oé la donnée est aprés la donnée de subdivision
198//                              else {
199//                                      cptNiv++;
200                                        // Cas oé on arrive é la derniére donnée du paramétre courant
201//                                      if (cptNiv > nbNiv) {
202//                                              cptParam++;
203//                                              cptNiv = 1;
204//                                      }
205//                                      indiceParam = cptParam;
206//                              }
207//                      }
208                        if (numDonnee < nbParams) {
209                                parametre = listeParams.get(numDonnee);//parametres.get(indiceParam);
210                                valeurAbsente = parametre.getValAbsente();
211                                type = parametre.getType();
212                                dates = new ArrayList<Date>();
213                                dates.add(parametre.getDateSince());
214                                dates.add(parametre.getDateDeb());
215                                dates.add(parametre.getDateFin());
216                                format = parametre.getFormat();
217                        } else {
218                                valeurAbsente = donnee;
219                                parametre = new ParametreModele();
220                        }
221                        // On teste les données n'étant pas égales é la valeur absente
222                        if (valeurAbsente == null || !donnee.equals(valeurAbsente)) {
223//                              if (dates.get(0) == null)
224                                        obj = format;
225//                              else
226                                        obj2 = dates;
227                                Object[] argumentsMethode = {donnee,obj,obj2};
228                                try {
229                                        // Création de la méthode correspondant au type trouvé
230                                        appelTest = ControleurType.class.getMethod("tester" + type,     paramMethode);
231                                        try {
232                                                // Invocation de la méthode sur la donnée
233                                                message = (Message) appelTest.invoke(null, argumentsMethode);
234//                                      } catch (IllegalArgumentException e1) {
235//                                              e1.printStackTrace();
236                                        } catch (IllegalAccessException e1) {
237                                                e1.printStackTrace();
238                                        } catch (InvocationTargetException e1) {
239                                                e1.printStackTrace();
240                                        }
241//                              } catch (SecurityException e) {
242//                                      e.printStackTrace();
243                                } catch (NoSuchMethodException e) {
244                                        e.printStackTrace();
245                                }
246                                // On affiche les erreurs éventuelles
247                                if (!message.isValid()) {
248                                    EcritureLog.ecrire("\nErreur é la ligne "+numLigne+" : " + message.getMessage(),"err");
249                                        erreurType++;
250                                }
251                        }
252                        // Si la donnée est une valeur absente et est une latitude : ERREUR
253                        else if (parametre.getNom().toLowerCase().equals(Constantes.nomParametreLatitude)) {
254                                EcritureLog.ecrire("\nErreur é la ligne "+numLigne+" : La latitude est une valeur absente ("+donnee+")","err");
255                                erreurType++;
256                        }
257                        // Si la donnée est une valeur absente et est une longitude : ERREUR
258                        else if (parametre.getNom().toLowerCase().equals(Constantes.nomParametreLongitude)) {
259                                EcritureLog.ecrire("\nErreur é la ligne "+numLigne+" : La longitude est une valeur absente ("+donnee+")","err");
260                                erreurType++;
261                        }
262                }
263                return erreurType;
264        }
265       
266        public int getNbErreursTotales() {
267                return nbErreursTotales;
268        }
269
270        public ArrayList<ParametreModele> getListeParams() {
271                return listeParams;
272        }
273       
274        public void vider() {
275                listeMesures = null;
276        }
277       
278}
Note: See TracBrowser for help on using the repository browser.