List<ResultatClasseServicePeriode> internalFindAll(List<StructureEnseignement> classes,
List<Service> services,
List<Periode> periodes,
- List<NaturePeriode> naturePeriodes) {
+ List<NaturePeriode> naturePeriodes,
+ Boolean fetchResultatsClasseSousServicePeriode = false) {
if (classes != null && classes.isEmpty()) {
return []
}
}
fetchMode('periode', FetchMode.JOIN)
fetchMode(ConstFonct.SERVICE, FetchMode.JOIN)
+ if(fetchResultatsClasseSousServicePeriode) {
+ fetchMode('resultatsClasseSousServicePeriode', FetchMode.JOIN)
+ }
}
return ress
*/
SyntheseClasse internalConstruisSyntheseClasse(StructureEnseignement classe,
List<Service> services,
- Periode periode) {
+ Periode periode,
+ Boolean fetchResultatsClasseSousServicePeriode = false) {
SyntheseClasse syntheseClasse = new SyntheseClasse()
syntheseClasse.classe = classe
syntheseClasse.resultatClasseServicePeriodes =
resultatClasseServicePeriodeService.
- internalFindAll([classe], services, [periode], null)
+ internalFindAll([classe], services, [periode], null, fetchResultatsClasseSousServicePeriode)
if (periode.isPeriodeNotation()) {
List<Periode> periodePrecedentes = periode.getPeriodesPrecedentes()
*/
List<SyntheseEleve> construisAllSyntheseEleveForClasse(StructureEnseignement classe,
List<Service> services,
- Periode periode)
+ Periode periode,
+ boolean fetchResultatsEleveSousServicePeriode)
throws AutorisationException {
if (!classe) {
List<ResultatEleveServicePeriode> resultatEleveServicePeriodes =
resultatEleveServicePeriodeService.findAll(
- elevesListes.eleves*.autorite, services, [periode], null)
+ elevesListes.eleves*.autorite, services, [periode], null, fetchResultatsEleveSousServicePeriode)
+
List<Enseignement> enseignements = []
services.each {Service service ->
String hqlQuery = """
SELECT distinct s FROM Service s
LEFT OUTER JOIN FETCH s.enseignements AS ens
- LEFT OUTER JOIN ens.enseignant AS aut
+ LEFT OUTER JOIN FETCH ens.enseignant AS aut
INNER JOIN FETCH s.relPeriodeServices AS rps
LEFT OUTER JOIN FETCH rps.periode AS per
LEFT OUTER JOIN FETCH per.typePeriode AS typeper
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteHqlFactory
import org.lilie.services.eliot.scolarite.structureenseignement.StructureEnseignementElevesListes
import org.lilie.services.eliot.annuaire.ResponsableEleve
-import org.hibernate.FetchMode
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.notes.Note
import org.lilie.services.eliot.constantes.ConstFonct
-import org.hibernate.Query
import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.scolarite.Periode
+import org.hibernate.SQLQuery
+import org.hibernate.SessionFactory
+import org.lilie.services.eliot.securite.impl.Autorite
/**
* Ce service fournis des informations concernant les élèves à partir de
static transactional = true
+ AnneeScolaireService anneeScolaireService
+ SessionFactory sessionFactory
+
+
static final String HQL_ELEVES_BY_STRUCTURE_ENSEIGNEMENT_FETCH = """
select distinct p
from PersonneProprietesScolarite pps
GROUP BY p.id
"""
- AnneeScolaireService anneeScolaireService
+ static final String FIND_ALL_ELEVE_INACTIFS_A_AFFICHER_SQL = """
+ WITH periodeIds AS (
+ SELECT per.id AS id
+ FROM ent.periode per
+ WHERE type_periode_id IN (:typePeriodeIds)
+ AND structure_enseignement_id IN (:structureIds)
+ )
+ SELECT {eleve.*}, {aut.*}
+ FROM ent.personne_propriete_scolarite pps
+ INNER JOIN ent.personne eleve ON eleve.id = pps.personne_id
+ INNER JOIN securite.autorite aut ON aut.id = eleve.autorite_id
+ INNER JOIN ent.propriete_scolarite ps ON ps.id = pps.propriete_scolarite_id,
+ periodeIds
+ WHERE pps.est_active = false
+ AND ps.structure_enseignement_id = :structureId
+ AND ps.fonction_id = :fonctionId
+ AND (
+ EXISTS (SELECT 1 FROM ent.eleve_archive_affiche eaa
+ WHERE eaa.personne_id = eleve.id
+ AND eaa.periode_id IN (periodeIds.id)
+ )
+ OR EXISTS (SELECT 1 FROM entnotes.appreciation_eleve_periode app
+ WHERE app.eleve_id = aut.id
+ AND app.periode_id IN (periodeIds.id)
+ )
+ OR EXISTS (SELECT 1 FROM entnotes.appreciation_eleve_enseignement_periode aeep
+ WHERE aeep.eleve_id = aut.id
+ AND aeep.periode_id IN (periodeIds.id)
+ )
+ OR EXISTS (SELECT 1 FROM entnotes.note note
+ INNER JOIN entnotes.evaluation ev ON ev.id = note.evaluation_id
+ INNER JOIN entnotes.rel_evaluation_periode rep ON rep.evaluation_id = ev.id
+ WHERE note.eleve_id = aut.id
+ AND rep.periode_id IN (periodeIds.id)
+ )
+ )
+ AND NOT EXISTS (SELECT id FROM ent.personne_propriete_scolarite ppsActive
+ WHERE ppsActive.est_active = true
+ AND ppsActive.personne_id = pps.personne_id
+ AND ppsActive.propriete_scolarite_id = pps.propriete_scolarite_id)
+ GROUP BY eleve.id, aut.id
+ """
List<Personne> findAllEleveByStructureEnseignement(StructureEnseignement structureEnseignement,
Boolean actif = true) {
return eleves
}
- private static final FIND_ALL_ELEVE_INACTIFS_A_AFFICHER_HQL = """
- select distinct eleve
- from PersonneProprietesScolarite pps
- inner join pps.personne eleve
- inner join fetch eleve.autorite autoriteEleve
- inner join pps.proprietesScolarite ps
- where pps.estActive = false
- and ps.structureEnseignement.id = :structuretId
- and ps.fonction.id = :fonctionId
- and (
- exists (
- select 1 from EleveArchiveAffiche eaa
- where eaa.eleve = eleve
- and eaa.periode.id in (:periodeIds)
- )
- or
- exists (
- select 1 from AppreciationElevePeriode app
- where app.eleve = autoriteEleve
- and app.periode.id in (:periodeIds)
- )
- or
- exists (
- select 1 from AppreciationEleveEnseignementPeriode app
- where app.eleve = autoriteEleve
- and app.periode.id in (:periodeIds)
- )
- or
- exists (
- select 1 from Note note
- inner join note.evaluation eval
- inner join eval.periodes p
- where note.eleve = autoriteEleve
- and p.id in (:periodeIds)
- )
- )
- and not exists (
- select ppsActive.id
- from PersonneProprietesScolarite ppsActive
- where ppsActive.estActive = true
- and ppsActive.personne = pps.personne
- and ppsActive.proprietesScolarite = pps.proprietesScolarite
- )
- """
-
/**
* Retourne les élèves de la structure d'enseignement désactivés mais qui ont
* au moins une données (appréciation d'enseignant, appréciation générale, note)
Fonction fonction = Fonction.findByCode(FonctionEnum.ELEVE.code, [cache: true])
- List<Long> periodeIds = (List<Long>) Periode.withCriteria{
- 'in'('typePeriode', typePeriodes)
- 'in'('classe', classes)
- projections {
- property('id')
- }
- }
+ SQLQuery sqlQuery = sessionFactory.getCurrentSession().createSQLQuery(FIND_ALL_ELEVE_INACTIFS_A_AFFICHER_SQL)
- List<Personne> eleves = Personne.executeQuery(
- FIND_ALL_ELEVE_INACTIFS_A_AFFICHER_HQL,
- [
- structuretId: structureEnseignement.id,
- fonctionId: fonction.id,
- periodeIds: periodeIds
- ]
- )
+ sqlQuery.addEntity("eleve", Personne)
- return eleves
+ sqlQuery.addEntity("aut", Autorite)
+ sqlQuery.setParameterList("typePeriodeIds", typePeriodes*.id)
+ sqlQuery.setParameterList("structureIds", classes*.id)
+ sqlQuery.setLong("structureId", structureEnseignement.id)
+ sqlQuery.setLong("fonctionId", fonction.id)
+
+ List personnesAutorite = sqlQuery.list()
+
+ return (List<Personne>)personnesAutorite.collect{it[0]}
}
/**
classes.sort {a, b -> cc.compare(a.code, b.code)}
if (classe) {
- // La liste des période dans combo triée
+ // La liste des périodes dans combo triée
List<Periode> periodes = classe.periodes.toList().sort()
periodeInfos = periodes.collect {
periodeId = periode.id
// Crée la synthese
- synthese = syntheseService.construisSynthese(classe, periode)
+ synthese = syntheseService.construisSynthese(classe, periode, true, true)
moyennesAjour = synthese.moyennesAjour
dateDernierCalculMoyennes = synthese.dateDernierCalculMoyennes
List<Periode> periodesPrecedentes = periode?.getPeriodesPrecedentes()
// Récupère la synthese
- Synthese synthese = syntheseService.construisSynthese(classe, periode)
+ Synthese synthese = syntheseService.construisSynthese(classe, periode, false, false)
donnees.colonnes = [message(code: 'eliot.notes.libelle.matiere', default: 'Matière')]
List ligneEnteteEns = [message(code: 'eliot.notes.libelle.enseignants', default: 'Enseignants')]
verifieDroitAccesObjetDomaine(classe)
// Crée la synthese
- Synthese synthese = syntheseService.construisSynthese(classe, periode)
+ Synthese synthese = syntheseService.construisSynthese(classe, periode, false, false)
//Ajoute les services de la classe aux élèves n'y participant pas - Pour tableau d'impression
syntheseService.ajouteTousServicesEleve(synthese)
trimestreServiceNotes.put(trimestre, serviceNotes)
}
- Synthese synthese = syntheseService.construisSynthese(classe, periode)
+ Synthese synthese = syntheseService.construisSynthese(classe, periode, false, false)
ApbServiceNotation serviceNotationMOYGEN =
findOrCreateApbServiceNotationMOYGEN(
* @author bper
*/
Synthese construisSynthese(StructureEnseignement classe,
- Periode periode) {
+ Periode periode,
+ boolean fetchResultatsEleveSousServicePeriode,
+ boolean fetchResultatsClasseSousServicePeriode) {
// Les services et tous ses groupes et de regroupements
List<Service> services = serviceService.findAllServiceEvaluableByClasseAndPeriode(
construisAllSyntheseEleveForClasse(
classe,
services,
- periode)
+ periode,
+ fetchResultatsEleveSousServicePeriode)
// Synthèse de la classe
SyntheseClasse syntheseClasse = syntheseClasseService.
internalConstruisSyntheseClasse(
classe,
services,
- periode)
+ periode,
+ fetchResultatsClasseSousServicePeriode)
Synthese synthese = new Synthese()
synthese.classe = classe
void testConstruisSynthese() {
// Le securité session d'un enseignant
SecuriteSession securiteSessionEnseignant =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1)
List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
List<SousService> sousServices = [sousServiceT1_1, sousServiceT1_2]
//Appeler la methode à tester
Synthese synthese = syntheseService.construisSynthese(
classe,
- periodeT1)
+ periodeT1,
+ false,
+ false)
//recuperer le resultatEleve Periode pour l'eleve1 et periodeT1
ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
//recuperer le resultatEleveServicePeriode pour eleve1,serviceNormal et periode T1
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode1 =
- getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve1.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve1.autorite)
//recuperer le resultatEleveServicePeriode pour eleve2,serviceNormal et periode T1
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode2 =
- getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve2.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve2.autorite)
//recuperer le resultatEleveServicePeriode pour eleve1,serviceParent et periode T1
ResultatEleveServicePeriode resultatEleveServiceParentPeriode1 =
- getResultatEleveServicePeriode(periodeT1, serviceParent, eleve1.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceParent, eleve1.autorite)
//recuperer le resultatEleveServicePeriode pour eleve2,serviceParent et periode T1
ResultatEleveServicePeriode resultatEleveServiceParentPeriode2 =
- getResultatEleveServicePeriode(periodeT1, serviceParent, eleve2.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceParent, eleve2.autorite)
//recuperer le resultatClassePeriode
ResultatClassePeriode resultatClassePeriode = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT1)
//recuperer le resultatClasseServicePeriode qui est attaché au serviceNormal pour la periode T1
ResultatClasseServicePeriode resultatClasseServiceNormalPeriode =
- getResultatClasseServicePeriode(periodeT1 ,serviceNormal, classe)
+ getResultatClasseServicePeriode(periodeT1 ,serviceNormal, classe)
//recuperer le resultatClasseServicePeriode qui est attaché au serviceParent pour la periode T1
ResultatClasseServicePeriode resultatClasseServiceParentPeriode =
- getResultatClasseServicePeriode(periodeT1 ,serviceParent, classe)
+ getResultatClasseServicePeriode(periodeT1 ,serviceParent, classe)
//verifier que la classe et la periode sont bien recuperés dans la synthese
//****verifier les resultatsEleveServicePeriodes dans syntheseEleve1 et syntheseEleve2
//la liste resultatEleveServicePeriodes attaché à l'eleve1
List<ResultatEleveServicePeriode> resultatEleveServicePeriodes_E1 =
- syntheseEleve1.resultatEleveServicePeriodes
+ syntheseEleve1.resultatEleveServicePeriodes
//le resultatEleveServiceNormal qui est attaché à l'eleve1 et le service normal
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode_E1 =
- resultatEleveServicePeriodes_E1.find{it.service.id == serviceNormal.id}
+ resultatEleveServicePeriodes_E1.find{it.service.id == serviceNormal.id}
//le resultatEleveServiceNormal qui est attaché à l'eleve1 et le serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode_E1 =
- resultatEleveServicePeriodes_E1.find{it.service.id == serviceParent.id}
+ resultatEleveServicePeriodes_E1.find{it.service.id == serviceParent.id}
//la liste resultatEleveServicePeriodes attaché à l'eleve2
List<ResultatEleveServicePeriode> resultatEleveServicePeriodes_E2 =
- syntheseEleve2.resultatEleveServicePeriodes
+ syntheseEleve2.resultatEleveServicePeriodes
//le resultatEleveServiceNormal qui est attaché à l'eleve2 et le service normal
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode_E2 =
- resultatEleveServicePeriodes_E2.find{it.service.id == serviceNormal.id}
+ resultatEleveServicePeriodes_E2.find{it.service.id == serviceNormal.id}
//le resultatEleveServiceNormal qui est attaché à l'eleve1 et le serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode_E2 =
- resultatEleveServicePeriodes_E2.find{it.service.id == serviceParent.id}
+ resultatEleveServicePeriodes_E2.find{it.service.id == serviceParent.id}
//verifer que le resultatEleveServicePeriode ,attaché à l'eleve1 et serviceNormal ,est bien recuperé dans syntheseEleve1
//recuperer la liste resultatClasseServicePeriodes de syntheseClasse
List<ResultatClasseServicePeriode> resultatClasseServicePeriodes =
- syntheseClasse.resultatClasseServicePeriodes
+ syntheseClasse.resultatClasseServicePeriodes
//le resultatClasseServiceNormalPeriode attaché au service normal
ResultatClasseServicePeriode resultatClasseServiceNormalPeriode1 =
- resultatClasseServicePeriodes.find{it.service.id == serviceNormal.id}
+ resultatClasseServicePeriodes.find{it.service.id == serviceNormal.id}
//le resultatClasseServiceParentPeriode attaché au service Parent
ResultatClasseServicePeriode resultatClasseServiceParentPeriode1 =
- resultatClasseServicePeriodes.find{it.service.id == serviceParent.id}
+ resultatClasseServicePeriodes.find{it.service.id == serviceParent.id}
//verifier que le resultatClasseServicePeriode attaché au serviceNormal est bien recuperée dans syntheseClasse
assertEquals("Le resultatClasseServicePeriode attaché au serviceNormal n'est pas correct",
// Teste la remonté des résultats des périodes précédentes
synthese = syntheseService.construisSynthese(
classe,
- periodeT3)
+ periodeT3,
+ false,
+ false)
List<ResultatClassePeriode> resultatClasseXmestrePrecedents =
- synthese.syntheseClasse.resultatClasseXmestrePrecedents
+ synthese.syntheseClasse.resultatClasseXmestrePrecedents
assertTrue(
"Les résultats de classe des xmestres précédentes ne contiennent pas ceux des périodes T1 et T2" ,
syntheseEleve1 = synthese.syntheseEleves.find {it.eleve.id == eleve1.id}
List<ResultatElevePeriode> resultatEleveXmestrePrecedents =
- syntheseEleve1.resultatEleveXmestrePrecedents
+ syntheseEleve1.resultatEleveXmestrePrecedents
assertTrue(
"Les résultats de l'élève 1 des xmestres précédentes ne contiennent pas ceux des périodes T1 et T2" ,
* @author mjao
*/
private ResultatClasseServicePeriode getResultatClasseServicePeriode(
- Periode periode,
- Service service,
- StructureEnseignement classe){
+ Periode periode,
+ Service service,
+ StructureEnseignement classe){
def criteria = ResultatClasseServicePeriode.createCriteria()
ResultatClasseServicePeriode resultatClasseServicePeriode = criteria.get {
and {
* @author mjao
*/
private ResultatEleveServicePeriode getResultatEleveServicePeriode(
- Periode periode,
- Service service,
- Autorite eleve) {
+ Periode periode,
+ Service service,
+ Autorite eleve) {
def criteria = ResultatEleveServicePeriode.createCriteria()
ResultatEleveServicePeriode resultatEleveServicePeriode = criteria.get {
and {