source: ether_megapoli/trunk/service/implementation/com/medias/integration_old/prevalidation/PreValidation.java @ 486

/*
 * Created on 16 Janvier. 2006
 */

package integration.prevalidation;

import com.medias.EcritureLog;
import com.medias.database.objects.Capteur;
import com.medias.database.objects.Parametre;
import integration.lecture_ecriture.LectureCapteurs;
import integration.lecture_ecriture.LectureParametres;
import integration.lecture_ecriture.LectureUnites;
import integration.vues.ParametreModele;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/**
 * @author
 * 
 * Classe permettant de Prevalider un ensemble de fichier d'un jeu donné
 */

public class PreValidation {
        public PreValidation(File fichier) {
                this.fichier = fichier;
                entete = new ArrayList<String>();
                mesures = new ArrayList<String>();
        }

        public void prevalider(LectureParametres lectureParametres, LectureUnites lectureUnites, LectureCapteurs lectureCapteurs
                        , ArrayList<Parametre> parametres, ArrayList<Capteur> capteurs, String nomJeu) {
                // Fichier constitué d'un entéte de type METEO
                if ((nomJeu.equals("METEO-SIRTA") || nomJeu.equals("weather SIRTA")) && fichier.getName().endsWith(".txt")) {
                        integration.prevalidation.PreValidationMETEOFILE prevalidationMETEOFILE = new integration.prevalidation.PreValidationMETEOFILE(fichier);
                        prevalidationMETEOFILE.lireFichier(lectureParametres,lectureUnites,lectureCapteurs,parametres,capteurs);
                        this.setEntete(prevalidationMETEOFILE.getEntete());
                        this.setMesures(prevalidationMETEOFILE.getMesures());
                        this.setNbParams(prevalidationMETEOFILE.getNbParams());
                        this.setInfoParams(prevalidationMETEOFILE.getInfoParams());
                        prevalidationMETEOFILE = null;
                }
                // Fichier constitué d'un entéte NASA AMES
                else if (fichier.getName().endsWith(".na") || fichier.getName().endsWith(".txt") || fichier.getName().endsWith(".ames") || fichier.getName().endsWith(".nas") || fichier.getName().endsWith(".ict")) {
                        int formatFichierNASAAMES = 0;
                        try {
                                BufferedReader buf = new BufferedReader(new FileReader(fichier));
                                String ligne = buf.readLine();
                                if (ligne != null) {
                                        formatFichierNASAAMES = Integer.parseInt(ligne.substring(ligne.indexOf(" ")+1).trim());
                                }
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                        if (formatFichierNASAAMES == 1001) {
                                integration.prevalidation.PreValidationNASAAMES1001 preValidationNASAAMES1001 = new integration.prevalidation.PreValidationNASAAMES1001(fichier);
                                preValidationNASAAMES1001.lireFichier(lectureParametres,lectureUnites,lectureCapteurs,parametres,capteurs);
                                this.setEntete(preValidationNASAAMES1001.getEntete());
                                this.setMesures(preValidationNASAAMES1001.getMesures());
                                this.setNbParams(preValidationNASAAMES1001.getNbParams());
                                this.setInfoParams(preValidationNASAAMES1001.getInfoParams());
                                preValidationNASAAMES1001 = null;
                        }
                }
                else {
                        EcritureLog.ecrire("\nErreur sur l'extension du fichier : Les extensions valides sont na, ames, txt, ict ou nas","err");
                }
        }

        public void vider() {
                fichier = null;
                mesures = null;
                entete = null;
                infoParams = null;
        }
        
        /**
         *  On retrouve les indices de capteurs correspondant aux noms de capteurs
         *  apparaissant dans le fichier de données
         */
        protected ArrayList<Integer> findIndicesCaptInFile(LectureCapteurs lectureCapteurs, ArrayList<Capteur> capteurs) {
                ArrayList<Integer> numsCapt = new ArrayList<Integer>();
                Capteur capt;
                String nomFromFile, modele, numserie, fabriquant, type;
                int captTrouve;
                for (int numCapt = 0; numCapt < lectureCapteurs.getTypesCapt().size(); numCapt++) {
                        nomFromFile = lectureCapteurs.getNomsCaptFromFile().get(numCapt);
                        captTrouve = -1;
                        for (String ligne: infoSup) {
                                if (captTrouve == -1 && ligne.indexOf(nomFromFile) != -1) {
                                        // On a trouvé un nom de capteur dans le fichier qui correspond au capteur numCapt de la liste des capteurs
                                        modele = lectureCapteurs.getModelesCapt().get(numCapt);
                                        numserie = lectureCapteurs.getNumsSeriesCapt().get(numCapt);
                                        fabriquant = lectureCapteurs.getFabriquantsCapt().get(numCapt);
                                        type = lectureCapteurs.getTypesCapt().get(numCapt);
                                        for (int numC = 0; numC < capteurs.size(); numC++) {
                                                capt = capteurs.get(numC);
                                                if ((type.equals("") || capt.getTypeCapteur().getTypeCapteurNom().equals(type))
                                                                && (fabriquant.equals("") || capt.getFabriquant().getFabriquantNom().equals(fabriquant))
                                                                && (modele.equals("") || capt.getCapteurModele().equals(modele))
                                                                && (numserie.equals("") || capt.getCapteurNumserie().equals(numserie))) {
                                                        // On a fait le lien entre le capteur numCapt de la liste XLS et le capteur numC de la liste d'objets
                                                        captTrouve = numC;
//                                                      numsCapt.add(new Integer(numC));
                                                        break;
                                                }
                                        }
                                }
                        }
                        if (captTrouve != -1) numsCapt.add(new Integer(captTrouve));
                }
                return numsCapt;
        }
        
        /**
         * A partir du nom d'unité, va chercher dans le tableau des unités et récupére le type et le code de l'unité
         */
        protected String[] findUnite(String nomUnite, LectureUnites lectureUnites) {
                String code, nom, type = null;
                String[] res = new String[2];
                for (int indiceUnite = 0; indiceUnite < lectureUnites.getCodesUni().size(); indiceUnite++) {
                        code = lectureUnites.getCodesUni().get(indiceUnite);
                        nom = lectureUnites.getNomsUni().get(indiceUnite);
                        if (code.trim().equals(nomUnite) || nom.trim().equals(nomUnite)) {
                                type = lectureUnites.getTypesUni().get(indiceUnite);
                                res[0] = code;
                                res[1] = type;
                                break;
                        }
                }
                return res;
        }

        /**
         * A partir du nom de paramétre du fichier, va chercher dans le tableau des paramétres, récupére le code du paramétre
         * puis renvoie l'indice é lequel est situé le paramétre correspondant dans la liste des paramétres du jeu
         */
        protected int findIndiceParam(String nomParam, LectureParametres lectureParametres, ArrayList<Parametre> parametres) {
                if (parametres.size() == 1) return 0;
                String nomInFile, code;
                for (int indiceP = 0; indiceP < lectureParametres.getNomsParam().size(); indiceP++) {
                        nomInFile = lectureParametres.getNomsParamFromFile().get(indiceP);
                        if (nomInFile.trim().equals(nomParam)) {
                                code = lectureParametres.getCodesMegapoliParam().get(indiceP);
                                for (int numP = 0; numP < parametres.size(); numP++) {
                                        if (parametres.get(numP).getParametreCode().equals(code)) return numP;
                                }
                        }
                }
                return -1;
        }
        
        /**
         * Retrouve l'indice du capteur correspondant au code de paramétre donné
         */
        protected int findIndiceCapt(String codeParam, ArrayList<Integer> indicesCapteur, ArrayList<Capteur> capteurs) {
                if (capteurs.size() == 1) return 0;
                Capteur capt;
                for (Integer indice: indicesCapteur) {
                        capt = capteurs.get(indice.intValue());
                        for (Parametre param : capt.getParametres()) {
                                if (param.getParametreCode().equals(codeParam)) {
                                        return indice.intValue();
                                }
                        }
                }
                return -1;
        }

        public ArrayList<String> getEntete() {
                return entete;
        }

        public void setEntete(ArrayList<String> entete) {
                this.entete = entete;
        }

        public ArrayList<String> getMesures() {
                return mesures;
        }

        public void setMesures(ArrayList<String> mesures) {
                this.mesures = mesures;
        }

        public File getFichier() {
                return fichier;
        }

        public void setFichier(File fichier) {
                this.fichier = fichier;
        }
        
        public int getNbParams() {
                return nbParams;
        }

        public void setNbParams(int nbParams) {
                this.nbParams = nbParams;
        }

        public ArrayList<ParametreModele> getInfoParams() {
                return infoParams;
        }

        public void setInfoParams(ArrayList<ParametreModele> infoParams) {
                this.infoParams = infoParams;
        }

//      private String jeu;

        protected File fichier;
        protected ArrayList<String> entete;
        protected ArrayList<String> mesures;
        protected int nbParams;
        protected ArrayList<ParametreModele> infoParams;
        protected ArrayList<String> infoSup;
}