source: ether_megapoli/trunk/service/implementation/com/medias/integration/validation/ControleurType.java @ 848

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

clean
  • Property svn:executable set to *
File size: 24.3 KB
Line 
1/*
2 * Created on 25 Jan. 2007
3 */
4package com.medias.integration.validation;
5
6import com.medias.Constantes;
7import com.medias.DateTime;
8import com.medias.Nombre;
9
10import java.util.ArrayList;
11import java.util.Calendar;
12import java.util.Date;
13/**
14 * @author
15 *
16 * Fournit les méthodes de test des données des fichiers fournis pour intégration dans la base.
17 */
18public class ControleurType {
19    /**
20     * Teste si une chaine est une date au format de date indiqué.
21     * @param str Chaine é tester.
22     * @return Le Message de test associé.
23     */
24        @SuppressWarnings("unchecked")
25        public static Message testerDate(String str, Object obj, Object obj2) {
26        Message mes = new Message();
27        String format = (String) obj;
28        String formatDateReel = format.replaceAll("DD", "dd").replaceAll("YYYY", "yyyy").replaceAll(":MM", ":mm").replaceAll(":SS", ":ss");
29//        String formatDateReel = DateTime.convertirFormat(format);
30        Date date = DateTime.stringToDate( str, formatDateReel );
31        boolean dateBonne = true;
32        if(date == null) {
33            dateBonne = false;
34            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une date au format "+format);
35        } else {
36                ArrayList<Date> dates = (ArrayList<Date>) obj2;
37                Date dateBegin = dates.get(1);
38                Date dateEnd = dates.get(2);
39                // On rajoute 1 jour é la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
40                Calendar c = Calendar.getInstance();
41                c.setTime(dateEnd);
42                c.add(Calendar.DAY_OF_YEAR, +1);
43                dateEnd = c.getTime();
44                if (date.getTime() < dateBegin.getTime()) {
45                        dateBonne = false;
46                        mes.setMessage("TROUVE: '" + str +
47                                        ", ATTENDU: une date supérieure é la date "+DateTime.dateToString(dateBegin, Constantes.formatDateJJMMAAAAHHMMSS));
48                } else if (date.getTime() >= dateEnd.getTime()) {
49                        dateBonne = false;
50                        mes.setMessage("TROUVE: '" + str +
51                                        ", ATTENDU: une date inférieure é la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
52                }
53        }
54        mes.setValid(dateBonne);
55        return mes;
56    }
57
58    /**
59     * Teste si une chaine est une année au format de date indiqué.
60     * @param str Chaine é tester.
61     * @return Le Message de test associé.
62     */
63    @SuppressWarnings("unchecked")
64    public static Message testerYear(String str, Object obj, Object obj2) {
65        Message mes = new Message();
66        String format = (String) obj;
67        String formatDateReel = format.replaceAll("YYYY", "yyyy");
68        Date date = DateTime.stringToDate( str, formatDateReel );
69        boolean anneeBonne = true;
70        if(date == null) {
71                anneeBonne = false;
72            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une année au format "+format);
73        } else {
74                ArrayList<Date> dates = (ArrayList<Date>) obj2;
75                Date dateBegin = dates.get(1);
76                Date dateEnd = dates.get(2);
77                Calendar c = Calendar.getInstance();
78                c.setTime(dateEnd);
79                int yearEnd = c.get(Calendar.YEAR);
80                c = Calendar.getInstance();
81                c.setTime(dateBegin);
82                int yearBegin = c.get(Calendar.YEAR);
83                c = Calendar.getInstance();
84                c.setTime(date);
85                int year = c.get(Calendar.YEAR);
86                if (year < yearBegin) {
87                        anneeBonne = false;
88                        mes.setMessage("TROUVE: '" + str + ", ATTENDU: une année supérieure ou égale é "+yearBegin);
89                } else if (year > yearEnd) {
90                        anneeBonne = false;
91                        mes.setMessage("TROUVE: '" + str + ", ATTENDU: une année inférieure ou égale é "+yearEnd);
92                }
93        }
94        mes.setValid(anneeBonne);
95        return mes;
96    }
97   
98    /**
99     * Teste si une chaine est un mois au format de date indiqué.
100     * @param str Chaine é tester.
101     * @return Le Message de test associé.
102     */
103    @SuppressWarnings("unchecked")
104    public static Message testerMonth(String str, Object obj, Object obj2) {
105        Message mes = new Message();
106        String format = (String) obj;
107        if (str.length() == 1) str = "0"+str;
108        Date date = DateTime.stringToDate( str, format );
109        boolean moisBon = true;
110        if(date == null) {
111                moisBon = false;
112            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un mois au format "+format);
113        } else {
114                ArrayList<Date> dates = (ArrayList<Date>) obj2;
115                Date dateBegin = dates.get(1);
116                Date dateEnd = dates.get(2);
117                Calendar c = Calendar.getInstance();
118                c.setTime(dateEnd);
119                int monthEnd = c.get(Calendar.MONTH);
120                c = Calendar.getInstance();
121                c.setTime(dateBegin);
122                int monthBegin = c.get(Calendar.MONTH);
123                c = Calendar.getInstance();
124                c.setTime(date);
125                int month = c.get(Calendar.MONTH);
126                if (month < monthBegin) {
127                        moisBon = false;
128                        mes.setMessage("TROUVE: '" + str + ", ATTENDU: un mois supérieur ou égal é "+(monthBegin+1));
129                } else if (month > monthEnd) {
130                        moisBon = false;
131                        mes.setMessage("TROUVE: '" + str + ", ATTENDU: un mois inférieur ou égal é "+(monthEnd+1));
132                }
133        }
134        mes.setValid(moisBon);
135        return mes;
136    }
137   
138    /**
139     * Teste si une chaine est un jour au format de date indiqué.
140     * @param str Chaine é tester.
141     * @return Le Message de test associé.
142     */
143    @SuppressWarnings("unchecked")
144    public static Message testerDay(String str, Object obj, Object obj2) {
145        Message mes = new Message();
146        String format = (String) obj;
147        String formatDateReel = format.replaceAll("DD", "dd");
148        if (str.length() == 1) str = "0"+str;
149        Date date = DateTime.stringToDate( str, formatDateReel );
150        boolean jourBon = true;
151        if(date == null) {
152                jourBon = false;
153            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un jour au format "+format);
154        } else {
155                ArrayList<Date> dates = (ArrayList<Date>) obj2;
156                Date dateBegin = dates.get(1);
157                Date dateEnd = dates.get(2);
158                Calendar c = Calendar.getInstance();
159                c.setTime(dateEnd);
160                int dayEnd = c.get(Calendar.DAY_OF_MONTH);
161                int monthEnd = c.get(Calendar.MONTH)+1;
162                c = Calendar.getInstance();
163                c.setTime(dateBegin);
164                int dayBegin = c.get(Calendar.DAY_OF_MONTH);
165                int monthBegin = c.get(Calendar.MONTH)+1;
166                c = Calendar.getInstance();
167                c.setTime(date);
168                int day = c.get(Calendar.DAY_OF_MONTH);
169                if (monthBegin == monthEnd) {
170                        if (day < dayBegin) {
171                                jourBon = false;
172                                mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour supérieur ou égal é "+dayBegin);
173                        } else if (day > dayEnd) {
174                                jourBon = false;
175                                mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour inférieur ou égal é "+dayEnd);
176                        }
177                } else {
178                        if (day < 1) {
179                                jourBon = false;
180                                mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour supérieur ou égal é 1");
181                        } else if (day > 31) {
182                                jourBon = false;
183                                mes.setMessage("TROUVE: '" + str + ", ATTENDU: un jour inférieur ou égal é 31");
184                        }
185                }
186        }
187        mes.setValid(jourBon);
188        return mes;
189    }
190   
191    /**
192     * Teste si une chaine est une heure au format de date indiqué.
193     * @param str Chaine é tester.
194     * @return Le Message de test associé.
195     */
196    public static Message testerHour(String str, Object obj, Object obj2) {
197        Message mes = new Message();
198        String format = (String) obj;
199        if (str.length() == 1) str = "0"+str;
200        Date date = DateTime.stringToDate( str, format );
201        boolean heureBonne = true;
202        if(date == null) {
203                heureBonne = false;
204            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une heure au format "+format);
205        }
206        mes.setValid(heureBonne);
207        return mes;
208    }
209   
210    /**
211     * Teste si une chaine est une minute au format de date indiqué.
212     * @param str Chaine é tester.
213     * @return Le Message de test associé.
214     */
215    public static Message testerMinute(String str, Object obj, Object obj2) {
216        Message mes = new Message();
217        String format = (String) obj;
218        String formatDateReel = format.replaceAll("MM", "mm");
219        if (str.length() == 1) str = "0"+str;
220        Date date = DateTime.stringToDate( str, formatDateReel );
221        boolean minuteBonne = true;
222        if(date == null) {
223                minuteBonne = false;
224            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une minute au format "+format);
225        }
226        mes.setValid(minuteBonne);
227        return mes;
228    }
229   
230    /**
231     * Teste si une chaine est une seconde au format de date indiqué.
232     * @param str Chaine é tester.
233     * @return Le Message de test associé.
234     */
235    public static Message testerSecond(String str, Object obj, Object obj2) {
236        Message mes = new Message();
237        String format = (String) obj;
238        String formatDateReel = format.replaceAll("SS", "ss");
239        if (str.length() == 1) str = "0"+str;
240        Date date = DateTime.stringToDate( str, formatDateReel );
241        boolean secondeBonne = true;
242        if(date == null) {
243                secondeBonne = false;
244            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une seconde au format "+format);
245        }
246        mes.setValid(secondeBonne);
247        return mes;
248    }
249   
250    /**
251     * Teste si une chaine est un Réel positif indiquant le nombre de secondes depuis une date donnée,
252     * la date obtenue doit étre comprise entre les dates de début et de fin fournies en paramétres
253     */
254    @SuppressWarnings("unchecked")
255    public static Message testerSecondsSince(String str, Object obj, Object obj2) {
256        String str2 = str.replaceAll(",", ".");
257        Message mes = new Message();
258        boolean doubleBon = Nombre.isDoublePositif(str);
259
260        if(!doubleBon) {
261            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel positif");
262        } else {
263                ArrayList<Date> dates = (ArrayList<Date>) obj2;
264                Date dateSince = dates.get(0);
265                Date dateBegin = dates.get(1);
266                Date dateEnd = dates.get(2);
267                double val = Double.parseDouble(str2);
268                if (dateSince != null) {
269                        Date date = DateTime.secondsSinceToDate(val, dateSince);
270                        // On rajoute 1 jour é la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
271                        Calendar c = Calendar.getInstance();
272                        c.setTime(dateEnd);
273                        c.add(Calendar.DAY_OF_YEAR, +1);
274                        dateEnd = c.getTime();
275//                      EcritureLog.ecrire("\ndateDeb="+DateTime.dateToString(dateBegin, Constantes.formatDateDefault)
276//                                      +", dateFin="+DateTime.dateToString(dateEnd, Constantes.formatDateDefault)
277//                                      +", dateSince="+DateTime.dateToString(dateSince, Constantes.formatDateDefault)
278//                                      +", val="+val
279//                                      +", date="+DateTime.dateToString(date, Constantes.formatDateDefault),"err");
280                        if (date.getTime() < dateBegin.getTime()) {
281                                doubleBon = false;
282                                mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
283                                                ", ATTENDU: un nombre de secondes supérieur é la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
284                        } else if (date.getTime() >= dateEnd.getTime()) {
285                                doubleBon = false;
286                                mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
287                                                ", ATTENDU: un nombre de secondes inférieur é la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
288                        }
289                }
290        }
291        mes.setValid(doubleBon);
292        return mes;
293    }
294       
295    /**
296     * Teste si une chaine est un Réel positif indiquant le nombre d'heures depuis une date donnée,
297     * la date obtenue doit étre comprise entre les dates de début et de fin fournies en paramétres
298     */
299    @SuppressWarnings("unchecked")
300        public static Message testerHoursSince(String str, Object obj, Object obj2) {
301        String str2 = str.replaceAll(",", ".");
302        Message mes = new Message();
303        boolean doubleBon = Nombre.isDoublePositif(str);
304
305        if(!doubleBon) {
306            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel positif");
307        } else {
308                ArrayList<Date> dates = (ArrayList<Date>) obj2;
309                Date dateSince = dates.get(0);
310                Date dateBegin = dates.get(1);
311                Date dateEnd = dates.get(2);
312                double val = Double.parseDouble(str2);
313                Date date = DateTime.hoursSinceToDate(val, dateSince);
314                // On rajoute 1 jour é la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
315                Calendar c = Calendar.getInstance();
316                c.setTime(dateEnd);
317                c.add(Calendar.DAY_OF_YEAR, +1);
318                dateEnd = c.getTime();
319                if (date.getTime() < dateBegin.getTime()) {
320                        doubleBon = false;
321                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
322                                        ", ATTENDU: un nombre d'heures supérieur é la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
323                } else if (date.getTime() >= dateEnd.getTime()) {
324                        doubleBon = false;
325                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
326                                        ", ATTENDU: un nombre d'heures inférieur é la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
327                }
328        }
329        mes.setValid(doubleBon);
330        return mes;
331    }
332   
333    /**
334     * Teste si une chaine est un Réel positif indiquant le nombre de jours depuis une date donnée,
335     * la date obtenue doit étre comprise entre les dates de début et de fin fournies en paramétres
336     */
337    @SuppressWarnings("unchecked")
338        public static Message testerDaysSince(String str, Object obj, Object obj2) {
339        String str2 = str.replaceAll(",", ".");
340        Message mes = new Message();
341        boolean doubleBon = Nombre.isDoublePositif(str);
342
343        if(!doubleBon) {
344            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel positif");
345        } else {
346                ArrayList<Date> dates = (ArrayList<Date>) obj2;
347                Date dateSince = dates.get(0);
348                Date dateBegin = dates.get(1);
349                Date dateEnd = dates.get(2);
350                double val = Double.parseDouble(str2);
351                Date date = DateTime.daysSinceToDate(val, dateSince);
352                // On rajoute 1 jour é la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
353                Calendar c = Calendar.getInstance();
354                c.setTime(dateEnd);
355                c.add(Calendar.DAY_OF_YEAR, +1);
356                dateEnd = c.getTime();
357                if (date.getTime() < dateBegin.getTime()) {
358                        doubleBon = false;
359                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
360                                        ", ATTENDU: un nombre de jours supérieur é la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
361                } else if (date.getTime() >= dateEnd.getTime()) {
362                        doubleBon = false;
363                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
364                                        ", ATTENDU: un nombre de jours inférieur é la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
365                }
366        }
367        mes.setValid(doubleBon);
368        return mes;
369    }
370       
371    /**
372     * Teste si une chaine est un Réel positif indiquant le nombre d'année depuis une date donnée,
373     * la date obtenue doit étre comprise entre les dates de début et de fin fournies en paramétres
374     */
375    @SuppressWarnings("unchecked")
376        public static Message testerYearsSince(String str, Object obj, Object obj2) {
377        String str2 = str.replaceAll(",", ".");
378        Message mes = new Message();
379        boolean doubleBon = Nombre.isDoublePositif(str);
380
381        if(!doubleBon) {
382            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel positif");
383        } else {
384                ArrayList<Date> dates = (ArrayList<Date>) obj2;
385                Date dateSince = dates.get(0);
386                Date dateBegin = dates.get(1);
387                Date dateEnd = dates.get(2);
388                double val = Double.parseDouble(str2);
389                Date date = DateTime.yearsSinceToDate(val, dateSince);
390                // On rajoute 1 jour é la date de fin (ex: 23/07/2009 00:00:00 devient 24/07/2009 00:00:00)
391                Calendar c = Calendar.getInstance();
392                c.setTime(dateEnd);
393                c.add(Calendar.DAY_OF_YEAR, +1);
394                dateEnd = c.getTime();
395                if (date.getTime() < dateBegin.getTime()) {
396                        doubleBon = false;
397                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
398                                        ", ATTENDU: un nombre d'années supérieur é la date "+DateTime.dateToString(dateBegin,Constantes.formatDateJJMMAAAAHHMMSS));
399                } else if (date.getTime() >= dateEnd.getTime()) {
400                        doubleBon = false;
401                        mes.setMessage("TROUVE: '" + str + "' soit la date "+DateTime.dateToString(date,Constantes.formatDateJJMMAAAAHHMMSS)+
402                                        ", ATTENDU: un nombre d'années inférieur é la date "+DateTime.dateToString(dateEnd,Constantes.formatDateJJMMAAAAHHMMSS));
403                }
404        }
405        mes.setValid(doubleBon);
406        return mes;
407    }
408   
409    /**
410     * Teste si une chaine est valide.
411     * @param str Chaine é tester.
412     * @return Le Message de test associé.
413     */
414    public static Message testerString(String str, Object obj, Object obj2) {
415        Message mes = new Message();
416        mes.setValid(true);
417        return mes;
418    }
419
420    /**
421     * Teste si une chaine est un Réel.
422     * @param str Chaine é tester.
423     * @param nul Booléen indiquant si la chaine peut étre nulle.
424     * @return Le Message de test associé.
425     */
426    public static Message testerDouble(String str, Object obj, Object obj2) {
427        Message mes = new Message();
428        boolean doubleBon = Nombre.isDouble(str);
429
430        if(!doubleBon) {
431            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel");
432        }
433        mes.setValid(doubleBon);
434        return mes;
435    }
436
437    /**
438     * Teste si une chaine est un Réel positif.
439     * @param str Chaine é tester.
440     * @param nul Booléen indiquant si la chaine peut étre nulle.
441     * @return Le Message de test associé.
442     */
443    public static Message testerDoublePositif(String str, Object obj, Object obj2) {
444        Message mes = new Message();
445        boolean doubleBon = Nombre.isDoublePositif(str);
446
447        if(!doubleBon) {
448            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un réel positif");
449        }
450        mes.setValid(doubleBon);
451        return mes;
452    }
453   
454    /**
455     * Teste si une chaine est un Integer.
456     * @param str Chaine é tester.
457     * @return Le Message de test associé.
458     */
459    public static Message testerInteger(String str, Object obj, Object obj2) {
460        Message mes = new Message();
461        boolean integerBon = Nombre.isInteger(str);
462       
463        if(!integerBon) {
464            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier");
465        }
466        mes.setValid(integerBon);
467        return mes;
468    }
469
470    public static Message testerIntegerPositif(String str, Object obj, Object obj2) {
471        Message mes = new Message();
472        boolean integerBon = Nombre.isIntegerPositif(str);
473       
474        if(!integerBon) {
475            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier positif");
476        }
477        mes.setValid(integerBon);
478        return mes;
479    }
480   
481    /**
482     * Teste si une chaine est un Long.
483     * @param str Chaine é tester.
484     * @param nul Booléen indiquant si la chaine peut étre nulle.
485     * @return Le Message de test associé.
486     */
487    public static Message testerLong(String str, Object obj, Object obj2) {
488        Message mes = new Message();
489        boolean longBon = Nombre.isLong(str);
490
491        if(!longBon) {
492            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un entier long");
493        }
494        mes.setValid(longBon);
495        return mes;
496    }
497   
498    /**
499     * Teste si une chaine est une longitude.
500     * @param str2 Chaine é tester.
501     * @return Le Message de test associé.
502     */
503    public static Message testerLongitude(String str2, Object obj, Object obj2) {
504        String str = str2.replaceAll(",", ".");
505        Message mes = new Message();
506        boolean longitudeBonne = true;
507
508        try {
509                        double longitude = Double.parseDouble(str);
510                        longitudeBonne = (longitude >= Constantes.longitudeMini && longitude <= Constantes.longitudeMaxi);
511                } catch (NumberFormatException e) {
512                        longitudeBonne = false;
513                }
514
515        if(!longitudeBonne) {
516            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une longitude en degrés décimaux");
517        }
518        mes.setValid(longitudeBonne);
519        return mes;
520    }
521
522    /**
523     * Teste si une chaine est une latitude.
524     * @param str2 Chaine é tester.
525     * @return Le Message de test associé.
526     */
527    public static Message testerLatitude(String str2, Object obj, Object obj2) {
528        String str = str2.replaceAll(",", ".");
529        Message mes = new Message();
530        boolean latitudeBonne = true;
531
532        try {
533                        double latitude = Double.parseDouble(str);
534                        latitudeBonne = (latitude >= Constantes.latitudeMini && latitude <= Constantes.latitudeMaxi);
535                } catch (NumberFormatException e) {
536                        latitudeBonne = false;
537                }
538
539        if(!latitudeBonne) {
540            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une latitude en degrés décimaux");
541        }
542        mes.setValid(latitudeBonne);
543        return mes;
544    }
545
546    /**
547     * Teste si une chaine est une altitude.
548     * @param str2 Chaine é tester.
549     * @return Le Message de test associé.
550     */
551    public static Message testerAltitude(String str2, Object obj, Object obj2) {
552        String str = str2.replaceAll(",", ".");
553        Message mes = new Message();
554        boolean altitudeBonne;
555
556        try {
557                        double altitude = Double.parseDouble(str);
558                        altitudeBonne = (altitude >= Constantes.altitudeMini && altitude <= Constantes.altitudeMaxi);
559                } catch (NumberFormatException e) {
560                        altitudeBonne = false;
561                }
562
563        if(!altitudeBonne) {
564            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une altitude");
565        }
566        mes.setValid(altitudeBonne);
567        return mes;
568    }
569
570    /*****************************/
571    /**
572     * Teste si une chaine est une altitude géopotentiel.
573     * @param str2 Chaine é tester.
574     * @return Le Message de test associé.
575     */
576   
577    public static Message testerAltitudeGeop(String str2, Object obj, Object obj2) {
578        String str = str2.replaceAll(",", ".");
579        Message mes = new Message();
580        boolean altitudeGeopBonne;
581        try {
582                        double geop = Double.parseDouble(str);
583                        // Si la donnée est un géopotentiel, il faut la convertir en altitude en divisant par 9.8
584                        double altitude = Nombre.geopToAltitude(new Double(geop)).doubleValue();   
585                        altitudeGeopBonne = (altitude >= Constantes.altitudeMini && altitude <= Constantes.altitudeMaxi);
586                } catch (NumberFormatException e) {
587                        altitudeGeopBonne = false;
588                }
589
590        if(!altitudeGeopBonne) {
591            mes.setMessage("TROUVE: '" + str + "', ATTENDU: une altitude");
592        }
593        mes.setValid(altitudeGeopBonne);
594        return mes;
595    }
596   
597    /****************************/
598    /***************************/
599    /**
600     * Teste si une chaine est un pourcentage réel.
601     * @param str2 Chaine é tester.
602     * @return Le Message de test associé.
603     */
604    public static Message testerDoublePourcent(String str, Object obj, Object obj2) {
605        Message mes = new Message();
606        boolean doubleBon = Nombre.isDoubleInIntervalBis( str, 0, 100 );
607
608        if(!doubleBon) {
609            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un pourcentage réel");
610        }
611        mes.setValid(doubleBon);
612        return mes;
613    }
614
615    public static Message testerDoubleUn(String str, Object obj, Object obj2) {
616        Message mes = new Message();
617        boolean doubleBon = Nombre.isDoubleInIntervalBis( str, 0, 1 );
618
619        if(!doubleBon) {
620            mes.setMessage("TROUVE: '" + str + "', ATTENDU: un nombre réel compris entre 0 et 1");
621        }
622        mes.setValid(doubleBon);
623        return mes;
624    }
625}
Note: See TracBrowser for help on using the repository browser.