Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client;

import java.util.Iterator;
import java.util.List;

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.PersonnesAsyncDao;
import org.tela_botanica.client.modeles.ProjetsListe;
import org.tela_botanica.client.modeles.ProjetsListeAsyncDao;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.PublicationListeAsyncDao;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureAPersonne;
import org.tela_botanica.client.modeles.StructureAPersonneAsyncDao;
import org.tela_botanica.client.modeles.StructureAPersonneListe;
import org.tela_botanica.client.modeles.StructureAsyncDao;
import org.tela_botanica.client.modeles.StructureConservation;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.StructureValorisation;
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;

import com.extjs.gxt.ui.client.Registry;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;

// TODO : le transformer en SINGLETON
public class Modele implements Rafraichissable {

        public Modele() {
                Registry.register(RegistreId.MODELE, this);
        }

        public void rafraichir(Object nouvelleDonnees) {
                if (nouvelleDonnees instanceof StructureListe) {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).afficherListeStructures((StructureListe) nouvelleDonnees);
                } else if (nouvelleDonnees instanceof Utilisateur) {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).mettreAJourEtatIdentification((Utilisateur) nouvelleDonnees);
                } else if (nouvelleDonnees instanceof ValeurListe) {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).afficherListeValeurs((ValeurListe) nouvelleDonnees);
                } else if (nouvelleDonnees instanceof PublicationListe) {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).afficherListePublication((PublicationListe) nouvelleDonnees);
                } else if (nouvelleDonnees instanceof PersonneListe) {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).afficherListePersonnes((PersonneListe) nouvelleDonnees);
                } else if (nouvelleDonnees instanceof ProjetsListe)     {
                        ((Mediateur) Registry.get(RegistreId.MEDIATEUR)).afficherListeProjets((ProjetsListe) nouvelleDonnees);                  
                }
        }
        
        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES VALEURS ET LISTES
        //+----------------------------------------------------------------------------------------------------------------+
        
        public void obtenirListeValeurs(Integer id) {
                ValeurListeAsyncDao lsDao = new ValeurListeAsyncDao(this);
                lsDao.obtenirListe(id);
        }
        
        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES UTILISATEURS
        //+----------------------------------------------------------------------------------------------------------------+
        
        // pour obtenir la liste de personne et la fournir à des éléments spécifiques
        public void obtenirListePersonnes(Rafraichissable r) {
                // Lance le service JREST associé au personne via la class PersonneListeAsyncDAO
                PersonnesAsyncDao plDao = new PersonnesAsyncDao(r);
                plDao.obtenirListePersonnes();
        }

        public void connecterUtilisateur(String login, String mdp) {
                Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR);
                utilisateur.setLogin(login);
                utilisateur.setMotDePasse(mdp);
                UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(this);
                uDao.connecterUtilisateur();            
        }
        
        public void deconnecterUtilisateur() {
                UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(this);
                uDao.deconnecterUtilisateur();          
        }
        
        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES STRUCTURES
        //+----------------------------------------------------------------------------------------------------------------+

        public void obtenirListeStructures(Rafraichissable r, String utilisateurId, String projetId) {
                StructureAsyncDao sDao = new StructureAsyncDao();
                sDao.selectionner(r, utilisateurId, projetId,"");
        }
        
        public void selectionnerStructure(Rafraichissable r, String idUtilisateur, String projetId, String idStr, String idRole) {
                // Gestion des données des tables coel_structure, coel_structure_conservation et coel_structure_valorisation 
                StructureAsyncDao sDao = new StructureAsyncDao();
                sDao.selectionner(r, idUtilisateur, projetId, idStr);
                // Gestion des données de la table coel_structure_a_personne
                // TODO : créer une méthode séparée pour les données structure_a_personne
                if (idStr != null && idRole != null) {
                        StructureAPersonneAsyncDao sapDao = new StructureAPersonneAsyncDao();
                        sapDao.selectionner(r, idUtilisateur, idStr, idRole);
                }
        }
        
        public void selectionnerStructures(String idUtilisateur, String projetId) {
                Rafraichissable r = this;
                String idStr = null;
                String idRole = null;
                selectionnerStructure(r, idUtilisateur, projetId, idStr, idRole);
        }
        
        /** Lance la creation d'une Structure
         * @param vue la vue demandant a être rafraichie
         * @param structure les données de la structure
         */
        public void ajouterStructure(Rafraichissable vue, String idUtilisateur, Structure structure) {
                StructureAsyncDao structureDao = new StructureAsyncDao();
                structureDao.ajouter(vue, idUtilisateur, structure);
        }

        public void supprimerStructure(Rafraichissable vue, String idUtilisateur, String idStr) {
                StructureAsyncDao structureDao = new StructureAsyncDao();
                structureDao.supprimer(vue, idUtilisateur, idStr);
        }
        
        public void modifierStructure(Rafraichissable vue, String utilisateurId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
                StructureAsyncDao structureDao = new StructureAsyncDao();
                structureDao.modifier(vue, utilisateurId, structure, conservation, valorisation);
        }

        public void modifierStructureAPersonne(Rafraichissable vue, String utilisateurId, StructureAPersonne personnel) {
                StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
                structureAPersonneDao.modifier(vue, utilisateurId, personnel);
        }
        
        public void ajouterStructureAPersonne(Rafraichissable vue, String utilisateurId, String structureId, StructureAPersonne personnel) {
                StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
                structureAPersonneDao.ajouter(vue, utilisateurId, structureId, personnel);      
        }
        
        public void supprimerStructureAPersonne(Rafraichissable vue, String utilisateurId, String personnelId) {
                StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
                structureAPersonneDao.supprimer(vue, utilisateurId, personnelId);
        }
        
        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES PROJETS
        //+----------------------------------------------------------------------------------------------------------------+
        
        public void obtenirListeProjets ()      {
                ProjetsListeAsyncDao projetsDao = new ProjetsListeAsyncDao(this);
                projetsDao.obtenirListeProjets();
                
        }

        public void supprimerPersonne(Rafraichissable vue, String utilisateurId,
                        String idStr) {
                PersonnesAsyncDao personneDao = new PersonnesAsyncDao(vue);
                personneDao.supprimer(vue, utilisateurId, idStr);
                
        }

        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES PERSONNES
        //+----------------------------------------------------------------------------------------------------------------+
        
        public void obtenirListePersonnes() {
                // Lance le service JREST associé au personne via la class PersonneListeAsyncDAO
                PersonnesAsyncDao plDao = new PersonnesAsyncDao(this);
                plDao.obtenirListePersonnes();
        }
        
        public void selectionnerPersonne(Rafraichissable vue, String personneId, String projetId, String nomComplet) {
                PersonnesAsyncDao pDao = new PersonnesAsyncDao(vue);
                pDao.selectionner(personneId, projetId, nomComplet);
        }
        
        //+----------------------------------------------------------------------------------------------------------------+
        //                                                                                              GESTION DES PUBLICATIONS
        //+----------------------------------------------------------------------------------------------------------------+
        
        public void obtenirListePublications() {                
                PublicationListeAsyncDao lsDao = new PublicationListeAsyncDao(this);
                lsDao.obtenirListePublication();
        }
        
        public void modifierPublication(String utilisateurId, Publication publi) {
                PublicationListeAsyncDao pDao = new PublicationListeAsyncDao(this);
                pDao.modifierPublication(this, utilisateurId, publi);
        }

        public void ajouterPublication(String utilisateurId, Publication publi) {
                PublicationListeAsyncDao pDao = new PublicationListeAsyncDao(this);
                pDao.ajouterPublication(this, utilisateurId, publi);
        }

        public void supprimerPublication(String utilisateurId,
                        List<Publication> publicationListe) {
                String idPubs = "";
                for(Iterator<Publication> it = publicationListe.iterator(); it.hasNext();) {
                        Publication pub = it.next();
                        idPubs += pub.getId();
                        if(it.hasNext()) {
                                idPubs += ",";
                        }
                }
                PublicationListeAsyncDao pDao = new PublicationListeAsyncDao(this);
                pDao.supprimerPublication(this, utilisateurId, idPubs); 
        }

}