source: ether_megapoli/trunk/service/implementation/com/medias/integration/repartition/Repartition.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: 44.3 KB
Line 
1/**
2 * Created on 00 00. 0000
3 *  @author
4 */
5
6package integration.repartition;
7import integration.hibernate.*;
8import integration.lecture_ecriture.*;
9import integration.utils.*;
10import integration.vues.*;
11import java.io.File;
12import java.math.BigDecimal;
13import java.util.*;
14
15public class Repartition {
16
17        private LectureModeleXML lectureModeleXML;
18        private LectureCapteurs lectureCapteurs;
19        private LecturePlateformes lecturePlateformes;
20        private LectureParametres lectureParametres;
21        private LecturePersonnes lecturePersonnes;
22        private LectureUnites lectureUnites;
23        private LectureOrganismes lectureOrganismes;
24       
25        /**
26         * Classe permettant de lire et d'écrire dans un fichier
27         */
28        public Repartition(LectureModeleXML lectureModeleXML, LectureCapteurs lectureCapteurs,
29                        LecturePlateformes lecturePlateformes,
30                        LectureParametres lectureParametres,
31                        LecturePersonnes lecturePersonnes, LectureUnites lectureUnites,
32                        LectureOrganismes lectureOrganismes) {
33                this.lectureModeleXML = lectureModeleXML;
34                this.lectureCapteurs = lectureCapteurs;
35                this.lecturePlateformes = lecturePlateformes;
36                this.lectureParametres = lectureParametres;
37                this.lecturePersonnes = lecturePersonnes;
38                this.lectureUnites = lectureUnites;
39                this.lectureOrganismes = lectureOrganismes;
40        }
41
42        /**
43         * Traitement des informations personnes
44         */
45        public ArrayList<Personne> repartirPersonnes() {
46                ArrayList<Personne> personnes = new ArrayList<Personne>();
47                /** Traitement de personne Intégrateur */
48                String numIntegrateur = lectureModeleXML.getNumeroIntegrateur();
49                if (numIntegrateur == null) {
50                        EcritureLog.ecrire("Erreur : pas d'intégrateur trouvé", "err");
51                } else {
52                        Personne integrateur = repartirPersonne(numIntegrateur);
53                        personnes.add(integrateur);
54                }
55
56                /** Traitement de la personne Contact */
57                String numContact = lectureModeleXML.getNumeroContact();
58                if (numContact == null) {
59                        EcritureLog.ecrire("Erreur : pas de contact trouvé ", "err");
60                } else {
61                        Personne contact = repartirPersonne(numContact);
62                        personnes.add(contact);
63                }
64
65                /** Traitement de la personne PI */
66                String numPI = lectureModeleXML.getNumeroPi();
67                if (numPI != null) {
68                        Personne pi = repartirPersonne(numPI);
69                        personnes.add(pi);
70                }
71                return personnes;
72        }
73       
74        /**
75         * Répartition d'un objet personne é partir de son numéro
76         */
77        public Personne repartirPersonne(String num) {
78                // On va chercher dans la liste des personnes la personne correspondant au numéro trouvé
79                int indicePers = lecturePersonnes.getIndice(Integer.parseInt(num));
80                String mail = lecturePersonnes.getMailsPers().get(indicePers);
81                String nom = lecturePersonnes.getNomsPers().get(indicePers);
82                String prenom = lecturePersonnes.getPrenomsPers().get(indicePers);
83                String numOrg = lecturePersonnes.getNumOrgsPers().get(indicePers);
84                String role = lecturePersonnes.getDescriptionsPers().get(indicePers);
85                Organisme organisme = null;
86                // On va chercher dans la liste des organismes l'organisme correspondant au numéro trouvé
87                if (numOrg == null) {
88                        EcritureLog.ecrire("Erreur : pas d'organisme trouvé pour "+prenom+" "+nom, "err");
89                } else {
90                        organisme = repartirOrganisme(numOrg);
91                }
92                Personne personne = new Personne();
93                Commentaire commentaire = new Commentaire();
94                commentaire.setCommentaireTxt(role);
95                commentaire.setLangue(Constantes.langueEN);
96                personne.setCommentaire(commentaire);
97                personne.setOrganisme(organisme);
98                personne.setPersonneMail(mail);
99                personne.setPersonneNom(nom);
100                personne.setPersonnePrenom(prenom);
101                return personne;
102        }
103
104        /**
105         * Répartition d'un objet organisme é partir de son numéro
106         */
107        public Organisme repartirOrganisme(String num) {
108                int indiceOrg = lectureOrganismes.getIndice(Integer.parseInt(num));
109                String codepostal = lectureOrganismes.getCodesPostalsOrg().get(indiceOrg);
110                String descriptionOrg = lectureOrganismes.getDescriptionsOrg().get(indiceOrg);
111                String mailOrg = lectureOrganismes.getMailsOrg().get(indiceOrg);
112                String nomOrg = lectureOrganismes.getNomsOrg().get(indiceOrg);
113                String pays = lectureOrganismes.getPaysOrg().get(indiceOrg);
114                String rue = lectureOrganismes.getRuesOrg().get(indiceOrg);
115                String urlOrg = lectureOrganismes.getUrlsOrg().get(indiceOrg);
116                String ville = lectureOrganismes.getVillesOrg().get(indiceOrg);
117                Adresse adresse = new Adresse();
118                adresse.setAdressePays(pays);
119                adresse.setAdresseRue(rue);
120                adresse.setAdresseVille(ville);
121                adresse.setAdresseZip(codepostal);
122                Organisme organisme = new Organisme();
123                organisme.setAdresse(adresse);
124                Commentaire commentaire = new Commentaire();
125                commentaire.setCommentaireTxt(descriptionOrg);
126                commentaire.setCommentaireUrl(urlOrg);
127                Langue langue = (pays.equals("France")?Constantes.langueFR:Constantes.langueEN);
128                commentaire.setLangue(langue);
129                organisme.setCommentaire(commentaire);
130                organisme.setOrganismeMail(mailOrg);
131                organisme.setOrganismeNom(nomOrg);
132                return organisme;
133        }
134       
135        /**
136         * Traitement des informations Jeu
137         */
138        public Jeu repartirJeu(ArrayList<Personne> personnes, String numVersion) {
139                /** On recupere les infos du modéle */
140                String nomCategorie = lectureModeleXML.getNomCategorie();
141                String nomJeu = lectureModeleXML.getNomJeu();
142                String descriptionJeu = lectureModeleXML.getDescriptionJeu();
143                String numOrganisme = lectureModeleXML.getNumOrganismeJeu();
144                Langue langue = Constantes.langueEN;
145                // On va chercher dans la liste des personnes la personne correspondant au numéro trouvé
146                Jeu jeu = new Jeu();
147                Categorie categorie = new Categorie();
148                categorie.setCategorieId(getCategorieId(nomCategorie));
149                categorie.setCategorieNom(nomCategorie);
150                jeu.setCategorie(categorie);
151                jeu.setJeuDateinser(new Date(System.currentTimeMillis()));
152                jeu.setJeuNom(nomJeu);
153                jeu.setJeuNumversion(numVersion);
154                // On va chercher les infos sur l'organisme du jeu
155                if (numOrganisme == null) {
156                        EcritureLog.ecrire("Erreur : pas d'organisme trouvé pour le jeu","err");
157                } else {
158                        Organisme organisme = repartirOrganisme(numOrganisme);
159                        jeu.setOrganisme(organisme);
160                        if (organisme.getAdresse().getAdressePays().equals("France"))
161                                langue = Constantes.langueFR;
162                }
163                if (descriptionJeu != null) {
164                        Commentaire commentaire = new Commentaire();
165                        commentaire.setCommentaireTxt(descriptionJeu);
166                        commentaire.setLangue(langue);
167                        jeu.setCommentaire(commentaire);
168                }
169                jeu.setPersonneByContactId(personnes.get(Constantes.indiceContact));
170                jeu.setPersonneByIntegrateurId(personnes.get(Constantes.indiceIntegrateur));
171                if (personnes.size() == 3) {
172                        jeu.setPersonneByPiId(personnes.get(Constantes.indicePI));
173                }
174                return jeu;
175        }
176
177        /**
178         * Traitement des informations Capteurs
179         */
180        public ArrayList<Capteur> repartirCapteurs(ArrayList<Parametre> parametres) {
181                ArrayList<Capteur> capteurs = new ArrayList<Capteur>();
182                ArrayList<String> numsCapteur = lectureModeleXML.getNumsCapteur();
183                Capteur capteur;
184                String numCapteur;
185                // On retrouve les infos de chaque capteur é partir de son numéro
186                for (int num = 0; num < numsCapteur.size(); num++) {
187                        numCapteur = numsCapteur.get(num);
188                        if (numCapteur == null) {
189                                EcritureLog.ecrire("Erreur : pas de capteur trouvé", "err");
190                        } else {
191                                capteur = repartirCapteur(numCapteur, parametres);
192                                capteurs.add(capteur);
193                        }
194                }
195                return capteurs;
196        }
197       
198        public Capteur repartirCapteur(String num, ArrayList<Parametre> parametres) {
199                int indiceCapteur = lectureCapteurs.getIndice(Integer.parseInt(num));
200                String modele = lectureCapteurs.getModelesCapt().get(indiceCapteur);
201                String numSerie = lectureCapteurs.getNumsSeriesCapt().get(indiceCapteur);
202                String etalonnage = lectureCapteurs.getEtalonnagesCapt().get(indiceCapteur);
203//              String descriptionCapt = lectureCapteurs.getDescriptionsCapt().get(indiceCapteur);
204                String nomTypeCapt = lectureCapteurs.getTypesCapt().get(indiceCapteur);
205//              String descriptionTypeCapt = lectureCapteurs.getDescriptionsTypeCapt().get(indiceCapteur);
206                String nomFabriquant = lectureCapteurs.getFabriquantsCapt().get(indiceCapteur);
207                ArrayList<String> numsParametres = lectureCapteurs.getNumsParametresCapt().get(indiceCapteur);
208
209                Capteur capteur = new Capteur();
210                capteur.setCapteurEtalonnage((etalonnage.equals("")?null:etalonnage));
211                capteur.setCapteurModele((modele.equals("")?Constantes.unknown:modele));
212                capteur.setCapteurNumserie((numSerie.equals("")?Constantes.unknown:numSerie));
213//              if (descriptionCapt != null && !descriptionCapt.trim().equals("")) {
214//                      commentaireCapt = new Commentaire();
215//                      commentaireCapt.setCommentaireTxt(descriptionCapt);
216//                      commentaireCapt.setLangue(Constantes.langueFR);
217//                      capteur.setCommentaire(commentaireCapt);
218//              }
219                Fabriquant fabriquant = new Fabriquant();
220                fabriquant.setFabriquantNom((nomFabriquant.equals("")?Constantes.unknown:nomFabriquant));
221                capteur.setFabriquant(fabriquant);
222                // Répartition des paramétres du capteur
223                Set<Parametre> parametresCapt = new HashSet<Parametre>();
224                Parametre parametreCapt;
225                for (String numParametre: numsParametres) {
226                        if (numParametre != null && !numParametre.equals("")) {
227                                parametreCapt = repartirParametre(numParametre);
228                                for (Parametre parametre: parametres) {
229                                        if (parametre.getParametreCode().equals(parametreCapt.getParametreCode())) {
230                                                parametresCapt.add(parametreCapt);
231                                                break;
232                                        }
233                                }
234                        }
235                }
236                capteur.setParametres(parametresCapt);
237//              Set<Jeu> jeuxCapt = new HashSet<Jeu>();
238//              jeuxCapt.add(jeu);
239//              capteur.setJeus(jeuxCapt);
240                TypeCapteur typeCapteur = new TypeCapteur();
241                typeCapteur.setTypeCapteurNom(nomTypeCapt);
242//              if (descriptionTypeCapt != null && !descriptionCapt.trim().equals("")) {
243//                      commentaireTypeCapt = new Commentaire();
244//                      commentaireTypeCapt.setCommentaireTxt(descriptionTypeCapt);
245//                      commentaireTypeCapt.setLangue(Constantes.langueFR);
246//                      typeCapteur.setCommentaire(commentaireTypeCapt);
247//              }
248                capteur.setTypeCapteur(typeCapteur);
249                return capteur;
250        }
251
252        /**
253         * Traitement des informations Parametres
254         */
255        public ArrayList<Parametre> repartirParametres() {
256                ArrayList<Parametre> parametres = new ArrayList<Parametre>();
257                ArrayList<ParametreModele> parametresJeu = lectureModeleXML.getParametres();
258                Parametre parametre;
259                String numParametre;
260                // On retrouve les infos de chaque paramétre é partir de son numéro
261                for (ParametreModele paramJeu: parametresJeu) {
262                        numParametre = paramJeu.getNumero();
263                        if (numParametre != null) {
264                                parametre = repartirParametre(numParametre);
265                                parametre.setDelta(paramJeu.getDelta());
266                                parametre.setLod(paramJeu.getLod());
267                                parametres.add(parametre);
268                        }
269                }
270                return parametres;
271        }
272       
273        public Parametre repartirParametre(String num) {
274                int indiceParametre = lectureParametres.getIndice(Integer.parseInt(num));
275                String nomPar = lectureParametres.getNomsParam().get(indiceParametre);
276                String codeMegapoliPar = lectureParametres.getCodesMegapoliParam().get(indiceParametre);
277                String numUnitePar = lectureParametres.getNumsUnitesParam().get(indiceParametre);
278//              descriptionPar = lectureParametres.getDescriptionsParam().get(indiceParametre);
279                String categoriePar = lectureParametres.getCategoriesParam().get(indiceParametre);
280                Parametre parametre = new Parametre();
281                CategorieParam categorieParam = new CategorieParam();
282                categorieParam.setCategorieParamDomaine(Constantes.domaineCategorieParam);
283                categorieParam.setCategorieParamNom((categoriePar.equals("")?Constantes.unknown:categoriePar));
284                parametre.setCategorieParam(categorieParam);
285//              commentairePar = new Commentaire();
286//              commentairePar.setCommentaireTxt(descriptionPar);
287//              commentairePar.setLangue(Constantes.langueFR);
288//              parametre.setCommentaire(commentairePar);
289                parametre.setParametreCode(codeMegapoliPar);
290                parametre.setParametreNom(nomPar);
291//              Set<Jeu> jeuxParam = new HashSet<Jeu>();
292//              jeuxParam.add(jeu);
293//              parametre.setJeus(jeuxParam);
294                // on recupere l'unité du paramétre
295                if (numUnitePar == null) {
296                        EcritureLog.ecrire("Erreur : pas d'unité trouvée pour le paramétre "+nomPar, "err");
297                } else {
298                        Unite unite = repartirUnite(numUnitePar);
299                        parametre.setUnite(unite);
300                }
301                return parametre;
302        }
303
304        public Unite repartirUnite(String num) {
305                int indiceUnite = lectureUnites.getIndice(Integer.parseInt(num));
306                String codeUnitePar = lectureUnites.getCodesUni().get(indiceUnite);
307                String nomUnitePar = lectureUnites.getNomsUni().get(indiceUnite);
308                Unite unite = new Unite();
309                unite.setUniteCode(codeUnitePar);
310                unite.setUniteNom(nomUnitePar);
311                return unite;
312        }
313       
314        /**
315         * Traitement des informations Plateformes
316         */
317        public ArrayList<Plateforme> repartirPlateformes(String pays, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) {
318                ArrayList<Plateforme> platesformes = new ArrayList<Plateforme>();
319                ArrayList<String> numsPlateforme = lectureModeleXML.getNumsPlateforme();
320                Plateforme plateforme;
321                String numPlat;
322                // On retrouve les infos de chaque plateforme é partir de son numéro
323                for (int num = 0; num < numsPlateforme.size(); num++) {
324                        numPlat = numsPlateforme.get(num);
325                        if (numPlat == null) {
326                                EcritureLog.ecrire("Erreur : pas de plateforme trouvé", "err");
327                        } else {
328                                plateforme = repartirPlateforme(numPlat, pays, capteurs, parametres);
329                                platesformes.add(plateforme);
330                        }
331                }
332                return platesformes;
333        }
334       
335        public Plateforme repartirPlateforme(String num, String pays, ArrayList<Capteur> capteurs, ArrayList<Parametre> parametres) {
336                int indicePlat = lecturePlateformes.getIndice(Integer.parseInt(num));
337                String nomPlat = lecturePlateformes.getNomsPLat().get(indicePlat);
338                String nomTypePlat = lecturePlateformes.getTypesPlat().get(indicePlat);
339                String descriptionPlat = lecturePlateformes.getDescriptionsPLat().get(indicePlat);
340                ArrayList<String> numsCapteurs = lecturePlateformes.getNumsCaptPlat().get(indicePlat);
341                String altMaxPLat = lecturePlateformes.getAltMaxsPLat().get(indicePlat);
342                String altMinPLat = lecturePlateformes.getAltMinsPLat().get(indicePlat);
343                //hautSolMaxPlat = lecturePlateformes.getHautSolMaxsPlat().get(indicePlat);
344                //hautSolMinPlat = lecturePlateformes.getHautSolMinsPlat().get(indicePlat);
345                String latMaxPLat = lecturePlateformes.getLatMaxsPLat().get(indicePlat);
346                String latMinPLat = lecturePlateformes.getLatMinsPLat().get(indicePlat);
347                String longMaxPLat = lecturePlateformes.getLongMaxsPLat().get(indicePlat);
348                String longMinPLat = lecturePlateformes.getLongMinsPLat().get(indicePlat);
349                // On stocke la plateforme
350                PlateformeModele plateformeModele = new PlateformeModele();
351                plateformeModele.setAltMax(altMaxPLat);
352                plateformeModele.setAltMin(altMinPLat);
353                //plateformeModele.setHsMax(hautSolMaxPlat);
354                //plateformeModele.setHsMin(hautSolMinPlat);
355                plateformeModele.setLatMax(latMaxPLat);
356                plateformeModele.setLatMin(latMinPLat);
357                plateformeModele.setLonMax(longMaxPLat);
358                plateformeModele.setLonMin(longMinPLat);
359                plateformeModele.setNom(nomPlat);
360                plateformeModele.setType(nomTypePlat);
361                Statiques.plateformesModele.add(plateformeModele);
362                // On construit la plateforme
363                Plateforme plateforme = new Plateforme();
364                // Répartition des capteurs de la plateforme
365                Set<Capteur> capts = new HashSet<Capteur>();
366                Set<Parametre> params = new HashSet<Parametre>();
367                ArrayList<String> paramsCode = new ArrayList<String>();
368                Capteur capteurPlat;
369                for (String numCapteur: numsCapteurs) {
370                        if (numCapteur != null && !numCapteur.equals("")) {
371                                capteurPlat = repartirCapteur(numCapteur,parametres);
372                                for (Capteur capteur: capteurs) {
373                                        if (capteur.getCapteurModele().equals(capteurPlat.getCapteurModele())
374                                                        && capteur.getCapteurNumserie().equals(capteurPlat.getCapteurNumserie())
375                                                        && capteur.getFabriquant().getFabriquantNom().equals(capteurPlat.getFabriquant().getFabriquantNom())
376                                                        && capteur.getTypeCapteur().getTypeCapteurNom().equals(capteurPlat.getTypeCapteur().getTypeCapteurNom())) {
377                                                capts.add(capteurPlat);
378                                                // Répartition des paramétres du capteur dans la plateforme
379                                                for (Parametre parametre : capteurPlat.getParametres()) {
380                                                        if (!paramsCode.contains(parametre.getParametreCode())) {
381                                                                paramsCode.add(parametre.getParametreCode());
382                                                                params.add(parametre);
383                                                        }
384                                                }
385                                                break;
386                                        }
387                                }
388                        }
389                }
390                plateforme.setCapteurs(capts);
391                plateforme.setParametres(params);
392                // Répartition de la localisation de la plateforme
393                Set<RequetePlatLoc> requetePlatLocs = new HashSet<RequetePlatLoc>();
394                RequetePlatLoc requetePlatLoc = new RequetePlatLoc();
395                requetePlatLoc.setAltMax(Nombre.altDoubleToInt(Double.valueOf(altMaxPLat)));
396                requetePlatLoc.setAltMin(Nombre.altDoubleToInt(Double.valueOf(altMinPLat)));
397                requetePlatLoc.setLatMax(Nombre.latDoubleToInt(Double.valueOf(latMaxPLat)));
398                requetePlatLoc.setLatMin(Nombre.latDoubleToInt(Double.valueOf(latMinPLat)));
399                requetePlatLoc.setLonMax(Nombre.latDoubleToInt(Double.valueOf(longMaxPLat)));
400                requetePlatLoc.setLonMin(Nombre.latDoubleToInt(Double.valueOf(longMinPLat)));
401                requetePlatLocs.add(requetePlatLoc);
402                plateforme.setRequetePlatLocs(requetePlatLocs);
403                // Répartition du jeu de la plateforme
404//              Set<Jeu> jeuxPlat = new HashSet<Jeu>();
405//              jeuxPlat.add(jeu);
406//              plateforme.setJeus(jeuxPlat);
407                if (descriptionPlat != null && !descriptionPlat.trim().equals("")) {
408                        Commentaire commentaire = new Commentaire();
409                        commentaire.setCommentaireTxt(descriptionPlat);
410                        Langue langue = (pays.equals("France")?Constantes.langueFR:Constantes.langueEN);
411                        commentaire.setLangue(langue);
412                        plateforme.setCommentaire(commentaire);
413                }
414                plateforme.setPlateformeNom(nomPlat);
415                TypePlateforme typePlateforme = new TypePlateforme();
416                typePlateforme.setTypePlateformeNom(nomTypePlat);
417                plateforme.setTypePlateforme(typePlateforme);
418                return plateforme;
419        }
420       
421        /**
422         * Traitement des informations fichier
423         */
424        public Fichier repartirFichier(Jeu jeu, File file) {
425                Fichier fichier = new Fichier();
426                fichier.setFichierNom(file.getName());
427                BigDecimal taille = new BigDecimal(file.length());
428                taille = taille.divide(new BigDecimal(1024),3,BigDecimal.ROUND_HALF_DOWN);
429                fichier.setFichierTaille(taille);
430                fichier.setJeu(jeu);
431                return fichier;
432        }
433
434        /**
435         * Traitement des informations des données de la mesure
436         */
437        public MesureModele repartirDonnees(ArrayList<String> donneesMesure,ArrayList<ParametreModele> parametresModele) {
438                //, String numSequencePrecedent, int indiceNiv) {
439                MesureModele mesureModele = new MesureModele();
440                ArrayList<ParametreModele> paramsValeur = new ArrayList<ParametreModele>();
441                String donnee, fonctionParam, formatDate, nomParam, typeDate, dateStr = "";
442                ParametreModele parametreModele;
443                ValeurModele valeurModele;
444                Date date = null;
445                ArrayList<ValeurModele> valeursMesure = new ArrayList<ValeurModele>();
446//              int indiceParam;
447//              String numUniteParam = null;
448//              Integer lat_s = null, lon_s = null, alt_s = null, hs_s = null;
449//              boolean subdiviser = Boolean.parseBoolean(lectureModeleXML.getSubdiviser());
450//              SequenceModele sequenceModele = null;
451//              int cptParam = 0;
452//              int cptNiv = 0;
453                // Cas oé il y'a une subdivision
454//              int nbNiv = 1;
455//              if (subdiviser) {
456//                      nbNiv = Integer.parseInt(donneesMesure.get(indiceNiv));
457//              }
458                // Pour chaque donnée de la ligne de mesure...
459                for(int numDonnee = 0 ; numDonnee < donneesMesure.size() ; numDonnee++){
460                        donnee = donneesMesure.get(numDonnee);
461
462                        // On recherche le paramétre associé é la donnée
463                        // Cas oé il n'y a pas de subdivision
464//                      if (!subdiviser) {
465//                              indiceParam = numDonnee;
466//                      }
467                        // Cas oé il y a subdivision
468//                      else {
469                                // Cas oé la donnée est avant la donnée de subdivision
470//                              if (numDonnee <= indiceNiv) {
471//                                      indiceParam = numDonnee;
472//                                      cptParam++;
473//                              }
474                                // Cas oé la donnée est aprés la donnée de subdivision
475//                              else {
476//                                      cptNiv++;
477                                        // Cas oé on arrive é la derniére donnée du paramétre courant
478//                                      if (cptNiv > nbNiv) {
479//                                              cptParam++;
480//                                              cptNiv = 1;
481//                                      }
482//                                      indiceParam = cptParam;
483//                              }
484//                      }
485                       
486                        parametreModele = parametresModele.get(numDonnee);//indiceParam);
487                        fonctionParam = parametreModele.getFonction();
488                        nomParam = parametreModele.getNom();
489                        // Si la donnée est une date
490                        if (fonctionParam.equals(Constantes.nomFonctionDate)){
491                                formatDate = parametreModele.getFormat();
492                                typeDate = parametreModele.getType();
493                                if (formatDate == null) {
494                                        if (typeDate.equals("HoursSince"))
495                                                date = DateTime.hoursSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
496                                        else if (typeDate.equals("SecondsSince"))
497                                                date = DateTime.secondsSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
498                                        else if (typeDate.equals("YearsSince"))
499                                                date = DateTime.yearsSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
500                                        else
501                                                date = DateTime.daysSinceToDate(Double.parseDouble(donnee.replaceAll(",", ".")), parametreModele.getDateSince());
502                                } else {
503                                        formatDate = formatDate.replaceAll("DD", "dd").replaceAll("YYYY", "yyyy").replaceAll(":MM", ":mm").replaceAll(":SS", ":ss");
504                                        if (typeDate.equals("Date")) {
505                                                date = DateTime.stringToDate(donnee, formatDate);
506                                        } else if (typeDate.equals("Year")) {
507                                                dateStr = donnee;
508                                        } else if (typeDate.equals("Month")) {
509                                                dateStr += (donnee.length()==1?"0":"")+donnee;
510                                        } else if (typeDate.equals("Day")) {
511                                                dateStr += (donnee.length()==1?"0":"")+donnee;
512                                        } else if (typeDate.equals("Hour")) {
513                                                dateStr += (donnee.length()==1?"0":"")+donnee;
514                                        } else if (typeDate.equals("Minute")) {
515                                                dateStr += (donnee.length()==1?"0":"")+donnee;
516                                        } else if (typeDate.equals("Second")) {
517                                                dateStr += (donnee.length()==1?"0":"")+donnee;
518                                        }
519                                        if (/*date == null && */dateStr.length() == 14) {
520                                                date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHHMMSS);
521                                        } else if (dateStr.length() == 12) {
522                                                date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHHMM);
523                                        } else if (dateStr.length() == 10) {
524                                                date = DateTime.stringToDate(dateStr, Constantes.formatDateAAAAMMJJHH);
525                                        }
526                                }
527                                if (date != null) {
528                                        mesureModele.setDate(DateTime.dateToString(date, Constantes.formatDateDefault));
529                                }
530//                              mesureModele.setFormatDate(formatDate);
531                        }
532                        // Si la donnée est un mois
533//                      if (nomParam != null && nomParam.equals(Constantes.nomParametreMois)){
534//                              formatDate = parametreModele.getFormat();
535//                              mesureModele.setMois(donnee);
536//                              mesureModele.setFormatMois(formatDate);
537//                      }
538                        // Si la donnée est un jour
539//                      if (nomParam != null && nomParam.equals(Constantes.nomParametreJour)){
540//                              formatDate = parametreModele.getFormat();
541//                              mesureModele.setJour(donnee);
542//                              mesureModele.setFormatJour(formatDate);
543//                      }       
544                        // Si la donnée est une annee
545//                      if (nomParam != null && nomParam.equals(Constantes.nomParametreAnnee)){
546//                              formatDate = parametreModele.getFormat();
547//                              mesureModele.setAnnee(donnee);
548//                              mesureModele.setFormatAnnee(formatDate);
549//                      }
550                        // Si la donnée est une heure
551//                      if (nomParam != null && nomParam.equals(Constantes.nomParametreHeure)){
552//                              formatDate = parametreModele.getFormat();
553//                              mesureModele.setHeure(donnee);
554//                              mesureModele.setFormatHeure(formatDate);
555//                      }
556                        // Si la donnée est une minute
557//                      if (nomParam != null && nomParam.equals(Constantes.nomParametreMinute)){
558//                              formatDate = parametreModele.getFormat();
559//                              mesureModele.setMinutes(donnee);
560//                              mesureModele.setFormatMinutes(formatDate);
561//                      }
562                        else if(fonctionParam.equals(Constantes.nomFonctionInsererLoc)) {
563                                // Si la donnée est une latitude
564                                if (nomParam.toLowerCase().equals(Constantes.nomParametreLatitude)){
565                                        mesureModele.setLatitude(donnee);
566                                }
567                                // Si la donnée est une longitude
568                                else if (nomParam.toLowerCase().equals(Constantes.nomParametreLongitude)){
569                                        mesureModele.setLongitude(donnee);
570                                 }
571                                // Si la donnée est une altitude
572                                else if (nomParam.toLowerCase().equals(Constantes.nomParametreAltitude)){
573//                                      if (!subdiviser){
574                                                if (donnee.equals(parametreModele.getValAbsente())) {
575                                                        mesureModele.setAltitude("0");
576                                                } else {
577                                                        mesureModele.setAltitude(donnee);
578                                                }
579//                                      } else {
580//                                              if (mesureModele.getAlts() == null) {
581//                                                      mesureModele.setAlts(new ArrayList<String>());
582//                                              }
583//                                              mesureModele.getAlts().add(donnee);
584//                                      }
585                                }
586                                // Si la donnée est une altitude géopotentielle
587//                              else if (nomParam != null && nomParam.equals(Constantes.nomParametreGeop)){
588//                                      if (mesureModele.getGeops() == null) {
589//                                              mesureModele.setGeops(new ArrayList<String>());
590//                                      }
591//                                      mesureModele.getGeops().add(donnee);
592//                              }                       
593                                // Si la donnée est une hauteur sol
594                                else if (nomParam != null && nomParam.equals(Constantes.nomParametreHauteurSol)){
595                                        mesureModele.setHauteurSol(donnee);
596                                }
597                        }
598                        // Si la donnée est une information sur la sequence
599//                      else if(fonctionParam.equals(Constantes.nomFonctionInsererSeq)){
600//                              mesureModele.setNumSequence(donnee);
601//                              Statiques.numSeq = Integer.valueOf(donnee);
602//                              lat_s = Nombre.latDoubleToInt(Double.parseDouble(mesureModele.getLatitude()));
603//                              lon_s = Nombre.latDoubleToInt(Double.parseDouble(mesureModele.getLongitude()));
604//                              alt_s = Nombre.altDoubleToInt(Double.parseDouble(mesureModele.getAltitude()));
605//                              if (mesureModele.getHauteurSol() != null) {
606//                                      hs_s = Nombre.altDoubleToInt(Double.parseDouble(mesureModele.getHauteurSol()));
607//                              }
608//                              date = DateTime.stringToDate(mesureModele.getDate(), DateTime.convertirFormat(mesureModele.getFormatDate()));
609                                // Si c'est une nouvelle séquence...
610//                              if (!donnee.equals(numSequencePrecedent)) {
611                                        // Si ce n'est pas la premiére séquence, on construit la séquence précédant la nouvelle séquence
612//                                      if (Statiques.dateMinSeq != null) {
613//                                              sequenceModele = new SequenceModele();
614//                                              sequenceModele.setAltMaxSeq(Statiques.altMaxSeq);
615//                                              sequenceModele.setAltMinSeq(Statiques.altMinSeq);
616//                                              sequenceModele.setDateMaxSeq(Statiques.dateMaxSeq);
617//                                              sequenceModele.setDateMinSeq(Statiques.dateMinSeq);
618                                                // Séquence ascendante : 1
619                                                // Séquence descendante : 0
620//                                              if (Integer.parseInt(numSequencePrecedent) == Constantes.numSequencesAscendante) {
621//                                                      sequenceModele.setDescription(Constantes.descriptionSequencesAscendante);
622//                                              } else if (Integer.parseInt(numSequencePrecedent) == Constantes.numSequencesDescendante) {
623//                                                      sequenceModele.setDescription(Constantes.descriptionSequencesDescendante);
624//                                              }
625//                                              sequenceModele.setHsMaxSeq(Statiques.hsMaxSeq);
626//                                              sequenceModele.setHsMinSeq(Statiques.hsMinSeq);
627//                                              sequenceModele.setLatMaxSeq(Statiques.latMaxSeq);
628//                                              sequenceModele.setLatMinSeq(Statiques.latMinSeq);
629//                                              sequenceModele.setLonMaxSeq(Statiques.lonMaxSeq);
630//                                              sequenceModele.setLonMinSeq(Statiques.lonMinSeq);
631//                                              sequenceModele.setNbMesures(Statiques.nbMesuresSeq);
632//                                              Statiques.sequencesModeles.add(sequenceModele);
633//                                      }
634//                                      Statiques.dateMinSeq = date;
635//                                      Statiques.dateMaxSeq = date;
636//                                      Statiques.latMinSeq = lat_s;
637//                                      Statiques.latMaxSeq = lat_s;
638//                                      Statiques.lonMinSeq = lon_s;
639//                                      Statiques.lonMaxSeq = lon_s;
640//                                      Statiques.altMinSeq = alt_s;
641//                                      Statiques.altMaxSeq = alt_s;
642//                                      if (hs_s != null) {
643//                                              Statiques.hsMinSeq = hs_s;
644//                                              Statiques.hsMaxSeq = hs_s;
645//                                      }
646//                                      Statiques.nbMesuresSeq = 1;
647//                              }
648                                // Ce n'est pas une nouvelle séquence
649//                              else {
650                                        // On calcule les bornes
651//                              if (Statiques.latMinSeq.intValue() > lat_s.intValue()) {
652//                                      Statiques.latMinSeq = lat_s;
653//                              }
654//                              if (Statiques.latMaxSeq.intValue() < lat_s.intValue()) {
655//                                      Statiques.latMaxSeq = lat_s;
656//                              }
657//                              if (Statiques.lonMinSeq.intValue() > lon_s.intValue()) {
658//                                      Statiques.lonMinSeq = lon_s;
659//                              }
660//                              if (Statiques.lonMaxSeq.intValue() < lon_s.intValue()) {
661//                                      Statiques.lonMaxSeq = lon_s;
662//                              }
663//                              if (Statiques.altMinSeq.intValue() > alt_s.intValue()) {
664//                                      Statiques.altMinSeq = alt_s;
665//                              }
666//                              if (Statiques.altMaxSeq.intValue() < alt_s.intValue()) {
667//                                      Statiques.altMaxSeq = alt_s;
668//                              }
669//                              if (hs_s != null && Statiques.hsMinSeq.intValue() > hs_s.intValue()) {
670//                                      Statiques.hsMinSeq = hs_s;
671//                              }
672//                              if (hs_s != null && Statiques.hsMaxSeq.intValue() < hs_s.intValue()) {
673//                                      Statiques.hsMaxSeq = hs_s;
674//                              }
675//                              if (Statiques.dateMinSeq.getTime() > date.getTime()) {
676//                                      Statiques.dateMinSeq = date;
677//                              }
678//                              if (Statiques.dateMaxSeq.getTime() < date.getTime()) {
679//                                      Statiques.dateMaxSeq = date;
680//                              }
681//                              Statiques.nbMesuresSeq++;
682//                              }
683//                      }
684                        // Si la donnée est un flag validité
685//                      else if(fonctionParam.equals(Constantes.nomFonctionInsererFlagValidite)){
686//                              mesureModele.setFlagValidite(donnee);
687//                      }
688                        // Si la donnée est une valeur
689                        else if(fonctionParam.equals(Constantes.nomFonctionInsererVal)){
690                                //      On vérifie que la donnée n'est pas une valeur absente
691                                //      if (!donnee.equals(lectureModeleXML.getValeurAbsente())){
692//                                      numUniteParam = parametreModele.getNumUnite();
693                                paramsValeur.add(parametreModele);
694                                valeurModele = new ValeurModele();
695//                                      valeurModele.setNumUnite(numUniteParam);
696                                valeurModele.setValeurDelta(parametreModele.getDelta());
697                                valeurModele.setValeurLod(parametreModele.getLod());
698                                valeurModele.setValeurVal(donnee);
699//                                      if (subdiviser) {
700//                                              if (mesureModele.getGeops() != null) {
701//                                                      valeurModele.setValeurFlag("geop_"+mesureModele.getGeops().get(cptNiv-1));
702//                                              }
703//                                              if (mesureModele.getAlts() != null) {
704//                                                      valeurModele.setValeurFlag("alt_"+mesureModele.getAlts().get(cptNiv-1));
705//                                              }
706//                                      }
707                                valeursMesure.add(valeurModele);
708                        // }
709                        }
710                        // Si la donnée est un delta
711//                      else if(fonctionParam.equals(Constantes.nomFonctionInsererDelta)){
712                                // On cherche la valeur qui a pour delta cette donnée
713//                              for (int numValeur = 0; numValeur < valeursMesure.size(); numValeur++) {
714//                                      valeurModele = valeursMesure.get(numValeur);
715                                        // Si la valeur a pour delta cette donnée, on attribue le delta é cette valeur
716//                                      if (nomParam != null && nomParam.equals(valeurModele.getDelta())
717//                                                      && !donnee.equals(lectureModeleXML.getValeurAbsente())) {
718                                                // Pas de subdivision
719//                                              if (!subdiviser){
720//                                                      valeurModele.setValeurDelta(donnee);
721//                                              }
722                                                // Cas oé il y a subdivision
723//                                              else {
724//                                                      valeursMesure.get(numValeur+cptNiv-1).setValeurDelta(donnee);
725//                                              }
726//                                              break;
727//                                      }
728//                              }
729//                      }
730                        mesureModele.setParamsValeur(paramsValeur);
731                        mesureModele.setValeursMesure(valeursMesure);
732                }
733                return mesureModele;
734        }
735       
736        /**
737         * Répartition de l'objet Mesure
738         */
739        public Mesure repartirMesure(MesureModele mesureModele, Fichier fichier, ArrayList<Plateforme> plateformes) {
740                Mesure mesure = new Mesure();
741                mesure.setFichier(fichier);
742
743                // Plateforme
744                Plateforme plateforme = null;
745                PlateformeModele plateformeModele = null;
746                // Cas une seule plateforme
747                if (plateformes.size() == 1) {
748                        plateforme = plateformes.get(0);
749                        plateformeModele = Statiques.plateformesModele.get(0);
750                }
751                // Cas plusieurs plateformes
752                else {
753                        for (PlateformeModele platMod: Statiques.plateformesModele){
754                                for (Plateforme plat: plateformes){
755                                        // On cherche la plateforme correspondant au modéle
756                                        if (plat.getPlateformeNom().equals(platMod.getNom())) {
757                                                plateforme = plat;
758                                                break;
759                                        }
760                                }
761                                // On cherche la plateforme associée é la mesure é partir du nom du fichier
762                                if (fichier.getFichierNom().toLowerCase().indexOf(platMod.getNom().toLowerCase()) != -1) {
763                                        plateformeModele = platMod;
764                                        break;
765                                }
766                        }
767                }
768                mesure.setPlateforme(plateforme);
769                // Construction de la localisation
770                Localisation localisation = new Localisation();
771                String altitude = mesureModele.getAltitude();
772                String hauteurSol = mesureModele.getHauteurSol();
773                String latitude = mesureModele.getLatitude();
774                String longitude = mesureModele.getLongitude();
775                if (altitude != null) {
776                        // Plateforme mobile : une altitude par mesure
777                        localisation.setLocalisationAlt(Nombre.altDoubleToInt(Double.valueOf(altitude)).intValue());
778                } else {
779                        // Plateforme fixe
780                        localisation.setLocalisationAlt(Nombre.altDoubleToInt(Double.valueOf(plateformeModele.getAltMin())).intValue());
781                }
782                if (hauteurSol != null) {
783                        // Plateforme mobile : une hauteur sol par mesure
784                        localisation.setLocalisationHs(Nombre.altDoubleToInt(Double.valueOf(hauteurSol)).intValue());
785                } else {
786                        // Plateforme fixe et la plateforme a une hauteur sol
787                        if (plateformeModele.getHsMin() != null && !plateformeModele.getHsMin().trim().equals("")) {
788                                localisation.setLocalisationHs(Nombre.altDoubleToInt(Double.valueOf(plateformeModele.getHsMin())).intValue());
789                        }
790                }
791                if (latitude != null ) {
792                        // Plateforme mobile : une latitude par mesure
793                        localisation.setLocalisationLat(Nombre.latDoubleToInt(Double.valueOf(latitude.replaceAll(",","."))).intValue());
794                } else {
795                        // Plateforme fixe
796                        localisation.setLocalisationLat(Nombre.latDoubleToInt(Double.valueOf(plateformeModele.getLatMin())).intValue());
797                }
798                if (longitude != null) {
799                        // Plateforme mobile : une longitude par mesure
800                        localisation.setLocalisationLon(Nombre.latDoubleToInt(Double.valueOf(longitude.replaceAll(",","."))).intValue());
801                } else {
802                        // Plateforme fixe
803                        localisation.setLocalisationLon(Nombre.latDoubleToInt(Double.valueOf(plateformeModele.getLonMin())).intValue());
804                }
805                mesure.setLocalisation(localisation);
806                // Date de la mesure
807                String sdate = mesureModele.getDate();
808//              String sMinutes = mesureModele.getMinutes();
809//              String sheure = mesureModele.getHeure();
810//              String sJour = mesureModele.getJour();
811//              String sMois = mesureModele.getMois();
812//              String sAnnee = mesureModele.getAnnee();
813//              String formatDate = mesureModele.getFormatDate();       
814
815                //si l'heure!=null
816//              if (sMois != null && sJour != null && sAnnee!= null && sheure != null && sMinutes != null){
817//                      String formatMinutes = mesureModele.getFormatMinutes();
818//                      String formatHeure = mesureModele.getFormatHeure();
819//                      String formatJour = mesureModele.getFormatJour();
820//                      String formatAnnee = mesureModele.getFormatAnnee();
821//                      String formatMois = mesureModele.getFormatMois();
822//                      formatDate = formatJour+"/"+formatMois+"/"+formatAnnee+" "+formatHeure+":"+formatMinutes+":SS";
823//                      sdate = sJour+"/"+sMois+"/"+sAnnee+" "+sheure+":"+sMinutes+":00";
824//              }else if (sheure != null){
825//                      String formatHeure = mesureModele.getFormatHeure();     
826//                      formatDate += " "+formatHeure;
827//                      sdate += " "+sheure;
828//              }
829                Date date = DateTime.stringToDate(sdate, Constantes.formatDateDefault);//DateTime.convertirFormat(formatDate));
830                mesure.setMesureDate(date);
831               
832                // Mises é jour des extrema: - Dates min et max du jeu
833                if (Statiques.dateMinJeu.getTime() > date.getTime()) {
834                Statiques.dateMinJeu = date;
835        }
836        if (Statiques.dateMaxJeu.getTime() < date.getTime()) {
837                Statiques.dateMaxJeu = date;
838        }
839        // On calcule les bornes
840                int lat_j = localisation.getLocalisationLat();
841                int lon_j = localisation.getLocalisationLon();
842                int alt_j = localisation.getLocalisationAlt();
843                Integer hs_j = null;
844                if (localisation.getLocalisationHs() != null) {
845                        hs_j = localisation.getLocalisationHs();
846                }
847        // Integer lat = null;
848        if (Statiques.latMinJeu.intValue() > lat_j) {
849                Statiques.latMinJeu = new Integer(lat_j);
850        }
851        if (Statiques.latMaxJeu.intValue() < lat_j) {
852                Statiques.latMaxJeu = new Integer(lat_j);
853        }
854        //Integer lon = null;
855        if (Statiques.lonMinJeu.intValue() > lon_j) {
856                Statiques.lonMinJeu =  new Integer(lon_j);
857        }
858        if (Statiques.lonMaxJeu.intValue() < lon_j) {
859                Statiques.lonMaxJeu =  new Integer(lon_j);
860        }
861        // Integer alt = null;
862        if (Statiques.altMinJeu.intValue() > alt_j) {
863                Statiques.altMinJeu =  new Integer(alt_j);
864        }
865        if (Statiques.altMaxJeu.intValue() < alt_j) {
866                Statiques.altMaxJeu =  new Integer(alt_j);
867        }
868        // Integer hs = null;
869                if (hs_j != null && Statiques.hsMinJeu.intValue() > hs_j.intValue()) {
870                Statiques.hsMinJeu = hs_j;
871        }
872        if (hs_j != null && Statiques.hsMaxJeu.intValue() < hs_j.intValue()) {
873                Statiques.hsMaxJeu = hs_j;
874        }
875                return mesure;
876        }
877       
878        /**
879         * Traitement des informations valeur
880         */
881        public Valeur repartirValeur(Mesure mesure, ValeurModele valeurModele, ParametreModele parametreModele, Parametre parametre, Capteur capteur) {
882                //, String flagValidite, ArrayList<Capteur> capteurs, String codeUnite,ArrayList<String> codesUnite) {
883                Valeur valeur = null;
884                // On vérifie que la donnée n'est pas une valeur absente
885                Double valeurVal = Double.valueOf(valeurModele.getValeurVal().replaceAll(",", "."));
886                double valAbs = Double.valueOf(parametreModele.getValAbsente());
887//              System.out.println("val="+valeurVal+", abs="+valAbs+", param="+parametreModele.getNom());
888//              if (!valeurModele.getValeurVal().equals(parametreModele.getValAbsente())) {
889                if (valeurVal.doubleValue() != valAbs) {
890                        double coef = 1;
891                        if (parametreModele.getCoef() != null) coef = Double.valueOf(parametreModele.getCoef());
892                        valeurVal = Nombre.mult(valeurVal, coef);
893                        valeur = new Valeur();
894                        // CAPTEUR
895//                      Capteur capteur = null;
896                        // Cas un seul capteur
897//                      if (capteurs.size() == 1) {
898//                              capteur = capteurs.get(0);
899//                      }
900                        // Cas plusieurs capteurs
901//                      else {
902//                              Capteur capt, captPlat;
903//                              Parametre paramCapt;
904                                // On récupére la liste des capteurs de la plateforme courante
905//                              Iterator<Capteur> itCaptPlat = mesure.getPlateforme().getCapteurs().iterator();
906//                              Iterator<Parametre> itParamCapt;
907//                              while (itCaptPlat.hasNext()) {
908//                                      captPlat = itCaptPlat.next();
909                                        // On recherche les capteurs associés é la plateforme courante
910//                                      for (int numCapt = 0; numCapt < capteurs.size(); numCapt++) {
911//                                              capt = capteurs.get(numCapt);
912//                                              if (capt.getCapteurModele().equals(captPlat.getCapteurModele())
913//                                                              && capt.getCapteurNumserie().equals(captPlat.getCapteurNumserie())
914//                                                              && capt.getFabriquant().getFabriquantNom().equals(captPlat.getFabriquant().getFabriquantNom())
915//                                                              && capt.getTypeCapteur().getTypeCapteurNom().equals(captPlat.getTypeCapteur().getTypeCapteurNom())) {
916                                                        // On recherche le capteur associé au paramétre de la valeur
917//                                                      itParamCapt = capt.getParametres().iterator();
918//                                                      while (itParamCapt.hasNext()) {
919//                                                              paramCapt = itParamCapt.next();
920//                                                              if (parametre.getParametreCode().equals(paramCapt.getParametreCode())) {
921//                                                                      capteur = capt;
922//                                                                      break;
923//                                                              }
924//                                                      }
925//                                              }
926//                                      }
927//                              }
928//                      }
929                        valeur.setCapteur(capteur);
930                        // Flag VALEUR
931                        if (valeurModele.getValeurFlag() != null) {
932                                Flag flag = new Flag();
933                                flag.setFlagNom(valeurModele.getValeurFlag());
934                                valeur.setFlagByValeurFlag(flag);
935                        }
936                        // Flag VALIDITE
937//                      if (flagValidite != null) {
938//                              int numFlagValidite = Integer.parseInt(flagValidite);
939//                              Flag flag = new Flag();
940//                              if (numFlagValidite == Constantes.numFlagValiditeBon) {
941//                                      flag.setFlagNom(Constantes.descriptionFlagValiditeBonne);
942//                              } else if (numFlagValidite == Constantes.numFlagValiditeMauvais) {
943//                                      flag.setFlagNom(Constantes.descriptionFlagValiditeMauvaise);
944//                              }
945//                              valeur.setFlagByValiditeFlag(flag);
946//                      }
947                        // MESURE
948                        valeur.setMesure(mesure);
949
950                        // PARAMETRE
951                        valeur.setParametre(parametre);
952
953                        // DELTA
954                        String valeurDelta = valeurModele.getValeurDelta();
955                        if (valeurDelta != null) {
956                                valeur.setValeurDelta(Double.valueOf(valeurDelta));
957                        }
958                        // LOD (Limit Of Detection)
959                        String valeurLod = valeurModele.getValeurLod();
960                        if (valeurLod != null) {
961                                valeur.setValeurLod(Double.valueOf(valeurLod));
962                        }
963                        // VALEUR
964                        String codeUniteModele = parametreModele.getNomUnite();
965                        // On compare l'unité du paramétre inséré avec l'unité du paramétre contenu dans le modéle
966                        String codeUniteParam = parametre.getUnite().getUniteCode();
967                        // on recupere l'indice de l'unité du parametre
968//                      int indiceUnite = lectureUnites.getIndice(Integer.parseInt(numUniteParam));
969//                      String codeUniteModele = lectureUnites.getCodesUni().get(indiceUnite);
970                        // Si les unités sont différentes, il y a une conversion é faire
971                        if (!codeUniteParam.equals(codeUniteModele)) {
972                                if (codeUniteModele.equals(Constantes.unitePPB) && codeUniteParam.equals(Constantes.unitePPM)) {
973                                        valeurVal = Nombre.divMille(valeurVal);
974                                }
975                                else if (codeUniteModele.equals(Constantes.unitePPB) && codeUniteParam.equals(Constantes.unitePPT)) {
976                                        valeurVal = Nombre.mult(valeurVal,1000);
977                                }
978                                else if (codeUniteModele.equals(Constantes.unitePPT) && codeUniteParam.equals(Constantes.unitePPB)) {
979                                        valeurVal = Nombre.divMille(valeurVal);
980                                }
981                                else if (codeUniteModele.equals(Constantes.uniteKelvin) && codeUniteParam.equals(Constantes.uniteCelsius)) {
982                                        valeurVal = Nombre.kelvinToCelsius(valeurVal);
983                                }
984                                else if (codeUniteModele.equals(Constantes.unitekPa) && codeUniteParam.equals(Constantes.unitembar)) {
985                                        valeurVal = Nombre.mult(valeurVal,10);
986                                }
987                                else if (codeUniteModele.equals(Constantes.unitepm) && codeUniteParam.equals(Constantes.unitepmm)) {
988                                        valeurVal = Nombre.divMille(valeurVal);
989                                }
990                                else if (codeUniteModele.equals(Constantes.unitengm_3) && codeUniteParam.equals(Constantes.uniteugm_3)) {
991                                        valeurVal = Nombre.divMille(valeurVal);
992                                }
993                        }
994                        valeur.setValeurVal(valeurVal.doubleValue());
995                }
996                return valeur;
997        }
998       
999        /**
1000         * Construction de la derniére séquence
1001         */             
1002        public void repartirDerniereSequence() {
1003                if (Statiques.dateMinSeq != null) {
1004                        SequenceModele sequenceModele = new SequenceModele();
1005                        sequenceModele.setAltMaxSeq(Statiques.altMaxSeq);
1006                        sequenceModele.setAltMinSeq(Statiques.altMinSeq);
1007                        sequenceModele.setDateMaxSeq(Statiques.dateMaxSeq);
1008                        sequenceModele.setDateMinSeq(Statiques.dateMinSeq);
1009                        // Séquence ascendante : 1
1010                        // Séquence descendante : 0
1011                        if (Statiques.numSeq.intValue() == Constantes.numSequencesAscendante) {
1012                                sequenceModele.setDescription(Constantes.descriptionSequencesAscendante);
1013                        } else if (Statiques.numSeq.intValue() == Constantes.numSequencesDescendante) {
1014                                sequenceModele.setDescription(Constantes.descriptionSequencesDescendante);
1015                        }
1016                        sequenceModele.setHsMaxSeq(Statiques.hsMaxSeq);
1017                        sequenceModele.setHsMinSeq(Statiques.hsMinSeq);
1018                        sequenceModele.setLatMaxSeq(Statiques.latMaxSeq);
1019                        sequenceModele.setLatMinSeq(Statiques.latMinSeq);
1020                        sequenceModele.setLonMaxSeq(Statiques.lonMaxSeq);
1021                        sequenceModele.setLonMinSeq(Statiques.lonMinSeq);
1022                        sequenceModele.setNbMesures(Statiques.nbMesuresSeq);
1023                        Statiques.sequencesModeles.add(sequenceModele);
1024                }
1025        }
1026       
1027        /**
1028         *traitement de la sequence
1029         */
1030        public Sequence repartirSequence(Jeu jeu, SequenceModele sequenceModele) {
1031                Sequence sequence =  new Sequence();
1032                String description = sequenceModele.getDescription();
1033                if (description != null) {
1034                        Commentaire commentaireSeq = new Commentaire();
1035                        commentaireSeq.setCommentaireTxt(description);
1036                        commentaireSeq.setLangue(Constantes.langueFR);
1037                        sequence.setCommentaire(commentaireSeq);
1038                }
1039                sequence.setJeu(jeu);
1040                // sequence Altitude Maximale
1041                Integer sequenceAltMax = sequenceModele.getAltMaxSeq();
1042                sequence.setSequenceAltf(sequenceAltMax);
1043                // sequence Altitude Minimale
1044                Integer sequenceAltMin = sequenceModele.getAltMinSeq();
1045                sequence.setSequenceAltd(sequenceAltMin);
1046                // sequence hauteur Sol Maximale
1047                Integer sequenceHsMax = sequenceModele.getHsMaxSeq();
1048                if (sequenceHsMax != null) {
1049                        sequence.setSequenceHsf(sequenceHsMax);
1050                }
1051
1052                // sequence hauteur Sol Minimale
1053                Integer sequenceHsMin = sequenceModele.getHsMinSeq();
1054                if (sequenceHsMin != null) {
1055                        sequence.setSequenceHsd(sequenceHsMin);
1056                }
1057                // repartir date max
1058                Date sequenceDatef = sequenceModele.getDateMaxSeq();           
1059                sequence.setSequenceDatef(sequenceDatef);
1060                // répartir date min
1061                Date sequenceDated = sequenceModele.getDateMinSeq();           
1062                sequence.setSequenceDated(sequenceDated);
1063               
1064                // sequence Latitude Minimale
1065                Integer sequenceLatd = sequenceModele.getLatMinSeq();
1066                sequence.setSequenceLatd(sequenceLatd);
1067                // sequence Latitude Maximale
1068                Integer sequenceLatf = sequenceModele.getLatMaxSeq();
1069                sequence.setSequenceLatf(sequenceLatf);
1070                // sequence Longitude Minimale
1071                Integer sequenceLond = sequenceModele.getLonMinSeq();
1072                sequence.setSequenceLond(sequenceLond);
1073                // sequence Longitude Maximale
1074                Integer sequenceLonf = sequenceModele.getLonMaxSeq();
1075                sequence.setSequenceLonf(sequenceLonf); 
1076               
1077                return sequence;
1078        }
1079       
1080        public int getCategorieId(String nomCat) {
1081                if (nomCat.equals(Constantes.nomCatAVION)) {
1082                        return Constantes.numCatAVION;
1083                } else if  (nomCat.equals(Constantes.nomCatSURF_FIXE)) {
1084                        return Constantes.numCatSURF_FIXE;
1085                } else {
1086                        return Constantes.numCatSURF_MOBILE;
1087                }
1088        }
1089}
1090       
Note: See TracBrowser for help on using the repository browser.