Subversion Repositories eFlore/Applications.coel

Compare Revisions

Ignore whitespace Rev 452 → Rev 453

/trunk/src/org/tela_botanica/client/modeles/CollectionListe.java
New file
0,0 → 1,46
package org.tela_botanica.client.modeles;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
 
/**
* Table de hachage composée d'informations sur les Structures, renvoyé par un objet de type DAO
* La clé est le nom de l'entite + le nom de l'entite parente
*
* @author david delon
*
*/
public class CollectionListe extends aDonneeListe<Collection> {
private static final long serialVersionUID = 8024454926649039456L;
 
public CollectionListe() {
super();
}
public CollectionListe(int taille) {
super(taille);
}
/**
* Constructeur pour une liste d'institutions
* @param dates
*/
public CollectionListe(JSONArray structures) {
super(structures.size()) ;
final int taillemax = structures.size();
for (int i = 0; i < taillemax; i++) {
JSONObject collectionCourante = structures.get(i).isObject() ;
if (collectionCourante != null) {
Collection collection = new Collection(collectionCourante);
CollectionBotanique botanique = new CollectionBotanique(collectionCourante);
collection.setBotanique(botanique);
this.put(collection.getId(), collection);
}
}
}
}
/trunk/src/org/tela_botanica/client/modeles/Collection.java
New file
0,0 → 1,95
package org.tela_botanica.client.modeles;
 
import java.util.Iterator;
import java.util.Set;
 
import com.extjs.gxt.ui.client.data.BaseModelData;
import com.google.gwt.json.client.JSONObject;
 
public class Collection extends aDonnee {
public static final String PREFIXE = "cc";
private CollectionBotanique botanique = null;
 
public Collection() {
}
public Collection(JSONObject collection) {
// l'objet JSON est une table de hachage
Set<String> im = collection.keySet();
 
// Parcourt pour chaque clé
for (Iterator<String> it = im.iterator(); it.hasNext();) {
// Si elle est associée à une valeur, nous l'ajoutons
String cle = it.next();
if (cle.startsWith(PREFIXE+"_")) {
// Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet
String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", "");
// Sinon, nous ajoutons la clé avec une valeur vide
String valeur = "";
if (collection.get(cle).isString() != null) {
valeur = collection.get(cle).isString().stringValue();
}
this.set(cleObjet, valeur);
}
}
}
 
// BOTANIQUE
public CollectionBotanique getBotanique() {
return botanique;
}
public void setBotanique(CollectionBotanique botaniqueAStocker) {
botanique = botaniqueAStocker;
}
// ID
public String getId() {
return renvoyerValeurCorrecte("id_collection");
}
public void setId(String idCollection) {
this.set("id_collection", idCollection);
}
// CE PROJET
public String getIdProjet() {
return renvoyerValeurCorrecte("ce_projet");
}
public void setIdProjet(String idProjet) {
this.set("ce_projet", idProjet);
}
// CE STRUCTURE
public String getIdStructure() {
return renvoyerValeurCorrecte("ce_structure");
}
public void setIdStructure(String idStructure) {
this.set("ce_structure", idStructure);
}
 
// GUID
public String getGuid() {
return renvoyerValeurCorrecte("guid");
}
public void setGuid(String guid) {
this.set("guid", guid);
}
// NOM
public String getNom() {
return renvoyerValeurCorrecte("nom");
}
public void setNom(String nom) {
this.set("nom", nom);
}
 
// TRUK IDENTIFIANT ALTERNATIF
public String getIdAlternatif() {
return renvoyerValeurCorrecte("truk_identifiant_alternatif");
}
public void setIdAlternatif(String idAlter) {
this.set("truk_identifiant_alternatif", idAlter);
}
}
/trunk/src/org/tela_botanica/client/modeles/CollectionBotanique.java
New file
0,0 → 1,35
package org.tela_botanica.client.modeles;
 
import java.util.Iterator;
import java.util.Set;
 
import com.google.gwt.json.client.JSONObject;
 
public class CollectionBotanique extends aDonnee {
public static final String PREFIXE = "ccb";
public CollectionBotanique() {
}
public CollectionBotanique(JSONObject botanique) {
// l'objet JSON est une table de hachage
Set<String> im = botanique.keySet();
 
// Parcourt pour chaque clé
for (Iterator<String> it = im.iterator(); it.hasNext();) {
// Si elle est associée à une valeur, nous l'ajoutons
String cle = it.next();
if (cle.startsWith(PREFIXE+"_")) {
// Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet
String cleObjet = cle.replaceFirst("^"+PREFIXE+"_", "");
// Sinon, nous ajoutons la clé avec une valeur vide
String valeur = "";
if (botanique.get(cle).isString() != null) {
valeur = botanique.get(cle).isString().stringValue();
}
this.set(cleObjet, valeur);
}
}
}
}
/trunk/src/org/tela_botanica/client/Mediateur.java
9,6 → 9,7
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
27,6 → 28,7
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.CollectionListeVue;
import org.tela_botanica.client.vues.CollectionVue;
import org.tela_botanica.client.vues.ContenuVue;
import org.tela_botanica.client.vues.EnteteVue;
import org.tela_botanica.client.vues.PersonneForm;
46,6 → 48,7
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.WindowEvent;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.Info;
180,8 → 183,9
} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
modele.selectionnerPublications(panneauCentre);
} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) {
modele.selectionnerPersonne(panneauCentre, null, getProjetId(), null);
} else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) {
selectionnerCollection(panneauCentre, null);
} else {
GWT.log("Non implémenté! Menu id : "+codeMenuClique, null);
}
282,7 → 286,18
}
}
 
