source: ether_megapoli/trunk/service/implementation/com/medias/integration/principal/Principal.java @ 488

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

BO insertion données _ ajout code medias
clean
  • Property svn:executable set to *
File size: 19.2 KB
Line 
1package com.medias.integration.principal;
2
3import com.medias.Chrono;
4import com.medias.Constantes;
5import com.medias.DateTime;
6import com.medias.EcritureLog;
7import com.medias.database.objects.Capteur;
8import com.medias.database.objects.Fichier;
9import com.medias.database.objects.Jeu;
10import com.medias.database.objects.Localisation;
11import com.medias.database.objects.Mesure;
12import com.medias.database.objects.Parametre;
13import com.medias.database.objects.Personne;
14import com.medias.database.objects.Plateforme;
15import com.medias.database.objects.Valeur;
16import com.medias.integration.insertion.Insertion;
17import com.medias.integration.lecture_ecriture.LectureCapteurs;
18import com.medias.integration.lecture_ecriture.LectureModeleXML;
19import com.medias.integration.lecture_ecriture.LectureOrganismes;
20import com.medias.integration.lecture_ecriture.LectureParametres;
21import com.medias.integration.lecture_ecriture.LecturePlateformes;
22import com.medias.integration.lecture_ecriture.LectureUnites;
23import com.medias.integration.lecture_ecriture.LecturePersonnes;
24import com.medias.integration.prevalidation.PreValidation;
25import com.medias.integration.repartition.Repartition;
26import com.medias.integration.utils.CommunicationBD;
27import com.medias.integration.utils.Nombre;
28import com.medias.integration.utils.Statiques;
29import com.medias.integration.validation.Validation;
30import com.medias.integration.vues.MesureModele;
31import com.medias.integration.vues.ParametreModele;
32import com.medias.integration.vues.ValeurModele;
33import com.medias.integration.vues.PlateformeModele;
34
35import java.io.File;
36import java.io.FileInputStream;
37import java.io.FileNotFoundException;
38import java.io.IOException;
39import java.util.ArrayList;
40import java.util.Collections;
41import java.util.Properties;
42
43/**
44 * Created on 24 Jan. 2007
45 *
46 */
47
48/**
49 * @author *******************************************************************************************************************
50 *         Classe permettant de prevalider, valider, répartir et inserer un ensemble de fichier d'un jeu donné.                        *
51 *         *******************************************************************************************************************
52 */
53
54public class Principal
55{
56    public static void main( String[] args )
57    {
58        // Argument 0 : LE NOM DE LA CATEGORIE
59        String nomCategorie = args[0];
60        // Argument 1 : LE NOM DU JEU
61        String nomJeu = args[1];
62        // Argument 2 : LE NUMERO DE VERSION
63        String numVersion = args[2];
64
65        /**
66         * Lancement du chronométre
67         */
68        Chrono chrono = new Chrono();
69        chrono.start();
70        // Attribution des constantes
71//              String fichierProp = new File("megapoli.properties").getAbsolutePath();
72        String emplacementProp = Principal.class.getResource( "" ).getPath();
73        emplacementProp = emplacementProp.substring( 0, emplacementProp.lastIndexOf( "/" ) ) + "/../../../";
74        String fichierProp = emplacementProp + "megapoli.properties";
75        Properties prop = new Properties();
76        try
77        {
78            prop.load( new FileInputStream( fichierProp ) );
79        }
80        catch( FileNotFoundException e )
81        {
82            e.printStackTrace();
83        }
84        catch( IOException e )
85        {
86            e.printStackTrace();
87        }
88        Constantes.cheminFichierSortie = prop.getProperty( "data.output" );
89        Constantes.cheminDonnees = prop.getProperty( "data.upload" );
90        Constantes.cheminListes = prop.getProperty( "data.metadata" );
91        Constantes.cheminModeles = prop.getProperty( "data.model" );
92        Constantes.cheminDonneesSortie = prop.getProperty( "data.download" );
93        // Fichier de log
94        EcritureLog.init( nomJeu, nomCategorie );
95        // ***********************************************
96        // ************ On recherche les fichiers du jeu *
97        // ***********************************************
98        String cheminJeu = Constantes.cheminDonnees + "/" + nomCategorie + "/" + nomJeu + "/";
99        String cheminJeuSortie = Constantes.cheminDonneesSortie + "/" + nomCategorie + "/" + nomJeu + "/";
100        //      On récupére tous les fichiers du répertoire
101        File fileCourant = new File( cheminJeu );
102        // Création du répertoire de sortie
103        File fileDest = new File( cheminJeuSortie );
104        if( !fileDest.exists() ) fileDest.mkdir();
105        String[] listeFics = fileCourant.list();
106        ArrayList<String> listeFichiers = new ArrayList<String>();
107        // On enléve de la liste les fichiers inutiles
108        for( String fic : listeFics )
109        {
110            if( !fic.endsWith( ".xml" ) && !fic.endsWith( ".svn" ) )
111            {
112                listeFichiers.add( fic );
113            }
114        }
115        //      S'il y a au moins un fichier dans le jeu
116        if( listeFichiers.size() != 0 )
117        {
118            Chrono chronoMeta = new Chrono();
119            chronoMeta.start();
120            //  Trier les fichiers par ordre alphabétique
121            Collections.sort( listeFichiers );
122            //  Etape 1 : On lit le modéle XML du jeu
123            LectureModeleXML lectureModeleXML = new LectureModeleXML( nomCategorie, nomJeu );
124            lectureModeleXML.lireModele();
125            //  Etape 2 : On lit les listes EXCEL de capteurs, paramétres, plateformes, ...
126            LectureUnites lectureUnites = new LectureUnites();
127            lectureUnites.lireFichier();
128            LectureParametres lectureParametres = new LectureParametres();
129            lectureParametres.lireFichier();
130            LectureCapteurs lectureCapteurs = new LectureCapteurs();
131            lectureCapteurs.lireFichier();
132            LecturePlateformes lecturePlateformes = new LecturePlateformes();
133            lecturePlateformes.lireFichier();
134            LectureOrganismes lectureOrganismes = new LectureOrganismes();
135            lectureOrganismes.lireFichier();
136            LecturePersonnes lecturePersonnes = new LecturePersonnes();
137            lecturePersonnes.lireFichier();
138
139            //  Etape 3 : Répartition des métadonnées du jeu
140            Repartition repartition = new Repartition( lectureModeleXML, lectureCapteurs,
141                    lecturePlateformes, lectureParametres, lecturePersonnes, lectureUnites, lectureOrganismes );
142            ArrayList<Personne> personnes = repartition.repartirPersonnes();
143            Jeu jeu = repartition.repartirJeu( personnes, numVersion );
144            Statiques.plateformesModele = new ArrayList<PlateformeModele>();
145            ArrayList<Parametre> parametres = repartition.repartirParametres();
146            ArrayList<Capteur> capteurs = repartition.repartirCapteurs( parametres );
147            ArrayList<Plateforme> plateformes = repartition.repartirPlateformes( jeu.getOrganisme().getAdresse().getAdressePays(), capteurs, parametres );
148
149            //  Etape 4 : Insertion des métadonnées du jeu
150            Insertion insertion = new Insertion();
151            try
152            {
153                synchronized( Principal.class )
154                {
155                    //  Insertion des personnes (PI, contact, intégrateur)
156                    insertion.insererPersonne( jeu.getPersonneByIntegrateurId() );
157                    insertion.insererPersonne( jeu.getPersonneByContactId() );
158                    // on teste si le pi n est pas null : on l'insere
159                    if( jeu.getPersonneByPiId() != null )
160                        insertion.insererPersonne( jeu.getPersonneByPiId() );
161                    //  Insertion du jeu
162                    insertion.insererJeu( jeu );
163                    // Insertion des parametres
164                    for( Parametre parametre : parametres )
165                        insertion.insererParametre( parametre );
166                    //  Insertion des capteurs
167                    for( Capteur capteur : capteurs )
168                        insertion.insererCapteur( capteur, parametres );
169                    //  Insertion des plateformes
170                    for( Plateforme plateforme : plateformes )
171                        insertion.insererPlateforme( plateforme, capteurs, parametres );
172                    //  On ouvre la connexion
173                    CommunicationBD.open();
174                    //  Mise é jour des liaisons capteurs/jeu
175                    insertion.mettreAJourRequeteCaptJeu( jeu, capteurs );
176                    //  Mise é jour des liaisons parametres/jeu
177                    insertion.mettreAJourRequeteParamJeu( jeu, parametres );
178                    //  Mise é jour des liaisons plateformes/jeu
179                    insertion.mettreAJourRequetePlatJeu( jeu, plateformes );
180                    //  Mise é jour des liaisons paramétres/capteurs
181                    insertion.mettreAJourRequeteParamCapt( capteurs, parametres );
182                    //  Mise é jour des liaisons capteurs/plateformes et paramétres/plateformes
183                    insertion.mettreAJourRequeteCaptPlatParam( plateformes, capteurs, parametres );
184                    //  Insertion de la table bilan
185                    insertion.insererBilan( jeu, plateformes, capteurs, parametres );
186                    //  On ferme la connexion
187                    CommunicationBD.close();
188                    chronoMeta.stop();
189                    chronoMeta.afficheChrono( "METADONNEES" );
190
191                    // Etape 5 : Traitement des fichiers de données
192                    /*****************************************************************************************************
193                     * On parcourt les fichiers du jeu                                                                                                                                   *
194                     ******************************************************************************************************
195                     */
196                    //  Initialisations
197                    //  Initialialisation des :  altitude,latitude, longitude et hauteur sol. On convertit une altitude, latitude, longitude ou hauteur sol de Double vers Integer.
198                    //  altitude du jeu
199                    Statiques.altMaxJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.altitudeMoinsInf ) );
200                    Statiques.altMinJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.altitudePlusInf ) );
201                    //  latitude du jeu
202                    Statiques.latMaxJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.latitudeMoinsInf ) );
203                    Statiques.latMinJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.latitudePlusInf ) );
204                    //  longitude du jeu
205                    Statiques.lonMaxJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.longitudeMoinsInf ) );
206                    Statiques.lonMinJeu = Nombre.latDoubleToInt( Double.valueOf( Constantes.longitudePlusInf ) );
207                    //  hauteur sol du jeu
208                    Statiques.hsMaxJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.hsMoinsInf ) );
209                    Statiques.hsMinJeu = Nombre.altDoubleToInt( Double.valueOf( Constantes.hsPlusInf ) );
210                    // Dates
211                    Statiques.dateMinJeu = DateTime.stringToDate( Constantes.datePlusInf, Constantes.formatDateJJMMAAAAHHMMSS );
212                    Statiques.dateMaxJeu = DateTime.stringToDate( Constantes.dateMoinsInf, Constantes.formatDateJJMMAAAAHHMMSS );
213
214                    ArrayList<ArrayList<String>> listeDonnees;
215                    PreValidation preValidation;
216                    Validation validation;
217                    String cheminFichier, cheminFichierSortie;
218                    Chrono chronoFichier;
219                    Fichier fichier;
220                    MesureModele mesureModele;
221                    Mesure mesure;
222                    ArrayList<Localisation> listeLocs = new ArrayList<Localisation>();
223                    ArrayList<ParametreModele> paramsMesure, paramsValeur;
224                    ParametreModele parametreModele;
225                    Parametre parametre;
226                    Capteur capteur;
227                    ArrayList<ValeurModele> valeursMesure;
228                    ValeurModele valeurModele;
229                    Valeur valeur;
230                    int nbMesures = 0, nbValeurs = 0, nbErreurs = 0, numFichier = 0;
231                    int nbFichiers = listeFichiers.size();// - 1; // On enléve le fichier de métadonnées xml
232                    // Pour chaque fichier de données...
233                    for( int numFic = 0; numFic < nbFichiers; numFic++ )
234                    {
235                        cheminFichier = cheminJeu + listeFichiers.get( numFic );
236                        fileCourant = new File( cheminFichier );
237                        //      Si le fichier existe et n'est pas vide
238                        if( fileCourant.exists() && !cheminFichier.endsWith( "metadata.xml" ) && !cheminFichier.endsWith( ".svn" ) )
239                        {
240                            numFichier++;
241                            chronoFichier = new Chrono();
242                            chronoFichier.start();
243                            EcritureLog.ecrire( "\n- [" + numFichier + "/" + nbFichiers + "] Fichier " + fileCourant.getName(), "out-ln" );
244                            //  Etape 6 : prévalidation : On prévalide le fichier
245                            preValidation = new PreValidation( fileCourant );
246                            preValidation.prevalider( lectureParametres, lectureUnites, lectureCapteurs, parametres, capteurs, nomJeu );
247                            EcritureLog.ecrire( " -> Prévalidation OK", "out-ln" );
248                            //  Etape 7 : validation : On valide le fichier
249                            validation = new Validation( preValidation );
250                            listeDonnees = validation.valider( lectureModeleXML, fileCourant.getName() );
251                            preValidation.vider();
252                            validation.vider();
253
254                            int nbErreursValidation = validation.getNbErreursTotales();
255                            nbErreurs += nbErreursValidation;
256                            if( nbErreursValidation == 0 )
257                            {
258                                EcritureLog.ecrire( " -> Validation OK", "out-ln" );
259                                //      Etape 8 : répartition du fichier
260                                fichier = repartition.repartirFichier( jeu, fileCourant );
261                                //      On ouvre la connexion
262                                CommunicationBD.open();
263                                // Etape 9 : insertion du fichier
264                                insertion.insererFichier( fichier );
265                                nbMesures += listeDonnees.size();
266                                paramsMesure = validation.getListeParams();
267                                //      Pour chaque mesure...
268                                for( ArrayList<String> donneesMesure : listeDonnees )
269                                {
270                                    //  Etape 10 : Rangement des données sur la ligne et répartition des séquences
271                                    mesureModele = repartition.repartirDonnees( donneesMesure, paramsMesure );//,numSeqPrecedent,parametresModele,indiceNiv);
272                                    paramsValeur = mesureModele.getParamsValeur();
273                                    //  Etape 11 : repartition de la mesure
274                                    mesure = repartition.repartirMesure( mesureModele, fichier, plateformes );
275                                    //  Etape 12 : Insertion de la mesure
276                                    insertion.insererMesure( mesure, listeLocs );//,flagLocId);
277                                    valeursMesure = mesureModele.getValeursMesure();
278                                    //  Pour chaque valeur...
279                                    for( int numValeur = 0; numValeur < valeursMesure.size(); numValeur++ )
280                                    {
281                                        valeurModele = valeursMesure.get( numValeur );
282                                        // On récupére les infos du paramétre associé é la valeur
283                                        parametreModele = paramsValeur.get( numValeur );
284                                        parametre = parametres.get( parametreModele.getIndiceParam() );
285                                        capteur = capteurs.get( parametreModele.getIndiceCapt() );
286                                        //      Etape 13 : repartition de la valeur
287                                        valeur = repartition.repartirValeur( mesure, valeurModele, parametreModele, parametre, capteur );
288
289                                        //      Etape 14 : insertion de la valeur
290                                        if( valeur != null )
291                                        {
292                                            insertion.insererValeur( valeur );//,flagValidId);
293                                            nbValeurs++;
294                                        }
295                                    }
296//                                                      }
297                                }
298                                //      On ferme la connexion
299                                CommunicationBD.close();
300                                EcritureLog.ecrire( " -> Insertion OK", "out-ln" );
301                                // Le fichier est validé et ses données sont insérées: on déplace le fichier dans le répertoire "download"
302                                cheminFichierSortie = cheminJeuSortie + listeFichiers.get( numFic );
303                                fileDest = new File( cheminFichierSortie );
304                                if( !fileDest.exists() )
305                                {
306                                    fileCourant.renameTo( fileDest );
307                                }
308                            }
309                            chronoFichier.stop();
310                            chronoFichier.afficheChrono( " -> FICHIER" );
311                        }
312                        else if( !cheminFichier.endsWith( "metadata.xml" ) && !cheminFichier.endsWith( ".svn" ) )
313                        {
314                            EcritureLog.ecrire( "- Fichier " + fileCourant.getName() + " non trouvé !", "err" );
315                        }
316                    }
317                    if( nbErreurs != 0 )
318                    {
319                        EcritureLog.ecrire( "\n-> Il y a au total " + nbErreurs + " erreur(s) dans les fichiers du jeu " + nomJeu + "\n", "err" );
320                    }
321                    Chrono chronoFin = new Chrono();
322                    chronoFin.start();
323                    //  On ouvre la connexion
324                    CommunicationBD.open();
325                    //  Mise é jour du jeu
326                    insertion.mettreAjourJeu( jeu );
327                    //  Mise é jour des infos sur la quantité de données insérée
328                    insertion.mettreAJourRequeteNbValsJeu( jeu, nbFichiers, nbMesures, nbValeurs );
329                    //  Mise é jour du bilan
330                    insertion.mettreAJourBilan( jeu );
331                    //  On ferme la connexion
332                    CommunicationBD.close();
333                    //  Fin du chrono
334                    chronoFin.stop();
335                    chronoFin.afficheChrono( "FINALISATION" );
336                }// Fin synchronized
337            }
338            catch( Exception e )
339            {
340                e.printStackTrace();
341            }
342        }
343        else
344        {
345            EcritureLog.ecrire( "Pas de fichiers é valider dans le jeu " + nomJeu, "err" );
346        }
347        /** Arrét du chronométre */
348        chrono.stop();
349        chrono.afficheChrono( "TOTAL" );
350    }
351}
Note: See TracBrowser for help on using the repository browser.