import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.scolarite.PeriodeService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class JsonFicheEleveController extends AbstractEliotController {
FicheEleveAbsencesCalendrierService ficheEleveAbsencesCalendrierService
LocalPersonneService localPersonneService
PeriodeService periodeService
+ LocalClasseService localClasseService
/**
* Retourne la fiche de l'élève.
}
+
+
def construisInfoBulletin = {
Map result = tryCatch {
if (params.periodeId == null || params.periodeId == "") {
StructureEnseignement classeEleve =
- localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
+ localClasseService.findClasseForEleve(securiteSession, eleve)
periode = periodeService.findPeriodeByOrdre(classeEleve, 1)
import org.lilie.services.eliot.applications.absences.BasicCriteresRecherche
import org.lilie.services.eliot.applications.absences.StatAbsences
import org.lilie.services.eliot.applications.absences.AutoritePublipostageService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class BilanService {
MotifService motifService
PlageHoraireService plageHoraireService
AutoritePublipostageService autoritePublipostageService
+ LocalClasseService localClasseService
SessionFactory sessionFactory
) {
Personne personneEleve = localPersonneService.findPersonneByAutorite(eleve)
if (!classeEleve) {
- classeEleve = localStructureEnseignementService.
+ classeEleve = localClasseService.
findClasseForEleve(securiteSession, personneEleve)
}
PreferencesEtablissementAbsences pref = preferencesEtablissementAbsencesService.
import org.lilie.services.eliot.applications.absences.PriseEnCompteMotif
import org.lilie.services.eliot.parametrages.motifs.MotifService
import org.lilie.services.eliot.impression.ImpressionInfoGenerale
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* Cette classe a pour but de rechercher les données associées aux demandes d'impression
MotifService motifService
ImpressionRequetageSanctionPunitionService impressionRequetageSanctionPunitionService
ImpressionRetardDepartService impressionRetardDepartService
+ LocalClasseService localClasseService
private final static String CODE_MESSAGE_DEMI_PENSION = "Demi-pension"//message(code: 'absences.menu.publipostage.selection.heure.demi-pension')
private final static String CODE_MESSAGE_INTERNAT = "Internat" //message(code: 'absences.menu.publipostage.selection.heure.internat')
localStructureEnseignementService.findDerniereClasseQuitteeForEleve(eleve, etablissement)
} else {
structure =
- localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
+ localClasseService.findClasseForEleve(securiteSession, eleve)
}
if (!elevesParClasse[structure]) {
elevesParClasse[structure] = []
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.LocalResponsableService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* @author jtra
String url = getUrl(
applicationContext,
- localStructureEnseignementService,
evaluation,
eleve
)
* Si eleve est not null, on construit une url specifique pour cet eleve.
*/
private String getUrl(ApplicationContext applicationContext,
- LocalStructureEnseignementService localStructureEnseignementService,
Evaluation evaluation,
Personne eleve = null) {
Map<String, String> params = [:]
if (eleve) {
+ LocalClasseService localClasseService=
+ applicationContext.getBean('localClasseService')
+
StructureEnseignement classeEleve =
- localStructureEnseignementService.findClasseForEleve(eleve)
+ localClasseService.findClasseForEleve(eleve)
Periode periode = evaluation.periodes.find { it.classeId == classeEleve.id }
String url = getUrl(
applicationContext,
- localStructureEnseignementService,
evaluation,
(allEnfant.size()==1 ? allEnfant.first() : null)
)
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class FicheEleveCommentaireService {
static transactional = true
LocalStructureEnseignementService localStructureEnseignementService
+ LocalClasseService localClasseService
/**
* Enregistre un commentaire pour un élève.
// Sécurité : vérifie que l'utilisateur est un CPE ou un Directeur dans
// l'établissement de l'élève
- StructureEnseignement classe = localStructureEnseignementService.
+ StructureEnseignement classe = localClasseService.
findClasseForEleve(securiteSession, eleve)
securiteSession.verifieAccesFonctionnalite(
import org.lilie.services.eliot.absences.parametrage.general.GeneralService
import org.lilie.services.eliot.securite.EliotDroitsService
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class FicheEleveService {
FicheEleveAbsencesTableauService ficheEleveAbsencesTableauService
GeneralService generalService
EliotDroitsService eliotDroitsService
+ LocalClasseService localClasseService
/**
* Construit la fiche d'élève qui regroupe les infos personnelles d'un élève.
private StructureEnseignement getClasseCourante(SecuriteSession securiteSession,
Personne eleve) {
- StructureEnseignement classe = localStructureEnseignementService.
+ StructureEnseignement classe = localClasseService.
findClasseForEleve(securiteSession, eleve)
// Dans le cas d'un élève sans classe courante, on prend la dernière classe
* Si on specifie naturePeriode la recherche est faite seulement sur les
* periodes de cette nature.
*/
- FicheEleveClassesInfo findAllClassesFicheEleve(SecuriteSession securiteSession,
+ public FicheEleveClassesInfo findAllClassesFicheEleve(SecuriteSession securiteSession,
Personne eleve,
StructureEnseignement classeCourante) {
List<StructureEnseignement> classesEleve =
- localStructureEnseignementService.findAllClasseForEleve(
+ localClasseService.findAllClasseForEleve(
securiteSession,
eleve
)
--- /dev/null
+package org.lilie.services.eliot.scolarite.structureenseignement
+
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteHqlFactory
+import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
+import org.lilie.services.eliot.securite.Autorite
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+
+/**
+ * code issu du service LocalStructureEnseignementService et ne servant qu'à manipuler des classes
+ */
+class LocalClasseService {
+
+ AnneeScolaireService anneeScolaireService
+ LocalPersonneService localPersonneService
+
+ /**
+ * Retourne toutes les classes d'un élève (la classe actuelle et les classes anciennes)
+ * @param securiteSession la session de sécurité Eliot de l'utilisateur
+ * déclenchant l'action (pour transmettre le code porteur ENT)
+ * @param eleve Personne représentant l'élève
+ * @return une StructureEnseignement de type CLASSE
+ * @author bper
+ */
+ public List<StructureEnseignement> findAllClasseForEleve(SecuriteSession securiteSession,
+ Personne eleve) {
+
+ ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
+ proprietesScolarite: new ProprieteScolariteParam(),
+ script: {
+
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
+
+ listeFrom "PersonneProprietesScolarite pps"
+
+ listeWhere "pps.personne=?",
+ "pps.proprietesScolarite.structureEnseignement.type=?",
+ "pps.proprietesScolarite.anneeScolaire=?"
+ }
+ )
+
+ List<StructureEnseignement> lst = StructureEnseignement.executeQuery(
+ hqlFactory.hql(),
+ [
+ eleve,
+ StructureEnseignement.TYPE_CLASSE,
+ anneeScolaireService.anneeScolaireEnCours()
+ ]
+ )
+
+ return lst
+ }
+
+public List<StructureEnseignement> findAllClassesForEleve(Personne eleve) {
+
+ return (List<StructureEnseignement>) PersonneProprietesScolarite.createCriteria().listDistinct {
+
+ createAlias('personne', 'p')
+ createAlias('proprietesScolarite', 'ps')
+ createAlias('ps.structureEnseignement', 'se')
+
+ eq('p.id', eleve.id)
+ eq('se.type', StructureEnseignement.TYPE_CLASSE)
+
+ projections {
+ groupProperty('ps.structureEnseignement')
+ }
+ }
+ }
+
+ /**
+ * @return la première structure de type classe de l'élève
+ */
+ public StructureEnseignement findClasseForEleve(Personne eleve) {
+ String hql = """
+ select struct
+ from PersonneProprietesScolarite as pps
+ inner join pps.proprietesScolarite as ps
+ inner join ps.structureEnseignement as struct
+ where struct.type = :type
+ and struct.actif = :actif
+ and pps.estActive = :actif
+ and pps.personne = :eleve
+ order by struct.code
+"""
+ List<StructureEnseignement> structures = StructureEnseignement.executeQuery(hql, [
+ type: StructureEnseignement.TYPE_CLASSE,
+ actif: true,
+ eleve: eleve
+ ])
+ if (structures) {
+ return structures[0]
+ } else {
+ return null
+ }
+ }
+
+
+ /**
+ * Retourne la classe d'un élève
+ * @param securiteSession la session de sécurité Eliot de l'utilisateur
+ * déclenchant l'action (pour transmettre le code porteur ENT)
+ * @param eleve Personne représentant l'élève
+ * @return une StructureEnseignement de type CLASSE
+ */
+ public StructureEnseignement findClasseForEleve(SecuriteSession securiteSession,
+ Personne eleve) {
+
+ ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
+ proprietesScolarite: new ProprieteScolariteParam(),
+ script: {
+
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
+
+ listeFrom "PersonneProprietesScolarite pps"
+
+ listeWhere "pps.personne=?",
+ "pps.estActive=true",
+ "pps.proprietesScolarite.structureEnseignement.type=?"
+
+ }
+ )
+
+ List<StructureEnseignement> lst = StructureEnseignement.executeQuery(
+ hqlFactory.hql(),
+ [eleve, StructureEnseignement.TYPE_CLASSE]
+ )
+
+ if (lst.size() > 0) {
+ return lst[0]
+ } else {
+ return null
+ }
+ }
+
+ /**
+ * Retourne la classe d'un élève
+ * @param securiteSession la session de sécurité Eliot de l'utilisateur
+ * déclenchant l'action (pour transmettre le code porteur ENT)
+ * @param eleve Autorité représentant l'élève
+ * @return une StructureEnseignement de type CLASSE
+ */
+ public StructureEnseignement findClasseForEleve(SecuriteSession securiteSession,
+ Autorite eleve) {
+ return findClasseForEleve(securiteSession,
+ localPersonneService.findPersonneByAutorite(eleve))
+ }
+
+}
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBord
import org.lilie.services.eliot.absences.statistiques.tableaudebord.TableauDeBordParams
-import org.lilie.services.eliot.impression.constantes.TemplateTypeFonctionnaliteEnum
-import org.lilie.services.eliot.impression.constantes.TypeMedia
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.AnneeScolaire
-import org.lilie.services.eliot.temps.DateUtil
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.securite.Autorite
import org.lilie.services.eliot.annuaire.TypeStructureEnum
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.PeriodeService
-import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.annuaire.FonctionEnum
* Retourne toutes les structures d'enseignements d'un établissement
* pour une matière donnée
*/
- List<StructureEnseignement> findStructuresEnseignementByMatiereAndEtablissement(
+ public List<StructureEnseignement> findStructuresEnseignementByMatiereAndEtablissement(
Matiere matiere,
Etablissement etablissement
) {
return structureEnseignements
}
- /**
- * Teste le lien Classe / Sous-groupe entre deux structures d'enseignements
- * @param groupe : le sous-groupe
- * @param classe : la classe
- * @return <code>true</code> si groupe est un sous-groupe de classe,
- * <code>false</code> sinon
- * @throws IllegalArgumentException si groupe n'est pas de type 'groupe' ou
- * si classe n'est pas de type 'classe'
- */
- Boolean isSousGroupeExclusivementDe(StructureEnseignement groupe,
- StructureEnseignement classe)
- throws IllegalArgumentException {
- if (!groupe.type == StructureEnseignement.TYPE_GROUPE) {
- throw new IllegalArgumentException(
- "La structure d'enseignement $groupe n'est pas de type 'groupe'."
- )
- }
-
- if (!classe.type == StructureEnseignement.TYPE_CLASSE) {
- throw new IllegalArgumentException(
- "La structure d'enseignement $classe n'est pas de type 'classe'."
- )
- }
-
- List<StructureEnseignement> liste = StructureEnseignement.withCriteria {
- createAlias('groupes', 'g')
- eq('g.id', groupe.id)
- }
-
- return (liste?.size() == 1) && (liste.get(0).id == classe.id)
- }
-
/**
* Retrouve la liste des classes d'un établissement
* @param etablissement : l'établissement sur lesquel porte la recherche
}
}
-/**
- * Retourne la classe d'un élève
- * @param securiteSession la session de sécurité Eliot de l'utilisateur
- * déclenchant l'action (pour transmettre le code porteur ENT)
- * @param eleve Personne représentant l'élève
- * @return une StructureEnseignement de type CLASSE
- */
- StructureEnseignement findClasseForEleve(SecuriteSession securiteSession,
- Personne eleve) {
-
- ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(),
- script: {
-
- listeSelect "pps.proprietesScolarite.structureEnseignement"
-
- listeFrom "PersonneProprietesScolarite pps"
-
- listeWhere "pps.personne=?",
- "pps.estActive=true",
- "pps.proprietesScolarite.structureEnseignement.type=?"
-
- }
- )
-
- List<StructureEnseignement> lst = StructureEnseignement.executeQuery(
- hqlFactory.hql(),
- [eleve, StructureEnseignement.TYPE_CLASSE]
- )
-
- if (lst.size() > 0) {
- return lst[0]
- } else {
- return null
- }
- }
-
- /**
- * Retourne toutes les classes d'un élève (la classe actuelle et les classes anciennes)
- * @param securiteSession la session de sécurité Eliot de l'utilisateur
- * déclenchant l'action (pour transmettre le code porteur ENT)
- * @param eleve Personne représentant l'élève
- * @return une StructureEnseignement de type CLASSE
- * @author bper
- */
- List<StructureEnseignement> findAllClasseForEleve(SecuriteSession securiteSession,
- Personne eleve) {
-
- ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(),
- script: {
-
- listeSelect "pps.proprietesScolarite.structureEnseignement"
-
- listeFrom "PersonneProprietesScolarite pps"
-
- listeWhere "pps.personne=?",
- "pps.proprietesScolarite.structureEnseignement.type=?",
- "pps.proprietesScolarite.anneeScolaire=?"
- }
- )
-
- List<StructureEnseignement> lst = StructureEnseignement.executeQuery(
- hqlFactory.hql(),
- [
- eleve,
- StructureEnseignement.TYPE_CLASSE,
- anneeScolaireService.anneeScolaireEnCours()
- ]
- )
-
- return lst
- }
-
- List<StructureEnseignement> findAllClassesForEleve(Personne eleve) {
- return (List<StructureEnseignement>) PersonneProprietesScolarite.createCriteria().listDistinct {
-
- createAlias('personne', 'p')
- createAlias('proprietesScolarite', 'ps')
- createAlias('ps.structureEnseignement', 'se')
-
- eq('p.id', eleve.id)
- eq('se.type', StructureEnseignement.TYPE_CLASSE)
-
- projections {
- groupProperty('ps.structureEnseignement')
- }
- }
- }
-
- /**
- * @return la première structure de type classe de l'élève
- */
- public StructureEnseignement findClasseForEleve(Personne eleve) {
- String hql = """
- select struct
- from PersonneProprietesScolarite as pps
- inner join pps.proprietesScolarite as ps
- inner join ps.structureEnseignement as struct
- where struct.type = :type
- and struct.actif = :actif
- and pps.estActive = :actif
- and pps.personne = :eleve
- order by struct.code
-"""
- List<StructureEnseignement> structures = StructureEnseignement.executeQuery(hql, [
- type: StructureEnseignement.TYPE_CLASSE,
- actif: true,
- eleve: eleve
- ])
- if (structures) {
- return structures[0]
- } else {
- return null
- }
- }
-
-/**
- * Retourne la classe d'un élève
- * @param securiteSession la session de sécurité Eliot de l'utilisateur
- * déclenchant l'action (pour transmettre le code porteur ENT)
- * @param eleve Autorité représentant l'élève
- * @return une StructureEnseignement de type CLASSE
- */
- StructureEnseignement findClasseForEleve(SecuriteSession securiteSession,
- Autorite eleve) {
- return findClasseForEleve(securiteSession,
- localPersonneService.findPersonneByAutorite(eleve))
- }
-
/**
* Teste si un élève appartient à une structure d'enseignement
* @param securiteSession la session de sécurité de l'utilisateur déclenchant
* Retourne une map associant une liste de personne élèves avec leur classe
* @return une map associant une liste de personne élèves avec leur classe
*/
- Map<Personne, StructureEnseignement> findAllClassesForAllEleves(Set<Personne> eleves,
+ public Map<Personne, StructureEnseignement> findAllClassesForAllEleves(Set<Personne> eleves,
String query = null,
AnneeScolaire anneeScolaire = null) {
if (!anneeScolaire) {
* d'élèves
* @return une liste de classes concernent la liste de élèves demandée
*/
- List<StructureEnseignement> findAllClassesForAllEleves(List<Personne> eleves,
+ public List<StructureEnseignement> findAllClassesForAllEleves(List<Personne> eleves,
AnneeScolaire anneeScolaire = null) {
List<StructureEnseignement> classes = []
Map datas = (Map) findAllClassesForAllEleves(eleves as Set,
import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
import org.lilie.services.eliot.scolarite.PreferencesEtablissement
import org.lilie.services.eliot.absences.PreferencesEtablissementAbsences
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class EliotDroitsService {
@SuppressWarnings('GrailsStatelessService')
GrailsApplication grailsApplication
LocalStructureEnseignementService localStructureEnseignementService
+ LocalClasseService localClasseService
void verifieDroitFonctionnalite(SecuriteSession securiteSession,
Personne eleve) {
return isObjetDansPerimetre(securiteSession, PerimetreEleve, eleve) ||
- localStructureEnseignementService.findAllClassesForEleve(eleve).
+ localClasseService.findAllClassesForEleve(eleve).
any {hasDroitAccesClasseEntiere(securiteSession, it)}
}
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.constantes.ConstFonct
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class FicheEleveServiceTests extends GrailsUnitTestCase {
)
}
+ LocalClasseService localClasseService
def testFindAllClassesFicheEleve() {
)
List<StructureEnseignement> classesEleve =
- localStructureEnseignementService.findAllClasseForEleve(
+ localClasseService.findAllClasseForEleve(
securiteSession,
eleve
)
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.constantes.ConstFonct
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* Tests : LocalStructureEnseignementService
ServiceService serviceService
StructureEnseignementNotesService structureEnseignementNotesService
LocalResponsableService localResponsableService
+ LocalClasseService localClasseService
Etablissement etablissement1
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
void testFindAllClasseForEleve() {
- List liste1 = localStructureEnseignementService.findAllClasseForEleve(
+ List liste1 = localClasseService.findAllClasseForEleve(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
)
)
}
+ LocalClasseService localClasseService
+
+
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
void testFindClasseForElevePersonne() {
- StructureEnseignement structure1 = localStructureEnseignementService.
+ StructureEnseignement structure1 = localClasseService.
findClasseForEleve(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
structure1.id
)
- StructureEnseignement structure2 = localStructureEnseignementService.
+ StructureEnseignement structure2 = localClasseService.
findClasseForEleve(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
void testFindClasseForEleveAutorite() {
- StructureEnseignement structure1 = localStructureEnseignementService.
+ StructureEnseignement structure1 = localClasseService.
findClasseForEleve(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_1_CLASSE_1)
structure1.id
)
- StructureEnseignement structure2 = localStructureEnseignementService.
+ StructureEnseignement structure2 = localClasseService.
findClasseForEleve(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
void testIsSousGroupeExclusivementDe() {
assertTrue(
"GROUPE_1_8 est bien un sous-groupe exclusivement de CLASSE_1",
- localStructureEnseignementService.isSousGroupeExclusivementDe(
+ isSousGroupeExclusivementDe(
localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_8
),
assertFalse(
"GROUPE_1_4 n'est pas un sous-groupe exclusivement de CLASSE_1_2",
- localStructureEnseignementService.isSousGroupeExclusivementDe(
+ isSousGroupeExclusivementDe(
localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_4
),
assertFalse(
"GROUPE_1_4 n'est pas un sous-groupe de CLASSE_1 du tout",
- localStructureEnseignementService.isSousGroupeExclusivementDe(
+ isSousGroupeExclusivementDe(
localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_4
),
}
}
+ /**
+ * Teste le lien Classe / Sous-groupe entre deux structures d'enseignements
+ * @param groupe : le sous-groupe
+ * @param classe : la classe
+ * @return <code>true</code> si groupe est un sous-groupe de classe,
+ * <code>false</code> sinon
+ * @throws IllegalArgumentException si groupe n'est pas de type 'groupe' ou
+ * si classe n'est pas de type 'classe'
+ */
+ private Boolean isSousGroupeExclusivementDe(StructureEnseignement groupe,
+ StructureEnseignement classe)
+ throws IllegalArgumentException {
+ if (!groupe.type == StructureEnseignement.TYPE_GROUPE) {
+ throw new IllegalArgumentException(
+ "La structure d'enseignement $groupe n'est pas de type 'groupe'."
+ )
+ }
+
+ if (!classe.type == StructureEnseignement.TYPE_CLASSE) {
+ throw new IllegalArgumentException(
+ "La structure d'enseignement $classe n'est pas de type 'classe'."
+ )
+ }
+
+ List<StructureEnseignement> liste = StructureEnseignement.withCriteria {
+ createAlias('groupes', 'g')
+ eq('g.id', groupe.id)
+ }
+
+ return (liste?.size() == 1) && (liste.get(0).id == classe.id)
+ }
+
+
}
import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.junit.Ignore
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class StructureEnseignementServiceTests extends grails.test.GrailsUnitTestCase {
}
+ LocalClasseService localClasseService
+
/**
* La classe de l'élève 1 doit être la classe 1
*/
SecuriteSession securiteSession = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
Personne eleve = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
- StructureEnseignement rep = localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
+ StructureEnseignement rep = localClasseService.findClasseForEleve(securiteSession, eleve)
println rep.nomAffichage
assertEquals(
void testIsEleveDansStructureEnseignement() {
SecuriteSession securiteSession = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
Personne eleve = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
- StructureEnseignement rep = localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
+ StructureEnseignement rep = localClasseService.findClasseForEleve(securiteSession, eleve)
assertTrue "L'élève doit être dans la classe 1", localStructureEnseignementService.isEleveDansStructureEnseignement(
eleve,
PreferencesEtablissementAbsences preferences =
getPreferencesEtablissementCourant()
- Calendrier calendrier =
- calendrierService.getCalendrierForEtablissement(preferences.etablissement)
Locale locale = RCU.getLocale(request)
- modele.anneeScolaire = [
- debutAnneeScolaire: formateDate(calendrier.premierJour),
- finAnneeScolaire: formateDate(calendrier.dernierJour)
- ] as JSON
+ modele = marshallCalendrier(preferences, modele)
+
modele.isModeModification = true
modele.dataTypesPunition = getAllTypesPunition() as JSON
modele.dataMotifs = getAllMotifs(true) as JSON
import org.lilie.services.eliot.notification.absences.AbsenceSansMotifNotification
import org.lilie.services.eliot.absences.Appel
import org.lilie.services.eliot.absences.PlageHoraire
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class AbsenceService {
LocalPersonneService localPersonneService
LocalStructureEnseignementService localStructureEnseignementService
DemandeNotificationService demandeNotificationService
+ LocalClasseService localClasseService
/**
* Fait le save sur l'AppelLigne est gère les notifications
structureEnseignement = appelLigne.appel.evenement.agendaMaitre.
structureEnseignement
} else {
- structureEnseignement = localStructureEnseignementService.
+ structureEnseignement = localClasseService.
findClasseForEleve(eleve)
}
structureEnseignement
import org.lilie.services.eliot.temps.Evenement
import org.lilie.services.eliot.scolarite.etablissement.PreferencesEtablissementAbsencesService
import org.lilie.services.eliot.absences.saisie.AbsenceService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
class DemiPensionInternatService extends AbsenceService {
StructureEnseignement structureEnseignement = null // anti N+1 select
if(params.lignes) { // même structureEnseignement pour tous les élèves
structureEnseignement =
- localStructureEnseignementService.findClasseForEleve(
+ localClasseService.findClasseForEleve(
params.lignes.first().eleve
)
}
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
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* Récupération d'informations pour le publipostage des notes
ImpressionBulletinOptionsService impressionBulletinOptionsService
LocalPersonneService localPersonneService
ReleveOptionsService releveOptionsService
+ LocalClasseService localClasseService
+
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
* Crée les infos sur les notes d'un élève
* @author bper
*/
- TableauImpressionInfo creeDonneesTableau(SecuriteSession securiteSession,
+ private TableauImpressionInfo creeDonneesTableau(SecuriteSession securiteSession,
EleveImpressionInfo eleveImpressionInfo,
TypePeriode typePeriode,
Periode periode,
Personne eleve = eleveImpressionInfo.personne
StructureEnseignement classe =
- localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
+ localClasseService.findClasseForEleve(securiteSession, eleve)
// Si la période est spécifiée on vérifie que l'élève est ou était dans
// la classe de la période.
import org.lilie.services.eliot.notes.NotesDroitService
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.securite.perimetre.PerimetreEleve
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* @author bper
NotesDroitService notesDroitService
LocalStructureEnseignementService localStructureEnseignementService
EleveAnnuaireService eleveAnnuaireService
+ LocalClasseService localClasseService
static transactional = true
enfants.each {Personne enfant ->
List<StructureEnseignement> classesEnfant =
- localStructureEnseignementService.findAllClassesForEleve(enfant)
+ localClasseService.findAllClassesForEleve(enfant)
if (classesEnfant.any{it.id == classe.id}) {
eleves << enfant
}
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.textes.TypeActivite
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* Tests de NotesEvaluationService
LocalPersonneService localPersonneService
AnneeScolaireService anneeScolaireService
StructureEnseignementNotesService structureEnseignementNotesService
+ LocalClasseService localClasseService
def sessionFactory
//creer les dates
getAutorite(PopulationTestActeur.ELEVE_4_CLASSE_2)
classe1enTrimestres =
- localStructureEnseignementService.findClasseForEleve(
+ localClasseService.findClasseForEleve(
securiteSessionDirection,
localPersonneService.findPersonneByAutorite(eleve1classe1)
)
// Récupération de la structure CLASSE_2 Etab 1
classe2enTrimestres =
- localStructureEnseignementService.findClasseForEleve(
+ localClasseService.findClasseForEleve(
securiteSessionDirection,
localPersonneService.findPersonneByAutorite(eleve4classe2)
)
import org.lilie.services.eliot.utils.NoteFormateur
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.notes.avis.AvisService
-import org.lilie.services.eliot.notes.notes.EtablissementNotesService
import org.lilie.services.eliot.textes.TypeActivite
import org.lilie.services.eliot.impression.TemplateDocument
import org.lilie.services.eliot.impression.constantes.TemplateDocumentEnum
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalClasseService
/**
* tests:NotesImpressionServiceTests.
InfoCalculMoyennesClasseService infoCalculMoyennesClasseService
LocalStructureEnseignementService localStructureEnseignementService
AvisService avisService
- EtablissementNotesService etablissementNotesService
+ LocalClasseService localClasseService
StructureEnseignementNotesService structureEnseignementNotesService
Etablissement etablissement1 = null
templateDocument)
StructureEnseignement classe =
- localStructureEnseignementService.findClasseForEleve(
+ localClasseService.findClasseForEleve(
securiteSessionDicerteur,
eleve1)
NoteFormateur nf = classe.etablissement.etablissementNotes.getNoteFormateur()