public class SecuriteFilters implements ApplicationContextAware {
private static final String HEART_BEAT = "heartBeat"
+ private static final String TEST_CATALOGUE = "testCatalogue"
ApplicationContext applicationContext
LilieCasSimulateurService lilieCasSimulateurService
return true
}
+ if ((ConfigurationHolder.config.eliot.textes.liaison.debug)&&(controllerName == TEST_CATALOGUE)) {
+ return true
+ }
+
// Pas de contrôle pour les pages d'erreur (sinon boucle infinie)
if (isControllerErreur(controllerName)) {
return true
} catch (IllegalStateException e) {
if (log.warnEnabled) {
log.warn("Tentative d'accès non autorisé", e)
- params.each{k,v -> log.warn "$k=$v"}
+ params.each {k, v -> log.warn "$k=$v"}
}
throw AutorisationException.consultationContenuException()
}
import org.lilie.services.eliot.textes.Ressource
import org.lilie.services.eliot.textes.ActiviteRessourceType
import org.lilie.services.eliot.applications.textes.catalogue.exceptions.CatalogueWsException
+import org.lilie.services.eliot.securite.Autorite
/**
* @author jbui
ICatalogueCommunicationService catalogueCommunicationService
PortailService portailService
+ public TextesDocumentCatalogueInfo getDocument(SecuriteSession securiteSession,
+ Autorite autorite,
+ String idExterne) {
+
+ WsCatalogueRechercheParams wsParams = createWsParams(
+ autorite,
+ idExterne
+ )
+
+ return lanceRequeteCatalogue(securiteSession, wsParams, idExterne)
+
+ }
+
/**
* Retourne un document complet par son id externe
*/
- TextesDocumentCatalogueInfo getDocument(SecuriteSession securiteSession,
- String idExterne) {
- WsCatalogueRechercheParams wsParams = new WsCatalogueRechercheParams(
- utilisateurId: securiteSession.defaultAutorite.idExterne,
- docIds: [idExterne]
+ public TextesDocumentCatalogueInfo getDocument(SecuriteSession securiteSession,
+ String idExterne) {
+
+ WsCatalogueRechercheParams wsParams = createWsParams(
+ securiteSession.defaultAutorite,
+ idExterne
)
+ return lanceRequeteCatalogue(securiteSession, wsParams, idExterne)
+
+ }
+
+ private TextesDocumentCatalogueInfo lanceRequeteCatalogue(SecuriteSession securiteSession,
+ WsCatalogueRechercheParams wsParams,
+ String idExterne) {
+
ReponseCatalogue docListe = interrogeCatalogue(securiteSession, wsParams)
if (docListe.documentInfos?.size() > 1) {
* Teste si l'acces au catalogue est actif, en fonction de la valeur retournée
* par l'API et du paramétrage.
*/
- Boolean isAccesCatalogueActif(SecuriteSession securiteSession,
+ public Boolean isAccesCatalogueActif(SecuriteSession securiteSession,
Etablissement etablissement) {
Boolean result = false
if (ConfigurationHolder.config.eliot.textes.liaison.catalogue.actif) {
return result
}
- /**
- * Methode commune pour la recherche des docs et ids
- */
- private ReponseCatalogue generiqueGetAllDocuments(SecuriteSession securiteSession,
- CatalogueRechercheParams catalogueRechercheParams) {
-
- WsCatalogueRechercheParams wsParams = new WsCatalogueRechercheParams(
- utilisateurId: securiteSession.defaultAutorite.idExterne,
- docIds: catalogueRechercheParams?.docIds
- )
-
- return interrogeCatalogue(securiteSession, wsParams)
- }
-
- /**
- * Appelle le service de communication avec les paramètres et gère le résultat
- * @return List < TextesDocumentCatalogueInfo >
- */
- private ReponseCatalogue interrogeCatalogue(SecuriteSession securiteSession,
- WsCatalogueRechercheParams params) {
- ReponseCatalogue rep = catalogueCommunicationService.findAllDocument(
- securiteSession,
- params
- )
-
- if (rep.typeReponse != TypeReponse.SUCCES) {
- log.error("Le service de communication avec le web service a " +
- "retourné un type ${rep.typeReponse.name()}.")
- }
- return rep
- }
-
/**
* Indique si l'utilisateur connecté peut avoir accès au catalogue
* @return true si l'utilisateur peut accéder au catalogue, false sinon
}
}
return securiteSession.hasFonctionIn(fonctionsAutorisees)
+
}
/**
* @return une Map associant à chaque document, son URL
*/
public Map getDocInfos(SecuriteSession securiteSession, Activite activite, Etablissement etablissement) {
+
Map result = [:]
- if (isAccesCatalogueAutorise(
+
+ Boolean catalogueAutorise = isAccesCatalogueAutorise(
securiteSession
- ) && isAccesCatalogueActif(
+ )
+
+ Boolean catalogueActif = isAccesCatalogueActif(
securiteSession,
etablissement
- )) {
+ )
+
+ if (catalogueAutorise && catalogueActif) {
try {
+
List<Ressource> ressourceDocCatalogues = (List<Ressource>) activite.ressources.findAll {
Ressource ressource ->
ressource.typeRessource == ActiviteRessourceType.DOCUMENT_CATALOGUE_PASS_TECH
}.toList()
+
ressourceDocCatalogues.each {
TextesDocumentCatalogueInfo docInfo = getDocument(
securiteSession,
))
}
+ private WsCatalogueRechercheParams createWsParams(Autorite autorite, String idExterne) {
+
+ WsCatalogueRechercheParams wsParams = new WsCatalogueRechercheParams(
+ utilisateurId: autorite.idExterne,
+ docIds: [idExterne]
+ )
+ return wsParams
+ }
+
+ /**
+ * Methode commune pour la recherche des docs et ids
+ */
+ private ReponseCatalogue generiqueGetAllDocuments(SecuriteSession securiteSession,
+ CatalogueRechercheParams catalogueRechercheParams) {
+
+ WsCatalogueRechercheParams wsParams = new WsCatalogueRechercheParams(
+ utilisateurId: securiteSession.defaultAutorite.idExterne,
+ docIds: catalogueRechercheParams?.docIds
+ )
+
+ return interrogeCatalogue(securiteSession, wsParams)
+ }
+
+ /**
+ * Appelle le service de communication avec les paramètres et gère le résultat
+ * @return List < TextesDocumentCatalogueInfo >
+ */
+ private ReponseCatalogue interrogeCatalogue(SecuriteSession securiteSession,
+ WsCatalogueRechercheParams params) {
+ ReponseCatalogue rep = catalogueCommunicationService.findAllDocument(
+ securiteSession,
+ params
+ )
+
+ if (rep.typeReponse != TypeReponse.SUCCES) {
+ log.error("Le service de communication avec le web service a " +
+ "retourné un type ${rep.typeReponse.name()}.")
+ }
+ return rep
+ }
+
}
* @param catalogueRechercheParams parametres de recherche
* @return liste des infos sur les documents
*/
- ReponseCatalogue findAllDocumentByCriteria(SecuriteSession securiteSession,
- CatalogueRechercheParams catalogueRechercheParams) {
+ public ReponseCatalogue findAllDocumentByCriteria(SecuriteSession securiteSession,
+ CatalogueRechercheParams catalogueRechercheParams) {
if (!cacheCatalogueDocument) {initialiseCache(securiteSession)}
List<ItemCacheDocument> itemsDansCache =
return modeleCatalogue
}
-
/**
* Interroge le catalogue pour récupérer les documents incomplets, puis
* met à jour le cache
environments {
production {
eliot.externe.catalogue.url = "www.changeme.com"
+ eliot.textes.liaison.debug = false
}
development {
- eliot.externe.catalogue.url = "${grails.serverURL}/testCatalogue/wsUserTitles.json"
+ eliot.externe.catalogue.url = "http://localhost:8081/eliot-textes/testCatalogue/wsUserTitles.json"
+ // mode debug
+ eliot.textes.liaison.debug = true
}
test {
+ eliot.textes.liaison.debug = false
eliot.externe.catalogue.url = "${grails.serverURL}/testCatalogue/wsUserTitles.json"
}
}
eliot.textes.datastore.migration.rapport.racine = "/tmp/rapportMigration"
-eliot.externe.catalogue.url = "${grails.serverURL}/testCatalogue/wsUserTitles.json"
+//eliot.externe.catalogue.url = "${grails.serverURL}/testCatalogue/wsUserTitles.json"
+//eliot.externe.catalogue.url = "${grails.serverURL}/testCatalogue/wsUserTitles.json"
+//http://localhost:8081/eliot-textes/testCatalogue/wsUserTitles.json?uid=UT110000000000005027&acteurLo
+
+eliot.textes.liaison.catalogue.actif = true
//// Permet d'activer/désactiver l'accès sso vers la vie scolaire
//eliot.accesLvs.active = false // Mettre par défaut à false
dialect = "org.lilie.services.eliot.EliotPostgreSQLDialect"
username = "eliot"
password = "eliot"
- loggingSql = true
+ loggingSql = false
}
hibernate {
generate_statistics = false
dateDebut: parseDate(params.dateDebut),
dateFin: parseDate(params.dateFin),
avecChapitreVide: !Boolean.valueOf(params.chapitreSansActivite),
- imprimeActiviteAvecDate : Boolean.valueOf(params.activiteAvecDate),
+ imprimeActiviteAvecDate: Boolean.valueOf(params.activiteAvecDate),
plusieursCahiers: plusieursCahiers,
- ids: params.ids.split(',')*.toLong()
+ ids: params.ids.split(',')*.toLong(),
+ etablissementId: etablissementCourant().id,
+ autoriteId: securiteSession.getDefaultAutorite().id
)
DemandeTraitement demandeTraitement =
}
// Enregistre les ressources
- resultat.ressourcesEchoues = enregistreRessources(resultat.activite,
- activiteParams, securiteSession)
+ resultat.ressourcesEchoues = enregistreRessources(
+ resultat.activite,
+ activiteParams,
+ securiteSession
+ )
// Enregistre l'espace de discussions
enregistreDiscussion(resultat.activite, activiteParams, securiteSession)
return convertionDocbookVersPdf(docbookXML)
}
-
-// String docbookXML = renderDocbook(model)
-
/**
* création d'un document pdf à partir d'un template gsp + des données contenu
* dans model
--- /dev/null
+package org.lilie.services.eliot.textes.impression
+
+import org.lilie.services.eliot.applications.textes.catalogue.CatalogueService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.textes.Activite
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.textes.Ressource
+import org.lilie.services.eliot.textes.ActiviteRessourceType
+import org.lilie.services.eliot.applications.textes.catalogue.TextesDocumentCatalogueInfo
+import org.lilie.services.eliot.applications.textes.catalogue.exceptions.CatalogueWsException
+import org.lilie.services.eliot.securite.Autorite
+
+class ImpressionCatalogueService extends CatalogueService {
+
+ public Map getDocInfos(SecuriteSession securiteSession,
+ Autorite autorite,
+ Activite activite,
+ Etablissement etablissement) {
+ Map result = [:]
+
+ Boolean catalogueActif = isAccesCatalogueActif(
+ securiteSession,
+ etablissement
+ )
+
+ if (catalogueActif) {
+
+ try {
+
+ List<Ressource> ressourceDocCatalogues = (List<Ressource>) activite.ressources.findAll {
+ Ressource ressource ->
+ ressource.typeRessource == ActiviteRessourceType.DOCUMENT_CATALOGUE_PASS_TECH
+ }.toList()
+
+ ressourceDocCatalogues.each {
+ TextesDocumentCatalogueInfo docInfo = getDocument(
+ securiteSession,
+ autorite,
+ it.catalogueRessourceIdExterne
+ )
+ if (docInfo) {
+ result.put(docInfo.idExterne, docInfo)
+ }
+ }
+ } catch (CatalogueWsException e) {
+ log.error(
+ "Erreur durant l'accès au catalogue par l'utilisateur $securiteSession.defaultAutorite.idExterne.",
+ e
+ )
+ result = [:]
+ }
+ }
+
+ return result
+ }
+
+
+}
}
-
- DemandeTraitement enregistreDemande(SecuriteSession securiteSession,
+ public DemandeTraitement enregistreDemande(SecuriteSession securiteSession,
TextesImpressionParam param) {
param.validate()
import java.text.DateFormat
import java.text.SimpleDateFormat
import org.codehaus.groovy.grails.web.json.JSONObject
+import org.lilie.services.eliot.scolarite.Etablissement
/**
* @author bper
// indique si l'utilisateur qui a lancé l'impression peut voir les activités publiés des cahiers de textes
List<Boolean> peutVoirActivitesNonPublies = []
+ Long autoriteId
+
+ Long etablissementId
+
String toJSON() {
validate()
dateDebut: df.format(dateDebut),
dateFin: df.format(dateFin),
avecChapitreVide: avecChapitreVide,
- imprimeActiviteAvecDate:imprimeActiviteAvecDate,
+ imprimeActiviteAvecDate: imprimeActiviteAvecDate,
plusieursCahiers: plusieursCahiers,
ids: ids.join(','),
- peutVoirActivitesNonPublies: peutVoirActivitesNonPublies.join(',')
+ peutVoirActivitesNonPublies: peutVoirActivitesNonPublies.join(','),
+ etablissementId: etablissementId,
+ autoriteId: autoriteId
]
return map.encodeAsJSON()
avecChapitreVide: Boolean.valueOf(params.avecChapitreVide.toString()),
plusieursCahiers: Boolean.valueOf(params.plusieursCahiers.toString()),
ids: params.ids.split(',')*.toLong(),
- peutVoirActivitesNonPublies: params.peutVoirActivitesNonPublies.split(',')*.toBoolean()
+ peutVoirActivitesNonPublies: params.peutVoirActivitesNonPublies.split(',')*.toBoolean(),
+ etablissementId: params.etablissementId,
+ autoriteId: params.autoriteId
)
param.validate()
import org.dom4j.Document
import org.lilie.services.eliot.textes.impression.requetage.donnees.ElementChapitreVide
import java.nio.charset.Charset
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
+import org.lilie.services.eliot.textes.impression.ImpressionCatalogueService
+import org.lilie.services.eliot.securite.impl.Autorite
/**
* Module de requetage pour l'impression des cahiers de textes
TextesImpressionStockageService textesImpressionStockageService
DocbookService docbookService
HtmlService htmlService
+ ImpressionCatalogueService impressionCatalogueService
static private final String HQL_TOUTES_ACTIVITES = """
select
"""
+ private Map findNoticesBiblio(Etablissement etablissement, Activite activite, Autorite autorite) {
+
+ SecuriteSession securiteSession = DefaultSecuriteSessionFactory.
+ getEliotTextesSecuriteSessionForCodePorteurENT(
+ etablissement.codePorteurENT
+ )
+
+ Map activiteDocInfos = impressionCatalogueService.getDocInfos(
+ securiteSession,
+ autorite,
+ activite,
+ etablissement
+ )
+
+ return activiteDocInfos
+ }
+
/**
* Construction de la branche ou du morceaux de branche correspondant au chapitre
* du cahier de texte
*/
public ElementLivre findDonneesImpression(
CahierDeTextes cdt,
+ Autorite autorite,
+ Etablissement etablissement,
boolean avecChapitreVide = false,
Date dateDebut = null,
Date dateFin = null,
Date dateFinFormattee = formateDateFin(dateFin)
ElementLivre livreCahierDeTextes = new ElementLivre(cdt)
+
livreCahierDeTextes.description = cdt.description
livreCahierDeTextes.nom = cdt.nom
livreCahierDeTextes.debut = dateDebut
activites.each {
Activite activite ->
- if (log.infoEnabled) {log.info "Activite : " + activite}
+ if (log.infoEnabled) {
+ log.info "Activite : " + activite
+ }
ElementActivite elementActivite = new ElementActivite(activite)
+ elementActivite.docInfos = findNoticesBiblio(etablissement, activite, autorite)
+
Chapitre chap = activite.chapitre
if (chap) {
- if (log.infoEnabled) {log.info "L'activité est dans un chapitre"}
+
+ if (log.infoEnabled) {
+ log.info "L'activité est dans un chapitre"
+ }
ElementCahierDeTextes elementChapitre = livreCahierDeTextes.findElement(chap)
ElementLivre donnees = findDonneesImpression(
cdt,
+ Autorite.get(param.autoriteId),
+ Etablissement.get(param.etablissementId),
param.avecChapitreVide,
param.dateDebut,
param.dateFin,
index++
findDonneesImpression(
it,
+ Autorite.get(param.autoriteId),
+ Etablissement.get(param.etablissementId),
param.avecChapitreVide,
param.dateDebut,
param.dateFin,
import org.lilie.services.eliot.textes.ActiviteRessourceType
import java.text.SimpleDateFormat
import org.lilie.services.eliot.textes.DateActivite
-import org.apache.commons.lang.StringEscapeUtils
/**
* Représente les données de l'activité pour l'impression
* @author othe
*/
class ElementActivite extends ElementCahierDeTextes {
- String contexte
- String type
- String statut
- List<Ressource> ressources
- boolean hasDescription
+ String contexte
+ String type
+ String statut
+ List<Ressource> ressources
- static private final SDF = new SimpleDateFormat(DateConstantes.DD_MM_YYYY, Locale.FRANCE)
+ Map docInfos
- public Activite getActivite() {
- return ((Activite) objetDomaine)
- }
+ boolean hasDescription
- public ElementActivite(Activite activite) {
- objetDomaine = activite
- description = activite.description
- hasDescription = activite.hasDescription
- nom = activite.titre
- }
+ static private final SDF = new SimpleDateFormat(DateConstantes.DD_MM_YYYY, Locale.FRANCE)
- public Long getOrdre() {
- getActivite().ordre
- }
+ public Activite getActivite() {
+ return ((Activite) objetDomaine)
+ }
- public String getObjectif() {
- return corrigeCaractereReserve(getActivite()?.objectif)
- }
+ public ElementActivite(Activite activite) {
+ objetDomaine = activite
+ description = activite.description
+ hasDescription = activite.hasDescription
+ nom = activite.titre
+ }
- public String getEnonce() {
- return corrigeCaractereReserve(getActivite()?.enonce)
- }
+ public Long getOrdre() {
+ getActivite().ordre
+ }
- public boolean hasDescription() {
- return hasDescription
- }
+ public String getObjectif() {
+ return corrigeCaractereReserve(getActivite()?.objectif)
+ }
- public boolean hasEnonce() {
- if (!enonce) {
- return false
- }
- (enonce.trim() != "")
- }
+ public String getEnonce() {
+ return corrigeCaractereReserve(getActivite()?.enonce)
+ }
- public boolean hasObjectif() {
- if (!getActivite()?.objectif) {
- return false
- }
- (getActivite()?.objectif?.trim() != "" && getActivite()?.objectif?.trim() != "null")
+ public boolean hasDescription() {
+ return hasDescription
+ }
+
+ public boolean hasEnonce() {
+ if (!enonce) {
+ return false
}
+ (enonce.trim() != "")
+ }
- public boolean hasRessources() {
- (getRessources().size() > 0)
+ public boolean hasObjectif() {
+ if (!getActivite()?.objectif) {
+ return false
}
+ (getActivite()?.objectif?.trim() != "" && getActivite()?.objectif?.trim() != "null")
+ }
- /**
- * Liste des ressources
- */
- public List<RessourceInfo> getRessources() {
+ public boolean hasRessources() {
+ (getRessources().size() > 0)
+ }
- List<RessourceInfo> listeRessource = []
- if (getActivite().ressources) {
+ /**
+ * Liste des ressources
+ */
+ public List<RessourceInfo> getRessources() {
- getActivite().ressources.each {Ressource ressource ->
+ List<RessourceInfo> listeRessource = []
+ if (getActivite().ressources) {
- String description = corrigeCaractereReserve(ressource.description)
+ getActivite().ressources.each {Ressource ressource ->
- switch (ressource.typeRessource) {
+ String description = corrigeCaractereReserve(ressource.description)
- case ActiviteRessourceType.URL:
- listeRessource << new RessourceInfo(
- nom: corrigeCaractereReserve(ressource.urlAffichage),
- description: description
- )
- break
+ switch (ressource.typeRessource) {
- case ActiviteRessourceType.FICHIER:
- listeRessource << new RessourceInfo(
- nom: corrigeCaractereReserve(ressource.fichier.nom),
- description: description
- )
- break
+ case ActiviteRessourceType.URL:
+ listeRessource << new RessourceInfo(
+ nom: corrigeCaractereReserve(ressource.urlAffichage),
+ description: description
+ )
+ break
- case ActiviteRessourceType.DOCUMENT_CATALOGUE_PASS_TECH:
- listeRessource << new RessourceInfo(
- nom: corrigeCaractereReserve(ressource.catalogueRessourceIdExterne),
- description: description
- )
- break
+ case ActiviteRessourceType.FICHIER:
+ listeRessource << new RessourceInfo(
+ nom: corrigeCaractereReserve(ressource.fichier.nom),
+ description: description
+ )
+ break
- }
- }
+ case ActiviteRessourceType.DOCUMENT_CATALOGUE_PASS_TECH:
- }
+ Map valeurs = findDocumentsCatalogue(ressource)
+ String nom = valeurs.nom
+ String descriptionCatalogue = valeurs.url
- return listeRessource
- }
+ listeRessource << new RessourceInfo(
+ nom: nom ? nom : "",
+ description: descriptionCatalogue ? descriptionCatalogue : ""
+ )
+ break
- /**
- * Retourne le type d'activité
- */
- public String typeActivite() {
- String nom = corrigeCaractereReserve(getActivite()?.typeActivite?.libelle)
- if (nom) {
- return nom
- } else {
- return ""
}
- }
-
- /**
- * Retourne le nom du contexte
- */
- public String contexte() {
- corrigeCaractereReserve(getActivite()?.contexteActivite?.nom)
- }
-
- /**
- * Retourne le code de l'activité
- */
- public String codeActivite() {
- corrigeCaractereReserve(getActivite()?.contexteActivite?.code)
- }
-
- /**
- * indique si l'on a des dates à imprimer
- */
- public boolean hasDates() {
- (getActivite()?.dates?.size() > 0)
- }
-
- public List<String> getDateActivites() {
- List<DateActivite> dateActivites = getActivite()?.dates?.toList()
- if (!dateActivites) {return []}
- List<Date> dates = dateActivites.findAll {it.dateActivite}*.dateActivite.sort()
- return dates.collect {SDF.format(it)}
- }
-
- public List<String> getDateEcheances() {
- List<DateActivite> dateActivites = getActivite()?.dates?.toList()
- if (!dateActivites) {return []}
- List<Date> dates = dateActivites.findAll {it.dateEcheance}*.dateEcheance.sort()
- return dates.collect {SDF.format(it)}
- }
-
- public String getDateDonneeLe() {
- Date date = getActivite()?.dateDonneeLe
- return date ? SDF.format(date) : ''
- }
+ }
+
+ }
+
+ return listeRessource
+ }
+
+ private Map findDocumentsCatalogue(Ressource ressource) {
+
+ Map result = ressource.infos()
+
+ if (docInfos == null) {
+ throw new IllegalStateException("docInfos est obligatoire.")
+ }
+
+ result.nom = docInfos.get(ressource.catalogueRessourceIdExterne)?.titre
+ result.url = docInfos.get(ressource.catalogueRessourceIdExterne)?.accesUrl
+
+ return result
+ }
+
+ /**
+ * Retourne le type d'activité
+ */
+ public String typeActivite() {
+ String nom = corrigeCaractereReserve(getActivite()?.typeActivite?.libelle)
+ if (nom) {
+ return nom
+ } else {
+ return ""
+ }
+ }
+
+ /**
+ * Retourne le nom du contexte
+ */
+ public String contexte() {
+ corrigeCaractereReserve(getActivite()?.contexteActivite?.nom)
+ }
+
+ /**
+ * Retourne le code de l'activité
+ */
+ public String codeActivite() {
+ corrigeCaractereReserve(getActivite()?.contexteActivite?.code)
+ }
+
+ /**
+ * indique si l'on a des dates à imprimer
+ */
+ public boolean hasDates() {
+ (getActivite()?.dates?.size() > 0)
+ }
+
+ public List<String> getDateActivites() {
+ List<DateActivite> dateActivites = getActivite()?.dates?.toList()
+ if (!dateActivites) {return []}
+ List<Date> dates = dateActivites.findAll {it.dateActivite}*.dateActivite.sort()
+ return dates.collect {SDF.format(it)}
+ }
+
+ public List<String> getDateEcheances() {
+ List<DateActivite> dateActivites = getActivite()?.dates?.toList()
+ if (!dateActivites) {return []}
+ List<Date> dates = dateActivites.findAll {it.dateEcheance}*.dateEcheance.sort()
+ return dates.collect {SDF.format(it)}
+ }
+
+ public String getDateDonneeLe() {
+ Date date = getActivite()?.dateDonneeLe
+ return date ? SDF.format(date) : ''
+ }
}