timeToLiveSeconds="600"
/>
+ <cache name="org.lilie.services.eliot.scolarite.Personne"
+ maxElementsInMemory="10000"
+ timeToIdleSeconds="0"
+ timeToLiveSeconds="600"
+ />
+
+ <!-- Les autorités sont environ 1.5 plus nombreuses à cause des autorités groupes -->
+ <cache name="org.lilie.services.eliot.securite.impl.Autorite"
+ maxElementsInMemory="15000"
+ timeToIdleSeconds="0"
+ timeToLiveSeconds="600"
+ />
+
+ <cache name="org.lilie.services.eliot.securite.impl.Autorisation"
+ maxElementsInMemory="10000"
+ timeToIdleSeconds="0"
+ timeToLiveSeconds="600"
+ />
+
<!-- Les objets à duré de vie courte, modifiable par l'utilisateur et utilisés sur les modules différents -->
- <!-- Le cache des requetes -->
+ <!-- Le cache des requêtes -->
<!--
Stock les timestamps des modifications par table.
timeToLiveSeconds="3600"
/>
+ <!--
+ Espace de stockage des requêtes de recherche des personne par leurs autorités.
+ La relation entre une personne et son autorité ne change jamais, on ne limite
+ donc pas la durée de vie de ces requêtes dans le cache.
+ -->
+ <cache name="query.AutoritePersonneMapping"
+ maxElementsInMemory="10000"
+ timeToIdleSeconds="600"
+ timeToLiveSeconds="0"
+ />
+
+ <!--
+ Espace de stockage des requêtes de recherche des Autorisations.
+ -->
+ <cache name="query.Autorisation"
+ maxElementsInMemory="10000"
+ timeToIdleSeconds="0"
+ timeToLiveSeconds="600"
+ />
</ehcache>
\ No newline at end of file
import org.lilie.services.eliot.scolarite.SousService
import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
import org.lilie.services.eliot.notes.ResultatEleveSousServicePeriode
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Marchaller des donnes de la fiche leve specifiques a Notes
*/
class FicheEleveNotesMarchallerService {
- static transactional = false
+ static transactional = true
+
+ LocalPersonneService localPersonneService
Map marchalleInfoConseil(Map result, NoteFormateur noteFormateur) {
result.tableauRecap = result.tableauRecap.collect {
List<String> recupereAppreciations(BulletinServiceResultat bulletinServiceResultat) {
// liste appreciations dans le meme ordre comme les professeurs dans le service
return bulletinServiceResultat.service.enseignements.toList().sort {
- Personne.findByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
+ localPersonneService.findPersonneByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
bulletinServiceResultat.appreciationEleveEnseignementPeriodes.find {
it.enseignement.id == enseignement.id }?.appreciation ?: ''
}
Map marchalleService(Service service) {
List<Enseignement> enseignements = service.enseignements.toList()
List<Personne> profs = enseignements*.enseignant.collect {
- Personne.findByAutorite(it) }.sort { it.nomAffichage() }
+ localPersonneService.findPersonneByAutorite(it) }.sort { it.nomAffichage() }
return [
matiere: service.matiere.libelleLong,
import org.lilie.services.eliot.absences.PartenaireAPrevenirIncident
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.absences.ProtagonisteIncident
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
class FicheEleveSanctionsMarshallerService {
def messageSource
+ LocalPersonneService localPersonneService
Map marshallFicheEleveSanctions(FicheEleveSanction ficheEleveSanction){
collect { it.partenaireAPrevenir.libelle }.join(', ')
String allProtagoniste = ProtagonisteIncident.findAllByIncident(it).
- collect { Personne.findByAutorite(it.autorite).nomAffichage() }.
+ collect { localPersonneService.findPersonneByAutorite(it.autorite).nomAffichage() }.
join(', ')
Map incident = [
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveAbsencesService
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveAbsencesCalendrierService
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
class JsonFicheEleveController extends AbstractEliotController {
FicheEleveAbsencesJourMarshallerService ficheEleveAbsencesJourMarshallerService
FicheEleveAbsencesService ficheEleveAbsencesService
FicheEleveAbsencesCalendrierService ficheEleveAbsencesCalendrierService
+ LocalPersonneService localPersonneServicel
/**
* Retourne la fiche de l'élève.
def getFicheEleveByIdAutorite = {
// redirige vers getFicheEleveByIdPersonne
Autorite eleveAutorite = Autorite.get(params?.eleveId.toLong())
- Personne eleve = Personne.findByAutorite(eleveAutorite)
+ Personne eleve = localPersonneServicel.findPersonneByAutorite(eleveAutorite)
redirect(action: 'getFicheEleveByIdPersonne', params: ['eleveId': eleve.id])
}
table('ent.personne')
version false
id column: 'id', generator: 'sequence', params: [sequence: 'ent.personne_id_seq']
- autorite column: 'autorite_id', fetch: 'join'
- civilite column: 'civilite_id'
- regime column: 'regime_id'
internalLogin column: 'login'
internalEmail column: 'email'
internalNumeroBureau column: 'numero_bureau'
internalTelephonePro column: 'telephone_pro'
internalTelephonePerso column: 'telephone_perso'
internalTelephonePortable column: 'telephone_portable'
+ cache usage: 'nonstrict-read-write'
}
static constraints = {
autorisationHeritee column: 'autorisation_heritee_id'
id column: 'id', generator: 'sequence', params: [sequence: 'securite.autorisation_id_seq']
valeurPermissionsExpliciteDefaut column: 'valeur_permissions_explicite_defaut'
+ cache usage: 'nonstrict-read-write'
}
static transients = ['valeurPermissions', 'valeurPermissionsDefaut']
org.lilie.services.eliot.securite.Permission.
PEUT_CONSULTER_CONTENU
);
-
}
/**
public String toString() {
- return "Autorisation{" +
- "autorite: " + autorite +
- ", item: " + item +
- ", proprietaire: " + proprietaire +
- '}';
+ return "Autorisation{autorite: $autoriteId, item: $itemId, proprietaire: $proprietaire}"
}
/**
return (this.proprietaire ||
((this.valeurPermissionsExpliciteDefaut & permission) > 0))
}
+
+
+ //**** Les requete à mettre en cache ****
+
+ static Autorisation findByAutoriteAndItemCachable(Autorite autorite, Item item) {
+ return findByItemAndAutoriteCachable(item, autorite)
+ }
+
+ static Autorisation findByItemAndAutoriteCachable(Item item, Autorite autorite) {
+ return findByItemIdAndAutoriteIdCachable(item.id, autorite.id)
+ }
+
+ static Autorisation findByItemIdAndAutoriteIdCachable(Long itemId, Long autoriteId) {
+ return Autorisation.createCriteria().get {
+ eq('item.id', itemId)
+ eq('autorite.id', autoriteId)
+ cache true
+ cacheRegion 'query.Autorisation'
+ }
+ }
+
+
+ static Autorite findProprietaireByItemCachable(Item item) {
+ return findProprietaireByItemIdCachable(item.id)
+ }
+
+ static Autorite findProprietaireByItemIdCachable(Long itemId) {
+ return Autorisation.createCriteria().get {
+ eq('item.id', itemId)
+ eq('proprietaire', true)
+ projections {
+ property('autorite')
+ }
+ cache true
+ cacheRegion 'query.Autorisation'
+ }
+ }
+
+
+ static List<Autorisation> findAllByItemCachable(Item item) {
+ return findAllByItemIdCachable(item.id)
+ }
+
+ static List<Autorisation> findAllByItemIdCachable(Long itemId) {
+ return Autorisation.withCriteria {
+ eq('item.id', itemId)
+ cache true
+ cacheRegion 'query.Autorisation'
+ }
+ }
}
\ No newline at end of file
table('securite.autorite')
id column: 'id', generator: 'sequence', params: [sequence: 'securite.autorite_id_seq']
idEnregistrementCible column: 'enregistrement_cible_id'
+ cache usage: 'nonstrict-read-write'
}
AutoriteNomAffichageService autoriteNomAffichageService
* Méthode retournant les permissions de l'autorité sur l'item passé en paramètre
*/
public int findPermissionsOnItem(org.lilie.services.eliot.securite.Item item) {
- return Autorisation.findByAutoriteAndItem(this, item)?.valeurPermissions ?: 0;
+ return Autorisation.findByAutoriteAndItemCachable(this, item)?.valeurPermissions ?: 0;
}
/**
* Retourne le pripriétaire de l'agenda
*/
Autorite getProprietaire() {
- Autorisation autorisation = null
- if (this && this.item) {
- autorisation = Autorisation.findByItemAndProprietaire(
- this.item,
- Boolean.TRUE
- )
- }
- return (autorisation ? autorisation.autorite : null)
+ return itemId ? Autorisation.findProprietaireByItemIdCachable(itemId) : null
}
/**
*/
Autorite getProprietaire() {
if (proprietaire == null) {
- Autorisation autorisation
- if (this?.item) {
- autorisation = Autorisation.findByItemAndProprietaire(this.item, true)
+ if (itemId) {
+ proprietaire = Autorisation.findProprietaireByItemIdCachable(itemId)
}
- proprietaire = autorisation?.autorite
}
return proprietaire
}
if (this && this.item && autorite) {
Autorisation autorisation =
- Autorisation.findByItemAndAutorite(this.item, autorite)
+ Autorisation.findByItemAndAutoriteCachable(this.item, autorite)
if (autorisation) {
RelDossierAutorisationCahier rel =
RelDossierAutorisationCahier.findByAutorisation(autorisation)
CahierDeTextes cdt,\r
Autorite autorite) {\r
RelDossierAutorisationCahier rel\r
- Autorisation auto = Autorisation.findByAutoriteAndItem(autorite, cdt.item)\r
+ Autorisation auto = Autorisation.findByAutoriteAndItemCachable(autorite, cdt.item)\r
\r
if (auto) {\r
rel = RelDossierAutorisationCahier.findByDossierAndAutorisation(dossier, auto)\r
* @return l'autorisation de l'autorité sur l'item si elle existe, sinon null
*/
Autorisation findAutorisation(Autorite autorite, Item item) {
- return Autorisation.findByAutoriteAndItem(autorite, item)
+ return Autorisation.findByAutoriteAndItemCachable(autorite, item)
}
}
*/
List<Autorite> getAutoritesForTypeAndIdExterne(String type,
List<String> idsExternes,
- forceCreation = true
- ) {
-
+ forceCreation = true) {
List<Autorite> autorites = []
autorites = Autorite.withCriteria {
'in'("idExterne", idsExternes)
eq("type", type)
+ cache false
}
}
List<Autorite> autoriteActeurs = Autorite.withCriteria {
eq('type', Autorite.TYPE_ACTEUR)
'in'('idExterne', acteursIdExternes)
+ cache false
}
// Crée les autorités manquantes
if (typeAutorite) {
eq('type', typeAutorite)
}
+ cache false
}.size() > 0
}
projections {
property('item.id')
}
+ cache false
}
if (itemIdListe.isEmpty()) {
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.annuaire.SecuriteSession
import groovy.sql.Sql
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Gestion des fonctions des personnes de l'annuaire
static transactional = true
CiteScolaireService citeScolaireService
+ LocalPersonneService localPersonneService
private static final Boolean CITE_SCOLAIRE_DROITS_ETTENDUS =
ConfigurationHolder.config.eliot.citeScolaire.droits.etendus
assert fonction != null, 'fonction ne doit pas être null'
assert etablissement != null, 'etablissement ne doit pas être null'
+ Personne personne = localPersonneService.findPersonneByAutorite(autorite)
+
List<FonctionEtablissement> list =
- findAllFonctionEtablissementForUtilisateurNormal(Personne.findByAutorite(autorite))
+ findAllFonctionEtablissementForUtilisateurNormal(personne)
+
return (list.find {FonctionEtablissement fonctionEtablissement ->
- (
(fonctionEtablissement.getEtablissement().idExterne == etablissement.idExterne) &&
(fonctionEtablissement.getFonctionEnum().getCode() == fonction.getCode())
-
- )
-
-
}) != null
}
/**
* Recherche une personne par son idExterne (id dans le référentiel AAF)
- * @param idExterne
* @return La personne pour l'idExterne fournit
* @author jtra
*/
public Personne findPersonneByIdExterne(String personneIdExterne) {
// Récupération de la personne
- Personne personne = (Personne) Personne.createCriteria().get {
- 'autorite' {
+ Personne personne = Personne.createCriteria().get {
+ autorite {
eq('type', Autorite.TYPE_ACTEUR)
eq('idExterne', personneIdExterne)
}
+ cache false
}
if (!personne) {
/**
* Recherche une personne par l'id de son autorité
- * @param autoriteId
* @return La personne pour l'autoriteId fournit
* @author bper
*/
public Personne findPersonneByAutoriteId(Long autoriteId) {
// Récupération de la personne
Personne personne = Personne.createCriteria().get {
- autorite {
- eq('id', autoriteId)
- }
+ eq('autorite.id', autoriteId)
+ cache true
+ cacheRegion 'query.AutoritePersonneMapping'
}
if (!personne) {
)
}
- Personne personne = Personne.findByAutorite(autorite)
+ // La méthode findPersonneByAutoriteId utilise le cache!
+ Personne personne = findPersonneByAutoriteId(autorite.id)
if (!personne) {
throw new IllegalStateException(
}
List<Personne> personnes = Personne.withCriteria {
- 'in'('autorite', autorites)
- fetchMode('autorite', FetchMode.JOIN)
+ 'in'('autorite.id', autorites*.id)
+ cache true
+ cacheRegion 'query.AutoritePersonneMapping'
}
if (autorites.size() != personnes.size()) {
/**
* retourne le nom d'affichage à partir d'un autorite personne
- * @param autorite
- * @return
*/
String getNomAffichage(Autorite autorite) {
- return getNomAffichage(Personne.findByAutorite(autorite))
+ return getNomAffichage(findPersonneByAutorite(autorite))
}
/**
- * @param personne une personne
* @return le nom d'affichage d'une personne
*/
String getNomAffichage(Personne personne) {
/**
* Construis le nom d'affichage de nom et prenom
- * @param nom
- * @param prenom
* @return le nom d'affichage, null returné si nom est prenom sont null
*/
String getNomAffichage(String nom, String prenom) {
/**
* Lecture de la liste des nom/prénoms des personne correspondant à la liste
* d'autorités passés en paramètre
- * @param autorite
* @param autoriseAutoritesSansPersonnes si mis a true, l'exception n'est pas
* levee quand une autorite n'a pas une personne. un null est mis dans le map au lieu.
* @return une map associant l'idExterne avec le nom d'affichage
* Retourne une liste de personne correspondant aux critères.
* Ne tient pas compte de la casse et des accents.
* La date de naissance n'est pas prise en compte si elle a la valeur null
- * @param nom
- * @param prenom
- * @param dateNaissance
* @return la liste de personne correspondant aux critères fournis
* @author jtra
*/
if (dateNaissance != null) {
eq('dateNaissance', dateNaissance)
}
+ cache false
}
}
/**
* Indique s'il existe une personne correspondant à l'id externe
- * @param idExterne
- * @return
*/
public boolean isPersonneExisteForIdExterne(String idExterne) {
Autorite
Autorite.TYPE_ACTEUR
)
if (autorite) {
- return (Personne.findByAutorite(
- autorite
- ) != null)
+ return (Personne.findByAutorite(autorite) != null)
} else {
return false
}
/**
* Cherche personnes qui ont au moins une fonction dans l'établissement donné
- * @param etablissement
- * @param fonctions liste des fonctions
- * @param fetchAutorite fetch les autorités des personnes
- * @param actif
- * @return
* @author msan
* @author bper
*/
/**
* Retourne une liste des personne pour une liste de leurs identifiants.
- * @param ids
- * @return liste des peresonnes
* @author bper
*/
public List<Personne> findAllPersonne(List<Long> ids) {
}
return Personne.createCriteria().list {
'in'('id', ids)
+ cache false
}
}
/**
* Retourne une liste de personne à partir d'une liste d'id d'autorites
- * @param autoriteIds
- * @return List < Personne >
*/
public List<Personne> findAllPersonneForAllAutoriteIds(List<Long> autoriteIds) {
if (autoriteIds == null) {
return []
}
return Personne.createCriteria().list {
- 'autorite' {
- 'in'('id', autoriteIds)
- }
+ 'in'('autorite.id', autoriteIds)
+ cache true
+ cacheRegion 'query.AutoritePersonneMapping'
}
}
/**
* Cree une persone
- * @param nom
- * @param prenom
- * @return
*/
Personne creePersonne(String nom, String prenom) {
List<Autorisation> autorisations = []
if ((items*.value).size() > 0 && autorites.size() > 0) {
- autorisations = (List<Autorisation>) org.lilie.services.eliot.securite.impl.Autorisation.withCriteria {
+ autorisations = org.lilie.services.eliot.securite.impl.Autorisation.withCriteria {
'in'("item", items*.value)
and {
'in'("autorite", autorites)
}
+ cache false
}
}
return autorisations
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
-import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.securite.permission.partageauto.AgendaPartageAutoService
TypeAgendaService typeAgendaService
TempsSecuriteService tempsSecuriteService
EleveAnnuaireService eleveAnnuaireService
- CiteScolaireService citeScolaireService
AnneeScolaireService anneeScolaireService
AgendaPartageAutoService agendaPartageAutoService
Item itemAgenda = agenda.getItem()
agenda.delete(flush: true)
// Suppression de toutes les autorisations
- List<Autorisation> autorisations = Autorisation.findAllByItem(itemAgenda)
+ List<Autorisation> autorisations = Autorisation.findAllByItemCachable(itemAgenda)
autorisations.each {
it.delete()
}
eq('id', securiteSession.defaultAutorite.id)
}
eq('proprietaire', true)
+ cache false
} != null
)
}
eq('idSts', personneCodeSts)
eq('type', Autorite.TYPE_ACTEUR)
}
+ cache false
}
if (!personnes) {
return findAutorisationsOnItem(item.itemParent)
}
def autorisations = org.lilie.services.eliot.securite.impl.Autorisation.withCriteria {
- eq("item", item)
+ eq("item.id", item.id)
and {
- 'in'("autorite", autorites)
+ 'in'("autorite.id", autorites*.id)
}
+ cache true
+ cacheRegion 'query.Autorisation'
}
return (List<Autorisation>) autorisations
}
SecuriteSession session)
throws AutorisationException {
super(item, autorite, session);
- autorisation = Autorisation.findByAutoriteAndItem(autorite, item)
+ autorisation = Autorisation.findByAutoriteAndItemCachable(autorite, item)
}
/**
}
private Autorisation findAutorisation() {
- return Autorisation.findByItemAndAutorite(item, autorite)
+ return Autorisation.findByItemAndAutoriteCachable(item, autorite)
}
private void actualisePM(DefaultPermissionsManager pm) {
Item item = cdt.item
assertNotNull item
Autorisation autorisation =
- Autorisation.findByItemAndAutorite(item, enseignant)
+ Autorisation.findByItemAndAutoriteCachable(item, enseignant)
assertNotNull autorisation
assertTrue autorisation.proprietaire
Item item2 = cdt2.item
assertNotNull item2
Autorisation autorisation2 =
- Autorisation.findByItemAndAutorite(item2, enseignant2)
+ Autorisation.findByItemAndAutoriteCachable(item2, enseignant2)
assertNotNull autorisation2
assertTrue autorisation2.proprietaire
assertNotNull("Le cdt de test doit exister à la fin du test.", cdt)
assertNull("Le service du cdt doit être null", cdt.service)
- List<Autorisation> autorisations = Autorisation.findAllByItem(cdt.item)
+ List<Autorisation> autorisations = Autorisation.findAllByItemCachable(cdt.item)
assertEquals(
"Il ne doit y avoir qu'une seule autorisation sur le cdt",
1,
)
)
}
- protagonistesModInfo.sort {Personne.findByAutorite(Autorite.get(it.idAutorite)).nom}
+ protagonistesModInfo.sort {localPersonneService.findPersonneByAutoriteId(it.idAutorite).nom}
return protagonistesModInfo
}
import org.lilie.services.eliot.scolarite.Etablissement
import org.codehaus.groovy.grails.web.json.JSONObject
import org.lilie.services.eliot.impression.TemplateDocument
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.securite.impl.Autorite
import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Le job permet de lancer des traitements différés de différents types.
@SuppressWarnings('GrailsStatelessService')
GrailsApplication grailsApplication
+ LocalPersonneService localPersonneService
def concurrent = false
if(grailsApplication.config.eliot.notification.actif){
absencesNotificationService.finPublipostage(
Etablissement.get(defaultDemande.getEtablissementId()),
- Personne.findByAutorite(
- Autorite.get(defaultDemande.demandeurAutoriteId)
+ localPersonneService.findPersonneByAutoriteId(
+ defaultDemande.demandeurAutoriteId
),
defaultDemande.getNom(),
template.nom,
projections {
property('id')
}
+ cache false
}
// Collecte les id des messages re-indexés
List<String> recupereAppreciations(BulletinServiceResultat bulletinServiceResultat) {
// liste appreciations dans le meme ordre comme les professeurs dans le service
return bulletinServiceResultat.service.enseignements.toList().sort {
- Personne.findByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
+ localPersonneService.findPersonneByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
bulletinServiceResultat.appreciationEleveEnseignementPeriodes.find {
it.enseignement.id == enseignement.id }?.appreciation ?: ''
}
private Map toMap(Service service) {
List<Enseignement> enseignements = service.enseignements.toList()
List<Personne> profs = enseignements*.enseignant.collect {
- Personne.findByAutorite(it) }.sort { it.nomAffichage() }
+ localPersonneService.findPersonneByAutorite(it) }.sort { it.nomAffichage() }
return [
matiere: service.matiere.libelleLong,
}
- /**
- * Verifie que si c'est le prof qui accede cette fonction, il est le prof
- * principal de la classe concernee
- */
- private void verifieAccesProfPrincipal(StructureEnseignement classe) throws AutorisationException{
- if (!notesDroitService.isProfPrincipalInClasseByPerimetre(securiteSession, classe)) {
- Personne personne = Personne.findByAutorite(securiteSession.defaultAutorite)
- throw new AutorisationException("Enseignant ${personne.id} n'est pas "+
- "le professeur principal de la classe ${classe.code}")
- }
- }
-
-
/**
* Retourne l'appréciation de l'élève et le tableau de recap
*/
import org.lilie.services.eliot.notes.notification.NotesNotificationService
import org.codehaus.groovy.grails.web.json.JSONObject
import org.lilie.services.eliot.impression.TemplateDocument
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.securite.impl.Autorite
import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
class NotesPublipostageJob {
DemandeTraitementService demandeTraitementService
PublipostageBatchService publipostageBatchService
NotesNotificationService notesNotificationService
+ LocalPersonneService localPersonneService
static triggers = {
if (grailsApplication.config.eliot.notification.actif){
notesNotificationService.finPublipostage(
Etablissement.get(defaultDemande.getEtablissementId()),
- Personne.findByAutorite(
- Autorite.get(defaultDemande.demandeurAutoriteId)
+ localPersonneService.findPersonneByAutoriteId(
+ defaultDemande.demandeurAutoriteId
),
defaultDemande.getNom(),
template.nom,
import org.lilie.services.eliot.impression.donnees.eleve.SousMatiereImpressionInfo
import org.lilie.services.eliot.impression.template.bulletin.option.ImpressionBulletinOptionsService
import org.lilie.services.eliot.impression.template.bulletin.option.BulletinOptionsPersonnalise
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Récupération d'informations pour le publipostage des notes
BulletinService bulletinService
ReleveService releveService
ImpressionBulletinOptionsService impressionBulletinOptionsService
+ LocalPersonneService localPersonneService
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
mii.libelle = service.matiere.libelleLong
mii.prof = service.enseignements?.collect {
- Personne.findByAutorite(it.enseignant).nomAffichageInitiales()
+ localPersonneService.findPersonneByAutorite(it.enseignant).nomAffichageInitiales()
}?.join(', ')
// sous-services
import java.text.Normalizer
import org.lilie.services.eliot.annuaire.impl.DistantDonneesPersoService
import org.lilie.services.eliot.annuaire.impl.DonneesPerso
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
class AnnuaireConsultationService {
ProprietesScolariteService proprietesScolariteService
DistantDonneesPersoService distantDonneesPersoService
+ LocalPersonneService localPersonneService
public List<AnnuaireConsultationInfo> rechereByIdExterne(String idExterne) {
if (!idExterne) {
throw new IllegalStateException("Le champ IdExterne doit être renseigné")
}
- def criteria = Personne.createCriteria()
- List<Personne> users = criteria.list() {
- "autorite" {
- eq("idExterne", idExterne)
- }
- }
- if (users.size() > 1) {
- throw new IllegalStateException("Plusieurs personnes trouvées pour le même idExerne ${idExterne}")
- }
- if (users.size() == 0) {
- throw new IllegalStateException("Aucune personne trouvée pour l'idExterne ${idExterne}")
- }
- Personne user = users.first()
+ Personne user = localPersonneService.findPersonneByIdExterne(idExterne)
+
AnnuaireConsultationInfo modelDonnees = new AnnuaireConsultationInfo()
Etablissement etab = user.etablissementRattachement
Autorite.TYPE_ACTEUR
)
-
- Personne user = Personne.findByAutorite(autorite)
+ Personne user = localPersonneService.findPersonneByAutorite(autorite)
AnnuaireConsultationInfo modelDonnees = new AnnuaireConsultationInfo()
projections {
rowCount()
}
+ cache false
}
}
Etablissement filtreEtab = null
if (etab) {
- filtreEtab = Etablissement.findById(etab.toString().toLong())
+ filtreEtab = Etablissement.get(etab.toString().toLong())
}
ajouterNombreEtablissementsTotal(model)
ajouterNombreEtablissementsActif(model)
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
-
import org.lilie.services.eliot.url.UrlServeurResolutionMode
import org.lilie.services.eliot.environnement.EnvironnementUtil
-import org.lilie.services.eliot.textes.DataStoreId
-import org.lilie.services.eliot.applications.textes.datastore.verification.DataStoreErreurConsequence
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
def sqlRequetes = ['org.hibernate.SQL']
def sqlParams = ['org.hibernate.type']
+/*
debug additivity: false,
stdout: classesEliot + sqlRequetes,
applicatif_dev: classesEliot,
sqlRequetes: sqlRequetes
+*/
trace additivity: false,
sqlRequetes: sqlParams,
)
// Autorisation propriétaire du cdt
- Autorisation autorisation = Autorisation.findByItemAndAutorite(
+ Autorisation autorisation = Autorisation.findByItemAndAutoriteCachable(
cahierDeTextes.item,
autoriteScolarite
)
private void copieDroitsCahierDeTextes(CahierDeTextes source, CahierDeTextes cible) {
- List<Autorisation> allAutorisation = Autorisation.findAllByItem(source.item)
+ List<Autorisation> allAutorisation = Autorisation.findAllByItemCachable(source.item)
allAutorisation.each {Autorisation autorisationSource ->
cahier.save(flush: true, failOnError: true)
// pour chaque droit sur le cdt maître, on vérifie si on doit supprimer ou non ce droit
- List<Autorisation> allAutorisationSurCahierMaitre = Autorisation.findAllByItem(cahierMaitre.item)
+ List<Autorisation> allAutorisationSurCahierMaitre = Autorisation.findAllByItemCachable(cahierMaitre.item)
allAutorisationSurCahierMaitre.each {Autorisation autorisationSurCahierMaitre ->
cahierMaitre.cahiersIncorpores?.each { CahierDeTextes cahierFusionne ->
- Autorisation droitSurCahierFusionne = Autorisation.createCriteria().get {
- eq('item', cahierFusionne.item)
- eq('autorite', autorisationSurCahierMaitre.autorite)
- }
+ Autorisation droitSurCahierFusionne = Autorisation.findByItemAndAutoriteCachable(
+ cahierFusionne.item,
+ autorisationSurCahierMaitre.autorite
+ )
if (droitSurCahierFusionne) {
existeDroitsSurCahiersFusionnes = true
private Autorisation findAutorisationProprietaireDuCahierDeTextes(CahierDeTextes cahierDeTextes,
Autorite autorite) {
List<Autorisation> autorisations =
- Autorisation.findAllByItem(cahierDeTextes.item)
+ Autorisation.findAllByItemCachable(cahierDeTextes.item)
Autorisation autorisation = (Autorisation) autorisations.find {
Autorisation aut ->
private Autorisation findAutorisationSurCahierDeTextes(CahierDeTextes cahierDeTextes,
Autorite autorite) {
List<Autorisation> autorisations =
- Autorisation.findAllByItem(cahierDeTextes.item)
+ Autorisation.findAllByItemCachable(cahierDeTextes.item)
Autorisation autorisation = (Autorisation) autorisations.find {
Autorisation aut ->