public void obtenirListeValeurEtRafraichir(Rafraichissable vue, String listeId) {
modele.obtenirListeValeurs(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId));
}
public void obtenirValeurEtRafraichir(Rafraichissable vue, String listeId, String identifiantValeur) {
modele.obtenirValeur(vue, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur);
}
public void obtenirListeRegionsEtRafraichir(Rafraichissable vue, String strListeId, String strPays) {
modele.obtenirListeRegion(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION des PROJETS
//+----------------------------------------------------------------------------------------------------------------+
322,6 → 337,15
// GESTION DES STRUCTURES
//+----------------------------------------------------------------------------------------------------------------+
 
public void afficherListeStructures(StructureListe structuresACharger) {
// TODO : créer dès l'initialisation de l'application InsitutionVue et la cacher
StructureVue institutionVue = new StructureVue(this);
panneauCentre.add(institutionVue);
panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_LISTE);
contenuPanneauCentre = institutionVue;
institutionVue.rafraichir(structuresACharger);
}
public void clicListeStructure(Structure structure) {
contenuPanneauCentre.rafraichir(structure);
if (structure.getPersonnel() == null) {
331,15 → 355,6
}
}
 
public void afficherListeStructures(StructureListe structuresACharger) {
// TODO : créer dès l'initialisation de l'application InsitutionVue et la cacher
StructureVue institutionVue = new StructureVue(this);
panneauCentre.add(institutionVue);
panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_LISTE);
contenuPanneauCentre = institutionVue;
institutionVue.rafraichir(structuresACharger);
}
public void clicAjouterStructure() {
panneauCentre.removeAll();
StructureForm structureForm = new StructureForm(this, StructureForm.MODE_AJOUTER);
378,26 → 393,22
message = "Êtes vous sur de vouloir supprimer la structure sélectionnée ?";
}
final Listener<WindowEvent> suppressionEcouteur = new Listener<WindowEvent>() {
public void handleEvent(WindowEvent ce) {
Dialog dialog = (Dialog) ce.component;
Button btn = dialog.getButtonPressed();
 
if (btn.getText().equals(dialog.yesText)) {
String idStr = "" ;
for(int i = 0 ; i < structureSelection.size() ; i++) {
idStr += structureSelection.get(i).getId()+"," ;
}
supprimerStructure(vue, idStr);
}
}
};
final Listener listenerSuppression = new Listener<ComponentEvent>() {
public void handleEvent(ComponentEvent ce) {
Dialog dialog = (Dialog) ce.component;
Button btn = dialog.getButtonPressed();
if (btn.getText().equals(dialog.yesText)) {
String idStr = "" ;
for(int i = 0 ; i < structureSelection.size() ; i++) {
idStr += structureSelection.get(i).getId()+"," ;
}
modele.supprimerStructure(vue, getUtilisateurId(), idStr);
}
}
};
MessageBox.confirm("Supprimer une structure", message, listenerSuppression);
MessageBox.confirm("Supprimer une structure", message, suppressionEcouteur);
} else {
Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerStructure() du Médiateur.");
}
404,15 → 415,9
}
public void selectionnerStructure(Rafraichissable vue, String structureId) {
GWT.log("Structure : "+structureId, null);
modele.selectionnerStructure(vue, null, structureId);
modele.selectionnerStructure(vue, getProjetId(), structureId);
}
/**
* TODO : afficher un message du type "Structure ajoutée".
* Lance la creation d'une structure
* @param les données de la structure saisie
*/
public void ajouterStructure(Rafraichissable vue, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
modele.ajouterStructure(vue, getUtilisateurId(), structure, conservation, valorisation);
}
420,7 → 425,11
public void modifierStructure(Rafraichissable vue, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
modele.modifierStructure(vue, getUtilisateurId(), structureId, structure, conservation, valorisation);
}
 
