Subversion Repositories eFlore/Applications.coel

Compare Revisions

Ignore whitespace Rev 1366 → Rev 1367

/trunk/src/org/tela_botanica/client/Mediateur.java
93,6 → 93,7
private Modele modele = null;
public static final Constantes i18nC = getI18nConstante();
public static final ErrorMessages i18nM = getI18nMessage();
public static final boolean DEBUG = true;
private EnteteVue panneauNord = null;
private NavigationVue panneauOuest = null;
243,13 → 244,13
} else if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) {
selectionnerStructure(panneauCentre, null, null);
} else if (codeMenuClique.equals(MenuApplicationId.COLLECTION)) {
selectionnerCollection(panneauCentre, null, null);
selectionnerCollection(panneauCentre, null, null, null);
} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) {
selectionnerPersonne(panneauCentre, null, getProjetId(), null);
} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
selectionnerPublication(panneauCentre, null, null);
} else if (codeMenuClique.equals(MenuApplicationId.COMMENTAIRE)) {
selectionnerCommentaire(panneauCentre, null);
selectionnerCommentaire(panneauCentre, null, null);
} else {
GWT.log(i18nM.nonImplemente(codeMenuClique), null);
}
370,11 → 371,14
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES VALEURS ET LISTES
//+----------------------------------------------------------------------------------------------------------------+
 
/** Cette méthode est un "wrapper" **/
public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, Sequenceur sequenceur) {
obtenirListeValeurEtRafraichir(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), sequenceur);
}
 
public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, int listeId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe");
Integer numeroSequence = null;
if (sequenceur != null) {
numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
382,8 → 386,9
}
modele.obtenirListeValeurs(vueARafraichir, listeId, numeroSequence);
}
 
