* @author fsil , msan
*/
-class Acteur {
+class Acteur implements Serializable {
SecuriteSession securiteSession
List<Long> groupesIds
* @author jtra
* @author fsil
*/
-public class OrganisationInfo {
+public class OrganisationInfo implements Serializable {
String nom
Long idExterneAsLong
* @author agia
* @author bper
*/
-abstract class Perimetre {
+abstract class Perimetre implements Serializable {
private List<Long> ids
package org.lilie.services.eliot.securite.impl
import org.lilie.services.eliot.scolarite.personne.AutoriteNomAffichageService
+import org.codehaus.groovy.grails.commons.ApplicationHolder
-class Autorite implements org.lilie.services.eliot.securite.Autorite {
+class Autorite implements org.lilie.services.eliot.securite.Autorite, Serializable {
public static final String ID_EXTERNE_DEFAULT_AUTORITE = "AUTORITE_PAR_DEFAUT"
//cache usage: 'nonstrict-read-write'
}
- AutoriteNomAffichageService autoriteNomAffichageService
static transients = [
- 'autoriteNomAffichageService',
'typeEliot'
]
* @param avecMEF si le nom de groupe devrait contenir l'information sur le MEF ou pas
*/
String nomAffichage(Boolean avecMEF = false) {
+ def ctx = ApplicationHolder.getApplication().getMainContext()
+ AutoriteNomAffichageService autoriteNomAffichageService =
+ (AutoriteNomAffichageService) ctx.getBean('autoriteNomAffichageService')
+
if (nomAffichage == null) {
nomAffichage = autoriteNomAffichageService.getNomAffichage(this, avecMEF)
}
+++ /dev/null
-package org.lilie.services.eliot.annuaire
-
-import org.lilie.services.eliot.scolarite.Etablissement
-
-/**
- * Service Session pour cacher les informations sur les groupes qui ne changent
- * pas souvant
- * @author msan
- */
-@SuppressWarnings('GrailsStatelessService')
-class DistantGroupeSessionService extends DistantGroupeService {
-
- static scope = "session"
- static transactional = true
-
- Map<Long, GroupeInfo> mapGroupesDirection = [:]
-
- GroupeInfo getGroupeInfoDeDirection(Etablissement etablissement) {
- GroupeInfo groupeInfo = mapGroupesDirection.get(etablissement.id)
- if (groupeInfo == null) {
- groupeInfo = super.getGroupeInfoDeDirection(etablissement)
- mapGroupesDirection.put(
- etablissement.id,
- groupeInfo
- )
- }
- return groupeInfo
- }
-
-}
* Gestion du cache des documents du catalogue
* @author jbui
*/
-class CacheCatalogueDocument {
+class CacheCatalogueDocument implements Serializable {
// Map associant l'idExterne d'un document à son ItemCacheDocument
private Map<String, ItemCacheDocument> items = (Map) [:]
import org.lilie.services.eliot.StringUtils
import org.lilie.services.eliot.utils.query.PaginationParams
-import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.textes.Activite
-import org.lilie.services.eliot.textes.Ressource
-import org.lilie.services.eliot.textes.ActiviteRessourceType
-import org.lilie.services.eliot.applications.textes.catalogue.exceptions.CatalogueWsException
/**
* Service retournant les documents de l'utilisateur connecté.
* @author msan
*/
@SuppressWarnings('GrailsStatelessService')
-class CatalogueSessionService extends CatalogueService {
+class CatalogueSessionService extends CatalogueService implements Serializable {
static scope = "session"
+ static transactional = false
//cache des documents
private CacheCatalogueDocument cacheCatalogueDocument
* @return liste des infos sur les documents
*/
ReponseCatalogue findAllDocumentByCriteria(SecuriteSession securiteSession,
- CatalogueRechercheParams catalogueRechercheParams
- ) {
+ CatalogueRechercheParams catalogueRechercheParams) {
if (!cacheCatalogueDocument) {initialiseCache(securiteSession)}
List<ItemCacheDocument> itemsDansCache =
* Document cache\r
* @author msan\r
*/\r
-class ItemCacheDocument {\r
+class ItemCacheDocument implements Serializable {\r
TextesDocumentCatalogueInfo docInfo\r
NiveauDetailDocument niveauDetail = NiveauDetailDocument.BASIQUE\r
}\r
* DTO d'un document de catalogue\r
* @author msan\r
*/\r
-class TextesDocumentCatalogueInfo {\r
+class TextesDocumentCatalogueInfo implements Serializable {\r
String idExterne // docId\r
String titre // title\r
String editeur // publisher\r
* @author jtra
* @author othe
*/
-abstract class AbstractEtatApplication implements EtatApplication {
+abstract class AbstractEtatApplication implements EtatApplication, Serializable {
// Stocke les descriptions des variables d'états & permet d'accéder à
// une variable par son nom
private Map<String, EtatVariable> variablesFOByNom
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.etat
/**
* @author jtra
*/
@SuppressWarnings('GrailsStatelessService') // jtra : service de scope session
-class EtatApplicationSessionService {
+class EtatApplicationSessionService implements Serializable {
static scope = "session"
static transactional = false
* @author jtra
* @author othe
*/
-class EtatListeVariables {
+class EtatListeVariables implements Serializable {
// L'objet portant cette variable d'état
private def fieldObject
// L'attribut associé à cette variable d'état
- private Field field
+ private Class fieldClass
+ private String fieldName
// L'annotation de l'attribut associé à cette variable d'état
private BindEtatListVariables annotation
*/
def EtatListeVariables(fieldObject, Field field) {
this.fieldObject = fieldObject
- this.field = field
+ this.fieldClass = field.type
+ this.fieldName = field.name
this.annotation = field.getAnnotation(BindEtatListVariables.class)
}
* @return la classe de cette variable d'état
*/
Class getClazz() {
- return field.getType()
+ return fieldClass
}
Class getObjectClass() {
* @return le nom de l'attribut associé à cette variable d'état
*/
String getCodeBackOffice() {
- return field.name
+ return fieldName
}
/**
String fnExporte = annotation.fnExporte()
- def valeur = fieldObject[field.name]
+ def valeur = fieldObject[fieldName]
if (valeur == null) {
return null
package org.lilie.services.eliot.etat.annotations
-import java.lang.reflect.Field
-
/**
* Représente une variable d'état d'une application cliente
* @author jtra
* @author othe
*/
-class EtatVariable {
+class EtatVariable implements Serializable {
// L'objet portant cette variable d'état
private def fieldObject
// L'attribut associé à cette variable d'état
- private Field field
+ private Class fieldClass
+ private String fieldName
// L'annotation de l'attribut associé à cette variable d'état
private BindEtatVariable annotation
*/
def EtatVariable(fieldObject, field) {
this.fieldObject = fieldObject;
- this.field = field;
+ this.fieldClass = field.type
+ this.fieldName = field.name
this.annotation = field.getAnnotation(BindEtatVariable.class)
}
* @return la classe de cette variable d'état
*/
Class getClazz() {
- return field.getType()
+ return fieldClass
}
/**
* @return le nom de l'attribut associé à cette variable d'état
*/
String getCodeBackOffice() {
- return field.name
+ return fieldName
}
/**
Object exporteValeur() {
String fnExporte = annotation.fnExporte()
- def valeur = fieldObject[field.name]
+ def valeur = fieldObject[fieldName]
if (valeur == null) {
return null
* Permet de représenter en mémoire le chemin pour accéder à un noeud
* @author jtra
*/
-class Chemin {
+class Chemin implements Serializable {
// Liste ordonnée des noeuds composant le chemin (de la racine vers le
// noeud de correspondant à ce chemin)
* Représente l'état d'un arbre ExtJs
* @author jtra
*/
-class EtatArbre implements Additionnable {
+class EtatArbre implements Additionnable, Serializable {
// nom de la valeur json qui donne la description de l'arbre (valeur obligatoire)
private static final JSON_ROOT_NAME = 'stateHash'
private static final JSON_SELECTED_NODE_PATH = 'noeudSelectionnePath'
/**
* Représente un noeud de l'arbre.
*/
-class Noeud {
+class Noeud implements Serializable {
/**
* identifiant front du noeud
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
package org.lilie.services.eliot.parametrages.calendrier
import org.lilie.services.eliot.temps.Evenement
* session HTTP
* @author jtra
*/
-class LilieHttpInfo {
+class LilieHttpInfo implements Serializable {
String codePorteurENT
String personneIdExterne
List<Long> groupesIds // ids des groupes dans le référentiel de l'annuaire distant
* Modélise le droit d'accès à toutes les données d'un ensemble de classes
* @author agia
*/
-class PerimetreClasseEnseignantPrincipal extends Perimetre{
+class PerimetreClasseEnseignantPrincipal extends Perimetre implements Serializable {
private static final List<FonctionEnum> FONCTIONS_AYANT_ACCES_AU_PERIMETRE = [
FonctionEnum.ENSEIGNANT,
* Modélise le droit d'accès à toutes les données d'un ensemble d'élèves
* @author agia
*/
-class PerimetreEleve extends Perimetre {
+class PerimetreEleve extends Perimetre implements Serializable {
private static final List<FonctionEnum> FONCTIONS_AYANT_ACCES_AU_PERIMETRE = [
FonctionEnum.ELEVE,
/**
* @author bper
*/
-class PerimetreEnseignement extends Perimetre{
+class PerimetreEnseignement extends Perimetre implements Serializable {
private static final List<FonctionEnum> FONCTIONS_AYANT_ACCES_AU_PERIMETRE = [
FonctionEnum.ENSEIGNANT,
* Modélise le droit d'accès à toutes les données de l'établissement courant
* @author agia
*/
-class PerimetreEtablissement extends Perimetre {
+class PerimetreEtablissement extends Perimetre implements Serializable {
private static final List<FonctionEnum> FONCTIONS_AYANT_ACCES_AU_PERIMETRE =
getAllFonctionAyantAccesAuPerimetre()
* LocalFonctionEtablissement (annuaire local) et DistantFonctionEtablissement (annuaire distant)
* @author jtra
*/
-abstract class AbstractFonctionEtablissement implements FonctionEtablissement {
+abstract class AbstractFonctionEtablissement implements FonctionEtablissement, Serializable {
// Fonction de cette association Fonction/Etablissement
FonctionEnum fonctionEnum
* @author fsil
* @author jtra
*/
-class LocalFonctionEtablissement extends AbstractFonctionEtablissement {
+class LocalFonctionEtablissement extends AbstractFonctionEtablissement implements Serializable {
Long etablissementId // Mise en cache de l'id de l'établissement
// Note jtra : Récupération du bean etablissementService pour pouvoir accéder aux établissements
- EtablissementService etablissementService =
- (EtablissementService) SpringUtils.getMainContext().getBean(
- "etablissementService"
- )
+ transient EtablissementService etablissementService =
+ (EtablissementService) SpringUtils.getMainContext().getBean("etablissementService")
+
+
/**
* @return l'établissement (domaine) de cette association Fonction/Etablissement
import org.lilie.services.eliot.securite.Permission
import org.hibernate.Hibernate
-class AbstractACLSession {
+class AbstractACLSession implements Serializable {
// Liste des toutes les autorités (acteur & groupe) associées à cette session
List<Autorite> autorites
- def grailsApplication = ApplicationHolder.application
+ transient def grailsApplication = ApplicationHolder.application
- SessionFactory sessionFactory = (SessionFactory) SpringUtils.getMainContext().getBean("sessionFactory")
+ transient SessionFactory sessionFactory =
+ (SessionFactory) SpringUtils.getMainContext().getBean("sessionFactory")
// Service de gestion des groupes de scolarité locaux (= propriétés scolarités)
- LocalGroupeService localGroupeService =
+ transient LocalGroupeService localGroupeService =
(LocalGroupeService) SpringUtils.getMainContext().getBean("localGroupeService")
+ protected void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ ois.defaultReadObject();
+
+ grailsApplication = ApplicationHolder.application
+ sessionFactory = (SessionFactory) SpringUtils.getMainContext().getBean("sessionFactory")
+ localGroupeService = (LocalGroupeService) SpringUtils.getMainContext().getBean("localGroupeService")
+ }
+
+
/**
* Méthode retournant la liste des autorisations de la session sur l'item donné
*/
* méthode à l'une ou l'autre
* @author jtra
*/
-class DefaultSecuriteSession implements SecuriteSession {
+class DefaultSecuriteSession implements SecuriteSession, Serializable {
ACLSession aclSession
AnnuaireSession annuaireSession
import org.lilie.services.eliot.DistantAutoriteService
import org.lilie.services.eliot.utils.SpringUtils
import org.lilie.services.eliot.portail.http.LilieHttpInfo
+import org.springframework.context.ApplicationContext
/**
* Implémentation de l'interface ACLSession pour les modules utilisant uniquement
* construction de cet objet ; ce point pourra être amélioré en ne fournissant que l'id de la
* personne, et récupérant les informations en base (avec mise en cache)
*/
-class DistantACLSession extends AbstractACLSession implements ACLSession {
+class DistantACLSession extends AbstractACLSession implements ACLSession, Serializable {
// Service de gestion des autorités
- DistantAutoriteService distantAutoriteService =
+ transient DistantAutoriteService distantAutoriteService =
(DistantAutoriteService) SpringUtils.getMainContext().getBean("distantAutoriteService")
+ protected void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ super.readObject(ois)
+
+ ApplicationContext ctx = SpringUtils.getMainContext()
+ distantAutoriteService = (DistantAutoriteService) ctx.getBean("distantAutoriteService")
+ }
+
+
// Autorité représentant l'utilisateur associé à cette session
Autorite defaultAutorite
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.utils.SpringUtils
import org.lilie.services.eliot.applications.BaseDonneesEliot
+import org.springframework.context.ApplicationContext
/**
* Implémentation de l'interface ACLSession pour les modules utilisant uniquement
* l'annuaire local
* @author jtra
*/
-class LocalACLSession extends AbstractACLSession implements ACLSession {
+class LocalACLSession extends AbstractACLSession implements ACLSession, Serializable {
String nomAffichage
Autorite defaultAutorite
- LocalPersonneService localPersonneService =
- (LocalPersonneService)SpringUtils.mainContext.getBean(
- 'localPersonneService'
- )
+ transient LocalPersonneService localPersonneService =
+ (LocalPersonneService)SpringUtils.mainContext.getBean('localPersonneService')
+
+
+ protected void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ super.readObject(ois)
+
+ ApplicationContext ctx = SpringUtils.getMainContext()
+ localPersonneService = (LocalPersonneService) ctx.getBean('localPersonneService')
+ }
/**
* Construit la session ACL à partir des informations extraites de la requête & la session HTTP
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
import org.slf4j.Logger
import org.slf4j.LoggerFactory
+import org.springframework.context.ApplicationContext
/**
* Implémentation de l'interface AnnuaireSession utilisant l'annuaire local
* @author jtra
* @author othe
*/
-class LocalAnnuaireSession implements AnnuaireSession {
+class LocalAnnuaireSession implements AnnuaireSession, Serializable {
- def grailsApplication = SpringUtils.mainContext.getBean('grailsApplication')
-
- private static final Logger LOGGER =
- LoggerFactory.getLogger(LocalAnnuaireSession.class)
+ transient def grailsApplication = SpringUtils.mainContext.getBean('grailsApplication')
// Service de gestion des données perso (qui sont récupérées par API dans l'annuaire distant)
- DistantDonneesPersoService distantDonneesPersoService =
- (DistantDonneesPersoService) SpringUtils.mainContext.getBean(
- 'distantDonneesPersoService'
- )
+ transient DistantDonneesPersoService distantDonneesPersoService =
+ (DistantDonneesPersoService) SpringUtils.mainContext.getBean('distantDonneesPersoService')
// service des groupes étendus (basé sur l'API Logica)
- DistantGroupeEtenduService distantGroupeEtenduService =
- (DistantGroupeEtenduService) SpringUtils.mainContext.getBean(
- 'distantGroupeEtenduService'
- )
+ transient DistantGroupeEtenduService distantGroupeEtenduService =
+ (DistantGroupeEtenduService) SpringUtils.mainContext.getBean('distantGroupeEtenduService')
// Service de gestion des personnes
- LocalPersonneService localPersonneService =
- (LocalPersonneService) SpringUtils.mainContext.getBean(
- 'localPersonneService'
- )
+ transient LocalPersonneService localPersonneService =
+ (LocalPersonneService) SpringUtils.mainContext.getBean('localPersonneService')
+
+ transient FonctionAnnuaireService fonctionAnnuaireService =
+ (FonctionAnnuaireService) SpringUtils.mainContext.getBean('fonctionAnnuaireService')
- FonctionAnnuaireService fonctionAnnuaireService =
- (FonctionAnnuaireService) SpringUtils.mainContext.getBean(
- 'fonctionAnnuaireService'
- )
+ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ ois.defaultReadObject();
+
+ ApplicationContext ctx = SpringUtils.mainContext
+
+ grailsApplication = ctx.getBean('grailsApplication')
+ distantDonneesPersoService = (DistantDonneesPersoService) ctx.getBean('distantDonneesPersoService')
+ distantGroupeEtenduService = (DistantGroupeEtenduService) ctx.getBean('distantGroupeEtenduService')
+ localPersonneService = (LocalPersonneService) ctx.getBean('localPersonneService')
+ fonctionAnnuaireService = (FonctionAnnuaireService) ctx.getBean('fonctionAnnuaireService')
+ }
+
+
+ private static final Logger LOGGER =
+ LoggerFactory.getLogger(LocalAnnuaireSession.class)
// liste des groupes étendus associés à la session
private List<RessourceIndexeeInfo> listeGroupesEtendus = []
// de compatibilité
// Un mock est utilisé pour ne pas à avoir à charger toutes les données dans le mode
// annuaire local
- acteur = [
- getIdExterne: {lilieHttpInfo.personneIdExterne},
- getCodePorteurENT: {lilieHttpInfo.codePorteurENT},
- getGroupesIds: {lilieHttpInfo.groupesIds},
- getNomAffichage: {this.getNomAffichage()},
- getLogin: {this.login}
- ] as Acteur
+ acteur = new Acteur(
+ idExterne: lilieHttpInfo.personneIdExterne,
+ codePorteurENT: lilieHttpInfo.codePorteurENT,
+ groupesIds: lilieHttpInfo.groupesIds,
+ nomAffichage: this.getNomAffichage(),
+ login: this.login
+ )
}
import org.lilie.services.eliot.annuaire.Acteur
import org.lilie.services.eliot.securite.ACLSession
import org.lilie.services.eliot.applications.BaseDonneesEliot
+import org.springframework.context.ApplicationContext
/*
* Implémentation de l'interface ACLSession pour les modules
* utilisant à la fois l'annuaire local et l'annuaire de CGI
*/
-class MixteACLSession extends AbstractACLSession implements ACLSession {
+class MixteACLSession extends AbstractACLSession implements ACLSession, Serializable {
String nomAffichage
Autorite defaultAutorite
-
- LocalPersonneService localPersonneService =
- (LocalPersonneService)SpringUtils.mainContext.getBean(
- 'localPersonneService'
- )
+ transient LocalPersonneService localPersonneService =
+ (LocalPersonneService)SpringUtils.mainContext.getBean('localPersonneService')
// Service de gestion des autorités correspondant à des données de l'annuaire distant
- DistantAutoriteService distantAutoriteService =
- (DistantAutoriteService) SpringUtils.getMainContext().getBean(
- "distantAutoriteService"
- )
+ transient DistantAutoriteService distantAutoriteService =
+ (DistantAutoriteService) SpringUtils.getMainContext().getBean('distantAutoriteService')
+
+
+ protected void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ super.readObject(ois)
+
+ ApplicationContext ctx = SpringUtils.getMainContext()
+
+ localPersonneService = (LocalPersonneService) ctx.getBean('localPersonneService')
+ distantAutoriteService = (DistantAutoriteService) ctx.getBean('distantAutoriteService')
+ }
def MixteACLSession(LilieHttpInfo lilieHttpInfo){
* construction de cet objet ; ce point pourra être amélioré en ne fournissant que l'id de la
* personne, et récupérant les informations en base (avec mise en cache)
*/
-class SystemeACLSession extends AbstractACLSession implements ACLSession {
+class SystemeACLSession extends AbstractACLSession implements ACLSession, Serializable {
String nomAffichage = ""
List<Autorite> autorites = []
plugins.crypto=2.0
plugins.quartz=0.4.2
+# Plugin serializable-session est utilisé pour tester la sérialisation de la session.
+# Il ne faut jamais l'activer pour l'environnement de production.
+#plugins.serializable-session=0.4
+
+
* CommandObject permettant de bénéficier de la validation de grails...
*
*/
-class RechercheCommand {
+class RechercheCommand implements Serializable {
private static final SimpleDateFormat DF = new SimpleDateFormat(
DateConstantes.DD_MM_YYYY,
Locale.FRANCE
import org.lilie.services.eliot.textes.page.Page
import org.lilie.services.eliot.applications.textes.EvenementActiviteInfo
import org.lilie.services.eliot.applications.textes.TextesTempsService
-import org.lilie.services.eliot.applications.textes.catalogue.CatalogueSessionService
+import org.lilie.services.eliot.applications.textes.catalogue.CatalogueService
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.applications.textes.ActiviteService
import org.lilie.services.eliot.applications.textes.ActiviteAdjacenteService
TextesChapitreService textesChapitreService
TextesTempsService textesTempsService
AnneeScolaireService anneeScolaireService
- CatalogueSessionService catalogueSessionService
+ CatalogueService catalogueService
ActiviteService activiteService
ActiviteAdjacenteService activiteAdjacenteService
TypeActiviteService typeActiviteService
def afficheConsultation = {
Map modelParams = prepareBaseModele(Page.CREATION_ACTIVITE)
Activite activite = Activite.get(Long.parseLong(params.activiteId))
- Map docInfos = catalogueSessionService.getDocInfos(
+ Map docInfos = catalogueService.getDocInfos(
securiteSession,
activite,
getEtablissementDuCDT(activite.cahierDeTextes)
modelParams += [
activiteModele: activiteService.getActiviteModeleConsultation(
Long.parseLong(params.activiteId),
- catalogueSessionService.isCatalogueActifForContexte(
+ catalogueService.isCatalogueActifForContexte(
getEtablissementDuCDT(activite.cahierDeTextes),
securiteSession
),
import org.lilie.services.eliot.constantes.ConstController
import org.lilie.services.eliot.textes.ActiviteRessourceType
import org.lilie.services.eliot.applications.textes.catalogue.TextesDocumentCatalogueInfo
-import org.lilie.services.eliot.applications.textes.catalogue.CatalogueSessionService
+import org.lilie.services.eliot.applications.textes.catalogue.CatalogueService
import org.lilie.services.eliot.textes.vuejournaliere.TextesVueJournaliereService
import org.lilie.services.eliot.PagedResult
import org.lilie.services.eliot.textes.NomsAffichagesPourCahierDeTextes
private static final String RECHERCHE = 'recherche'
CriteresRechercheActiviteSessionService criteresRechercheActiviteSessionService
- CatalogueSessionService catalogueSessionService
+ CatalogueService catalogueService
TextesActiviteMarshallerService textesActiviteMarshallerService
ArbreService arbreService
TextesVueJournaliereService textesVueJournaliereService
nom = ressource.fichier?.nom
break
case ActiviteRessourceType.DOCUMENT_CATALOGUE_PASS_TECH:
- if (catalogueSessionService.isAccesCatalogueActif(securiteSession,
+ if (catalogueService.isAccesCatalogueActif(securiteSession,
getEtablissementDuCDT(ressource.activite.cahierDeTextes))) {
- TextesDocumentCatalogueInfo docInfo = catalogueSessionService.getDocument(
+ TextesDocumentCatalogueInfo docInfo = catalogueService.getDocument(
securiteSession,
ressource.catalogueRessourceIdExterne
)
import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRechercheCriteresLight
import org.lilie.services.eliot.textes.arbre.ArbreService
import org.lilie.services.eliot.annuaire.GroupeInfo
-import org.lilie.services.eliot.annuaire.DistantGroupeSessionService
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.textes.recherchecahierdetextes.CahierDeTextesRecherchePagineeInfo
import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.annuaire.DistantGroupeService
class CahierDeTextesRechercheController extends AbstractTextesController {
CahierDeTextesDroitsService cahierDeTextesDroitsService
TextesIndexationService textesIndexationService
ArbreService arbreService
- DistantGroupeSessionService distantGroupeSessionService
+ DistantGroupeService distantGroupeService
LocalGroupeService localGroupeService
public static final int NB_LIGNES_CAHIERS_PAR_PAGE =
GroupeInfo infoGroupeDirection = null
if (!grailsApplication.config.eliot.mode.autonome) {
- infoGroupeDirection = (GroupeInfo) distantGroupeSessionService.getGroupeInfoDeDirection(
+ infoGroupeDirection = (GroupeInfo) distantGroupeService.getGroupeInfoDeDirection(
etablissement
)
}
*
* @author jtra
*/
-class CriteresRechercheActiviteSessionService {
+class CriteresRechercheActiviteSessionService implements Serializable {
static scope = "session"
+ static transactional = false
@SuppressWarnings('GrailsStatelessService')
private RechercheCommand derniereRecherche = null
import org.lilie.services.eliot.textes.TypeActiviteParDefaut
import org.lilie.services.eliot.scolarite.TypeActiviteService
import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.applications.textes.catalogue.CatalogueSessionService
import org.lilie.services.eliot.temps.Evenement
import org.lilie.services.eliot.applications.textes.EvenementActiviteInfo
import org.lilie.services.eliot.temps.TempsEvenementService
FormulaireRequetageUtilsService formulaireRequetageUtilsService
ActiviteAdjacenteService activiteAdjacenteService
TypeActiviteService typeActiviteService
- // CatalogueSessionService catalogueSessionService
- CatalogueService catalogueService
+ CatalogueService catalogueService
TempsEvenementService tempsEvenementService
public FormulaireActivite prepareDonnees(SecuriteSession securiteSession, FormulaireActivite formulaireActivite) {
import org.lilie.services.eliot.textes.NodeUtils
import grails.converters.JSON
import org.lilie.services.eliot.textes.requetage.CahierDeTextesPersonnaliseService
+import org.springframework.context.ApplicationContext
+import org.codehaus.groovy.grails.commons.ApplicationHolder
/**
* Gestion des états du FO de l'application.
*
* @author othe
*/
-class AccueilEtatSessionService {
+class AccueilEtatSessionService implements Serializable {
EtatApplicationSessionService etatApplicationSessionService
- OuvertureCahierDeTextesActiviteService ouvertureCahierDeTextesActiviteService
- ArbreService arbreService
- CahierDeTextesArbreService cahierDeTextesArbreService
- ActiviteArbreService activiteArbreService
- CahierDeTextesPersonnaliseService cahierDeTextesPersonnaliseService
+ transient OuvertureCahierDeTextesActiviteService ouvertureCahierDeTextesActiviteService
+ transient ArbreService arbreService
+ transient CahierDeTextesArbreService cahierDeTextesArbreService
+ transient ActiviteArbreService activiteArbreService
+ transient CahierDeTextesPersonnaliseService cahierDeTextesPersonnaliseService
static scope = "session"
+ static transactional = false
private static final Integer ACCORDEON_DOSSIER = Integer.valueOf(1)
private static final Integer ACCORDEON_EDT = Integer.valueOf(0)
+ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ ois.defaultReadObject();
+
+ ApplicationContext ctx =
+ (ApplicationContext) ApplicationHolder.getApplication().getMainContext()
+
+ ouvertureCahierDeTextesActiviteService = ctx.getBean('ouvertureCahierDeTextesActiviteService')
+ arbreService = ctx.getBean('arbreService')
+ cahierDeTextesArbreService = ctx.getBean('cahierDeTextesArbreService')
+ activiteArbreService = ctx.getBean('activiteArbreService')
+ cahierDeTextesPersonnaliseService = ctx.getBean('cahierDeTextesPersonnaliseService')
+ }
+
/**
* Récupération etat page d'accueil + ouverture noeud par défaut
*/
* @author jtra
* @author othe
*/
-class TextesAccueilEtatApplication extends AbstractEtatApplication{
+class TextesAccueilEtatApplication extends AbstractEtatApplication implements Serializable{
EtatApplication plus(EtatApplication nouvelEtat) {
if (!nouvelEtat instanceof TextesAccueilEtatApplication) {