public void supprimerStructure(Rafraichissable vueARafraichir, String IdentifiantsStructureSepareParVirgule) {
modele.supprimerStructure(vueARafraichir, getUtilisateurId(), IdentifiantsStructureSepareParVirgule);
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la relation STRUCTURE A PERSONNE
public void selectionnerStructureAPersonne(Rafraichissable vue, String structureId, String roleId) {
428,6 → 437,14
modele.selectionnerStructureAPersonne(vue, getUtilisateurId(), null, structureId, roleId);
}
public void ajouterStructureAPersonne(Rafraichissable vue, String structureId, StructureAPersonneListe personnelAjoute) {
if (personnelAjoute != null && personnelAjoute.size() > 0) {
for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
modele.ajouterStructureAPersonne(vue, getUtilisateurId(), structureId, (StructureAPersonne) personnelAjoute.get(it.next()));
}
}
}
public void modifierStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelModifie) {
if (personnelModifie != null && personnelModifie.size() > 0) {
GWT.log("Mediateur :modif", null);
437,14 → 454,6
}
}
public void ajouterStructureAPersonne(Rafraichissable vue, String structureId, StructureAPersonneListe personnelAjoute) {
if (personnelAjoute != null && personnelAjoute.size() > 0) {
for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
modele.ajouterStructureAPersonne(vue, getUtilisateurId(), structureId, (StructureAPersonne) personnelAjoute.get(it.next()));
}
}
}
public void supprimerStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelSupprime) {
if (personnelSupprime != null && personnelSupprime.size() > 0) {
String idStrAPer = "" ;
459,6 → 468,18
// GESTION des COLLECTIONS
//+----------------------------------------------------------------------------------------------------------------+
public void afficherListeCollections(CollectionListe collectionsACharger) {
CollectionVue collectionVue = new CollectionVue(this);
panneauCentre.add(collectionVue);
panneauCentre.setId(ComposantId.PANNEAU_COLLECTION_LISTE);
contenuPanneauCentre = collectionVue;
collectionVue.rafraichir(collectionsACharger);
}
public void clicListeCollection(Collection collectionCliquee) {
contenuPanneauCentre.rafraichir(collectionCliquee);
}
public void clicAjouterCollection() {
// TODO Auto-generated method stub
469,23 → 490,36
}
 
public void clicSupprimerCollection(CollectionListeVue collectionListeVue,
List<Collection> collectionsASupprimer) {
public void clicSupprimerCollection(CollectionListeVue collectionListeVue, List<Collection> collectionsASupprimer) {
// TODO Auto-generated method stub
}
 
public void selectionnerCollection(Rafraichissable vueARafraichir, String structureId) {
modele.selectionnerCollection(vueARafraichir, getProjetId(), structureId);
}
public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
modele.ajouterCollection(vueARafraichir, getUtilisateurId(), collection);
}
public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
modele.modifierCollection(vueARafraichir, getUtilisateurId(), collection);
}
public void supprimerCollection(Rafraichissable vueARafraichir, String IdentifiantsCollectionSepareParVirgule) {
modele.supprimerCollection(vueARafraichir, getUtilisateurId(), IdentifiantsCollectionSepareParVirgule);
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES PERSONNES
//+----------------------------------------------------------------------------------------------------------------+
 
public void clicListePersonne(Personne personne) {
((PersonneDetailVue) Registry.get(RegistreId.PANNEAU_PERSONNE_DETAIL)).rafraichir(personne);
contenuPanneauCentre.rafraichir(personne);
}
 
public void afficherListePersonnes(PersonneListe personnesACharger) {
PersonneVue personneVue = new PersonneVue();
contenuPanneauCentre = personneVue;
panneauCentre.add(personneVue);
495,7 → 529,6
}
 
public void clicAjouterPersonne() {
afficherPopinChargement();
panneauCentre.removeAll();
515,8 → 548,6
selectionnerPersonne(formulairePersonneVue, personne);
panneauCentre.layout();
 
}
}
525,9 → 556,6
}
public void clicSupprimerPersonne(final Rafraichissable vue,final List<Personne> personneSelection) {
String ids = "" ;
if (personneSelection.size() == 0) {
Info.display("Information", "Veuillez sélectionner une personne.");
} else if(personneSelection.size() > 0) {
536,10 → 564,8
message = "Êtes vous sur de vouloir supprimer la personne sélectionnée ?";
}
final Listener listenerSuppression = new Listener<ComponentEvent>() {
public void handleEvent(ComponentEvent ce) {
final Listener<WindowEvent> listenerSuppression = new Listener<WindowEvent>() {
public void handleEvent(WindowEvent ce) {
Dialog dialog = (Dialog) ce.component;
Button btn = dialog.getButtonPressed();
 
555,7 → 581,7
}
}
};
MessageBox.confirm("Supprimer une personne", message, listenerSuppression);
} else {
Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerPersonne() du Médiateur.");
572,7 → 598,6
} else {
modele.ajouterPersonne(vue, personne);
}
}
//+----------------------------------------------------------------------------------------------------------------+
615,21 → 640,16
}
public void clicSupprimerPublication(final List<Publication> publicationListe) {
if(publicationListe.size() <= 0) {
if (publicationListe.size() <= 0) {
MessageBox.alert("Attention", "Vous devez sélectionner une publication", null);
} else {
String message = "" ;
String message = "Voulez-vous vraiment supprimer ces publication ?";
if(publicationListe.size() == 1) {
message = "Voulez-vous vraiment supprimer cette publication ?";
}
else {
message = "Voulez-vous vraiment supprimer ces publication ?";
}
final Listener listenerSuppression = new Listener<ComponentEvent>() {
public void handleEvent(ComponentEvent ce) {
final Listener<WindowEvent> listenerSuppression = new Listener<WindowEvent>() {
public void handleEvent(WindowEvent ce) {
Dialog dialog = (Dialog) ce.component;
Button btn = dialog.getButtonPressed();
641,23 → 661,22
MessageBox.confirm("Supprimer une publication", message, listenerSuppression);
}
}
 
public void ajouterPublication(PublicationForm publicationForm, Publication publi) {
modele.ajouterPublication(contenuPanneauCentre, getUtilisateurId(),publi);
modele.ajouterPublication(contenuPanneauCentre, getUtilisateurId(), publi);
}
public void modifierPublication(PublicationForm publicationForm, Publication publi) {
modele.modifierPublication(contenuPanneauCentre, getUtilisateurId(),publi);
modele.modifierPublication(contenuPanneauCentre, getUtilisateurId(), publi);
}
 
public void clicObtenirListeEditeurs(Rafraichissable vue) {
modele.selectionnerStructure(vue, null, null);
public void clicObtenirListeEditeurs(Rafraichissable vueARafraichir) {
modele.selectionnerStructure(vueARafraichir, null, null);
}
 
public void clicObtenirListeAuteurs(Rafraichissable vue) {
modele.selectionnerPersonne(vue, null, null, null);
public void clicObtenirListeAuteurs(Rafraichissable vueARafraichir) {
modele.selectionnerPersonne(vueARafraichir, null, null, null);
}
//+----------------------------------------------------------------------------------------------------------------+
672,32 → 691,14
}
}
/**
* Récupère la liste et rafraichit la vue donnée
*
* @param la vue à rafraichir
* @param l'id de la liste à récupérer
* */
public void obtenirListeValeurEtRafraichir(Rafraichissable vue, String listeId) {
modele.obtenirListeValeurs(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId));
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION du STATUT
//+----------------------------------------------------------------------------------------------------------------+
public void obtenirValeurEtRafraichir(Rafraichissable vue, String listeId, String identifiantValeur) {
modele.obtenirValeur(vue, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur);
}
public void obtenirListeRegionsEtRafraichir(Rafraichissable vue, String strListeId, String strPays) {
modele.obtenirListeRegion(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
}
/**
* Affiche la popin de chargement
*/
public void afficherPopinChargement() {
((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).center();
}
public void masquerPopinChargement() {
((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).hide();
}
/trunk/src/org/tela_botanica/client/ComposantId.java
9,8 → 9,9
public static final String MENU_BEL = "coel-id-menu-bel";
public static final String BTN_DECONNEXION = "coel-id-btn-deconnexion";
public static final String PANNEAU_AIDE = "coel-id-panneau-aide";
public static final String PANNEAU_STRUCTURE_FORM = "coel-id_panneau-structure-form";
public static final String PANNEAU_STRUCTURE_LISTE = "coel-id_panneau-structure-liste";
public static final String PANNEAU_COLLECTION_LISTE = "coel-id_panneau-liste-collection";
public static final String PANNEAU_STRUCTURE_FORM = "coel-id_panneau-form-structure";
public static final String PANNEAU_STRUCTURE_LISTE = "coel-id_panneau-liste-structure";
public static final String PANNEAU_FORM_PUBLICATION = "coel-id_panneau-form-publication";
public static final String PANNEAU_ENTETE = "coel-entete";
public static final String DIV_TITRE = "coel-titre";
/trunk/src/org/tela_botanica/client/vues/CollectionDetailVue.java
New file
0,0 → 1,156
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.ComposantId;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.ValeurListe;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Html;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.TabPanel;
import com.extjs.gxt.ui.client.widget.layout.AnchorLayout;
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
import com.google.gwt.core.client.GWT;
 
public class CollectionDetailVue extends DetailVue implements Rafraichissable {
 
private StructureListe structures = null;
private String enteteTpl = null;
private String generalTpl = null;
private Collection collection = null;
private ContentPanel panneauPrincipal = null;
private Html entete = null;
private TabPanel onglets = null;
private TabItem generalOnglet = null;
public CollectionDetailVue(Mediateur mediateurCourant) {
super(mediateurCourant);
initialiserTousLesTpl();
chargerOntologie();
panneauPrincipal = new ContentPanel();
panneauPrincipal.setLayout(new FlowLayout());
panneauPrincipal.setHeaderVisible(false);
panneauPrincipal.setBodyBorder(false);
entete = new Html();
entete.setId(ComposantId.ZONE_DETAIL_ENTETE);
panneauPrincipal.setTopComponent(entete);
onglets = new TabPanel();
onglets.setId(ComposantId.ZONE_DETAIL_CORPS);
onglets.setHeight("100%");
onglets.setBodyBorder(false);
 
generalOnglet = new TabItem(i18nC.structureInfoGeneral());
generalOnglet.setLayout(new AnchorLayout());
generalOnglet.setScrollMode(Scroll.AUTO);
onglets.add(generalOnglet);
panneauPrincipal.add(onglets);
add(panneauPrincipal);
}
private void initialiserTousLesTpl() {
initialiserEnteteHtmlTpl();
initialiserGeneralTpl();
}
private void initialiserEnteteHtmlTpl() {
enteteTpl =
"<div id='{css_id}'>"+
" <h1>{nom}</h1>"+
" <h2>{structure}<span class='{css_meta}'>{projet} - {id} - {guid}</span></h2>" +
" " +
"</div>";
}
private void initialiserGeneralTpl() {
generalTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_identification}</h2>"+
" <span class='{css_label}'>{i18n_sigle} :</span> {sigle}<br />"+
" </div>"+
"</div>";
}
private void chargerOntologie() {
}
public void rafraichir(Object nouvelleDonnees) {
if (nouvelleDonnees instanceof Collection) {
collection = (Collection) nouvelleDonnees;
afficherDetail();
} else if (nouvelleDonnees instanceof ProjetListe) {
projets = (ProjetListe) nouvelleDonnees;
} else if (nouvelleDonnees instanceof ValeurListe) {
ValeurListe ontologieReceptionnee = (ValeurListe) nouvelleDonnees;
ajouterListeValeursAOntologie(ontologieReceptionnee);
} else {
GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
}
}
private void afficherDetail() {
if (collection != null) {
afficherEntete();
afficherIdentification();
}
layout();
}
private void afficherEntete() {
Params enteteParams = new Params();
enteteParams.set("css_id", ComposantId.ZONE_DETAIL_ENTETE);
enteteParams.set("css_meta", ComposantClass.META);
enteteParams.set("nom", collection.getNom());
enteteParams.set("structure", construireTxtStructure(collection.getIdStructure()));
enteteParams.set("id", collection.getId());
enteteParams.set("guid", collection.getGuid());
enteteParams.set("projet", construireTxtProjet(collection.getIdProjet()));
String eHtml = Format.substitute(enteteTpl, enteteParams);
entete.getElement().setInnerHTML(eHtml);
}
private void afficherIdentification() {
Params generalParams = new Params();
generalParams.set("i18n_titre_identification", i18nC.titreAdministratif());
generalParams.set("i18n_acronyme", i18nC.acronyme());
 
String acronyme = construireTxtTruck(collection.getIdAlternatif());
generalParams.set("acronyme", acronyme);
afficherOnglet(generalTpl, generalParams, generalOnglet);
}
protected String construireTxtStructure(String idStructure) {
String chaineARetourner = idStructure;
if (structures != null) {
Structure structure = structures.get(idStructure);
String nomStructure = structure.getNom();
if (!nomStructure.equals("")) {
chaineARetourner = nomStructure;
}
}
return chaineARetourner;
}
}
/trunk/src/org/tela_botanica/client/vues/StructureDetailVue.java
34,13 → 34,8
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
import com.google.gwt.core.client.GWT;
 
public class StructureDetailVue extends LayoutContainer implements Rafraichissable {
public class StructureDetailVue extends DetailVue implements Rafraichissable {
 
private Mediateur mediateur = null;
private Constantes i18nC = null;
private HashMap<String, Valeur> ontologie = null;
private ProjetListe projets = null;
private String enteteTpl = null;
private String identificationTpl = null;
private String personnelTpl = null;
49,7 → 44,6
private String conservationTpl = null;
private String traitementConservationTpl = null;
private String valorisationTpl = null;
private String sautLigneTpl = null;
private String typeTraitementConservationTpl = null;
private String rechercheValorisationTpl = null;
67,16 → 61,11
private TabItem valorisationOnglet = null;
public StructureDetailVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
i18nC = mediateur.i18nC;
super(mediateurCourant);
initialiserTousLesTpl();
ontologie = new HashMap<String, Valeur>();
chargerOntologie();
setLayout(new FitLayout());
setBorders(false);
setScrollMode(Scroll.AUTO);
panneauPrincipal = new ContentPanel();
panneauPrincipal.setLayout(new FlowLayout());
panneauPrincipal.setHeaderVisible(false);
116,7 → 105,6
}
 
private void chargerOntologie() {
mediateur.selectionnerProjets(this);
mediateur.obtenirListeValeurEtRafraichir(this, "stpr");
mediateur.obtenirListeValeurEtRafraichir(this, "stpu");
mediateur.obtenirListeValeurEtRafraichir(this, "statut");
445,22 → 433,6
return cHtml;
}
private void afficherOnglet(String template, Params parametres, TabItem onglet) {
String cHtml = Format.substitute(template, parametres);
Params cssParams = new Params();
cssParams.set("css_corps", ComposantClass.DETAIL_CORPS_CONTENU);
cssParams.set("css_label", ComposantClass.LABEL);
cssParams.set("css_indentation", ComposantClass.INDENTATION);
cssParams.set("css_fieldset", ComposantClass.FIELDSET);
cssParams.set("css_clear", ComposantClass.CLEAR);
cHtml = Format.substitute(cHtml, cssParams);
HtmlContainer corpsConteneurDuHtml = new HtmlContainer(cHtml);
onglet.removeAll();
onglet.add(corpsConteneurDuHtml);
}
private void initialiserTousLesTpl() {
initialiserEnteteHtmlTpl();
initialiserIdentificationTpl();
472,7 → 444,6
initialiserTypeTraitementConservationTpl();
initialiserValorisationTpl();
initialiserRechercheValorisationTpl();
initialiserSautLigneTpl();
}
private void initialiserEnteteHtmlTpl() {
644,10 → 615,6
"<span class='{css_indentation} {css_label}'>{i18n_recherche_type} :</span> {recherche_type}<br />";
}
private void initialiserSautLigneTpl() {
sautLigneTpl = "<br />\n";
}
public void rafraichir(Object nouvelleDonnees) {
if (nouvelleDonnees instanceof Structure) {
structure = (Structure) nouvelleDonnees;
667,17 → 634,6
GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
}
}
private void ajouterListeValeursAOntologie(ValeurListe ontologieReceptionnee) {
Iterator<String> it = ontologieReceptionnee.keySet().iterator();
while (it.hasNext()) {
String cle = it.next();
Valeur valeur = ontologieReceptionnee.get(cle);
if (valeur != null) {
ontologie.put(cle, valeur);
}
}
}
 
protected void allouerPersonnelAStructure(StructureAPersonneListe personnel) {
structure.setPersonnel(personnel);
730,90 → 686,4
return chaineARetourner;
}
protected String construireTxtTruck(String chaineAAnalyser) {
ArrayList<String> termes = new ArrayList<String>();
if ((chaineAAnalyser != null) && (!chaineAAnalyser.trim().equals(""))) {
String[] valeurs = chaineAAnalyser.split(";;");
int nbreValeurs = valeurs.length;
if (nbreValeurs > 0) {
for (int i = 0; i < nbreValeurs; i++) {
String valeur = valeurs[i];
String valeurFormatee = formaterValeurTruck(valeur);
termes.add(valeurFormatee);
}
}
}
String chaineARetourner = formaterTableauDeTxt(termes);
return chaineARetourner;
}
private String formaterParenthese(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = "("+chaineAAfficher+")";
}
return chaineAAfficher;
}
private String formaterAutre(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = " ["+i18nC.autres()+" : "+chaineAAfficher+"]";
}
return chaineAAfficher;
}
private String formaterTableauDeTxt(ArrayList<String> tableauDeTxt) {
String chaineAAfficher = "";
int tailleDuTableau = tableauDeTxt.size();
if (tailleDuTableau > 0) {
int indexAvtDernier = tailleDuTableau - 1;
for (int i = 0; i < tailleDuTableau; i++) {
String mot = tableauDeTxt.get(i);
if (i != indexAvtDernier) {
chaineAAfficher += mot+", ";
} else {
chaineAAfficher += nettoyerPointFinal(mot)+".";
}
}
}
return chaineAAfficher;
}
private String formaterOuiNon(String chaineAFormater) {
String txtARetourner = "";
if (chaineAFormater.equals("0")) {
txtARetourner = i18nC.non();
} else if (chaineAFormater.equals("1")) {
txtARetourner = i18nC.oui();
}
return txtARetourner;
}
private String formaterSautDeLigne(String chaineAFormater) {
String txtARetourner = chaineAFormater.replaceAll("\n", sautLigneTpl);
return txtARetourner;
}
 
private String formaterValeurTruck(String valeur) {
String chaineARetourner = "";
if (valeur.matches("^[^#]+##[^$]+$")) {
String[] cleValeur = valeur.split("##");
chaineARetourner = cleValeur[1]+" "+formaterParenthese(cleValeur[0]);
} else if (!valeur.equals("")) {
chaineARetourner = valeur;
} else {
GWT.log("Valeur truck posant problèlme :"+valeur, null);
}
return chaineARetourner;
}
 
private String nettoyerPointFinal(String mot) {
mot = mot.replaceAll("[.]$", "");
return mot;
}
}
/trunk/src/org/tela_botanica/client/vues/PersonneVue.java
4,6 → 4,7
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.PersonneListe;
 
import com.extjs.gxt.ui.client.Registry;
36,7 → 37,9
}
 
public void rafraichir(Object nouvelleDonnees) {
if (nouvelleDonnees instanceof PersonneListe) {
if (nouvelleDonnees instanceof Personne) {
panneauPersonneDetail.rafraichir((Personne) nouvelleDonnees);
} else if (nouvelleDonnees instanceof PersonneListe) {
panneauPersonneListe.rafraichir((PersonneListe) nouvelleDonnees);
} else if (nouvelleDonnees instanceof Information) {
Information info = (Information) nouvelleDonnees;
/trunk/src/org/tela_botanica/client/vues/CollectionVue.java
New file
0,0 → 1,49
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
 
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
import com.google.gwt.core.client.GWT;
 
public class CollectionVue extends LayoutContainer implements Rafraichissable {
 
private Mediateur mediateur = null;
private CollectionListeVue listeCollectionPanneau = null;
private CollectionDetailVue detailCollectionPanneau = null;
 
public CollectionVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
BorderLayout layout = new BorderLayout();
layout.setEnableState(false);
setLayout(layout);
 
listeCollectionPanneau = new CollectionListeVue(mediateur);
add(listeCollectionPanneau, new BorderLayoutData(LayoutRegion.CENTER));
 
detailCollectionPanneau = new CollectionDetailVue(mediateur);
BorderLayoutData dispositionSud = new BorderLayoutData(LayoutRegion.SOUTH, .5f, 200, 1000);
dispositionSud.setSplit(true);
dispositionSud.setMargins(new Margins(5, 0, 0, 0));
add(detailCollectionPanneau, dispositionSud);
}
 
public void rafraichir(Object nouvelleDonnees) {
// Nous passons l'objet aux méthodes rafraichir des panneaux composant le panneau principal Structure
if (nouvelleDonnees instanceof Collection) {
detailCollectionPanneau.rafraichir(nouvelleDonnees);
} else if (nouvelleDonnees instanceof CollectionListe) {
listeCollectionPanneau.rafraichir(nouvelleDonnees);
} else {
GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
}
}
}
/trunk/src/org/tela_botanica/client/vues/CollectionListeVue.java
New file
0,0 → 1,177
package org.tela_botanica.client.vues;
 
import java.util.ArrayList;
import java.util.List;
 
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.Utilisateur;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.SelectionMode;
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.binder.TableBinder;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.table.Table;
import com.extjs.gxt.ui.client.widget.table.TableColumn;
import com.extjs.gxt.ui.client.widget.table.TableColumnModel;
import com.extjs.gxt.ui.client.widget.table.TableItem;
import com.extjs.gxt.ui.client.widget.toolbar.TextToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
 
public class CollectionListeVue extends ContentPanel implements Rafraichissable {
private Mediateur mediateur = null ;
private Constantes i18nC = null ;
 
private Table table = null;
private ListStore<Collection> store = null;
private TableBinder<Collection> binder = null;
 
private TextToolItem modifier;
private TextToolItem supprimer;
private TextToolItem ajouter;
 
public CollectionListeVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
i18nC = mediateur.i18nC;
Utilisateur utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
ToolBar toolBar = new ToolBar();
ajouter = new TextToolItem(i18nC.ajouter());
ajouter.setIconStyle(ComposantClass.ICONE_AJOUTER);
ajouter.addSelectionListener(new SelectionListener<ComponentEvent>() {
public void componentSelected(ComponentEvent ce) {
mediateur.clicAjouterCollection();
}
});
toolBar.add(ajouter);
 
modifier = new TextToolItem(i18nC.modifier());
modifier.setIconStyle(ComposantClass.ICONE_MODIFIER);
modifier.addSelectionListener(new SelectionListener<ComponentEvent>() {
public void componentSelected(ComponentEvent ce) {
mediateur.clicModifierCollection(binder.getSelection());
}
});
toolBar.add(modifier);
supprimer = new TextToolItem(i18nC.supprimer());
supprimer.setIconStyle(ComposantClass.ICONE_SUPPRIMER);
supprimer.addSelectionListener(new SelectionListener<ComponentEvent>() {
public void componentSelected(ComponentEvent ce) {
clicSupprimerCollection(binder.getSelection());
}
});
if (!utilisateur.isIdentifie()) {
supprimer.disable();
}
toolBar.add(supprimer);
 
setTopComponent(toolBar);
 
List<TableColumn> columns = new ArrayList<TableColumn>();
// ATTENTION : les noms des colonnes doivent correspondrent aux noms variables de la classe utilisée dans la liste
columns.add(new TableColumn("structure", i18nC.structure(), .3f));
columns.add(new TableColumn("nom", i18nC.nom(), .7f));
TableColumnModel cm = new TableColumnModel(columns);
table = new Table(cm);
table.setSelectionMode(SelectionMode.MULTI);
table.setBorders(false);
table.setStripeRows(true);
add(table);
store = new ListStore<Collection>();
store.sort("nom", SortDir.ASC);
binder = new TableBinder<Collection>(table, store);
binder.addSelectionChangedListener(new SelectionChangedListener<Structure>() {
public void selectionChanged(SelectionChangedEvent<Structure> event) {
Structure m = (Structure) event.getSelectedItem();
clicListe(m);
}
});
 
setLayout(new FitLayout());
}
 
private void clicListe(Structure structure) {
if (store.getCount() > 0) {
mediateur.clicListeStructure(structure);
}
}
private void clicSupprimerCollection(List<Collection> collectionsASupprimer) {
if (store.getCount() > 0) {
mediateur.clicSupprimerCollection(this, collectionsASupprimer);
}
}
 
public void rafraichir(Object nouvelleDonnees) {
if (nouvelleDonnees instanceof CollectionListe) {
CollectionListe collections = (CollectionListe) nouvelleDonnees;
setHeading(i18nC.collectionListeTitre());
List<Collection> liste = (List<Collection>) collections.toList();
store.removeAll();
store.add(liste);
 
mediateur.actualiserPanneauCentral();
if (store.getCount() > 0) {
table.getSelectionModel().select(0);
}
} else if (nouvelleDonnees instanceof Information) {
Information info = (Information) nouvelleDonnees;
if (info.getType().equals("suppression_collection")) {
// Affichage d'un message d'information
//GWT.log(info.toString(), null);
Info.display(i18nC.suppressionCollection(), info.toString().replaceAll("\n", "<br />"));
 
// Suppression des structures sélectionnées
List<TableItem> selectionCollection = table.getSelectedItems();
final int taille = selectionCollection.size();
for (int i = 0; i < taille; i++) {
//GWT.log("INDEX :"+table.indexOf(selectionStructure.get(i)), null);
table.remove(selectionCollection.get(i));
}
// Désactivation des boutons si la liste est vide
if (table.getItemCount() == 0) {
supprimer.disable();
modifier.disable();
}
} else if (info.getType().equals("maj_utilisateur")) {
if (((Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT)).isIdentifie()) {
if (table.getItemCount() != 0) {
supprimer.enable();
}
} else {
supprimer.disable();
}
}
} else {
GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
}
layout();
}
}
/trunk/src/org/tela_botanica/client/vues/DetailVue.java
New file
0,0 → 1,182
package org.tela_botanica.client.vues;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;
import com.extjs.gxt.ui.client.widget.HtmlContainer;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.google.gwt.core.client.GWT;
 
public abstract class DetailVue extends LayoutContainer implements Rafraichissable {
 
protected Mediateur mediateur = null;
protected Constantes i18nC = null;
 
protected HashMap<String, Valeur> ontologie = null;
protected ProjetListe projets = null;
 
protected String sautLigneTpl = null;
public DetailVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
i18nC = mediateur.i18nC;
initialiserSautLigneTpl();
ontologie = new HashMap<String, Valeur>();
chargerOntologie();
setLayout(new FitLayout());
setBorders(false);
setScrollMode(Scroll.AUTO);
}
private void initialiserSautLigneTpl() {
sautLigneTpl = "<br />\n";
}
private void chargerOntologie() {
mediateur.selectionnerProjets(this);
}
protected String construireTxtProjet(String idProjet) {
String chaineARetourner = idProjet;
if (projets != null) {
Projet projet = projets.get(idProjet);
String nomDuProjet = projet.getNom();
if (!nomDuProjet.equals("")) {
chaineARetourner = nomDuProjet;
}
}
return chaineARetourner;
}
protected String construireTxtTruck(String chaineAAnalyser) {
ArrayList<String> termes = new ArrayList<String>();
if ((chaineAAnalyser != null) && (!chaineAAnalyser.trim().equals(""))) {
String[] valeurs = chaineAAnalyser.split(";;");
int nbreValeurs = valeurs.length;
if (nbreValeurs > 0) {
for (int i = 0; i < nbreValeurs; i++) {
String valeur = valeurs[i];
String valeurFormatee = formaterValeurTruck(valeur);
termes.add(valeurFormatee);
}
}
}
String chaineARetourner = formaterTableauDeTxt(termes);
return chaineARetourner;
}
private String formaterValeurTruck(String valeur) {
String chaineARetourner = "";
if (valeur.matches("^[^#]+##[^$]+$")) {
String[] cleValeur = valeur.split("##");
chaineARetourner = cleValeur[1]+" "+formaterParenthese(cleValeur[0]);
} else if (!valeur.equals("")) {
chaineARetourner = valeur;
} else {
GWT.log("Valeur truck posant problèlme :"+valeur, null);
}
return chaineARetourner;
}
protected String formaterParenthese(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = "("+chaineAAfficher+")";
}
return chaineAAfficher;
}
protected String formaterTableauDeTxt(ArrayList<String> tableauDeTxt) {
String chaineAAfficher = "";
int tailleDuTableau = tableauDeTxt.size();
if (tailleDuTableau > 0) {
int indexAvtDernier = tailleDuTableau - 1;
for (int i = 0; i < tailleDuTableau; i++) {
String mot = tableauDeTxt.get(i);
if (i != indexAvtDernier) {
chaineAAfficher += mot+", ";
} else {
chaineAAfficher += nettoyerPointFinal(mot)+".";
}
}
}
return chaineAAfficher;
}
protected String nettoyerPointFinal(String mot) {
mot = mot.replaceAll("[.]$", "");
return mot;
}
protected void afficherOnglet(String template, Params parametres, TabItem onglet) {
String cHtml = Format.substitute(template, parametres);
Params cssParams = new Params();
cssParams.set("css_corps", ComposantClass.DETAIL_CORPS_CONTENU);
cssParams.set("css_label", ComposantClass.LABEL);
cssParams.set("css_indentation", ComposantClass.INDENTATION);
cssParams.set("css_fieldset", ComposantClass.FIELDSET);
cssParams.set("css_clear", ComposantClass.CLEAR);
cHtml = Format.substitute(cHtml, cssParams);
HtmlContainer corpsConteneurDuHtml = new HtmlContainer(cHtml);
onglet.removeAll();
onglet.add(corpsConteneurDuHtml);
}
protected String formaterAutre(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = " ["+i18nC.autres()+" : "+chaineAAfficher+"]";
}
return chaineAAfficher;
}
protected String formaterOuiNon(String chaineAFormater) {
String txtARetourner = "";
if (chaineAFormater.equals("0")) {
txtARetourner = i18nC.non();
} else if (chaineAFormater.equals("1")) {
txtARetourner = i18nC.oui();
}
return txtARetourner;
}
protected String formaterSautDeLigne(String chaineAFormater) {
String txtARetourner = chaineAFormater.replaceAll("\n", sautLigneTpl);
return txtARetourner;
}
protected void ajouterListeValeursAOntologie(ValeurListe ontologieReceptionnee) {
Iterator<String> it = ontologieReceptionnee.keySet().iterator();
while (it.hasNext()) {
String cle = it.next();
Valeur valeur = ontologieReceptionnee.get(cle);
if (valeur != null) {
ontologie.put(cle, valeur);
}
}
}
}
/trunk/src/org/tela_botanica/client/Modele.java
4,6 → 4,7
import java.util.List;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.PersonneAsyncDao;
import org.tela_botanica.client.modeles.ProjetAsyncDao;
18,6 → 19,7
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.UtilisateurAsyncDao;
import org.tela_botanica.client.modeles.ValeurListeAsyncDao;
import org.tela_botanica.client.vues.ContenuVue;
 
import com.extjs.gxt.ui.client.Registry;
import com.google.gwt.core.client.GWT;
65,7 → 67,16
UtilisateurAsyncDao uDao = new UtilisateurAsyncDao(vue);
uDao.deconnecterUtilisateur();
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES PROJETS
//+----------------------------------------------------------------------------------------------------------------+
public void selectionnerProjets(Rafraichissable vue) {
ProjetAsyncDao projetsDao = new ProjetAsyncDao(vue);
projetsDao.selectionner();
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES STRUCTURES
//+----------------------------------------------------------------------------------------------------------------+
125,16 → 136,33
StructureAPersonneAsyncDao structureAPersonneDao = new StructureAPersonneAsyncDao();
structureAPersonneDao.supprimer(vue, utilisateurId, personnelId);
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES PROJETS
// GESTION DES COLLECTIONS
//+----------------------------------------------------------------------------------------------------------------+
public void selectionnerProjets(Rafraichissable vue) {
ProjetAsyncDao projetsDao = new ProjetAsyncDao(vue);
projetsDao.selectionner();
public void selectionnerCollection(Rafraichissable vueARafraichir, String projetId, String collectionId) {
}
public void ajouterCollection(Rafraichissable vueARafraichir,
String utilisateurId, Collection collection) {
// TODO Auto-generated method stub
}
 
public void modifierCollection(Rafraichissable vueARafraichir,
String utilisateurId, Collection collection) {
// TODO Auto-generated method stub
}
 
public void supprimerCollection(Rafraichissable vueARafraichir,
String utilisateurId, String identifiantsCollectionSepareParVirgule) {
// TODO Auto-generated method stub
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES PERSONNES
//+----------------------------------------------------------------------------------------------------------------+
159,8 → 187,7
PersonneAsyncDao personneDao = new PersonneAsyncDao(vue);
personneDao.modifier(vue, personne);
}
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES PUBLICATIONS
//+----------------------------------------------------------------------------------------------------------------+