public void obtenirListeValeurEtRafraichir(Rafraichissable vueARafraichir, String nomListe, boolean pagination, String recherche, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe");
Integer numeroSequence = null;
if (sequenceur != null) {
numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
391,20 → 396,22
}
modele.obtenirListeValeurs(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(nomListe), pagination, recherche, start, nbElements, numeroSequence);
}
public void obtenirValeurEtRafraichir(Rafraichissable vue, String listeId, String identifiantValeur, Sequenceur sequenceur) {
 
public void obtenirValeurEtRafraichir(Rafraichissable vueARafraichir, String listeId, String identifiantValeur, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner ValeurListe");
Integer numeroSequence = null;
if (sequenceur != null) {
numeroSequence = sequenceur.lancerRequeteSynchrone(vue);
vue = sequenceur;
numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.obtenirValeur(vue, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur, numeroSequence);
modele.obtenirValeur(vueARafraichir, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur, numeroSequence);
}
public void obtenirListeRegionsEtRafraichir(Rafraichissable vue, String strListeId, String strPays) {
modele.obtenirListeRegion(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
 
public void obtenirListeRegionsEtRafraichir(Rafraichissable vueARafraichir, String strListeId, String strPays) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner obtenirListeRegions");
modele.obtenirListeRegion(vueARafraichir, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION des APPLETS de l'ACCUEIL
//+----------------------------------------------------------------------------------------------------------------+
520,28 → 527,37
* - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
*
*****************************************************************************************************/
public void selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Integer seqId) {
modele.selectionnerProjet(vueARafraichir, recherche, start, nbElements, seqId);
public void selectionnerProjet(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Projet");
Integer numeroSequence = null;
if (sequenceur != null) {
numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerProjet(vueARafraichir, recherche, start, nbElements, numeroSequence);
}
/** Cette méthode est un "wrapper" **/
public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
selectionnerProjet(sequenceur, projetId, null, 0, nbElements, seqId);
} else {
selectionnerProjet(vueARafraichir, projetId, null, 0, nbElements, seqId);
}
selectionnerProjet(vueARafraichir, projetId, null, 0, this.nbElements, sequenceur);
}
public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements, Integer seqId) {
modele.selectionnerProjet(vueARafraichir, projetId, nom, start, this.nbElements, seqId);
public void selectionnerProjet(Rafraichissable vueARafraichir, String projetId, String nom, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Projet");
Integer numeroSequence = null;
if (sequenceur != null) {
numeroSequence = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerProjet(vueARafraichir, projetId, nom, start, nbElements, numeroSequence);
}
 
/** AJOUTER **/
public void ajouterProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
modele.ajouterProjet(vueARafraichir, projetCollecte);
}
 
/** MODIFIER **/
public void modifierProjet(Rafraichissable vueARafraichir, Projet projetCollecte) {
modele.modifierProjet(vueARafraichir, projetCollecte);
}
569,13 → 585,13
} else if (panneauCentre.getContenu() instanceof StructureVue) {
selectionnerStructure(panneauCentre.getContenu(), null, null);
} else if (panneauCentre.getContenu() instanceof CollectionVue) {
selectionnerCollection(panneauCentre.getContenu(), null, null);
selectionnerCollection(panneauCentre.getContenu(), null, null, null);
} else if (panneauCentre.getContenu() instanceof PersonneVue) {
selectionnerPersonne(panneauCentre.getContenu(), null, getProjetId(), null);
} else if (panneauCentre.getContenu() instanceof PublicationVue) {
selectionnerPublication(panneauCentre.getContenu(), null, null);
} else if (panneauCentre.getContenu() instanceof CommentaireVue) {
selectionnerCommentaire(panneauCentre.getContenu(), null);
selectionnerCommentaire(panneauCentre.getContenu(), null, null);
}
}
690,37 → 706,57
* - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
*
*****************************************************************************************************/
public void selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Integer seqId) {
public void selectionnerStructure(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerStructure(vueARafraichir, recherche, start, nbElements, seqId);
}
public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
// On est en mode syncrhone
// La vue a rafraichir doit donc devenir le séquenceur
vueARafraichir = sequenceur;
}
modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, null, 0, nbElements, seqId);
}
public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, String projetId, String nom, int start, int nbElements) {
modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, nom, start, nbElements, null);
public void selectionnerStructure(Rafraichissable vueARafraichir, String structureId, String projetId, String nom, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerStructure(vueARafraichir, getProjetId(), structureId, nom, start, nbElements, seqId);
}
public void selectionnerStructureParProjet(Rafraichissable vueARafraichir, String projetId) {
modele.selectionnerStructure(vueARafraichir, projetId, null, null, 0, -1, null);
public void selectionnerStructureParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Structure");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerStructure(vueARafraichir, projetId, null, null, 0, -1, seqId);
}
/** AJOUTER **/
public void ajouterStructure(Rafraichissable vueARafraichir, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
modele.ajouterStructure(vueARafraichir, structure, conservation, valorisation);
}
/** MODIFIER **/
public void modifierStructure(Rafraichissable vueARafraichir, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
modele.modifierStructure(vueARafraichir, structureId, structure, conservation, valorisation);
}
/** SUPPRIMER **/
public void supprimerStructure(Rafraichissable vueARafraichir, String IdentifiantsStructureSepareParVirgule) {
modele.supprimerStructure(vueARafraichir, IdentifiantsStructureSepareParVirgule);
}
728,8 → 764,9
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la relation STRUCTURE A PERSONNE
public void selectionnerStructureAPersonne(Rafraichissable vueARafraichir, String structureId, String roleId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner StructureAPersonne");
Integer seqId = null;
if (sequenceur !=null) {
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
736,6 → 773,7
modele.selectionnerStructureAPersonne(vueARafraichir, structureId, roleId, seqId);
}
/** AJOUTER **/
public void ajouterStructureAPersonne(Rafraichissable vueARafraichir, String structureId, StructureAPersonneListe personnelAjoute) {
if (personnelAjoute != null && personnelAjoute.size() > 0) {
for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
744,6 → 782,7
}
}
/** MODIFIER **/
public void modifierStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelModifie) {
if (personnelModifie != null && personnelModifie.size() > 0) {
for (Iterator<String> it = personnelModifie.keySet().iterator(); it.hasNext();) {
752,6 → 791,7
}
}
/** SUPPRIMER **/
public void supprimerStructureAPersonne(Rafraichissable vueARafraichir, StructureAPersonneListe personnelSupprime) {
if (personnelSupprime != null && personnelSupprime.size() > 0) {
String idStructureAPersonneSepareParVirgule = "" ;
805,9 → 845,9
public void clicListeCollection(Collection collectionCliquee) {
panneauCentre.getContenu().rafraichir(collectionCliquee);
if (collectionCliquee != null) {
selectionnerCollectionAPersonne(panneauCentre.getContenu(), collectionCliquee.getId(), null);
selectionnerCollectionAPublication(panneauCentre.getContenu(), collectionCliquee.getId());
selectionnerCollectionACommentaire(panneauCentre.getContenu(), collectionCliquee.getId());
selectionnerCollectionAPersonne(panneauCentre.getContenu(), collectionCliquee.getId(), null, null);
selectionnerCollectionAPublication(panneauCentre.getContenu(), collectionCliquee.getId(), null);
selectionnerCollectionACommentaire(panneauCentre.getContenu(), collectionCliquee.getId(), null);
}
}
851,16 → 891,29
}
}
 
public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom) {
selectionnerCollection(vueARafraichir, collectionId, nom, 0, nbElements);
/** Cette méthode est un "wrapper" **/
public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, Sequenceur sequenceur) {
selectionnerCollection(vueARafraichir, collectionId, nom, 0, nbElements, sequenceur);
}
public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, int start, int nbElements) {
modele.selectionnerCollection(vueARafraichir, getProjetId(), collectionId, nom, start, nbElements);
public void selectionnerCollection(Rafraichissable vueARafraichir, String collectionId, String nom, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollection(vueARafraichir, getProjetId(), collectionId, nom, start, nbElements, seqId);
}
public void selectionnerCollectionParProjet(Rafraichissable vueARafraichir, String projetId) {
modele.selectionnerCollection(vueARafraichir, projetId, null, null, 0, -1);
public void selectionnerCollectionParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollection(vueARafraichir, projetId, null, null, 0, -1, seqId);
}
/****************************************************************************************************
887,18 → 940,27
* - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
*
*****************************************************************************************************/
public void selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements) {
modele.selectionnerCollection(vueARafraichir, recherche, start, nbElements);
public void selectionnerCollection(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Collection");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollection(vueARafraichir, recherche, start, nbElements, seqId);
}
/** AJOUTER **/
public void ajouterCollection(Rafraichissable vueARafraichir, Collection collection) {
modele.ajouterCollection(vueARafraichir, collection);
}
/** MODIFIER **/
public void modifierCollection(Rafraichissable vueARafraichir, Collection collection) {
modele.modifierCollection(vueARafraichir, collection);
}
/** SUPPRIMER **/
public void supprimerCollection(Rafraichissable vueARafraichir, List<Collection> collectionsListe) {
if (collectionsListe != null && collectionsListe.size() > 0) {
String idCollectionSeparesParVirgule = "" ;
920,10 → 982,17
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la relation COLLECTION A PERSONNE
public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId) {
modele.selectionnerCollectionAPersonne(vueARafraichir, collectionId, roleId);
public void selectionnerCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, String roleId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionAPersonne");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollectionAPersonne(vueARafraichir, collectionId, roleId, seqId);
}
/** AJOUTER **/
public void ajouterCollectionAPersonne(Rafraichissable vueARafraichir, String collectionId, CollectionAPersonneListe personnesAjoutees) {
if (personnesAjoutees != null && personnesAjoutees.size() > 0) {
for (Iterator<String> it = personnesAjoutees.keySet().iterator(); it.hasNext();) {
932,6 → 1001,7
}
}
/** MODIFIER **/
public void modifierCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesModifiees) {
if (personnesModifiees != null && personnesModifiees.size() > 0) {
for (Iterator<String> it = personnesModifiees.keySet().iterator(); it.hasNext();) {
940,6 → 1010,7
}
}
/** SUPPRIMER **/
public void supprimerCollectionAPersonne(Rafraichissable vueARafraichir, CollectionAPersonneListe personnesSupprimees) {
if (personnesSupprimees != null && personnesSupprimees.size() > 0) {
String idCollectionAPersonneSeparesParVirgule = "" ;
956,8 → 1027,14
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la relation COLLECTION A PUBLICATION
public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId) {
modele.selectionnerCollectionAPublication(vueARafraichir, collectionId);
public void selectionnerCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionAPublication");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollectionAPublication(vueARafraichir, collectionId, seqId);
}
public void ajouterCollectionAPublication(Rafraichissable vueARafraichir, String collectionId, CollectionAPublicationListe publicationsAjoutees) {
992,10 → 1069,17
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la relation COLLECTION A COMMENTAIRE
public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId) {
modele.selectionnerCollectionACommentaire(vueARafraichir, collectionId);
public void selectionnerCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner CollectionACommentaire");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCollectionACommentaire(vueARafraichir, collectionId, seqId);
}
/** AJOUTER **/
public void ajouterCollectionACommentaire(Rafraichissable vueARafraichir, String collectionId, CollectionACommentaireListe commentairesAjoutees) {
if (commentairesAjoutees != null && commentairesAjoutees.size() > 0) {
for (Iterator<String> it = commentairesAjoutees.keySet().iterator(); it.hasNext();) {
1004,6 → 1088,7
}
}
/** MODIFIER **/
public void modifierCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesModifiees) {
if (commentairesModifiees != null && commentairesModifiees.size() > 0) {
for (Iterator<String> it = commentairesModifiees.keySet().iterator(); it.hasNext();) {
1012,6 → 1097,7
}
}
/** SUPPRIMER **/
public void supprimerCollectionACommentaire(Rafraichissable vueARafraichir, CollectionACommentaireListe commentairesSupprimees) {
if (commentairesSupprimees != null && commentairesSupprimees.size() > 0) {
String idCollectionACommentaireSeparesParVirgule = "" ;
1133,20 → 1219,26
* - 'start' doit être supérieur ou égal à zéro. 'nbElements' doit être supérieur à zéro.
*
*****************************************************************************************************/
public void selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Integer seqId) {
modele.selectionnerProjet(vueARafraichir, recherche, start, nbElements, seqId);
public void selectionnerPersonne(Rafraichissable vueARafraichir, String recherche, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerPersonne(vueARafraichir, recherche, start, nbElements, seqId);
}
 
/** Cette méthode est un "wrapper" **/
public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, Sequenceur sequenceur) {
selectionnerPersonne(vueARafraichir, personne, projetId, 0, nbElements);
selectionnerPersonne(vueARafraichir, personne, projetId, 0, nbElements, sequenceur);
}
public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, int start, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
// On est en mode syncrhone
// La vue a rafraichir doit donc devenir le séquenceur
vueARafraichir = sequenceur;
}
String personneId = null;
1158,24 → 1250,27
modele.selectionnerPersonne(vueARafraichir, personneId, projetId, personneNom, start, nbElements, seqId);
}
public void selectionnerPersonne(Rafraichissable vueARafraichir, Personne personne, String projetId, int start, int nbElements) {
String personneId = null;
String personneNom = null;
if (personne != null) {
personneId = personne.getId();
personneNom = personne.getNom();
public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerPersonne(vueARafraichir, personneId, projetId, personneNom, start, nbElements);
modele.selectionnerPersonne(vueARafraichir, null, projetId, nomComplet, 0, -1, seqId);
}
public void selectionnerPersonneParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet) {
modele.selectionnerPersonne(vueARafraichir, null, projetId, nomComplet, 0, -1);
public void selectionnerPersonneParProjet(Rafraichissable vueARafraichir, String projetId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Personne");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerPersonne(vueARafraichir, null, projetId, null, 0, -1, seqId);
}
public void selectionnerPersonneParProjet(Rafraichissable vueARafraichir, String projetId) {
modele.selectionnerPersonne(vueARafraichir, null, projetId, null, 0, -1);
}
/** ENREGISTRER **/
public void enregistrerPersonne(Rafraichissable vue, Personne personne){
if (personne.getId() != null && !personne.getId().trim().equals("")) {
modele.modifierPersonne(vue, personne);
1251,31 → 1346,37
}
}
/** Cette méthode est un "wrapper" */
public void selectionnerPublication(Rafraichissable vueARafraichir, String publicationId, Sequenceur sequenceur) {
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
selectionnerPublication(vueARafraichir, getProjetId(), publicationId, null, 0, nbElements, seqId);
selectionnerPublication(vueARafraichir, getProjetId(), publicationId, null, 0, nbElements, sequenceur);
}
/** Cette méthode est un "wrapper" */
public void selectionnerPublicationParNomComplet(Rafraichissable vueARafraichir, String projetId, String nomComplet) {
selectionnerPublication(vueARafraichir, projetId, null, nomComplet, 0, nbElements, null);
}
public void selectionnerPublication(Rafraichissable vueARafraichir, String projetId, String publicationId, String nomComplet, int pageCourante, int nbElements, Integer seqId) {
public void selectionnerPublication(Rafraichissable vueARafraichir, String projetId, String publicationId, String nomComplet, int pageCourante, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Publication");
Integer seqId = null;
if (sequenceur!=null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerPublication(vueARafraichir, publicationId, projetId, nomComplet, nbElements, pageCourante, seqId);
}
/** AJOUTER **/
public void ajouterPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) {
modele.ajouterPublication(vueARafraichir, publication, seqId);
}
/** MODIFIER **/
public void modifierPublication(Rafraichissable vueARafraichir, Publication publication, Integer seqId) {
modele.modifierPublication(vueARafraichir, publication, seqId);
}
/** SUPPRIMER **/
public void supprimerPublication(Rafraichissable vueARafraichir, List<Publication> publicationsListe) {
if (publicationsListe != null && publicationsListe.size() > 0) {
String idPublicationSeparesParVirgule = "" ;
1292,11 → 1393,11
}
 
public void clicObtenirListeEditeurs(Rafraichissable vueARafraichir) {
selectionnerStructureParProjet(vueARafraichir, null);
selectionnerStructureParProjet(vueARafraichir, null, null);
}
 
public void clicObtenirListeAuteurs(Rafraichissable vueARafraichir) {
selectionnerPersonneParProjet(vueARafraichir, null);
selectionnerPersonneParProjet(vueARafraichir, null, null);
}
//+----------------------------------------------------------------------------------------------------------------+
1303,6 → 1404,7
// GESTION de la relation PUBLICATION A PERSONNE
 
public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, String roleId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne");
Integer seqId = null;
if (sequenceur != null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
1311,7 → 1413,14
modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleId, seqId);
}
public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, List<Valeur> roleId) {
public void selectionnerPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, String personnesId, List<Valeur> roleId, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner PublicationAPersonne");
Integer seqId = null;
if (sequenceur != null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
String roleIds = "";
Iterator<Valeur> itRole = roleId.iterator();
while (itRole.hasNext()) {
1320,9 → 1429,10
roleIds+=",";
}
}
modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleIds, null);
modele.selectionPublicationAPersonne(vueARafraichir, publicationId, personnesId, roleIds, seqId);
}
/** AJOUTER **/
public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, String publicationId, PublicationAPersonneListe personnesAjoutees, String roleId, Integer seqId) {
if (personnesAjoutees != null && personnesAjoutees.size() > 0) {
String idPublicationAPersonneSepareParVirgule = "" ;
1336,6 → 1446,8
}
}
/** SUPPRIMER **/
public void supprimerPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe personnesSupprimees) {
if (personnesSupprimees != null && personnesSupprimees.size() > 0) {
String idPublicationAPersonneSepareParVirgule = "" ;
1349,6 → 1461,7
}
}
/** AJOUTER **/
//Lier plusieurs publication à une personne
public void ajouterPublicationAPersonne(Rafraichissable vueARafraichir, PublicationAPersonneListe listePublications, String personneId, String roleId, Integer seqId) {
if (listePublications!=null && listePublications.size()>0) {
1434,25 → 1547,37
}
}
public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId) {
selectionnerCommentaire(vueARafraichir, commentaireId, null, 0, nbElements);
/** Cette méthode est un wrapper **/
public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, Sequenceur sequenceur) {
selectionnerCommentaire(vueARafraichir, commentaireId, null, 0, nbElements, sequenceur);
}
public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String titre, int pageCourante, int nbElements) {
modele.selectionnerCommentaire(vueARafraichir, commentaireId, getProjetId(), titre, pageCourante, nbElements);
public void selectionnerCommentaire(Rafraichissable vueARafraichir, String commentaireId, String titre, int pageCourante, int nbElements, Sequenceur sequenceur) {
if (Mediateur.DEBUG) System.out.println("MEDIATEUR - selectionner Commentaire");
Integer seqId = null;
if (sequenceur != null) {
seqId = sequenceur.lancerRequeteSynchrone(vueARafraichir);
vueARafraichir = sequenceur;
}
modele.selectionnerCommentaire(vueARafraichir, commentaireId, getProjetId(), titre, pageCourante, nbElements, seqId);
}
public void selectionnerCommentaireParTitre(Rafraichissable vueARafraichir, String titre) {
selectionnerCommentaire(vueARafraichir, null, titre, 0, nbElements);
/** Cette méthode est un wrapper **/
public void selectionnerCommentaireParTitre(Rafraichissable vueARafraichir, String titre, Sequenceur sequenceur) {
selectionnerCommentaire(vueARafraichir, null, titre, 0, nbElements, sequenceur);
}
/** AJOUTER **/
public void ajouterCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
modele.ajouterCommentaire(vueARafraichir, commentaire);
}
/** MODIFIER **/
public void modifierCommentaire(Rafraichissable vueARafraichir, Commentaire commentaire) {
modele.modifierCommentaire(vueARafraichir, commentaire);
}
/** SUPPRIMER **/
public void supprimerCommentaire(Rafraichissable vueARafraichir, List<Commentaire> commentairesListe) {
if (commentairesListe != null && commentairesListe.size() > 0) {
String idCommentaireSeparesParVirgule = "" ;