LocalPersonneService localPersonneService
+
+ final static String HQL_SERVICE_INFOS = """
+ select
+ s.id,
+ e.id,
+ p.nom,
+ p.prenom,
+ m.libelleLong
+ from Service s,
+ Personne p
+ join s.enseignements e
+ join s.matiere m
+ join e.enseignant a
+ where
+ p.autorite = a
+ and s.id in (:serviceIds)
+ order by p.nom, p.prenom
+ """
+
Map marchalleInfoConseil(Map result, NoteFormateur noteFormateur) {
result.tableauRecap = result.tableauRecap.collect {
marchalleRecapElevePeriode(it, noteFormateur)
List<ResultatEleveServicePeriode> resultatsPrecedents =
bulletin.syntheseEleve.resultatEleveServiceXmestrePrecedents
+ Map infosServices = mapServiceInfos(bulletin.services)
+
result.moyennesServices = bulletin.getServiceResultats()?.collect {
BulletinServiceResultat serviceResultat ->
marchalleBulletinServiceResultat(
serviceResultat,
noteFormateur,
- resultatsServicePrecedents
+ resultatsServicePrecedents,
+ infosServices
)
}
return result
}
+ /**
+ * Retourne une map : [serviceId:[profs:[[nom:..., prenom:...]], matiere:...]]
+ * Anti N+1 select
+ * @param services
+ * @return
+ */
+ private Map mapServiceInfos(List<Service> services) {
+
+ Map aRetourner = [:]
+ if(services) {
+ Map<Long, List> mapServiceAutorite = [:]
+ Map<Long, Map> mapEnseignant = [:]
+
+ Service.executeQuery(HQL_SERVICE_INFOS, [serviceIds: services*.id]).each{
+ if(!aRetourner[it[0]]){
+ aRetourner[it[0]] = [profs:[], matiere:it[4], enseignementIds:[]]
+ }
+ aRetourner[it[0]].profs << [nom:it[2], prenom:it[3]]
+ aRetourner[it[0]].enseignementIds << it[1] // triés par nom prénom du prof
+ }
+ }
+ return aRetourner
+ }
+
List marchallePeriodesPrecedentes(List<Periode> periodes) {
return periodes.collect {
[id: it.id, typePeriode: it.typePeriode]
*/
Map marchalleBulletinServiceResultat(BulletinServiceResultat sRes,
NoteFormateur noteFormateur,
- List<ResultatEleveServicePeriode> resultatsServicePrecedents = []) {
+ List<ResultatEleveServicePeriode> resultatsServicePrecedents = [],
+ Map infosServices = [:]) {
Map resultat = [
isSousService: false,
- service: marchalleService(sRes.service),
+ service: marchalleService(sRes.service, infosServices),
moyenneEleve: noteFormateur.format(
sRes.resultatEleveServicePeriode?.getValeurAffichage()
),
rang: (sRes.resultatEleveServicePeriode?.rang)!=null ?
sRes.resultatEleveServicePeriode.rang :
'',
- appreciations: recupereAppreciations(sRes),
+ appreciations: recupereAppreciations(sRes, infosServices),
sousServices: sRes.sousServiceResultats.collect {
BulletinSousServiceResultat bulletinSousServiceResultat->
return resultat
}
- List<String> recupereAppreciations(BulletinServiceResultat bulletinServiceResultat) {
+ List<String> recupereAppreciations(BulletinServiceResultat bulletinServiceResultat, Map infosServices = [:]) {
// liste appreciations dans le meme ordre comme les professeurs dans le service
- return bulletinServiceResultat.service.enseignements.toList().sort {
- localPersonneService.findPersonneByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
- bulletinServiceResultat.appreciationEleveEnseignementPeriodes.find {
- it.enseignementId == enseignement.id }?.appreciation ?: ''
+ if(infosServices) { // anti N+1 Select
+ infosServices[bulletinServiceResultat.service.id].enseignementIds.collect { Long enseignementId ->
+ bulletinServiceResultat.appreciationEleveEnseignementPeriodes.find {
+ it.enseignementId == enseignementId }?.appreciation ?: ''
+ }
+ } else {
+ return bulletinServiceResultat.service.enseignements.toList().sort {
+ localPersonneService.findPersonneByAutorite(it.enseignant).nomAffichage() }.collect { Enseignement enseignement ->
+ bulletinServiceResultat.appreciationEleveEnseignementPeriodes.find {
+ it.enseignementId == enseignement.id }?.appreciation ?: ''
+ }
}
}
/**
* Converteur pour Service
*/
- Map marchalleService(Service service) {
- List<Enseignement> enseignements = service.enseignements.toList()
- List<Personne> profs = enseignements*.enseignant.collect {
- localPersonneService.findPersonneByAutorite(it) }.sort { it.nomAffichage() }
-
- return [
- matiere: service.matiere.libelleLong,
- enseignements: profs?.collect { Personne prof ->
- [
- initialeProf: prof.initiales(),
- prenomProf: prof.prenom,
- nomProf: prof.nom
- ]
- }
- ]
+ Map marchalleService(Service service, Map infosServices = [:]) {
+ Map aRetourner = [:]
+ if(infosServices) { // anti N+1 select
+ Map serviceInfos = infosServices[service.id]
+ aRetourner = [
+ matiere: serviceInfos.matiere,
+ enseignements: serviceInfos.profs.collect {
+ [
+ initialeProf: localPersonneService.getInitiales(it.prenom),
+ prenomProf: it.prenom,
+ nomProf: it.nom
+ ]
+ }
+ ]
+ } else {
+ List<Enseignement> enseignements = service.enseignements.toList()
+ List<Personne> profs = enseignements*.enseignant.collect {
+ localPersonneService.findPersonneByAutorite(it) }.sort { it.nomAffichage() }
+
+ aRetourner = [
+ matiere: service.matiere.libelleLong,
+ enseignements: profs?.collect { Personne prof ->
+ [
+ initialeProf: prof.initiales(),
+ prenomProf: prof.prenom,
+ nomProf: prof.nom
+ ]
+ }
+ ]
+ }
+ return aRetourner
}