Long aafImportId
Long udtImportId
Date dateDesactivation
- Date dateDebut
+ Date dateDebut = new Date()
Date dateFin
OrigineEnum origine = OrigineEnum.AUTO
/**
* Libellé de service/nseignement pour l'affichage
- * @return
*/
String getLibelle() {
return "${structureEnseignement.nomAffichage}-${matiere.codeGestion}"
/**
* Année scolaire du service
- * @return AnneeScolaire
* @author bper
*/
AnneeScolaire getAnneeScolaire() {
/**
* Retourne la liste des périodes rattachée au service
- * @return List < Periode >
* @author bper
*/
List<Periode> getPeriodes() {
/**
* Coeff du service pour une période données
- * @param periode
- * @return
* @author msan
*/
BigDecimal getCoeffPourPeriode(Periode periode) {
/**
* Evaluabilité du service pour une période données
- * @param periode
* @return true si le service est evaluable pour la période donnée, sinon false
* @author msan
*/
/**
* Evaluabilité du service pour un type de période
- * @param typePeriode
* @return true si le service est evaluable au moins pour une des périodes
* du type donné, sinon false
* @author bper
/**
* Service optionel
- * @param periode
* @return true si le service est optionnel pour la période donnée, sinon false
* @author bper
*/
/**
* Retourne les sous-services pour un type de période
- * @param typePeriode
- * @return List<SousService>
* @author bper
*/
List<SousService> getSousServices(TypePeriode typePeriode) {
return this.sousServices?.findAll{
it.typePeriode.id == typePeriode.id
- }.toList()?.sort {it.ordre}
+ }?.toList()?.sort {it.ordre} ?: []
}
/**
- * Vérifie si le service a des sous-services pour un type de période.
- * @param typePeriode
- * @return true/false
+ * Vérifie si le service a des sous-services pour un type de période.
* @author bper
*/
Boolean hasSousServices(TypePeriode typePeriode) {
/**
* Retourne les sous-services pour une modalité de matière
- * @param typePeriode
- * @return List<SousService>
* @author bper
*/
List<SousService> getSousServices(ModaliteMatiere modaliteMatiere) {
return this.sousServices?.findAll{
it.modaliteMatiere.id == modaliteMatiere.id
- }.toList()?.sort {it.ordre}
+ }?.toList()?.sort {it.ordre} ?: []
}
/**
* Retourne le sous-service correspondant à un type de période et une modalité
* de matière.
- * @param typePeriode
- * @param modaliteMatiere
- * @return SousService
* @author bper
*/
SousService getSousService(TypePeriode typePeriode, ModaliteMatiere modaliteMatiere) {
- return this.sousServices.find {
+ return (SousService) this.sousServices?.find {
it.modaliteMatiere.id == modaliteMatiere.id &&
it.typePeriode.id == typePeriode.id
}
// Vérifie si l'élève est parmi les élèves de la classe
Boolean isEleveOfClasse = localStructureEnseignementService.
isEleveDansStructureEnseignement(
- null,
eleve,
classe)
boolean isEleveDansStructureEnseignement =
localStructureEnseignementService.isEleveDansStructureEnseignement(
- securiteSessionNotes,
destinataire,
structureEnseignement
)
* s'il n'en existe pas crée un nouveau PPS.\r
* @author bper\r
*/\r
- PersonneProprietesScolarite internalFindOrCreePPS(PersonneProprietesScolariteParam param) {\r
- return internalFindPPS(param) ?: internalCreePPS(param)\r
+ PersonneProprietesScolarite findOrCreePPS(PersonneProprietesScolariteParam param) {\r
+ return findPPS(param) ?: creePPS(param)\r
}\r
\r
/**\r
* Desactive tous les PPS correspondant aux paramètres donnés.\r
* @author bper\r
*/\r
- List<PersonneProprietesScolarite> internalDesactiveAllPPS(PersonneProprietesScolariteParam param) {\r
+ List<PersonneProprietesScolarite> desactiveAllPPS(PersonneProprietesScolariteParam param) {\r
\r
- List<PersonneProprietesScolarite> ppsList = internalFindAllPPS(param)\r
+ List<PersonneProprietesScolarite> ppsList = findAllPPS(param)\r
\r
ppsList.each {\r
it.estActive = false\r
* Retourne le premier PPS trouvé correspondant aux paramètres donnés.\r
* @author bper\r
*/\r
- PersonneProprietesScolarite internalFindPPS(PersonneProprietesScolariteParam param) {\r
- List<PersonneProprietesScolarite> ppsList = internalFindAllPPS(param)\r
+ PersonneProprietesScolarite findPPS(PersonneProprietesScolariteParam param) {\r
+ List<PersonneProprietesScolarite> ppsList = findAllPPS(param)\r
return ppsList.isEmpty() ? null : ppsList.first()\r
}\r
\r
* Retourne tous les PPS correspondants aux paramètres donnés.\r
* @author bper\r
*/\r
- List<PersonneProprietesScolarite> internalFindAllPPS(PersonneProprietesScolariteParam param) {\r
+ List<PersonneProprietesScolarite> findAllPPS(PersonneProprietesScolariteParam param) {\r
\r
List<ProprietesScolarite> psList =\r
- proprietesScolariteService.internalFindAllPS(param.proprietesScolariteParam)\r
+ proprietesScolariteService.findAllPS(param.proprietesScolariteParam)\r
\r
if (psList.isEmpty()) {\r
return []\r
* Crée un nouveau PPS à partir des paramètres donnés.\r
* @author bper\r
*/\r
- private PersonneProprietesScolarite internalCreePPS(PersonneProprietesScolariteParam param) {\r
+ private PersonneProprietesScolarite creePPS(PersonneProprietesScolariteParam param) {\r
\r
ProprietesScolarite ps =\r
- proprietesScolariteService.internalFindOrCreePS(param.proprietesScolariteParam)\r
+ proprietesScolariteService.findOrCreePS(param.proprietesScolariteParam)\r
\r
PersonneProprietesScolarite pps = new PersonneProprietesScolarite(\r
personne: param.personne,\r
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteHqlFactory
-import org.lilie.services.eliot.environnement.EnvironnementUtil
-import org.lilie.services.eliot.scolarite.AnneeScolaire
/**
* Fonctions de base sur les propriétés de scolarités
)
}
- /**
- * Cree un PS indiquant qu'une personne est un eleve dans une classe
- * @author msan
- */
- ProprietesScolarite creePSEleveDeClasse(StructureEnseignement classe,
- AnneeScolaire anneeScolaire) {
- if (!EnvironnementUtil.isEnvironmentDeveloppementOrTest()) {
- throw new IllegalStateException("Cette methode ne doit pas etre utilise en production")
- }
-
- return new ProprietesScolarite(
- structureEnseignement: classe,
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- anneeScolaire: anneeScolaire
- ).save(flush: true, failOnError: true)
- }
/**
* Retourne le premier PS trouvé correspondant aux paramètres donnés,
* s'il n'en exite pas crée un nouveau PS.
* @author bper
*/
- ProprietesScolarite internalFindOrCreePS(ProprietesScolariteParam param) {
- return internalFindPS(param) ?: internalCreePS(param)
+ ProprietesScolarite findOrCreePS(ProprietesScolariteParam param) {
+ return findPS(param) ?: creePS(param)
}
/**
* Retourne le premier PS trouvé correspondant aux paramètres donnés.
* @author bper
*/
- ProprietesScolarite internalFindPS(ProprietesScolariteParam param) {
- List<ProprietesScolarite> psList = internalFindAllPS(param)
+ ProprietesScolarite findPS(ProprietesScolariteParam param) {
+ List<ProprietesScolarite> psList = findAllPS(param)
return psList.isEmpty() ? null : psList.first()
}
* Retourne tous les PS trouvés correspondants aux paramètres donnés.
* @author bper
*/
- List<ProprietesScolarite> internalFindAllPS(ProprietesScolariteParam param) {
+ List<ProprietesScolarite> findAllPS(ProprietesScolariteParam param) {
return (List<ProprietesScolarite>) ProprietesScolarite.createCriteria().list {
eq('anneeScolaire', param.anneeScolaire)
eq('fonction', param.fonction)
- if (param.etablissement != null) {
- eq('etablissement', param.etablissement)
- }
-
if (param.structureEnseignement != null) {
eq('structureEnseignement', param.structureEnseignement)
+ } else if (param.etablissement != null) {
+ eq('etablissement', param.etablissement)
}
if (param.matiere != null) {
* Crée un nouveau PS à partir des paramètres donnés.
* @author bper
*/
- private ProprietesScolarite internalCreePS(ProprietesScolariteParam param) {
+ private ProprietesScolarite creePS(ProprietesScolariteParam param) {
ProprietesScolarite ps = new ProprietesScolarite(
etablissement: param.etablissement,
service.addToEnseignements(enseignement)
service.save(flush: true, failOnError: true)
- enseignantAnnuaireService.internalFindOrCreePPSForEnseignement(enseignement)
+ enseignantAnnuaireService.ajouteEnseignantDansAllGroupeParEnseignement(enseignement)
return enseignement
}
// mis à jour de la relation enseignant structure d'enseignement
// au niveau des PersonneProprietesScolarite
enseignantAnnuaireService.
- internalFindOrCreePPSForEnseignement(enseignement)
+ ajouteEnseignantDansAllGroupeParEnseignement(enseignement)
enseignementMisAjourRapport.enseignement = enseignement
if (!enseignement.isAttached()) {
enseignement = Enseignement.get(enseignement.id)
}
- enseignantAnnuaireService.internalDesactiveAllPPSByEnseignement(enseignement)
+ enseignantAnnuaireService.desactiveEnseignantDansAllGroupeByEnseignement(enseignement)
enseignement.delete()
}
}
import org.lilie.services.eliot.annuaire.FonctionEtablissement
import org.lilie.services.eliot.portail.TypeUtilisateur
import org.lilie.services.eliot.annuaire.impl.LocalFonctionEtablissement
-import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
static transactional = true
- ProprietesScolariteService proprietesScolariteService
CiteScolaireService citeScolaireService
private static final Boolean CITE_SCOLAIRE_DROITS_ETTENDUS =
ConfigurationHolder.config.eliot.citeScolaire.droits.etendus
+ private static final PPS_ETAB_ELEVE_MAPPING = """
+select distinct
+ pps,
+ se.etablissement
+from
+ PersonneProprietesScolarite pps
+ inner join pps.proprietesScolarite ps
+ inner join ps.structureEnseignement se
+where
+ pps in (:pps)
+"""
+
private static final HQL_FONCTION_ETAB = """
select distinct
- pps.proprietesScolarite.fonction,
- etab,
+ f,
+ coalesce(etab, se.etablissement),
re
from
- PersonneProprietesScolarite pps inner join pps.proprietesScolarite ps left join ps.etablissement etab,
- ResponsableEleve re right join re.personne p,
- Fonction f
+ ResponsableEleve re
+ right join re.personne p,
+ PersonneProprietesScolarite pps
+ inner join pps.proprietesScolarite ps
+ inner join ps.fonction f
+ left join ps.etablissement etab,
+ StructureEnseignement se
where
- p.autorite=:autorite and
- pps.personne=p and
- pps.estActive=true and
- pps.proprietesScolarite.fonction=f and
+ (ps.structureEnseignement is null or ps.structureEnseignement = se) and
+ pps.personne = p and
+ pps.personne.autorite = :autorite and
+ pps.estActive = true and
"""
private static final HQL_FONCTION_ETAB_POUR_ETAB =
- HQL_FONCTION_ETAB +
- "etab.id=:etabId"
+ HQL_FONCTION_ETAB + "(ps.etablissement.id = :etabId or se.etablissement.id = :etabId)"
private static final HQL_FONCTION_ETAB_POUR_ADMIN_LOCAL =
Boolean isPersonelEducation(Personne personne) {
return hasFonction(personne, FonctionEnum.EDUCATION)
}
-
+
/**
* Retrourne l'ensemble des fonctions établissements d'un utilisateur pour un établissement
* @param autorite
* @author bahj
*/
List<FonctionEtablissement> findAllFonctionEtablissementBy(Etablissement etablissement,
- Autorite autorite) {
+ Autorite autorite) {
List<FonctionEtablissement> fonctionEtablissements =
findAllFonctionEtablissement(
)
}
+ // Récupère les établissements liés au pps des enfants en une seul requête
+ Map resultMapping = [:]
+ if (pps.size() > 0) {
+ List result = PersonneProprietesScolarite.executeQuery(
+ PPS_ETAB_ELEVE_MAPPING,
+ [
+ pps: pps
+ ]
+ )
+ result.each {
+ resultMapping[(PersonneProprietesScolarite) it[0]] = (Etablissement) it[1]
+ }
+ }
+
+
pps.collect { PersonneProprietesScolarite personneProprietesScolarite ->
- Etablissement etabEleve =
- personneProprietesScolarite.proprietesScolarite.etablissement
+ Etablissement etabEleve = (Etablissement) resultMapping[personneProprietesScolarite]
return new LocalFonctionEtablissement(
etablissementId: etabEleve?.id,
import org.lilie.services.eliot.scolarite.structureenseignement.StructureEnseignementElevesListes
import org.lilie.services.eliot.annuaire.ResponsableEleve
import org.hibernate.FetchMode
-import org.lilie.services.eliot.environnement.EnvironnementUtil
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
-import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.notes.Note
-import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
-import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
/**
* Ce service fournis des informations concernant les élèves à partir de
List<Personne> findAllEleveByStructureEnseignement(StructureEnseignement structureEnseignement,
Boolean actif = true) {
- return (List<Personne>)PersonneProprietesScolarite.createCriteria().listDistinct{
+ return (List<Personne>) PersonneProprietesScolarite.createCriteria().listDistinct {
- proprietesScolarite{
+ proprietesScolarite {
eq('structureEnseignement', structureEnseignement)
- fonction{
+ fonction {
eq('code', FonctionEnum.ELEVE.getCode())
}
}
eq('estActive', actif)
eq('aut.estActive', actif)
} else {
- 'or'{
+ 'or' {
eq('estActive', actif)
eq('aut.estActive', actif)
}
order('p.nom')
order('p.prenom')
- projections{
+ projections {
property('personne')
}
}
*
*/
List<Personne> findAllEleveByService(SecuriteSession securiteSession,
- List<Long> serviceIds,
- Boolean actif = true) {
+ List<Long> serviceIds,
+ Boolean actif = true) {
List<Personne> eleves = []
Fonction fonctionEleve = Fonction.findByCode(
return eleves
}
-
/**
- * Recherche les élèves d'un établissement dont le nom comment par une chaine
- * donnée
- * @param debutNom
- * @param etab
+ * Recherche les élèves d'un établissement dont le nom comment par une chaine donnée
* @return une liste de Personne
*/
List<Personne> findAllPersonneEleveByDebutNomAndEtablissement(String debutNom,
/**
* Retourne les élèves d'un responsable
- * @param parent
* @return Liste des personnes eleve
* @author othe
*/
/**
* Retrouve les élèves d'un responsable dans un établissement
- * @param responsable
- * @param etablissement
- * @return une liste d'élèves
* @author othe
*/
public List<Personne> findAllEleveFromResponsableForEtablissement(Personne responsable,
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- etablissement: etablissement
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
),
select: ['pps.personne'],
from: [
- "PersonneProprietesScolarite pps inner join fetch pps.personne.autorite",
+ """PersonneProprietesScolarite pps inner join fetch pps.personne.autorite
+ inner join pps.proprietesScolarite.structureEnseignement se""",
"ResponsableEleve re"
],
"pps.estActive=true",
"re.personne=?",
"re.eleve=pps.personne",
- "re.estActive=true"
+ "re.estActive=true",
+ "se.etablissement=?"
// "re.estValidee=true" // Note jtra: contrainte relachée pour débloquer le publipostage
],
return (List<Personne>) StructureEnseignement.executeQuery(
hqlFactory.hql(),
- [responsable]
+ [responsable, etablissement]
)
}
/**
* Retrouve les élèves d'un responsable dans un établissement
- * @param responsable
- * @param structureEnseignement
- * @return une liste d'élèves
* @author jtra
*/
public List<Personne> findAllEleveFromResponsableForStructureEnseignement(Personne responsable,
/**
* Retourne les responsables d'un élève
- * @param eleve
* @return Liste des personnes responsables
* @author othe
*/
/**
* Vérifie si un élève est ou était dans une classe donnée
- * @param eleve
- * @param classe
- * @return
* @author msan
*/
public Boolean wasEleveDeClasse(Personne eleve, StructureEnseignement classe) {
return presence > 0
}
- /**
- * Ajoute un eleve dans une classe
- * @author msan
- */
- void ajouteEleveDansStructureEnseignement(Personne personne,
- StructureEnseignement classe,
- AnneeScolaire anneeScolaire = null) {
-
- if (!EnvironnementUtil.isEnvironmentDeveloppementOrTest()) {
- throw new IllegalStateException("Cette methode ne doit pas etre utilise en production")
- }
-
- if (anneeScolaire == null) {
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
- }
-
- // marque la personne comme eleve
- // mets la dans une classe
- ProprietesScolarite ps = proprietesScolariteService.creePSEleveDeClasse(
- classe,
- anneeScolaire
- )
- personneProprietesScolariteService.creePPS(personne, ps)
- }
-
- /**
- * Désactive un élève dans une classe. Méthode utilisée pour les tests.
- * @author bper
- */
- void desactiveEleveDansStructureEnseignement(Personne eleve,
- StructureEnseignement structure,
- AnneeScolaire anneeScolaire = null) {
-
- if (!EnvironnementUtil.isEnvironmentDeveloppementOrTest()) {
- throw new IllegalStateException("Cette methode ne doit pas etre utilise en production")
- }
-
- if (anneeScolaire == null) {
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
- }
-
- PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
- personne: eleve,
- proprietesScolariteParam: new ProprietesScolariteParam(
- structureEnseignement: structure,
- anneeScolaire: anneeScolaire,
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
- )
- )
-
- personneProprietesScolariteService.internalDesactiveAllPPS(param)
- }
/**
* Compte le nombre d'élève pour un établissement
- * @param etablissement
- * @param actif
- * @return
*/
- Integer countAllEleveByEtablissement(
- Etablissement etablissement,
- Boolean actif = true) {
+ Integer countAllEleveByEtablissement(Etablissement etablissement, Boolean actif = true) {
PersonneProprietesScolarite.createCriteria().count {
proprietesScolarite {
- eq('etablissement', etablissement)
- fonction {
- 'in'('code', FonctionEnum.ELEVE.code)
+ structureEnseignement {
+ eq('etablissement', etablissement)
}
- }
- if (actif != null) {
- eq('estActive', actif)
- }
- projections {
- distinct('personne')
- }
- }
-
- }
-
- /**
- * Compte le nombre d'élève pour une liste de classes
- * @param etablissement
- * @param niveau
- * @param actif
- * @return
- */
- Integer countAllEleveByAllClasse(
- Etablissement etablissement,
- List<StructureEnseignement> allClasses,
- Boolean actif = true) {
-
- if (!allClasses) {
- return 0
- }
- PersonneProprietesScolarite.createCriteria().count {
- proprietesScolarite {
- eq('etablissement', etablissement)
fonction {
'in'('code', FonctionEnum.ELEVE.code)
}
- 'in'('structureEnseignement', allClasses)
}
+
if (actif != null) {
eq('estActive', actif)
}
+
projections {
distinct('personne')
}
}
-
}
-
-
}
// pas par le même concept (Enseignement x ProprieteScolarite) on ne le fait pas
// TOREFACT : A remplacer par une seul méthode une fois les concepts Enseignement x ProprieteScolarite mergés
List<StructureEnseignement> classesPrincipal = localStructureEnseignementService.
- findAllClasseForProfesseurPrincipalForEtablissement(securiteSession,
+ findAllClasseForProfesseurPrincipalForEtablissement(
enseignant, etablissement)
structs.addAll(classesPrincipal)
structs.unique { it.id } // enléve les doublons
// Les groupes de l'élève
List<StructureEnseignement> groupes =
localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- securiteSession,
eleve
).findAll {it.isGroupe()}
origine: origine,
proprietesScolariteParam: new ProprietesScolariteParam(
structureEnseignement: structure,
- etablissement: structure.etablissement,
anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: true,
- porteurEnt: structure.etablissement.porteurEnt,
+ responsableStructureEnseignement: true
)
)
- return personneProprietesScolariteService.internalFindOrCreePPS(param)
+ return personneProprietesScolariteService.findOrCreePPS(param)
}
/**
responsableStructureEnseignement: isProfPrincipal
),
- where: ["pps.personne=?"]
+ where: ["pps.personne=?", "pps.estActive=true"]
)
List<Personne> lst = hqlFactory.listePersonne([prof])
* Crée un PPS correspondant à l'enseignement donné s'il n'en existe pas.
* @author bper
*/
- PersonneProprietesScolarite internalFindOrCreePPSForEnseignement(Enseignement enseignement) {
- PersonneProprietesScolariteParam param = initPPSParamFromEnseignement(enseignement)
- return personneProprietesScolariteService.internalFindOrCreePPS(param)
+ void ajouteEnseignantDansAllGroupeParEnseignement(Enseignement enseignement) {
+ ajouteEnseignantDansGroupeEnseignantStructure(enseignement)
+ ajouteEnseignantDansGroupeEnseignantMaitiereEtab(enseignement)
+ }
+
+ private void ajouteEnseignantDansGroupeEnseignantStructure(Enseignement enseignement) {
+ PersonneProprietesScolariteParam param = initPpsParamEnseignantDansStructure(enseignement)
+ personneProprietesScolariteService.findOrCreePPS(param)
+ }
+
+ private void ajouteEnseignantDansGroupeEnseignantMaitiereEtab(Enseignement enseignement) {
+ PersonneProprietesScolariteParam param = initPpsParamEnseignantMatiereDansEtab(enseignement)
+ personneProprietesScolariteService.findOrCreePPS(param)
}
/**
* Desactive tous les PPS correspondant à l'enseignement donné.
* @author bper
*/
- List<PersonneProprietesScolarite> internalDesactiveAllPPSByEnseignement(Enseignement enseignement) {
- PersonneProprietesScolariteParam param = initPPSParamFromEnseignement(enseignement)
- return personneProprietesScolariteService.internalDesactiveAllPPS(param)
+ void desactiveEnseignantDansAllGroupeByEnseignement(Enseignement enseignement) {
+ desactiveEnseignantDansGroupeEnseignantStructure(enseignement)
+ desactiveEnseignantDansGroupeEnseignantMaitiereEtab(enseignement)
+ }
+
+ private void desactiveEnseignantDansGroupeEnseignantStructure(Enseignement enseignement) {
+ if (!autreEnseignementAvecMemeEnseignantStructureExiste(enseignement)) {
+ PersonneProprietesScolariteParam param = initPpsParamEnseignantDansStructure(enseignement)
+ personneProprietesScolariteService.desactiveAllPPS(param)
+ }
+ }
+
+ private Boolean autreEnseignementAvecMemeEnseignantStructureExiste(Enseignement enseignement) {
+ Enseignement.createCriteria().count {
+ eq('enseignant', enseignement.enseignant)
+ service {
+ eq('structureEnseignement', enseignement.service.structureEnseignement)
+ }
+ ne('id', enseignement.id)
+ maxResults(1)
+ } as Boolean
+ }
+
+ private void desactiveEnseignantDansGroupeEnseignantMaitiereEtab(Enseignement enseignement) {
+ if (!autreEnseignementAvecMemeEnseignantMatiereEtabExiste(enseignement)) {
+ PersonneProprietesScolariteParam param = initPpsParamEnseignantMatiereDansEtab(enseignement)
+ personneProprietesScolariteService.desactiveAllPPS(param)
+ }
+ }
+
+ private Boolean autreEnseignementAvecMemeEnseignantMatiereEtabExiste(Enseignement enseignement) {
+ Enseignement.createCriteria().count {
+ eq('enseignant', enseignement.enseignant)
+ service {
+ structureEnseignement {
+ eq('etablissement', enseignement.service.structureEnseignement.etablissement)
+ }
+ eq('matiere', enseignement.service.matiere)
+ }
+ ne('id', enseignement.id)
+ maxResults(1)
+ } as Boolean
}
/**
* Instancie le DTO PersonneProprietesScolariteParam à partir de l'enseignement donné.
* @author bper
*/
- private PersonneProprietesScolariteParam initPPSParamFromEnseignement(Enseignement enseignement) {
+ private PersonneProprietesScolariteParam initPpsParamEnseignantDansStructure(Enseignement enseignement) {
Personne enseignant =
localPersonneService.findPersonneByAutorite(enseignement.enseignant)
personne: enseignant,
origine: enseignement.origine,
proprietesScolariteParam: new ProprietesScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
structureEnseignement: structure,
- etablissement: structure.etablissement,
anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- matiere: enseignement.service.matiere,
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: false,
- porteurEnt: structure.etablissement.porteurEnt,
- )
+ )
)
}
/**
- * Indique si la personne passée en paramètre est prof principal de la classe
- * @author othe
+ * Instancie le DTO PersonneProprietesScolariteParam à partir de l'enseignement donné.
+ * @author bper
*/
- Boolean isProfPrincipal(Personne prof,
- Etablissement etab,
- StructureEnseignement classe) {
+ private PersonneProprietesScolariteParam initPpsParamEnseignantMatiereDansEtab(Enseignement enseignement) {
+ Personne enseignant =
+ localPersonneService.findPersonneByAutorite(enseignement.enseignant)
- ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
+ StructureEnseignement structure = enseignement.service.structureEnseignement
- proprietesScolarite: new ProprieteScolariteParam(
- structureEnseignement: classe,
- etablissement: etab,
+ return new PersonneProprietesScolariteParam(
+ personne: enseignant,
+ origine: enseignement.origine,
+ proprietesScolariteParam: new ProprietesScolariteParam(
fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: true
- ),
-
- where: ["pps.personne=?", "pps.estActive=true"]
+ etablissement: structure.etablissement,
+ matiere: enseignement.service.matiere,
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ )
)
-
- List<Personne> lst = hqlFactory.listePersonne([prof])
-
- return (lst.size() > 0)
}
/**
/**
* Vérifie que l'utilisateur connecté est ou était l'élève de la classe
- * @param securiteSession
- * @param classe
- * @return true/false
* @author othe
*/
Boolean wasEnseignant(SecuriteSession securiteSession) {
/**
* Vérifie si un élève est ou était dans une classe donnée
- * @param eleve
- * @param classe
- * @return
* @author othe
*/
public Boolean wasEnseignant(Personne enseignant) {
pps.proprietesScolarite.structureEnseignement=:structureEnseignement
"""
- /**
- * Liste des structures d'enseignement par rapport à un porteur ENT (session), un élève
- * et un critère proprietesScolarite
- */
- private List<StructureEnseignement> findAllStructureEnseignementForPersonneEtProprieteScol(SecuriteSession securiteSession,
- Personne eleve,
- ProprieteScolariteParam proprietesScolarite) {
- ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: proprietesScolarite,
- distinct: true,
- script: {
-
- listeSelect "pps.proprietesScolarite.structureEnseignement"
-
- listeFrom "PersonneProprietesScolarite pps"
-
- listeWhere "pps.personne=?",
- "pps.estActive=true"
-
- }
- )
-
- return (List<StructureEnseignement>) StructureEnseignement.executeQuery(
- hqlFactory.hql(),
- [eleve]
- )
- }
-
public List<StructureEnseignement> findAllClasseForProfesseurPrincipal(Personne professeurPrincipal,
Etablissement etablissement) {
return (List<StructureEnseignement>) PersonneProprietesScolarite.createCriteria().list {
* l'action (pour transmettre le code porteur ENT)
* @return une liste de structure d'enseignement
*/
- List<StructureEnseignement> findAllStructureEnseignementForPersonne(SecuriteSession securiteSession,
- Personne personne) {
+ List<StructureEnseignement> findAllStructureEnseignementForPersonne(Personne personne) {
- return findAllStructureEnseignementForPersonneEtProprieteScol(
- securiteSession,
- personne,
- new ProprieteScolariteParam()
- )
+ return (List<StructureEnseignement>)PersonneProprietesScolarite.createCriteria().list{
+ eq('personne', personne)
+ eq('estActive', true)
+ 'proprietesScolarite'{
+ projections {
+ property('structureEnseignement')
+ }
+ }
+ }
}
/**
* Retourne la liste des structures d'enseignement où l'enseignant enseigne
*/
- List<StructureEnseignement> findAllStructureEnseignementForEnseignant(SecuriteSession securiteSession,
- Personne enseignant) {
-
- return findAllStructureEnseignementForPersonneEtProprieteScol(
- securiteSession,
- enseignant,
- new ProprieteScolariteParam(
- fonction: Fonction.getByCode(FonctionEnum.ENSEIGNANT)
- )
- )
+ List<StructureEnseignement> findAllStructureEnseignementForEnseignant(Personne enseignant) {
+
+ return (List<StructureEnseignement>)PersonneProprietesScolarite.createCriteria().list{
+ eq('personne', enseignant)
+ eq('estActive', true)
+ 'proprietesScolarite'{
+ eq('fonction', Fonction.getByCode(FonctionEnum.ENSEIGNANT))
+ projections {
+ property('structureEnseignement')
+ }
+ }
+ }
}
/**
* @return <code>true</code> si l'élève appartient à la structure,
* <code>false</code> sinon
*/
- boolean isEleveDansStructureEnseignement(SecuriteSession securiteSession,
- Personne eleve,
+ boolean isEleveDansStructureEnseignement(Personne eleve,
StructureEnseignement structureEnseignement) {
List<StructureEnseignement> rep =
- findAllStructureEnseignementForPersonneEtProprieteScol(
- securiteSession,
- eleve,
- new ProprieteScolariteParam(
- structureEnseignement: structureEnseignement
- )
- )
+ (List<StructureEnseignement>)PersonneProprietesScolarite.createCriteria().list{
+ eq('personne', eleve)
+ eq('estActive', true)
+ 'proprietesScolarite'{
+ eq('structureEnseignement', structureEnseignement)
+ projections {
+ property('structureEnseignement')
+ }
+ }
+ }
return (rep.size() > 0)
}
* Retourne la liste des classes dont le prof est prof principal
* @return la liste des classes
*/
- List<StructureEnseignement> findAllClasseForProfesseurPrincipal(SecuriteSession securiteSession,
- Personne prof) {
- return findAllStructureEnseignementForPersonneEtProprieteScol(
- securiteSession,
- prof,
- new ProprieteScolariteParam(
- // on veut les enseignants(doublon avec le fait que l'on
- // passe le prof en paramètre). Par contre comme la personne
- // n'est pas typé, on pourrait passer un élève par accident...
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- // qui sont responsables
- responsableStructureEnseignement: true
- )
- )
+ List<StructureEnseignement> findAllClasseForProfesseurPrincipal(Personne prof) {
+
+ return (List<StructureEnseignement>)PersonneProprietesScolarite.createCriteria().list{
+ eq('personne', prof)
+ eq('estActive', true)
+ 'proprietesScolarite'{
+ // on veut les enseignants(doublon avec le fait que l'on
+ // passe le prof en paramètre). Par contre comme la personne
+ // n'est pas typé, on pourrait passer un élève par accident...
+ eq('fonction', Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()))
+ // qui sont responsables
+ eq('responsableStructureEnseignement', true)
+ projections {
+ property('structureEnseignement')
+ }
+ }
+ }
}
/**
* un établissement donnée
* @return la liste des classes
*/
- List<StructureEnseignement> findAllClasseForProfesseurPrincipalForEtablissement(SecuriteSession securiteSession,
- Personne prof,
+ List<StructureEnseignement> findAllClasseForProfesseurPrincipalForEtablissement(Personne prof,
Etablissement etablissement) {
- return findAllStructureEnseignementForPersonneEtProprieteScol(
- securiteSession,
- prof,
- new ProprieteScolariteParam(
- // on cherche sur cet établissement
- etablissement: etablissement,
- // on veut les enseignants(doublon avec le fait que l'on
- // passe le prof en paramètre). Par contre comme la personne
- // n'est pas typé, on pourrait passer un élève par accident...
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- // qui sont responsables
- responsableStructureEnseignement: true
- )
- )
+
+ return (List<StructureEnseignement>)PersonneProprietesScolarite.createCriteria().list{
+ eq('personne', prof)
+ eq('estActive', true)
+ 'proprietesScolarite'{
+ // on cherche sur cet établissement
+ 'structureEnseignement'{
+ eq('etablissement', etablissement)
+ }
+ // on veut les enseignants(doublon avec le fait que l'on
+ // passe le prof en paramètre). Par contre comme la personne
+ // n'est pas typé, on pourrait passer un élève par accident...
+ eq('fonction', Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()))
+ // qui sont responsables
+ eq('responsableStructureEnseignement', true)
+ projections {
+ property('structureEnseignement')
+ }
+ }
+ }
}
/**
StructureEnseignement findDerniereClasseQuitteeForEleve(Personne eleve,
Etablissement etablissement) {
- return PersonneProprietesScolarite.createCriteria().get {
+ return (StructureEnseignement)PersonneProprietesScolarite.createCriteria().get {
eq('personne', eleve)
eq('estActive', false)
proprietesScolarite {
package org.lilie.services.eliot.test
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.annuaire.Mef
import org.lilie.services.eliot.annuaire.Niveau
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.Matiere
+
import org.lilie.services.eliot.notes.StructureEnseignementNotes
import org.lilie.services.eliot.scolarite.StructureEnseignementSts
+import org.lilie.services.eliot.environnement.EnvironnementUtil
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
+import org.lilie.services.eliot.scolarite.OrigineEnum
/**
* Classe utilitaire pour faciliter les tests d'intégration du nouvel annuaire
class ProprieteScolariteTestUtilService {
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ AnneeScolaireService anneeScolaireService
+ PersonneProprietesScolariteService personneProprietesScolariteService
private static final LIB_LONG = "Libellé long : "
private static final LIB_COURT = "lib court : "
* Inscription d'un élève dans une classe pour une matière, un niveau,
* une année, un établissement, etc...
*
- * @param eleve
- * @param etablissement nullable
- * @param classe nullable
- * @param anneeScolaire nullable
- * @param niveau nullable
- * @param matiere nullable
- * @param mef nullable
* @author othe
*/
- public void inscrireEleveClasse(Personne eleve,
- Etablissement etablissement,
- StructureEnseignement classe,
- AnneeScolaire anneeScolaire,
- Matiere matiere,
- Boolean delegue
- ) {
-
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
- etablissement: etablissement,
- structureEnseignement: classe,
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- matiere: matiere,
- anneeScolaire: anneeScolaire
+ public void ajouteEleveDansStructureEnseignement(Personne eleve,
+ StructureEnseignement structure,
+ Boolean delegue = null,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+ checkEnvironnement()
+
+ PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
+ personne: eleve,
+ origine: OrigineEnum.MANUEL,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ structureEnseignement: structure,
+ anneeScolaire: anneeScolaire,
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
+ responsableStructureEnseignement: delegue ?: null
+ )
)
- if (delegue != null) {
- proprietesScolarite.responsableStructureEnseignement = delegue
- }
+ personneProprietesScolariteService.findOrCreePPS(param)
+ }
+
+ /**
+ * Désactive un élève dans une classe. Méthode utilisée pour les tests.
+ * @author bper
+ */
+ void desactiveEleveDansStructureEnseignement(Personne eleve,
+ StructureEnseignement structure,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+ checkEnvironnement()
+
+ PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
+ personne: eleve,
+ origine: OrigineEnum.MANUEL,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ structureEnseignement: structure,
+ anneeScolaire: anneeScolaire,
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
+ )
+ )
- proprietesScolarite.save(flush: true, failOnError: true)
+ personneProprietesScolariteService.desactiveAllPPS(param)
+ }
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
- personne: eleve,
- proprietesScolarite: proprietesScolarite,
- estActive: true
- )
- personneProprietesScolarite.save(flush: true, failOnError: true)
+ void ajouteEnseignantDansStructureEnseignement(Personne enseignant,
+ StructureEnseignement structure,
+ Boolean isProfPrincipal = null,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+ checkEnvironnement()
+
+ PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
+ personne: enseignant,
+ origine: OrigineEnum.MANUEL,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ structureEnseignement: structure,
+ anneeScolaire: anneeScolaire,
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ responsableStructureEnseignement: isProfPrincipal ?: null
+ )
+ )
+
+ personneProprietesScolariteService.findOrCreePPS(param)
}
/**
* Création d'un niveau
- * @param code
- * @return
* @author othe
*/
public Niveau creeNiveau(String code) {
+ checkEnvironnement()
+
Niveau niveau = new Niveau()
niveau.libelleLong = LIB_LONG + code
niveau.libelleCourt = LIB_COURT + code
/**
* Création d'une mef
- * @param code
- * @param niveau
- * @return
* @author othe
*/
- public Mef creeMef(String code,
- Niveau niveau
- ) {
+ public Mef creeMef(String code, Niveau niveau) {
+ checkEnvironnement()
+
Mef mef = new Mef()
mef.code = code
mef.formation = "formation " + code
/**
* Création d'une classe pour l'établissement et pour l'année scolaire
- * @param code
- * @param etablissement
- * @param anneeScolaire
- * @return
*/
public StructureEnseignement creeClasse(String code,
Etablissement etablissement,
- AnneeScolaire anneeScolaire
- ) {
+ AnneeScolaire anneeScolaire) {
+
+ checkEnvironnement()
+
StructureEnseignement enseignement = new StructureEnseignement()
enseignement.code = code
enseignement.idExterne = -1
/**
* Création d'une classe pour l'établissement et pour l'année scolaire
- * @param populationTestClasse
- * @param anneeScolaire
- * @return une classe
*/
public StructureEnseignement creeClasse(PopulationTestClasse populationTestClasse,
- AnneeScolaire anneeScolaire
- ) {
+ AnneeScolaire anneeScolaire) {
+
+ checkEnvironnement()
+
Etablissement etablissement1 = localInitDonneesCommunesTestService.getEtablissement(
populationTestClasse.getEtablissement()
)
- return creeClasse(populationTestClasse.getCode(),
+
+ return creeClasse(
+ populationTestClasse.getCode(),
etablissement1,
- anneeScolaire)
+ anneeScolaire
+ )
}
+ private void checkEnvironnement() {
+ if (!EnvironnementUtil.isEnvironmentDeveloppementOrTest()) {
+ throw new IllegalStateException("Ce service ne doit être utilisé que pour les tests")
+ }
+ }
}
avis.save(flush: true, failOnError: true)
List<Avis> avisListe =
- avisService.findAllForEtablissement(etablissemen)
+ avisService.findAllForEtablissement(etablissement)
assertNotNull("La liste des avis est nulle", avisListe)
import org.lilie.services.eliot.notification.parametrage.NotificationPreferenceUtilisateurService
import org.lilie.services.eliot.notification.parametrage.PreferencePersonneEtablissement
+import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
+
class NotificationPreferenceUtilisateurServiceTests extends GrailsUnitTestCase {
NotificationPreferenceUtilisateurService notificationPreferenceUtilisateurService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ FonctionAnnuaireService fonctionAnnuaireService
Etablissement etablissement
SecuriteSession securiteSession
}
List<Fonction> fonctions =
- notificationPreferenceUtilisateurService.getAllFonction(
+ fonctionAnnuaireService.getAllFonction(
securiteSession,
etablissement
)
import org.lilie.services.eliot.test.SecuriteTestUtils
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.test.PopulationTestGroupe
-import org.lilie.services.eliot.test.PopulationTestEtablissement
+
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleve
import org.lilie.services.eliot.scolarite.personne.eleve.FicheEleveService
import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
-import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.junit.Ignore
import org.lilie.services.eliot.FicheEleveClassesInfo
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.notes.Note
import org.lilie.services.eliot.notes.Evaluation
import org.lilie.services.eliot.textes.TypeActivite
FicheEleveService ficheEleveService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
- ProprieteScolariteTestUtilService ProprieteScolariteTestUtilService
- AnneeScolaireService anneeScolaireService
- EleveAnnuaireService eleveAnnuaireService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
PeriodeService periodeService
LocalStructureEnseignementService localStructureEnseignementService
StructureEnseignement groupe = localInitDonneesCommunesTestService.
getGroupe(PopulationTestGroupe.GROUPE_1)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve,
- localInitDonneesCommunesTestService.
- getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1),
- groupe,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- false
- )
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, groupe)
SecuriteSession securiteSessionDirecteur =
localInitDonneesCommunesTestService.getSecuriteSession(
// Si l'eleve n'est pas present dans la classe courante, il faut l'y ajouter
if (!classesEleve.find { it.id == classeCourante.id }) {
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classeCourante)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classeCourante)
creeNote(eleve, (Periode) classeCourante.getXmestres().first())
}
)
periodeService.creePeriodesNotationPourStructureEnseignement(classe3)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe2)
- eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve, classe2)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe2)
+ proprieteScolariteTestUtilService.desactiveEleveDansStructureEnseignement(eleve, classe2)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe3)
- eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve, classe3)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe3)
+ proprieteScolariteTestUtilService.desactiveEleveDansStructureEnseignement(eleve, classe3)
FicheEleveClassesInfo ficheEleveClassesInfo =
ficheEleveService.findAllClassesFicheEleve(
assertFalse "Ce responsable d'élève n'est pas prof principal",
enseignantAnnuaireService.isProfPrincipal(
responsable,
- etab,
classe
)
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.scolarite
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.annuaire.ProprietesScolarite
-import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.test.PopulationTestGroupe
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.annuaire.Niveau
import org.junit.Ignore
-import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
import org.lilie.services.eliot.notes.StructureEnseignementNotes
StructureEnseignementNotesService structureEnseignementNotesService
Etablissement etablissement1
- AnneeScolaire anneeScolaire
StructureEnseignement classe1enTrimestres = null
StructureEnseignement classe2enTrimestres = null
StructureEnseignement classe3enTrimestres = null
- PersonneProprietesScolarite ppsE1 = null
- PersonneProprietesScolarite ppsE2 = null
- PersonneProprietesScolarite ppsE3 = null
-
Personne eleve1 = null
Personne eleve2 = null
Personne eleve3 = null
PopulationTestEtablissement.ETABLISSEMENT_1
)
- //anneescolaire
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
-
//creer des structuresEnseignements de type classe
classe1enTrimestres = creeClasse("1ndTest", "12222275000000")
classe2enTrimestres = creeClasse("2ndTest", "12578275000000")
classe3enTrimestres = creeClasse("3ndTest", "8578275000000")
- //creer des personne de type eleve et les ajouter dans les classes
- ProprietesScolarite propretesScolarite = creeProprietesScolarite()
-
+ //creer des personnes de type eleve et les ajouter dans les classes
eleve1 = creePersonne("111100098720000010")
- ppsE1 = creePersonneProprietesScolarite(
- eleve1,
- propretesScolarite
- )
-
eleve2 = creePersonne("11110147800011")
- ppsE2 = creePersonneProprietesScolarite(
- eleve2,
- propretesScolarite
- )
-
eleve3 = creePersonne("111101478000110008")
- ppsE3 = creePersonneProprietesScolarite(
- eleve3,
- propretesScolarite
- )
// Inscription de chaque eleve i dans chaque classe i
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- true
+ classe1enTrimestres
)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- classe2enTrimestres,
- anneeScolaire,
- null,
- true
+ classe2enTrimestres
)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve3,
- etablissement1,
- classe3enTrimestres,
- anneeScolaire,
- null,
- true
+ classe3enTrimestres
)
-
}
protected void tearDown() {
void testFindAllPersonneEleveAndClasseForAllClasses() {
-
- List<StructureEnseignement> classes = [classe1enTrimestres,
+ List<StructureEnseignement> classes = [
+ classe1enTrimestres,
classe2enTrimestres,
- classe3enTrimestres]
+ classe3enTrimestres
+ ]
List<List> listPersonneClasse = localStructureEnseignementService.
findAllPersonneEleveAndClasseForAllClasses(classes)
assertNotNull("La listPersonneClasse ne doit pas etre vide", listPersonneClasse)
assertEquals("La taille de la listPersonneClasse doit etre egale à 3", listPersonneClasse.size(), 3)
-
- List<PersonneProprietesScolarite> listPersonne = []
- List<StructureEnseignement> listClasses = []
-
-
- listPersonneClasse.each { def list ->
-
- PersonneProprietesScolarite pps = list[0]
- StructureEnseignement classe = list[1]
-
- listPersonne << pps
- listClasses << classe
- }
-
- PersonneProprietesScolarite pps1 = listPersonne.find {it.id == ppsE1.id}
- PersonneProprietesScolarite pps2 = listPersonne.find {it.id == ppsE2.id}
- PersonneProprietesScolarite pps3 = listPersonne.find {it.id == ppsE3.id}
-
-
}
private Matiere creeMatiere(String code, String nom, Etablissement etablissement,
Personne personne = new Personne(
nom: "Michal",
Prenom: "Luxo",
- indexTypePersonne: 1,
autorite: autorite,
etablissementRattachement: etablissement1,
- actif: true
- )
- personne.save()
- if (personne.hasErrors()) {
- println(personne.errors)
- }
- return personne
-
- }
-
- /**
- * Crée une ProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private ProprietesScolarite creeProprietesScolarite() {
-
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- etablissement: etablissement1
)
- proprietesScolarite.save()
- if (proprietesScolarite.hasErrors()) {
- println(proprietesScolarite.errors)
- }
- return proprietesScolarite
+ personne.save(failOnError: true)
- }
-
- /**
- * Crée une PersonneProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private PersonneProprietesScolarite creePersonneProprietesScolarite(
- Personne personne,
- ProprietesScolarite proprietesScolarite
- ) {
-
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
-
- personne: personne,
- proprietesScolarite: creeProprietesScolarite(),
- estActive: true
-
- )
- personneProprietesScolarite.save()
- return personneProprietesScolarite
+ return personne
}
private ModaliteCours getModaliteTestCG() {
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ENSEIGNANT_MULTI_ETAB),
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
)
+
assertEquals("La méthode doit retourner deux classes", 2, liste1.size())
+
assertNotNull("La liste doit contenir CLASSE_1_TES1", liste1.find {
it.id == localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_TES1
).id
})
+
assertNotNull("La liste doit contenir CLASSE_1_2", liste1.find {
it.id == localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_2
).id
})
+
List liste2 = localStructureEnseignementService.findAllClasseByEnseignantAndEtablissement(
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ENSEIGNANT_MULTI_ETAB),
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
)
+
assertEquals("La méthode doit retourner une classe", 1, liste1.size())
+
assertEquals(
"La liste contient la classe 1",
localInitDonneesCommunesTestService.getClasse(
il a besoin*/
void testFindAllClasseForProfesseurPrincipal() {
List liste1 = localStructureEnseignementService.findAllClasseForProfesseurPrincipal(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ENSEIGNANT_4_1)
)
+
assertEquals("La liste doit contenir une classe", 1, liste1.size())
+
assertNotNull("La liste doit contenir la classe_1_2", liste1.find {
it.id == localInitDonneesCommunesTestService.
getClasse(PopulationTestClasse.CLASSE_1_2).id
il a besoin*/
void testFindAllClasseForProfesseurPrincipalForEtablissement() {
List liste1 = localStructureEnseignementService.findAllClasseForProfesseurPrincipalForEtablissement(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ENSEIGNANT_4_1),
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
)
+
assertEquals("La liste doit contenir une classe", 1, liste1.size())
+
assertNotNull("La liste doit contenir la classe_1_2", liste1.find {
it.id == localInitDonneesCommunesTestService.
getClasse(PopulationTestClasse.CLASSE_1_2).id
})
List liste2 = localStructureEnseignementService.findAllClasseForProfesseurPrincipalForEtablissement(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ENSEIGNANT_4_1),
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_2)
)
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_2_CLASSE_1),
localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_1_CLASSE_1_2)
]
+
Map result = localStructureEnseignementService.
findAllClassesForAllAutoritesEleves(eleves)
+
assertEquals("La map doit contenir 4 éléments", 4, result.size())
+
assertEquals(
"La classe de ELEVE_1_CLASSE_1 est CLASSE_1",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_1
).id
)
+
assertEquals(
"La classe de ELEVE_1_CLASSE_2 est CLASSE_2",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_2
).id
)
+
assertEquals(
"La classe de ELEVE_2_CLASSE_1 est CLASSE_1",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_1
).id
)
+
assertEquals(
"La classe de ELEVE_1_CLASSE_1_2 est CLASSE_1_2",
result.get(localInitDonneesCommunesTestService.
]
Map result = localStructureEnseignementService.
findAllClassesForAllEleves((Set) eleves)
+
assertEquals("La map doit contenir 4 éléments", 4, result.size())
+
assertEquals(
"La classe de ELEVE_1_CLASSE_1 est CLASSE_1",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_1
).id
)
+
assertEquals(
"La classe de ELEVE_1_CLASSE_2 est CLASSE_2",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_2
).id
)
+
assertEquals(
"La classe de ELEVE_2_CLASSE_1 est CLASSE_1",
result.get(localInitDonneesCommunesTestService.
PopulationTestClasse.CLASSE_1
).id
)
+
assertEquals(
"La classe de ELEVE_1_CLASSE_1_2 est CLASSE_1_2",
result.get(localInitDonneesCommunesTestService.
List liste1 = localStructureEnseignementService.findAllElevesForStructure(
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1)
)
+
assertEquals("La méthode doit retourner 20 élèves", 20, liste1.size())
+
assertNotNull(
"La liste doit contenir ELEVE_1_CLASSE_1",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir ELEVE_2_CLASSE_1",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir ELEVE_3_CLASSE_1",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir ELEVE_4_CLASSE_1",
liste1.find {
List liste1 = localStructureEnseignementService.findAllGroupeByClasse(
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1_2)
)
+
assertEquals("La méthode doit retourner 4 groupes", 4, liste1.size());
+
assertNotNull(
"La liste doit contenir GROUPE_1_4",
liste1.find {
localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1)
)
+
assertEquals("La méthode doit retourner 20 parents", 20, liste1.size())
+
assertNotNull(
"La liste doit contenir PARENT_1",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir PARENT_2",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir PARENT_3",
liste1.find {
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_2)
]
)
+
assertEquals("La méthode doit retourner 25 élèves", 25, liste1.size())
assertNotNull("La liste doit contenir ELEVE_1_CLASSE_1", liste1.find {
PopulationTestActeur.ELEVE_1_CLASSE_1
).id
})
+
assertNotNull("La liste doit contenir ELEVE_2_CLASSE_1", liste1.find {
it.id == localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_2_CLASSE_1
).id
})
+
assertNotNull("La liste doit contenir ELEVE_3_CLASSE_1", liste1.find {
it.id == localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_3_CLASSE_1
).id
})
+
assertNotNull("La liste doit contenir ELEVE_1_CLASSE_2", liste1.find {
it.id == localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_2
).id
})
+
assertNotNull("La liste doit contenir ELEVE_2_CLASSE_2", liste1.find {
it.id == localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_2_CLASSE_2
il a besoin*/
void testFindAllStructureEnseignementByEnseignantAndEtablissement() {
List liste1 =
- localStructureEnseignementService.
- findAllStructureEnseignementByEnseignantAndEtablissement(
- localInitDonneesCommunesTestService.getAutorite(
- PopulationTestActeur.ENSEIGNANT_3_1
- ),
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- )
- )
+ localStructureEnseignementService.
+ findAllStructureEnseignementByEnseignantAndEtablissement(
+ localInitDonneesCommunesTestService.getAutorite(
+ PopulationTestActeur.ENSEIGNANT_3_1
+ ),
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ )
+ )
+
assertEquals(
"La méthode doit retourner 6 structures d'enseignement",
6,
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1),
TypeStructureEnum.CLASSE
)
+
assertEquals("La méthode doit retourner 4 classes", 4, liste2.size())
+
assertNotNull("La liste doit contenir CLASSE_1_2", liste2.find {
it.id == localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_2
).id
})
+
assertNotNull("La liste doit contenir CLASSE_1_TES1", liste2.find {
it.id == localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_TES1
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1),
TypeStructureEnum.GROUPE
)
+
assertEquals("La méthode doit retourner 2 structures d'enseignement", 2, liste3.size())
+
assertNotNull("La liste doit contenir GROUPE_1_5", liste3.find {
it.id == localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_5
).id
})
+
assertNotNull("La liste doit contenir GROUPE_1_6", liste3.find {
it.id == localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_6
void testFindAllStructureEnseignementByEtablissement() {
List<StructureEnseignement> listeAll = localStructureEnseignementService.
findAllStructureEnseignementByEtablissement(
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ )
)
- )
List<StructureEnseignement> listeClasses = localStructureEnseignementService.
findAllStructureEnseignementByEtablissement(
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- TypeStructureEnum.CLASSE
- )
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ ),
+ TypeStructureEnum.CLASSE
+ )
List<StructureEnseignement> listeGroupes = localStructureEnseignementService.
findAllStructureEnseignementByEtablissement(
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- TypeStructureEnum.GROUPE
- )
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ ),
+ TypeStructureEnum.GROUPE
+ )
assertEquals(
"La taille de la liste des structures doit etre egal a la somme de la " +
il a besoin*/
void testFindAllStructureEnseignementForEleve() {
List liste1 = localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_2_CLASSE_1)
)
+
assertEquals("La méthode doit retourner 1 structure", 1, liste1.size())
+
assertEquals(
"La liste doit contenir la CLASSE_1",
liste1[0].id,
)
List liste2 = localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
)
+
assertEquals("La méthode doit retourner 2 structures", 2, liste2.size())
+
assertNotNull(
"La liste doit contenir CLASSE_1",
liste2.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir GROUPE_1_2",
liste2.find {
)
}
- void testFindAllStructureEnseignementForPersonneEtProprieteScol() {
- List liste1 = localStructureEnseignementService.findAllStructureEnseignementForPersonneEtProprieteScol(
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
- localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ENSEIGNANT_1
- ),
- new ProprieteScolariteParam(
- etablissement: localInitDonneesCommunesTestService.
- getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- )
- )
- )
- assertEquals("La méthode doit retourner 2 structures", 2, liste1.size())
- liste1.each {
- assertEquals(
- "La liste ne doit contenir que des structures de l'établissement 1",
- localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ).id,
- it.etablissement.id
- )
- }
- }
@Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
il a besoin*/
List liste1 = localStructureEnseignementService.findAllStructuresForClasse(
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1)
)
+
assertEquals("La méthode doit retourner 3 structures", 3, liste1.size())
+
assertNotNull(
"La liste doit contenir CLASSE_1",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir GROUPE_1_7",
liste1.find {
).id
}
)
+
assertNotNull(
"La liste doit contenir GROUPE_1_8",
liste1.find {
void testFindClasseForElevePersonne() {
StructureEnseignement structure1 = localStructureEnseignementService.
findClasseForEleve(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
- localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
- )
+ localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
+ localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
+ )
+
assertEquals(
"La méthode doit retourne la CLASSE_1",
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1).id,
structure1.id
)
+
StructureEnseignement structure2 = localStructureEnseignementService.
findClasseForEleve(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
- localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
- )
+ localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
+ localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
+ )
+
assertEquals(
"La méthode doit retourne la CLASSE_1_2",
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1_2).id,
void testFindClasseForEleveAutorite() {
StructureEnseignement structure1 = localStructureEnseignementService.
findClasseForEleve(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
- localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_1_CLASSE_1)
- )
+ localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
+ localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_1_CLASSE_1)
+ )
+
assertEquals(
"La méthode doit retourne la CLASSE_1",
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1).id,
structure1.id
)
+
StructureEnseignement structure2 = localStructureEnseignementService.
findClasseForEleve(
- localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
- localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
- )
+ localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1),
+ localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ELEVE_2_CLASSE_1_2)
+ )
+
assertEquals(
"La méthode doit retourne la CLASSE_1_2",
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1_2).id,
PopulationTestEtablissement.ETABLISSEMENT_1
)
)
+
assertEquals(
"La méthode doit retourne la CLASSE_1",
structure1.id,
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1).id
)
+
StructureEnseignement structure2 = localStructureEnseignementService.findStructureEnseignement(
PopulationTestClasse.CLASSE_2.code,
StructureEnseignement.TYPE_CLASSE,
PopulationTestEtablissement.ETABLISSEMENT_2
)
)
+
assertEquals(
"La méthode doit retourne la CLASSE_2",
structure2.id,
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_2).id
)
+
StructureEnseignement structure4 = localStructureEnseignementService.findStructureEnseignement(
PopulationTestGroupe.GROUPE_1.code,
StructureEnseignement.TYPE_GROUPE,
PopulationTestEtablissement.ETABLISSEMENT_1
)
)
+
assertEquals(
"La méthode doit retourner le GROUPE_1",
structure4.id,
PopulationTestEtablissement.ETABLISSEMENT_1
)
)
+
assertEquals(
"La méthode doit retourne la CLASSE_1",
structure1.id,
PopulationTestEtablissement.ETABLISSEMENT_2
)
)
+
assertEquals(
"La méthode doit retourne la CLASSE_2",
structure2.id,
PopulationTestEtablissement.ETABLISSEMENT_2
)
)
+
assertNull("La méthode ne doit rien retourner", structure3)
StructureEnseignement structure4 = localStructureEnseignementService.findStructureEnseignement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
)
+
assertEquals(
"La méthode doit retourner le GROUPE_1",
structure4.id,
void testFindStructureEnseignementByEnseignantAndMatiereAndEtablissement() {
List liste1 = localStructureEnseignementService.
findStructureEnseignementByEnseignantAndMatiereAndEtablissement(
- localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ENSEIGNANT_1),
- localInitDonneesCommunesTestService.getMatiere(PopulationTestMatiere.ANGLAIS_LV1_ETAB1),
- localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
- )
+ localInitDonneesCommunesTestService.getAutorite(PopulationTestActeur.ENSEIGNANT_1),
+ localInitDonneesCommunesTestService.getMatiere(PopulationTestMatiere.ANGLAIS_LV1_ETAB1),
+ localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
+ )
+
assertNotNull("La liste doit contenir GROUPE_1_8", liste1.find {
it.id == localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_8
).id
})
+
assertNotNull("La liste doit contenir GROUPE_1_9", liste1.find {
it.id == localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1_9
List liste1 = localStructureEnseignementService.
findStructuresEnseignementByMatiereAndEtablissement(
- matiereTelugu,
- etablissement1
- )
+ matiereTelugu,
+ etablissement1
+ )
// cree des services
serviceService.creeService(
classe1enTrimestres,
getModaliteTestCG()
)
+
serviceService.creeService(
securiteSessionDirecteur,
matiereTelugu,
// verifie que les deux structures ont ete ajoute dans le resultat de recherche
List liste2 = localStructureEnseignementService.
findStructuresEnseignementByMatiereAndEtablissement(
- matiereTelugu,
- etablissement1
- )
+ matiereTelugu,
+ etablissement1
+ )
assertEquals("2 structures doivent etre ajoutees dans le resultat de recherche",
- 2, liste2.size() - liste1.size())
+ 2, liste2.size() - liste1.size()
+ )
+
assertNotNull("La liste doit contenir CLASSE_1",
liste2.find {it.id == classe1enTrimestres.id}
)
+
assertNotNull("La liste doit contenir CLASSE_1_2",
liste2.find {it.id == classe2enTrimestres.id}
)
PopulationTestClasse.CLASSE_1
)
)
+
localStructureEnseignementService.internalAddClasseToGroupe(
localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
PopulationTestGroupe.GROUPE_1
)
)
+
List groupes2 = localStructureEnseignementService.findAllGroupeByClasse(
localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
)
)
+
assertEquals(
"La méthode doit retourner un groupe de plus",
1,
groupes2.size() - groupes1.size()
)
+
try {
localStructureEnseignementService.internalAddClasseToGroupe(
localInitDonneesCommunesTestService.getGroupe(
assertTrue(
"ELEVE_1_CLASSE_1 fait bien partie de CLASSE_1",
localStructureEnseignementService.isEleveDansStructureEnseignement(
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_1
),
)
)
)
+
assertFalse(
"ELEVE_1_CLASSE_2 ne fait pas partie de CLASSE_1",
localStructureEnseignementService.isEleveDansStructureEnseignement(
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_2
),
)
)
)
+
assertTrue(
"ELEVE_1_CLASSE_1 fait bien partie de GROUPE_1_2",
localStructureEnseignementService.isEleveDansStructureEnseignement(
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- ),
localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_1
),
)
)
)
+
assertFalse(
"GROUPE_1_4 n'est pas un sous-groupe exclusivement de CLASSE_1_2",
localStructureEnseignementService.isSousGroupeExclusivementDe(
)
)
)
+
assertFalse(
"GROUPE_1_4 n'est pas un sous-groupe de CLASSE_1 du tout",
localStructureEnseignementService.isSousGroupeExclusivementDe(
PopulationTestClasse.CLASSE_1
)
)
+
localStructureEnseignementService.updateRelClasseGroupe(
localInitDonneesCommunesTestService.getGroupe(
PopulationTestGroupe.GROUPE_1
)
]
)
+
List groupes2 = localStructureEnseignementService.findAllGroupeByClasse(
localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
)
)
+
assertEquals(
"La liste doit comporter un groupe de plus",
1,
]
List<StructureEnseignement> structs = localStructureEnseignementService.
findAllStructureForAllIds(ids)
+
assertNotNull("La méthode doit retourner un résultat", structs)
assertEquals("La liste doit contenir 3 éléments", 3, structs.size())
+
assertNotNull("Le résultat doit contenir la classe 1", structs.collect {
it.code == PopulationTestClasse.CLASSE_1.getCode()
})
+
assertNotNull("Le résultat doit contenir la classe 2", structs.collect {
it.code == PopulationTestClasse.CLASSE_2.getCode()
})
+
assertNotNull("Le résultat doit contenir la classe 1_2", structs.collect {
it.code == PopulationTestClasse.CLASSE_1_2.getCode()
})
+
structs = localStructureEnseignementService.findAllStructureForAllIds([])
assertEquals("La liste doit être vide", 0, structs.size())
}
internalTestCreeMatiereManuelAutreEtablissement()
internalTestCreeMatiereManuelCodeGestionRedondant()
internalTestCreeMatiereManuelSansLibelle()
- internalTestCreeMatiereManuelMauvaisEtablissement()
internalTestCreeMatiereManuelSansCodeGestion()
}
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.test.PopulationTestMatiere
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.annuaire.SuppressionProprietesScolariteService
+import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
+
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
+
/**
* @author jbui
*/
class PersonneProprietesScolariteServiceTests extends GrailsUnitTestCase {
-
+
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
AnneeScolaireService anneeScolaireService
EleveAnnuaireService eleveAnnuaireService
SuppressionProprietesScolariteService suppressionProprietesScolariteService
SessionFactory sessionFactory
+ PersonneProprietesScolariteService personneProprietesScolariteService
void testSupprimeToutes() {
- ProprietesScolarite proprietesScolarite1 = new ProprietesScolarite(
- etablissement: localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- ),
- structureEnseignement: localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1
- ),
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- matiere: localInitDonneesCommunesTestService.getMatiere(PopulationTestMatiere.MATH),
- fonction: Fonction.findByCode(FonctionEnum.DOCUMENTALISTE.getCode()),
- responsableStructureEnseignement: false,
- porteurEnt: null
- ).save(flush: true, failOnError: true)
-
- PersonneProprietesScolarite pps = new PersonneProprietesScolarite(
- personne: localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.PARENT_1
- ),
- proprietesScolarite: proprietesScolarite1,
- estActive: true
- ).save(flush: true, failOnError: true)
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
+ structureEnseignement: localInitDonneesCommunesTestService.getClasse(
+ PopulationTestClasse.CLASSE_1
+ ),
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ fonction: Fonction.findByCode(FonctionEnum.DOCUMENTALISTE.getCode()),
+ responsableStructureEnseignement: false
+ )
+
+ PersonneProprietesScolariteParam paramPps =
+ new PersonneProprietesScolariteParam(
+ personne: localInitDonneesCommunesTestService.getPersonne(
+ PopulationTestActeur.PARENT_1
+ ),
+ proprietesScolariteParam: paramPs,
+ origine: OrigineEnum.MANUEL
+ )
+
+ PersonneProprietesScolarite pps = personneProprietesScolariteService.findOrCreePPS(paramPps)
assertNotNull("La pps n'a pas été enregistrée", pps.id)
session.clear()
assertNull(
- "La pps n'a pas été supprimée",
- PersonneProprietesScolarite.get(ppsId)
+ "La pps n'a pas été supprimée",
+ PersonneProprietesScolarite.get(ppsId)
)
}
void testWasEleveDeClasse() {
assertTrue(
- "L'élève fait partie de la classe",
- eleveAnnuaireService.wasEleveDeClasse(
- localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ELEVE_2_CLASSE_2
- ),
- localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_2
- )
- ))
+ "L'élève fait partie de la classe",
+ eleveAnnuaireService.wasEleveDeClasse(
+ localInitDonneesCommunesTestService.getPersonne(
+ PopulationTestActeur.ELEVE_2_CLASSE_2
+ ),
+ localInitDonneesCommunesTestService.getClasse(
+ PopulationTestClasse.CLASSE_2
+ )
+ ))
assertFalse(
- "L'élève ne fait partie de la classe",
- eleveAnnuaireService.wasEleveDeClasse(
- localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ELEVE_1_CLASSE_2
- ),
- localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1
- )
- ))
+ "L'élève ne fait partie de la classe",
+ eleveAnnuaireService.wasEleveDeClasse(
+ localInitDonneesCommunesTestService.getPersonne(
+ PopulationTestActeur.ELEVE_1_CLASSE_2
+ ),
+ localInitDonneesCommunesTestService.getClasse(
+ PopulationTestClasse.CLASSE_1
+ )
+ ))
assertFalse(
- "L'enseignant n'est pas un élève de la classe",
- eleveAnnuaireService.wasEleveDeClasse(
- localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.ENSEIGNANT_3
- ),
- localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1_2
- )
- ))
+ "L'enseignant n'est pas un élève de la classe",
+ eleveAnnuaireService.wasEleveDeClasse(
+ localInitDonneesCommunesTestService.getPersonne(
+ PopulationTestActeur.ENSEIGNANT_3
+ ),
+ localInitDonneesCommunesTestService.getClasse(
+ PopulationTestClasse.CLASSE_1_2
+ )
+ ))
}
}
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
import org.lilie.services.eliot.test.*
+import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
+
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
/**
* tests sur ProprietesScolariteService & les services associés de l'annuaire
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
ProprietesScolariteService proprietesScolariteService
+ PersonneProprietesScolariteService personneProprietesScolariteService
ServiceService serviceService
PersonneAnnuaireService personneAnnuaireService
FonctionAnnuaireService fonctionAnnuaireService
private ProprietesScolarite creeProprieteScolariteSurFonctionEtEtablissement(Fonction fonction,
Etablissement etablissement) {
- ProprietesScolarite ps = new ProprietesScolarite(
- fonction: fonction,
- etablissement: etablissement
+
+ return proprietesScolariteService.findOrCreePS(
+ new ProprietesScolariteParam(
+ fonction: fonction,
+ etablissement: etablissement,
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours()
+ )
)
- ps.save(flush: true, failOnError: true)
- return ps
}
private void ajoutFonctionASylvieChazal() {
)
}
-// void testGetFonctionSurEtablissement() {
-// ajout2FonctionsASylvieChazal()
-// List rep =
-// localProprieteScolariteService.findAllFonctionSurEtablissement(
-// sylvieChazal.autorite,
-// etablissement1
-// )
-//
-// assertTrue "Sylvie chazal a au moins 2 fonctions sur l'établissement 1",
-// rep.size() > 1
-//
-// }
void testFindAllEnseignantByEtablissement() {
List lst =
}
- void testFindAllFonctionEtablissementForResponsable() {
- List liste1 =
- fonctionAnnuaireService.findAllFonctionEtablissementForAutoriteActeur(
- localInitDonneesCommunesTestService.getAutorite(
- PopulationTestActeur.PARENT_1
- ),
- TypeUtilisateur.UTILISATEUR_NORMAL
- )
-
- assertEquals("La méthode doit retourner 9 fonctions", 9, liste1.size())
-
- }
-
void testFindAllFonctionEtablissementForCorrespondantDeploiement() {
List liste1 =
fonctionAnnuaireService.
),
FonctionEnum.DIRECTION
)
- assertEquals("La méthode doit retourner deux personne", 2, liste1.size())
+ assertEquals("La méthode doit retourner deux personnes", 2, liste1.size())
assertNotNull(
"La liste doit contenir DIRECTION1",
liste1.find {
)
}
- void testFindAllPersonnesByEtablissementAndParent() {
- Etablissement etablissement = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
- )
-
- Personne parent1 = localInitDonneesCommunesTestService.getPersonne(
- PopulationTestActeur.PARENT_1
- )
-
- FonctionEnum fonctionEnum = FonctionEnum.PERS_REL_ELEVE
- Fonction fonction = Fonction.findByCode(
- fonctionEnum.getCode()
- )
-
- List listeParentsParEtablissementAvant =
- personneAnnuaireService.findAllPersonnesByEtablissementAndFonction(
- etablissement,
- fonctionEnum
- )
-
- assertNotNull(
- "La liste doit contenir PARENT_1",
- listeParentsParEtablissementAvant.find {
- it.id == parent1.id
- }
- )
-
- creePersonnePourEtablissement(etablissement, fonction)
-
- List listeParentsParEtablissementApres =
- personneAnnuaireService.findAllPersonnesByEtablissementAndFonction(
- etablissement,
- fonctionEnum
- )
-
- assertNotNull(
- "La liste doit contenir PARENT_1",
- listeParentsParEtablissementApres.find {
- it.id == parent1.id
- }
- )
-
- assertEquals(
- "l'établissement 1 devrait avoir un parent supplémentaire",
- listeParentsParEtablissementApres.size(),
- listeParentsParEtablissementAvant.size() + 1
- )
-
- }
-
-
-
-
void testFindFonctionSurAutoriteEtProprieteScolarite() {
List liste1 =
proprietesScolariteService.findFonctionSurAutoriteEtProprieteScolarite(
)
)
enseignantAnnuaireService.
- internalFindOrCreePPSForEnseignement(enseignement)
+ ajouteEnseignantDansAllGroupeParEnseignement(enseignement)
List liste2 = PersonneProprietesScolarite.findAllByPersonne(
localInitDonneesCommunesTestService.getPersonne(
service: service,
nbHeures: 3
).save(flush: true)
- enseignantAnnuaireService.
- internalFindOrCreePPSForEnseignement(enseignement)
+
+ enseignantAnnuaireService.ajouteEnseignantDansAllGroupeParEnseignement(enseignement)
+
List liste1 = ProprietesScolarite.findAllByStructureEnseignementAndMatiere(
localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_2
)
personne.save(failOnError: true)
- // crée la propriété scolarité
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ // retrouve ou à défaut, crée la propriété scolarité
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
fonction: fonction,
etablissement: etablissement
)
- proprietesScolarite.save(failOnError: true)
+ proprietesScolariteService.findOrCreePS(paramPs)
- // crée la personne propriété scolarité
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
+ // retrouve ou à défaut, crée la personne propriété scolarité
+ PersonneProprietesScolariteParam paramPps =
+ new PersonneProprietesScolariteParam(
personne: personne,
- proprietesScolarite: proprietesScolarite,
- estActive: true
+ proprietesScolariteParam: paramPs,
+ origine: OrigineEnum.MANUEL
)
- personneProprietesScolarite.save(failOnError: true)
+ personneProprietesScolariteService.findOrCreePPS(paramPps)
}
}
List<StructureEnseignement> listStruct = localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- login.securiteSession,
eleve)
assertEquals("Nombre de structures de l'élève", 2, listStruct.size())
StructureEnseignement rep = localStructureEnseignementService.findClasseForEleve(securiteSession, eleve)
assertTrue "L'élève doit être dans la classe 1", localStructureEnseignementService.isEleveDansStructureEnseignement(
- securiteSession,
eleve,
rep
)
Personne eleve = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
List<StructureEnseignement> lstStruct = localStructureEnseignementService.findAllStructureEnseignementForPersonne(
- securiteSession, eleve)
+ eleve)
assertEquals(
"L'élève 1 de la classe 1 est associé à 2 structures d'enseignement",
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteParams
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteFonctionnalite
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteEtat
+import org.lilie.services.eliot.scolarite.annuaire.ProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
+import org.lilie.services.eliot.scolarite.OrigineEnum
+import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
+
class SaisieFonctionnaliteServiceTests extends GrailsUnitTestCase {
SaisieFonctionnaliteService saisieFonctionnaliteService
SecuriteFonctionnaliteService securiteFonctionnaliteService
AnneeScolaireService anneeScolaireService
+ PersonneProprietesScolariteService personneProprietesScolariteService
Etablissement etablissement1
Fonctionnalite fonctionnalite
}
private void verifieFonctionnalitePersonnes(FonctionnalitePersonneParams fonctionnalitePersonneParams,
- Etablissement etablissement,
- Personne personne) {
+ Etablissement etablissement,
+ Personne personne) {
fonctionnalitePersonneParams.listeFonctionnalitePersonne.each {
verifieFonctionnalitePersonne(
etablissement,
boolean isActif) {
AccesFonctionnalitePersonne droitAcces =
AccesFonctionnalitePersonne.createCriteria().get {
- eq('etablissement', etablissement)
- eq('personne', personne)
- fonctionnalite {
- eq('code', codeFonctionalite)
+ eq('etablissement', etablissement)
+ eq('personne', personne)
+ fonctionnalite {
+ eq('code', codeFonctionalite)
+ }
}
- }
if (isActif) {
assertNotNull(
boolean isActif) {
AccesFonctionnaliteFonction droitAcces =
AccesFonctionnaliteFonction.createCriteria().get {
- eq('etablissement', etablissement)
- 'fonction' {
- eq('code', codeFonction)
- }
- fonctionnalite {
- eq('code', codeFonctionnalite)
+ eq('etablissement', etablissement)
+ 'fonction' {
+ eq('code', codeFonction)
+ }
+ 'fonctionnalite' {
+ eq('code', codeFonctionnalite)
+ }
}
- }
assertEquals(
"L'acces de fonction a la fonctionnalite n'est pas comme prevu",
)
autorite.modifieEtat(CompteUtilisateurEtat.ACTIF)
- autorite.save(failOnError: true)
+ autorite.save(failOnError: true, flush: true)
// crée la personne
Personne personne = new Personne(
autorite: autorite,
etablissementRattachement: etablissement,
)
- personne.save(failOnError: true)
+ personne.save(failOnError: true, flush: true)
+
+ // retrouve ou cree la ps puis retrouve ou cree la pps
- // crée la propriété scolarité
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
+ etablissement: etablissement,
anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- fonction: fonction,
- etablissement: etablissement
+ fonction: fonction
)
- proprietesScolarite.save(failOnError: true)
- // crée la personne propriété scolarité
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
+ PersonneProprietesScolariteParam paramPps =
+ new PersonneProprietesScolariteParam(
personne: personne,
- proprietesScolarite: proprietesScolarite,
- estActive: true
+ proprietesScolariteParam: paramPs,
+ origine: OrigineEnum.MANUEL
)
- personneProprietesScolarite.save(failOnError: true)
+
+ personneProprietesScolariteService.findOrCreePPS(paramPps)
return personne
}
import org.lilie.services.eliot.scolarite.annuaire.hqlfactory.ProprieteScolariteParam
import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
import org.lilie.services.eliot.test.PopulationTestClasse
-import org.lilie.services.eliot.scolarite.AnneeScolaire
+
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.test.PopulationTestEtablissement
-import org.lilie.services.eliot.scolarite.Etablissement
+
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
*/
void testHql1() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(),
+ script: {
- listeSelect "pps.proprietesScolarite.structureEnseignement"
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- listeWhere "pps.personne=:eleve"
+ listeWhere "pps.personne=:eleve"
- }
+ }
)
String requete = hqlFactory.hql()
*/
void testHql2() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: true
- ),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ responsableStructureEnseignement: true
+ ),
+ script: {
- listeSelect "pps.proprietesScolarite.structureEnseignement"
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- listeWhere "pps.personne=:eleve"
+ listeWhere "pps.personne=:eleve"
- }
+ }
)
String requete = hqlFactory.hql()
*/
void testHql3() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: true
- ),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ responsableStructureEnseignement: true
+ ),
+ script: {
- listeSelect "pps.proprietesScolarite.fonction"
+ listeSelect "pps.proprietesScolarite.fonction"
- listeFrom "Personne p", "PersonneProprietesScolarite pps"
+ listeFrom "Personne p", "PersonneProprietesScolarite pps"
- listeWhere "p.autorite=?", "pps.personne=p"
+ listeWhere "p.autorite=?", "pps.personne=p"
- }
+ }
)
String requete = hqlFactory.hql()
*/
void testHql4() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(),
+ script: {
- listeSelect "pps.proprietesScolarite.structureEnseignement"
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- }
+ }
)
String requete = hqlFactory.hql()
*/
void testHql5() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(),
+ script: {
- listeSelect "pps.proprietesScolarite.structureEnseignement"
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- listeWhere "pps.personne=:eleve",
- "pps.proprietesScolarite.structureEnseignement.type='CLASSE'",
- "pps.proprietesScolarite.structureEnseignement.actif"
+ listeWhere "pps.personne=:eleve",
+ "pps.proprietesScolarite.structureEnseignement.type='CLASSE'",
+ "pps.proprietesScolarite.structureEnseignement.actif"
- }
+ }
)
String requete = hqlFactory.hql()
void testHql6() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: true
- ),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ responsableStructureEnseignement: true
+ ),
+ script: {
- listeSelect "pps.proprietesScolarite.structureEnseignement"
+ listeSelect "pps.proprietesScolarite.structureEnseignement"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- listeWhere "pps.personne=:eleve",
- "pps.proprietesScolarite.structureEnseignement.type='CLASSE'",
- "pps.proprietesScolarite.structureEnseignement.actif"
+ listeWhere "pps.personne=:eleve",
+ "pps.proprietesScolarite.structureEnseignement.type='CLASSE'",
+ "pps.proprietesScolarite.structureEnseignement.actif"
- }
+ }
)
String requete = hqlFactory.hql()
println requete
assertTrue "Erreur de construction de la requete",
- requete == "select pps.proprietesScolarite.structureEnseignement from PersonneProprietesScolarite pps where pps.personne=:eleve and pps.proprietesScolarite.structureEnseignement.type='CLASSE' and pps.proprietesScolarite.structureEnseignement.actif and (pps.proprietesScolarite.fonction.id=7) and (pps.proprietesScolarite.responsableStructureEnseignement=true)"
+ requete == "select pps.proprietesScolarite.structureEnseignement from PersonneProprietesScolarite pps where pps.personne=:eleve and pps.proprietesScolarite.structureEnseignement.type='CLASSE' and pps.proprietesScolarite.structureEnseignement.actif and (pps.proprietesScolarite.fonction.id=7) and (pps.proprietesScolarite.responsableStructureEnseignement=true)"
}
void testHql7() {
// inscription d'un élève dans une classe
- AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
-
StructureEnseignement structureEnseignement =
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1)
- Etablissement etablissement =
- localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
-
Personne eleve =
localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve,
- etablissement,
- structureEnseignement,
- anneeScolaire,
- null,
- true
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
+ eleve,
+ structureEnseignement,
+ true
)
// recherche de cet élève délégué dans cette classe
ProprieteScolariteHqlFactory hqlFactory =
new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- structureEnseignement: structureEnseignement,
- responsableStructureEnseignement: true
- ),
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
+ structureEnseignement: structureEnseignement,
+ responsableStructureEnseignement: true
+ ),
- script: {
+ script: {
- listeSelect "pps.personne"
+ listeSelect "pps.personne"
- listeFrom "PersonneProprietesScolarite pps"
+ listeFrom "PersonneProprietesScolarite pps"
- }
+ }
)
println requete
List lst = Personne.executeQuery(requete)
assertTrue "On doit avoir un délégué sur la classe",
- (lst.size() == 1)
+ (lst.size() == 1)
}
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
- ),
- script: {
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
+ ),
+ script: {
- listeSelect "pps.proprietesScolarite.fonction"
+ listeSelect "pps.proprietesScolarite.fonction"
- listeFrom "Personne p", "PersonneProprietesScolarite pps"
+ listeFrom "Personne p", "PersonneProprietesScolarite pps"
- listeWhere "p.autorite=?", "pps.personne=p"
+ listeWhere "p.autorite=?", "pps.personne=p"
- }
+ }
)
String requete = hqlFactory.hql()
println requete
assertTrue "Erreur de construction de la requete",
- requete == "select pps.proprietesScolarite.fonction from Personne p, PersonneProprietesScolarite pps where p.autorite=? and pps.personne=p and (pps.proprietesScolarite.fonction.id=5)"
+ requete == "select pps.proprietesScolarite.fonction from Personne p, PersonneProprietesScolarite pps where p.autorite=? and pps.personne=p and (pps.proprietesScolarite.fonction.id=5)"
}
void testHql9() {
ProprieteScolariteHqlFactory hqlFactory = new ProprieteScolariteHqlFactory(
- proprietesScolarite: new ProprieteScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
- ))
+ proprietesScolarite: new ProprieteScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode())
+ ))
hqlFactory.select.add('pps.personne')
hqlFactory.from.add("PersonneProprietesScolarite pps")
println requete
assertTrue "Erreur de construction de la requete",
- requete == "select pps.personne from PersonneProprietesScolarite pps where (pps.proprietesScolarite.fonction.id=5) order by pps.personne.nom, pps.personne.prenom"
+ requete == "select pps.personne from PersonneProprietesScolarite pps where (pps.proprietesScolarite.fonction.id=5) order by pps.personne.nom, pps.personne.prenom"
List lst = Personne.executeQuery(requete)
println lst
~ <http://www.gnu.org/licenses/> and
~ <http://www.cecill.info/licences.fr.html>.
-->
+
<databaseChangeLog
xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
--- /dev/null
+<!--
+ ~ Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ ~ This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ ~
+ ~ Lilie is free software. You can redistribute it and/or modify since
+ ~ you respect the terms of either (at least one of the both license) :
+ ~ - under the terms of the GNU Affero General Public License as
+ ~ published by the Free Software Foundation, either version 3 of the
+ ~ License, or (at your option) any later version.
+ ~ - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ ~ License, or any later version
+ ~
+ ~ There are special exceptions to the terms and conditions of the
+ ~ licenses as they are applied to this software. View the full text of
+ ~ the exception in file LICENSE.txt in the directory of this software
+ ~ distribution.
+ ~
+ ~ Lilie is distributed in the hope that it will be useful,
+ ~ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ~ Licenses for more details.
+ ~
+ ~ You should have received a copy of the GNU General Public License
+ ~ and the CeCILL-C along with Lilie. If not, see :
+ ~ <http://www.gnu.org/licenses/> and
+ ~ <http://www.cecill.info/licences.fr.html>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="bahj">
+ <preConditions onFail="MARK_RAN">
+ <sqlCheck expectedResult="1">
+ SELECT count(*)
+ FROM information_schema.columns
+ WHERE table_schema = 'td'
+ AND table_name = 'modalite_activite'
+ AND column_name = 'groupe_id'
+ </sqlCheck>
+ </preConditions>
+
+ <comment>
+ Mise à null de la référence au groupe_personne de la table modalite_activite de tdbase
+ </comment>
+
+ <sql>
+ UPDATE td.modalite_activite
+ SET groupe_id = null
+ </sql>
+ </changeSet>
+
+
+ <changeSet id="2" author="bahj">
+ <comment>
+ Suppression des autorités et items crées pour la génération des
+ groupe_personnes puis vidage de cette table en question
+ </comment>
+
+ <sql>
+ WITH
+ item_groupe_personnes_a_supprimer AS (
+ DELETE FROM securite.item
+ WHERE id in (SELECT item_id FROM ent.groupe_personnes)
+ ),
+ autorite_groupe_personnes_a_supprimer AS (
+ DELETE FROM securite.autorite
+ WHERE id in (SELECT autorite_id FROM ent.groupe_personnes)
+ )
+ DELETE FROM ent.groupe_personnes;
+ </sql>
+ </changeSet>
+
+
+ <changeSet id="1" author="bper">
+ <comment>
+ Ajout de contrainte NOT NULL sur la colonne 'annee_scolaire_id' de la table 'ent.propriete_scolarite'
+ </comment>
+
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET annee_scolaire_id = (SELECT id FROM ent.annee_scolaire WHERE annee_en_cours = TRUE)
+ WHERE annee_scolaire_id IS NULL
+ </sql>
+
+ <addNotNullConstraint schemaName="ent"
+ tableName="propriete_scolarite"
+ columnName="annee_scolaire_id"/>
+
+ </changeSet>
+
+
+ <changeSet id="2" author="bper">
+ <comment>
+ Ajout de la contrainte CHECK sur les colonnes 'responsable_structure_enseignement' et 'structure_enseignement_id' de la table 'ent.propriete_scolarite'
+ </comment>
+
+ <!--
+ La colonne 'responsable_structure_enseignement' ne peut avoir comme valeur null ou true.
+ Si la valeur est true la valeur de 'structure_enseignement_id' ne doit pas etre null.
+ Cela est nécessaire pour mettre les contraintes d'unicité et ne pas mettre une valeur
+ différente de null là où elle n'a pas de sens.
+ -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET responsable_structure_enseignement = NULL
+ WHERE structure_enseignement_id IS NULL;
+
+ UPDATE ent.propriete_scolarite
+ SET responsable_structure_enseignement = NULL
+ WHERE structure_enseignement_id IS NOT NULL
+ AND responsable_structure_enseignement = false;
+
+ ALTER TABLE ent.propriete_scolarite
+ ADD CONSTRAINT chk_responsable_structure_ens_dep_structure_ens
+ CHECK (
+ (responsable_structure_enseignement = true AND structure_enseignement_id IS NOT NULL)
+ OR
+ (responsable_structure_enseignement IS NULL)
+ );
+ </sql>
+
+ <dropDefaultValue
+ schemaName="ent"
+ tableName="propriete_scolarite"
+ columnName="responsable_structure_enseignement" />
+
+ </changeSet>
+
+
+ <changeSet id="3" author="bper">
+ <comment>
+ Ajout de la valeur par défaut et contrainte NOT NULL pour la colonne 'date_debut' de la table 'ent.personne_propriete_scolarite'
+ </comment>
+
+ <sql>
+ UPDATE ent.personne_propriete_scolarite
+ SET date_debut = now()
+ WHERE date_debut IS NULL;
+
+ ALTER TABLE ent.personne_propriete_scolarite
+ ALTER COLUMN date_debut SET DEFAULT CURRENT_TIMESTAMP;
+ </sql>
+
+ <addNotNullConstraint
+ schemaName="ent"
+ tableName="personne_propriete_scolarite"
+ columnName="date_debut" />
+
+ </changeSet>
+
+
+ <changeSet id="4" author="bper">
+ <comment>
+ Ajout de la contrainte NOT NULL pour la colonne 'fonction_id' de la table 'ent.propriete_scolarite'
+ </comment>
+
+ <!-- Les PS sans fonction n'ont aucun sens -->
+ <sql>
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE propriete_scolarite_id IN (
+ SELECT id FROM ent.propriete_scolarite
+ WHERE fonction_id IS NULL
+ );
+
+ DELETE FROM ent.propriete_scolarite
+ WHERE fonction_id IS NULL;
+ </sql>
+
+ <addNotNullConstraint
+ schemaName="ent"
+ tableName="propriete_scolarite"
+ columnName="fonction_id" />
+
+ </changeSet>
+
+
+ <changeSet id="5" author="bper">
+ <comment>
+ Nettoyage des tables 'personne_propriete_scolarite' et 'propriete_scolarite' pour le profil 'ELEVE'
+ </comment>
+
+ <!-- Suppression des doublons des PS des élèves délégués dans les structures d'enseignement -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, structure_enseignement_id, fonction_id, responsable_structure_enseignement
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ELEVE'
+ AND structure_enseignement_id IS NOT NULL
+ AND responsable_structure_enseignement IS NOT NULL
+ GROUP BY annee_scolaire_id, structure_enseignement_id, fonction_id, responsable_structure_enseignement
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.structure_enseignement_id = ps_doublon_a_garder.structure_enseignement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.responsable_structure_enseignement = ps_doublon_a_garder.responsable_structure_enseignement
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des doublons des PS des élèves dans les structures d'enseignement -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, structure_enseignement_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ELEVE'
+ AND structure_enseignement_id IS NOT NULL
+ AND responsable_structure_enseignement IS NULL
+ GROUP BY annee_scolaire_id, structure_enseignement_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.structure_enseignement_id = ps_doublon_a_garder.structure_enseignement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des PS sans lien avec structure d'enseignement -->
+ <sql>
+ WITH
+ ps_a_supprimer AS (
+ SELECT ps.id FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ELEVE'
+ AND ps.structure_enseignement_id IS NULL
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE propriete_scolarite_id IN (SELECT id FROM ps_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT id FROM ps_a_supprimer);
+ </sql>
+
+ <!-- Mise à null de porteur_ent_id -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET porteur_ent_id = NULL
+ WHERE fonction_id = (SELECT id FROM ent.fonction WHERE code = 'ELEVE')
+ AND porteur_ent_id IS NOT NULL;
+ </sql>
+
+ <!-- Mise à null de etablissement_id -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET etablissement_id = NULL
+ WHERE fonction_id = (SELECT id FROM ent.fonction WHERE code = 'ELEVE')
+ AND etablissement_id IS NOT NULL;
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="6" author="bper">
+ <comment>
+ Nettoyage des tables 'personne_propriete_scolarite' et 'propriete_scolarite' pour le profil 'PERS_REL_ELEVE'
+ </comment>
+
+ <!-- Suppression des doublons des PS liées aux structures d'enseignement -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, structure_enseignement_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'PERS_REL_ELEVE'
+ AND structure_enseignement_id IS NOT NULL
+ GROUP BY annee_scolaire_id, structure_enseignement_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.structure_enseignement_id = ps_doublon_a_garder.structure_enseignement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des doublons des PS liées aux porteur ENT -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, porteur_ent_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'PERS_REL_ELEVE'
+ AND porteur_ent_id IS NOT NULL
+ AND structure_enseignement_id IS NULL
+ GROUP BY annee_scolaire_id, porteur_ent_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.porteur_ent_id = ps_doublon_a_garder.porteur_ent_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des PS sans lien ni avec une structure d'enseignement ni avec un porteur ENT -->
+ <sql>
+ WITH
+ ps_a_supprimer AS (
+ SELECT ps.id FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'PERS_REL_ELEVE'
+ AND ps.structure_enseignement_id IS NULL
+ AND ps.porteur_ent_id IS NULL
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE propriete_scolarite_id IN (SELECT id FROM ps_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT id FROM ps_a_supprimer);
+ </sql>
+
+ <!-- Mise à null de porteur_ent_id -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET porteur_ent_id = NULL
+ WHERE fonction_id = (SELECT id FROM ent.fonction WHERE code = 'PERS_REL_ELEVE')
+ AND porteur_ent_id IS NOT NULL
+ AND structure_enseignement_id IS NOT NULL;
+ </sql>
+
+ <!-- Mise à null de etablissement_id -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET etablissement_id = NULL
+ WHERE fonction_id = (SELECT id FROM ent.fonction WHERE code = 'PERS_REL_ELEVE')
+ AND etablissement_id IS NOT NULL;
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="7" author="bper">
+ <comment>
+ Nettoyage des tables 'personne_propriete_scolarite' et 'propriete_scolarite' pour le profil 'ENS'
+ </comment>
+
+ <!-- Mise à null de porteur_ent_id -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET porteur_ent_id = NULL
+ FROM ent.fonction AS f
+ WHERE f.code = 'ENS'
+ AND fonction_id = f.id
+ </sql>
+
+ <!-- Création des groupes d'enseignants d'une matière dans un établissement -->
+ <sql>
+ WITH
+ pps_ens_matiere_a_creer AS (
+ SELECT pps.personne_id, ps.annee_scolaire_id, se.etablissement_id, ps.fonction_id, ps.matiere_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ent.propriete_scolarite AS ps ON pps.propriete_scolarite_id = ps.id
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ INNER JOIN ent.structure_enseignement AS se ON ps.structure_enseignement_id = se.id
+ WHERE f.code = 'ENS'
+ AND pps.est_active = true
+ AND ps.matiere_id IS NOT NULL
+ GROUP BY pps.personne_id, ps.annee_scolaire_id, se.etablissement_id, ps.fonction_id, ps.matiere_id
+ ),
+ ps_crees AS (
+ INSERT INTO ent.propriete_scolarite (id, annee_scolaire_id, etablissement_id, fonction_id, matiere_id)
+ SELECT
+ nextval('ent.propriete_scolarite_id_seq'),
+ annee_scolaire_id,
+ etablissement_id,
+ fonction_id,
+ matiere_id
+ FROM pps_ens_matiere_a_creer
+ WHERE NOT EXISTS (
+ SELECT annee_scolaire_id, etablissement_id, fonction_id, matiere_id
+ FROM ent.propriete_scolarite
+ WHERE annee_scolaire_id = pps_ens_matiere_a_creer.annee_scolaire_id
+ AND etablissement_id = pps_ens_matiere_a_creer.etablissement_id
+ AND fonction_id = pps_ens_matiere_a_creer.fonction_id
+ AND matiere_id = pps_ens_matiere_a_creer.matiere_id
+ AND structure_enseignement_id IS NULL
+ AND porteur_ent_id IS NULL
+ )
+ GROUP BY annee_scolaire_id, etablissement_id, fonction_id, matiere_id
+ )
+ INSERT INTO ent.personne_propriete_scolarite (id, personne_id, propriete_scolarite_id, est_active)
+ SELECT
+ nextval('ent.personne_propriete_scolarite_id_seq'),
+ pps_a_creer.personne_id,
+ ps.id,
+ true
+ FROM pps_ens_matiere_a_creer AS pps_a_creer
+ INNER JOIN ent.propriete_scolarite AS ps
+ ON ps.annee_scolaire_id = pps_a_creer.annee_scolaire_id
+ AND ps.etablissement_id = pps_a_creer.etablissement_id
+ AND ps.fonction_id = pps_a_creer.fonction_id
+ AND ps.matiere_id = pps_a_creer.matiere_id
+ AND structure_enseignement_id IS NULL
+ AND porteur_ent_id IS NULL
+ WHERE NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps_a_creer.personne_id
+ AND propriete_scolarite_id = ps.id
+ AND est_active = true
+ )
+ GROUP BY pps_a_creer.personne_id, ps.id;
+ </sql>
+
+ <!-- Création des groupes d'enseignants dans un établissement -->
+ <sql>
+ WITH
+ pps_ens_a_creer AS (
+ SELECT pps.personne_id, ps.annee_scolaire_id, se.etablissement_id, ps.fonction_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ent.propriete_scolarite AS ps ON pps.propriete_scolarite_id = ps.id
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ INNER JOIN ent.structure_enseignement AS se ON ps.structure_enseignement_id = se.id
+ WHERE f.code = 'ENS'
+ AND pps.est_active = true
+ GROUP BY pps.personne_id, ps.annee_scolaire_id, se.etablissement_id, ps.fonction_id
+ ),
+ ps_crees AS (
+ INSERT INTO ent.propriete_scolarite (id, annee_scolaire_id, etablissement_id, fonction_id)
+ SELECT
+ nextval('ent.propriete_scolarite_id_seq'),
+ annee_scolaire_id,
+ etablissement_id,
+ fonction_id
+ FROM pps_ens_a_creer
+ WHERE NOT EXISTS (
+ SELECT annee_scolaire_id, etablissement_id, fonction_id
+ FROM ent.propriete_scolarite
+ WHERE annee_scolaire_id = pps_ens_a_creer.annee_scolaire_id
+ AND etablissement_id = pps_ens_a_creer.etablissement_id
+ AND fonction_id = pps_ens_a_creer.fonction_id
+ AND structure_enseignement_id IS NULL
+ AND matiere_id IS NULL
+ )
+ GROUP BY annee_scolaire_id, etablissement_id, fonction_id
+ )
+ INSERT INTO ent.personne_propriete_scolarite (id, personne_id, propriete_scolarite_id, est_active)
+ SELECT
+ nextval('ent.personne_propriete_scolarite_id_seq'),
+ pps_a_creer.personne_id,
+ ps.id,
+ true
+ FROM pps_ens_a_creer AS pps_a_creer
+ INNER JOIN ent.propriete_scolarite AS ps
+ ON ps.annee_scolaire_id = pps_a_creer.annee_scolaire_id
+ AND ps.etablissement_id = pps_a_creer.etablissement_id
+ AND ps.fonction_id = pps_a_creer.fonction_id
+ AND ps.structure_enseignement_id IS NULL
+ AND ps.porteur_ent_id IS NULL
+ WHERE NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps_a_creer.personne_id
+ AND propriete_scolarite_id = ps.id
+ AND est_active = true
+ )
+ GROUP BY pps_a_creer.personne_id, ps.id;
+ </sql>
+
+ <!-- Mise à null de etablissement_id pour les PS dont la portée est 'structure d'enseignement' -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET etablissement_id = NULL
+ FROM ent.fonction AS f
+ WHERE f.code = 'ENS'
+ AND fonction_id = f.id
+ AND structure_enseignement_id IS NOT NULL
+ </sql>
+
+ <!-- Suppression des doublons des PS liées aux établissements avec matière -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, etablissement_id, matiere_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ENS'
+ AND etablissement_id IS NOT NULL
+ AND matiere_id IS NOT NULL
+ GROUP BY annee_scolaire_id, etablissement_id, matiere_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.etablissement_id = ps_doublon_a_garder.etablissement_id
+ AND ps_doublon_a_supprimer.matiere_id = ps_doublon_a_garder.matiere_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des doublons des PS liées aux établissements sans matière -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, etablissement_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ENS'
+ AND etablissement_id IS NOT NULL
+ AND matiere_id IS NULL
+ GROUP BY annee_scolaire_id, etablissement_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.etablissement_id = ps_doublon_a_garder.etablissement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ <!-- Suppression des doublons des PS liées aux structures d'enseignement -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, structure_enseignement_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ENS'
+ AND structure_enseignement_id IS NOT NULL
+ GROUP BY annee_scolaire_id, structure_enseignement_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.structure_enseignement_id = ps_doublon_a_garder.structure_enseignement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="8" author="bper">
+ <comment>
+ Nettoyage des tables 'personne_propriete_scolarite' et 'propriete_scolarite' pour le profil 'CD'
+ </comment>
+
+ <!-- Changement de la portée 'structure enseignement' et 'établissement' => 'porteur ENT' -->
+ <sql>
+ WITH
+ ps_a_modifier AS (
+ SELECT ps.id AS id, COALESCE(etab.porteur_ent_id, se_etab.porteur_ent_id) AS porteur_ent_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ LEFT JOIN ent.etablissement AS etab ON ps.etablissement_id = etab.id
+ LEFT JOIN ent.structure_enseignement AS se ON ps.structure_enseignement_id = se.id
+ LEFT JOIN ent.etablissement AS se_etab ON se.etablissement_id = etab.id
+ WHERE f.code = 'CD'
+ AND COALESCE(etab.porteur_ent_id, se_etab.porteur_ent_id) IS NOT NULL
+ AND ps.porteur_ent_id IS NULL
+ )
+ UPDATE ent.propriete_scolarite AS ps
+ SET porteur_ent_id = ps_a_modifier.porteur_ent_id
+ FROM ps_a_modifier
+ WHERE ps.id = ps_a_modifier.id;
+
+ UPDATE ent.propriete_scolarite
+ SET etablissement_id = NULL,
+ structure_enseignement_id = NULL
+ FROM ent.fonction AS f
+ WHERE f.code = 'CD'
+ AND fonction_id = f.id;
+ </sql>
+
+ <!-- Suppression des doublons des PS liées aux porteurs ENT-->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, porteur_ent_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'CD'
+ AND porteur_ent_id IS NOT NULL
+ GROUP BY annee_scolaire_id, porteur_ent_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.porteur_ent_id = ps_doublon_a_garder.porteur_ent_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="9" author="bper">
+ <comment>
+ Nettoyage des tables 'personne_propriete_scolarite' et 'propriete_scolarite' pour tous les profils sauf 'CD','ELEVE','PERS_REL_ELEVE','ENS'
+ </comment>
+
+ <!-- Seule portée 'établissement' est possible pour ces profils -->
+ <sql>
+ WITH ps_etab_a_initialiser AS (
+ SELECT ps.id AS id, se.etablissement_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ INNER JOIN ent.structure_enseignement AS se ON ps.structure_enseignement_id = se.id
+ WHERE f.code NOT IN ('CD','ELEVE','PERS_REL_ELEVE','ENS')
+ AND ps.etablissement_id IS NULL
+ )
+ UPDATE ent.propriete_scolarite AS ps
+ SET etablissement_id = ps_etab_a_initialiser.etablissement_id
+ FROM ps_etab_a_initialiser
+ WHERE ps.id = ps_etab_a_initialiser.id;
+
+ WITH ps_a_modifier AS (
+ SELECT ps.*
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code NOT IN ('CD','ELEVE','PERS_REL_ELEVE','ENS')
+ )
+ UPDATE ent.propriete_scolarite AS ps
+ SET structure_enseignement_id = NULL,
+ porteur_ent_id = NULL
+ FROM ps_a_modifier
+ WHERE ps.id = ps_a_modifier.id;
+ </sql>
+
+ <!-- Suppression des doublons -->
+ <sql>
+ WITH
+ ps_doublon_a_garder AS (
+ SELECT min(ps.id) AS id, annee_scolaire_id, etablissement_id, fonction_id
+ FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code NOT IN ('CD','ELEVE','PERS_REL_ELEVE','ENS')
+ AND etablissement_id IS NOT NULL
+ GROUP BY annee_scolaire_id, etablissement_id, fonction_id
+ HAVING count(*) > 1
+ ),
+ ps_doublon_id_map AS (
+ SELECT ps_doublon_a_supprimer.id AS ps_doublon_a_supprimer_id,
+ ps_doublon_a_garder.id AS ps_doublon_a_garder_id
+ FROM ent.propriete_scolarite AS ps_doublon_a_supprimer
+ INNER JOIN ps_doublon_a_garder
+ ON ps_doublon_a_supprimer.annee_scolaire_id = ps_doublon_a_garder.annee_scolaire_id
+ AND ps_doublon_a_supprimer.etablissement_id = ps_doublon_a_garder.etablissement_id
+ AND ps_doublon_a_supprimer.fonction_id = ps_doublon_a_garder.fonction_id
+ AND ps_doublon_a_supprimer.id NOT IN (SELECT id FROM ps_doublon_a_garder)
+ ),
+ pps_doublon_a_deplacer AS (
+ SELECT min(pps.id) AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = true
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = true
+ )
+ GROUP BY pps.personne_id, map.ps_doublon_a_garder_id
+ UNION
+ SELECT pps.id AS id, map.ps_doublon_a_garder_id AS new_ps_id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.est_active = false
+ AND pps.date_desactivation IS NOT NULL
+ AND NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = pps.personne_id
+ AND propriete_scolarite_id = map.ps_doublon_a_garder_id
+ AND est_active = false
+ AND date_desactivation >= pps.date_desactivation
+ )
+ ),
+ pps_doublon_a_supprimer AS (
+ SELECT pps.id
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ps_doublon_id_map AS map
+ ON pps.propriete_scolarite_id = map.ps_doublon_a_supprimer_id
+ WHERE pps.id NOT IN (SELECT id FROM pps_doublon_a_deplacer)
+ ),
+ pps_deplacees AS (
+ UPDATE ent.personne_propriete_scolarite AS pps
+ SET propriete_scolarite_id = pps_doublon_a_deplacer.new_ps_id
+ FROM pps_doublon_a_deplacer
+ WHERE pps.id = pps_doublon_a_deplacer.id
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE id IN (SELECT id FROM pps_doublon_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT ps_doublon_a_supprimer_id FROM ps_doublon_id_map);
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="10" author="bper">
+ <comment>
+ Ajout des contraintes d'intégrité
+ </comment>
+
+ <!-- Suppression des indexes inutiles -->
+ <dropIndex
+ schemaName="ent"
+ tableName="propriete_scolarite"
+ indexName="idx_propriete_scolarite_etablissement_id_fonction_id"/>
+
+ <dropIndex
+ schemaName="ent"
+ tableName="propriete_scolarite"
+ indexName="idx_propriete_scolarite_structure_enseignement_id_fonction_id_m"/>
+
+ <dropIndex
+ schemaName="ent"
+ tableName="personne_propriete_scolarite"
+ indexName="idx_personne_propriete_scolarite_compteur_references"/>
+
+ <!-- Matière n'a un sens que pour les groupes dont la portée est 'établissement' :
+ groupes d'enseignants d'une matière dans un établissement -->
+ <sql>
+ UPDATE ent.propriete_scolarite
+ SET matiere_id = NULL
+ WHERE id NOT IN (
+ SELECT ps.id FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'ENS'
+ AND ps.structure_enseignement_id IS NULL
+ AND ps.porteur_ent_id IS NULL
+ AND ps.etablissement_id IS NOT NULL
+ )
+ AND matiere_id IS NOT NULL;
+
+ ALTER TABLE ent.propriete_scolarite
+ ADD CONSTRAINT chk_matiere_id
+ CHECK (
+ (matiere_id IS NOT NULL AND etablissement_id IS NOT NULL)
+ OR
+ (matiere_id IS NULL)
+ );
+ </sql>
+
+ <!-- Suppression des PS sans portée définie -->
+ <sql>
+ WITH
+ ps_a_supprimer AS (
+ SELECT id FROM ent.propriete_scolarite
+ WHERE structure_enseignement_id IS NULL
+ AND etablissement_id IS NULL
+ AND porteur_ent_id IS NULL
+ ),
+ pps_supprimees AS (
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE propriete_scolarite_id IN (SELECT id FROM ps_a_supprimer)
+ )
+ DELETE FROM ent.propriete_scolarite
+ WHERE id IN (SELECT id FROM ps_a_supprimer);
+ </sql>
+
+ <!-- Contrainte d'exclusion des portées -->
+ <sql>
+ ALTER TABLE ent.propriete_scolarite
+ ADD CONSTRAINT chk_structure_enseignement_or_etablissement_or_porteur_not_null
+ CHECK (
+ (structure_enseignement_id IS NOT NULL AND etablissement_id IS NULL AND porteur_ent_id IS NULL)
+ OR
+ (structure_enseignement_id IS NULL AND etablissement_id IS NOT NULL AND porteur_ent_id IS NULL)
+ OR
+ (structure_enseignement_id IS NULL AND etablissement_id IS NULL AND porteur_ent_id IS NOT NULL)
+ );
+ </sql>
+
+ <!-- Ajout des contraintes d'unicité pour les groupes de la portée 'structure d'enseignement' -->
+ <sql>
+ CREATE UNIQUE INDEX idx_ps_structure_enseignement_id_fonction_id_responsable
+ ON ent.propriete_scolarite (structure_enseignement_id, fonction_id, responsable_structure_enseignement, annee_scolaire_id)
+ WHERE responsable_structure_enseignement IS NOT NULL;
+
+ CREATE UNIQUE INDEX idx_ps_structure_enseignement_id_fonction_id
+ ON ent.propriete_scolarite (structure_enseignement_id, fonction_id, annee_scolaire_id)
+ WHERE responsable_structure_enseignement IS NULL;
+ </sql>
+
+ <!-- Ajout des contraintes d'unicité pour les groupes de la portée 'établissement' -->
+ <sql>
+ CREATE UNIQUE INDEX idx_ps_etablissement_id_fonction_id_matiere_id
+ ON ent.propriete_scolarite (etablissement_id, fonction_id, matiere_id, annee_scolaire_id)
+ WHERE matiere_id IS NOT NULL;
+
+ CREATE UNIQUE INDEX idx_ps_etablissement_id_fonction_id
+ ON ent.propriete_scolarite (etablissement_id, fonction_id, annee_scolaire_id)
+ WHERE matiere_id IS NULL;
+ </sql>
+
+ <!-- Ajout des contraintes d'unicité pour les groupes de la portée 'porteur ENT' -->
+ <sql>
+ CREATE UNIQUE INDEX idx_ps_porteur_ent_id_fonction_id
+ ON ent.propriete_scolarite (porteur_ent_id, fonction_id, annee_scolaire_id)
+ </sql>
+
+ </changeSet>
+
+ <changeSet id="11" author="agia">
+
+ <sql>
+ ALTER TABLE ent.propriete_scolarite
+ DROP CONSTRAINT chk_responsable_structure_ens_dep_structure_ens;
+
+ ALTER TABLE ent.propriete_scolarite
+ ADD CONSTRAINT chk_responsable_structure_ens_dep_structure_ens
+ CHECK (
+ (responsable_structure_enseignement = true AND structure_enseignement_id IS NOT NULL)
+ OR
+ (responsable_structure_enseignement IS NULL)
+ OR
+ (responsable_structure_enseignement = false)
+ );
+ </sql>
+
+ </changeSet>
+
+</databaseChangeLog>
<include file="changelogs/scolarite/2013-07-16-0028847.xml"/>
<include file="changelogs/scolarite/2013-07-24-0028847.xml"/>
<include file="changelogs/scolarite/2013-07-31-0029591.xml"/>
+ <include file="changelogs/scolarite/2013-08-01-0028847.xml"/>
</databaseChangeLog>
Autorite eleve,
StructureEnseignement structureEnseignement) {
if (!localStructureEnseignementService.isEleveDansStructureEnseignement(
- securiteSession,
localPersonneService.findPersonneByAutorite(eleve),
structureEnseignement
)) {
throws IncidentException, SanctionException, PunitionException {
// supprime punitions + sanctions
- absencesSanctionService.internalSupprimeSanctions(incident)
+ absencesSanctionService.internalSupprimeSanctions(securiteSession,incident)
absencesPunitionService.internalSupprimePunitions(incident)
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
* @param incident
* @throws SanctionException
*/
- public void internalSupprimeSanctions(Incident incident) throws SanctionException {
+ public void internalSupprimeSanctions(SecuriteSession securiteSession,
+ Incident incident) throws SanctionException {
List<Sanction> sanctions = Sanction.findAllByIncident(incident)
// on n'attend pas trop des sanctions liees a un incident, donc on peut
// se permettre de faire un each - ca coute moins que les problemes avec
// la suppression par executeUpdate()
sanctions.each { Sanction sanction ->
- internalSupprimeSanction(sanction)
+ supprimeSanction(securiteSession, sanction)
}
}
referentiel.structureEnseignements = localStructureEnseignementService.
findAllStructureEnseignementForPersonne(
- securiteSession,
eleve
)
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeIncidentService
import org.lilie.services.eliot.absences.parametrage.incidentpunitionsanction.AbsencesTypeSanctionService
-class AbsencesIncidentServiceIntegrationTests extends GrailsUnitTestCase {
+class AbsencesIncidentServiceTests extends GrailsUnitTestCase {
AbsencesIncidentService absencesIncidentService
InitDonneesCommunesTestAbsenceService initDonneesCommunesTestAbsenceService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.absences.securite.DroitsService
-import org.lilie.services.eliot.absences.fonctionnalites.AbsencesFonctionnaliteAnc
+import org.lilie.services.eliot.absences.AbsencesFonctionnalite
class DroitsServiceIntegrationTests extends GrailsUnitTestCase {
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.AutoriteTypeEliot
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.absences.parametrage.general.AbsencesGeneralService
import org.lilie.services.eliot.parametrages.motifs.MotifService
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* @author bper
InitDonneesCommunesTestAbsenceJourneeService initDonneesCommunesTestAbsenceJourneeService
InitDonneesCommunesTestPreferencesAbsencesService initDonneesCommunesTestPreferencesAbsencesService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
PreferencesEtablissementAbsencesService preferencesEtablissementAbsencesService
AbsencesGeneralService absencesGeneralService
LocalStructureEnseignementService localStructureEnseignementService
TempsAgendaService tempsAgendaService
TempsEvenementService tempsEvenementService
- EleveAnnuaireService eleveAnnuaireService
MotifService motifService
classe.addToGroupes(groupe)
eleves.each {
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(it, groupe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(it, groupe)
}
return groupe
Boolean isEleveOfStructure = (recapComposant.eleve && recapComposant.service) ?
localStructureEnseignementService.
isEleveDansStructureEnseignement(
- securiteSession,
recapComposant.eleve,
recapComposant.service.structureEnseignement) : false
// Vérifie si l'élève est parmi les élèves de la classe
Boolean isEleveOfClasse = localStructureEnseignementService.
isEleveDansStructureEnseignement(
- securiteSession,
eleve,
periode.classe)
evaluation.enseignement.service.structureEnseignement
noteParams = noteParams.findAll {
localStructureEnseignementService.isEleveDansStructureEnseignement(
- null,
it.eleve,
structureEnseignement
)
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
-import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.annuaire.Fonction
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
import org.lilie.services.eliot.annuaire.Mef
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.scolarite.ModaliteMatiere
import org.lilie.services.eliot.scolarite.EleveProprietesService
import org.lilie.services.eliot.scolarite.EleveProprietesInfo
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Données de test et méthodes d'utilité
InitPeriodeTestService initPeriodeTestService
AnneeScolaireService anneeScolaireService
EleveProprietesService eleveProprietesService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
SessionFactory sessionFactory
}
void initPeriodesTrimestre(StructureEnseignement classe) {
- classe?.structureEnseignementNotes.typeIntervalle = TypeIntervalleEnum.TRIMESTRE
+ classe.structureEnseignementNotes.typeIntervalle = TypeIntervalleEnum.TRIMESTRE
classe.save()
getOuCreePeriode(initPeriodeTestService.t1, classe)
}
void initPeriodesSemestre(StructureEnseignement classe) {
- classe?.structureEnseignementNotes.typeIntervalle = TypeIntervalleEnum.SEMESTRE
+ classe.structureEnseignementNotes.typeIntervalle = TypeIntervalleEnum.SEMESTRE
classe.save()
getOuCreePeriode(initPeriodeTestService.s1, classe)
/**
* Crée un service minimal
- * @param matiere matière
* @author msan
*/
Service creeService(Matiere matiere,
/**
* Attache service à toutes les périodes de la structure
- * @param structureEnseignement
- * @param service
*/
private void attacheService(StructureEnseignement structureEnseignement, Service service) {
structureEnseignement.periodes.each { Periode periode ->
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
- * @return
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periode, service)
/**
* Crée un enseignement
- * @param enseignant
- * @param service
- * @return
*/
Enseignement creeEnseignement(Autorite enseignant, Service service) {
Enseignement enseignement = new Enseignement(
void attacheEleveClasse(Personne eleve,
StructureEnseignement classe) {
- ProprietesScolarite ps = new ProprietesScolarite(
- etablissement: classe.etablissement,
- structureEnseignement: classe,
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours()
- )
-
- ps.save(failOnError: true)
-
- PersonneProprietesScolarite pps =
- new PersonneProprietesScolarite(
- personne: eleve,
- proprietesScolarite: ps,
- estActive: true
- )
- pps.save(flush: true, failOnError: true)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe)
}
StructureEnseignement classe,
Boolean isProfPrincipal) {
- ProprietesScolarite ps = new ProprietesScolarite(
- etablissement: classe.etablissement,
- structureEnseignement: classe,
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- responsableStructureEnseignement: isProfPrincipal,
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours()
- )
-
- ps.save(failOnError: true)
-
- PersonneProprietesScolarite pps =
- new PersonneProprietesScolarite(
- personne: prof,
- proprietesScolarite: ps,
- estActive: true
- )
- pps.save(flush: true, failOnError: true)
+ proprieteScolariteTestUtilService.ajouteEnseignantDansStructureEnseignement(prof, classe, isProfPrincipal)
}
// creation des donnees de test est forcement longue et parait complexe a CodeNarc
/**
* Cree ResultatEleveServicePeriode
- * @param eleve
- * @param service
- * @param periode
- * @param note
- * @return resultat
*/
ResultatEleveServicePeriode creeResultatEleveServicePeriode(Personne eleve,
Service service,
/**
* Cree AppreciationElevePeriode
- * @param eleve
- * @param periode
- * @param appr
- * @return appreciation
*/
AppreciationElevePeriode creeAppreciationElevePeriode(Personne eleve,
Periode periode,
/**
* Cree AppreciationEleveEnseignementPeriode
- * @param eleve
- * @param periode
- * @param enseignement
- * @param appr
- * @return appreciation
*/
AppreciationEleveEnseignementPeriode creeAppreciationEleveEnseignementPeriode(Personne eleve,
Enseignement enseignement,
package org.lilie.services.eliot.notes
import grails.test.GrailsUnitTestCase
-import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.test.InitPeriodeTestService
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.notes.resultat.eleve.AppreciationElevePeriodeService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
InitDonneesNotesTestService initDonneesNotesTestService
InitPeriodeTestService initPeriodeTestService
- AnneeScolaireService anneeScolaireService
AppreciationElevePeriodeService appreciationElevePeriodeService
ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
initPeriodeTestService.initialisePeriodesDeTest()
initDonneesNotesTestService.initDonneesTest()
- //anneescolaire
- AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
-
//StrcureEnseignement
StructureEnseignement classe1 = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
// creer une personne eleve et l'ajouter dans la classe classe1enTrimestres
eleve = creePersonne("11110147800011")
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve,
- classe1.etablissement,
- classe1,
- anneeScolaire,
- null,
- true
+ classe1
)
//get periode de notation
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService\r
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService\r
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService\r
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService\r
import org.lilie.services.eliot.brevet.BrevetEpreuve\r
import org.lilie.services.eliot.brevet.BrevetSerie\r
import org.lilie.services.eliot.test.PopulationTestActeur\r
import org.lilie.services.eliot.textes.TypeActiviteParDefaut\r
import org.lilie.services.eliot.scolarite.IntervalleEnum\r
import java.math.RoundingMode\r
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService\r
\r
/**\r
* Testes de BrevetNoteService\r
LocalStructureEnseignementService localStructureEnseignementService\r
AnneeScolaireService anneeScolaireService\r
LocalPersonneService localPersonneService\r
- EleveAnnuaireService eleveAnnuaireService\r
BrevetRelEpreuveMatiereService brevetRelEpreuveMatiereService\r
MatiereService matiereService\r
ResultatEleveServicePeriodeService resultatEleveServicePeriodeService\r
AppreciationEleveEnseignementPeriodeService appreciationEleveEnseignementPeriodeService\r
RelPeriodeServiceService relPeriodeServiceService\r
InitDonneesNotesTestService initDonneesNotesTestService\r
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService\r
\r
Etablissement etablissement = null\r
StructureEnseignement classe = null\r
eleve2 = localPersonneService.creePersonne("nom2", "eleve prenom2")\r
prof1 = localPersonneService.creePersonne("nom1", "prof prenom1")\r
prof2 = localPersonneService.creePersonne("nom2", "prof prenom2")\r
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)\r
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)\r
+\r
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)\r
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)\r
\r
serie = BrevetSerie.findByLibelleCourtAndAnneeScolaire(\r
"Générale",\r
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.notes.brevet.BrevetOptionsEleve
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.notes.brevet.BrevetNoteService
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Options d'eleves
LocalStructureEnseignementService localStructureEnseignementService
AnneeScolaireService anneeScolaireService
LocalPersonneService localPersonneService
- EleveAnnuaireService eleveAnnuaireService
InitDonneesNotesTestService initDonneesNotesTestService
BrevetOptionsEleveService brevetOptionsEleveService
BrevetNoteService brevetNoteService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Etablissement etablissement = null
StructureEnseignement classe = null
eleve4 = localPersonneService.creePersonne("nom4", "prenom4")
eleve5 = localPersonneService.creePersonne("nom5", "prenom5")
eleve6 = localPersonneService.creePersonne("nom6", "prenom6")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve3, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve4, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve5, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve6, classe)
+
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve3, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve4, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve5, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve6, classe)
serieCollege = BrevetSerie.findByLibelleCourtAndAnneeScolaire(
"Générale",
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.notes.brevet.BrevetClasseService
import org.lilie.services.eliot.brevet.BrevetSerie
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
-import org.lilie.services.eliot.annuaire.SecuriteSession
import grails.test.GrailsUnitTestCase
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
class BrevetServiceTests extends GrailsUnitTestCase {
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
LocalStructureEnseignementService localStructureEnseignementService
LocalPersonneService localPersonneService
- EleveAnnuaireService eleveAnnuaireService
AnneeScolaireService anneeScolaireService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Etablissement etablissement = null
StructureEnseignement classe = null
eleve1 = localPersonneService.creePersonne("nom1", "prenom1")
eleve2 = localPersonneService.creePersonne("nom2", "prenom2")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)
+
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)
}
protected void tearDown() {
brevetClasseService.isClasseIncriteAuBrevet(classe)
)
- SecuriteSession securiteSession = DefaultSecuriteSessionFactory.
- getEliotNotesSecuriteSessionForCodePorteurENT(
- etablissement.codePorteurENT)
-
BrevetSerie serie = BrevetSerie.createCriteria().get{maxResults(1)}
brevetClasseService.inscrisClasseAuBrevet(classe, serie, new Date())
import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.securite.AutorisationException
+
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+
import org.lilie.services.eliot.annuaire.*
import org.lilie.services.eliot.scolarite.*
import org.lilie.services.eliot.test.*
Evaluation eval_SS1_T3 = null
Evaluation eval_SS2_T3 = null
- //L'année scolaire
- AnneeScolaire anneeScolaire = null
-
//les notes de serviceNormal pour chaque periode
Note note_SN_T1 = null
Note note_SN_T2 = null
"code1",
"libelle1",
etablissement1)
+
modaliteMatiere2 = creeModaliteMatiere(
"code2",
"libelle2",
etablissement1)
- //anneescolaire
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
-
//eleves
eleve1 = localInitDonneesCommunesTestService.getPersonne(
PopulationTestActeur.ELEVE_1_CLASSE_1)
classe1enTrimestres.save()
//ajouter (inscription) les deux eleves eleve1 et eleve2 au classe1Trimestre1
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- true
+ classe1enTrimestres
)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- true
+ classe1enTrimestres
)
//get periode de notation
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.scolarite.matiere.MatiereService
import org.lilie.services.eliot.brevet.BrevetFiche
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Publipostage des Brevets
LocalStructureEnseignementService localStructureEnseignementService
AnneeScolaireService anneeScolaireService
LocalPersonneService localPersonneService
- EleveAnnuaireService eleveAnnuaireService
InitDonneesNotesTestService initDonneesNotesTestService
ImpressionRequetageBrevetService impressionRequetageBrevetService
MatiereService matiereService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Etablissement etablissement = null
StructureEnseignement classe = null
ficheEleve2 = new BrevetFiche(eleve: eleve2, anneeScolaire: anneeScolaire)
ficheEleve2.save()
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe, anneeScolaire)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe, anneeScolaire)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)
matiere = matiereService.creeMatiereManuel(
securiteSessionDirection,
/**
* Verifie total des points
- * @param brevetImpressions
*/
void verifieTotal(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find
/**
* Verifie epreuve pas notee
- * @param brevetImpressions
*/
void verifieEpreuvePasNotee(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find
/**
* Verifie epreuve personalisable
- * @param brevetImpressions
*/
void verifieEpreuvePersonalisable(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie epreuve avec une note textuelle
- * @param brevetImpressions
*/
void verifieEpreuveNoteTextuelle(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie epreuve avec un coffeficinte > 1 (noteMax > 20)
- * @param brevetImpressions
*/
void verifieEpreuveCoeff(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie epreuve normal
- * @param brevetImpressions
*/
void verifieEpreuveNormalle(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie epreuve optionelle
- * @param brevetImpressions
*/
void verifieEpreuveOptionelle(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie epreuve indicative
- * @param brevetImpressions
*/
void verifieEpreuveIndicative(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie donnees generales des eleves
- * @param brevetImpressions
*/
void verifieDonnesGenerales(List<BrevetImpression> brevetImpressions) {
BrevetImpression brevetEleve1 = brevetImpressions.find { it.personne.id == eleve1.id }
/**
* Verifie les donnees d'un eleve
- * @param brevetImpression
- * @param eleve
- * @param etablissement
*/
void verifieInfoEleve(BrevetImpression brevetImpression,
Personne eleve,
/**
* Prepare les donnees de test
- * @param securiteSession
*/
void prepareNotesDeTest(SecuriteSession securiteSession) {
}
/**
- * Cree une note
- * @param eleve
- * @param epreuve
- * @param note
- * @param appreciation
- * @return
+ * Crée une note
*/
BrevetNote creeBrevetNote(Personne eleve,
BrevetEpreuve epreuve,
/**
* Cree une note textuelle
- * @param eleve
- * @param epreuve
- * @param notePart
- * @param appreciation
- * @return
*/
BrevetNote creeBrevetNoteTextuelle(Personne eleve,
BrevetEpreuve epreuve,
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.ModaliteCours
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.scolarite.matiere.MatiereService
import org.lilie.services.eliot.notes.notes.NotesNoteService
import org.lilie.services.eliot.notes.notes.NoteParams
import org.lilie.services.eliot.notes.notes.EvaluationParams
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Tests de MoyenneService pour les notes textuelles (Annotations)
LocalStructureEnseignementService localStructureEnseignementService
AnneeScolaireService anneeScolaireService
LocalPersonneService localPersonneService
- EleveAnnuaireService eleveAnnuaireService
MatiereService matiereService
NotesPeriodeService notesPeriodeService
NotesServiceService notesServiceService
NotesSousServiceService notesSousServiceService
ModaliteMatiereService modaliteMatiereService
ResultatEleveSousServicePeriodeService resultatEleveSousServicePeriodeService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Etablissement etablissement
SecuriteSession securiteSession
eleve = localPersonneService.creePersonne("nom1", "eleve prenom1")
profBaudet = localPersonneService.creePersonne("nom1 Baudet", "prof prenom1")
profChazal = localPersonneService.creePersonne("nom2 Chazal", "prof prenom2")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe)
matiereMath = matiereService.creeMatiereManuel(
securiteSession,
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.notes.brevet.NoteTextuellesEnum
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
import org.lilie.services.eliot.notes.export.notanet.dto.NotanetNote
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Extraction a verification des donnes pour Notanet
LocalStructureEnseignementService localStructureEnseignementService
AnneeScolaireService anneeScolaireService
LocalPersonneService localPersonneService
- EleveAnnuaireService eleveAnnuaireService
InitDonneesNotesTestService initDonneesNotesTestService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Etablissement etablissement = null
StructureEnseignement classe = null
eleve5 = localPersonneService.creePersonne("nom5", "prenom5")
eleve6 = localPersonneService.creePersonne("nom6", "prenom6")
eleve7 = localPersonneService.creePersonne("nom7", "prenom7")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve3, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve4, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve5, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve6, classe)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve7, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve3, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve4, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve5, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve6, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve7, classe)
}
protected void tearDown() {
/**
* Verifie que la note d'eleve pour une epreuve est comme prevu
- * @param export
- * @param eleve
- * @param codeEpreuve
- * @param noteAttendue
*/
private void verifieNote(NotanetExportNotanet export, Personne eleve,
String codeEpreuve, String noteAttendue, String appreciation = null) {
/**
* Verifie que l'infraction a ete detectee pour un eleve donne
- * @param exportNotanet
- * @param typeInfraction
- * @param eleve
*/
void verifieInfraction(NotanetExportNotanet exportNotanet,
TypeInfraction typeInfraction, Personne eleve) {
/**
* Preparation des donnees de test
- * @param securiteSession
*/
void prepareNotesDeTest(SecuriteSession securiteSession) {
/**
* Cree une note de brevet
- * @param eleve
- * @param epreuve
- * @param note
- * @param appreciation
- * @return
*/
BrevetNote creeBrevetNote(Personne eleve,
BrevetEpreuve epreuve,
/**
* Cree une note textuelle de brevet
- * @param eleve
- * @param epreuve
- * @param notePart
- * @param appreciation
- * @return
*/
BrevetNote creeBrevetNoteTextuelle(Personne eleve,
BrevetEpreuve epreuve,
initPeriodeTestService.annee, classe1enTrimestres)
//ajouter (inscription) l' eleve1 au classe1Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe1enTrimestres
)
//ajouter (inscription) l' eleve2 au classe1Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- classe1enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe1enTrimestres
)
//Enseignant
}
//ajouter (inscrire) l 'eleve1 dans classe1Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe1enTrimestres
)
//creer une classe
}
//ajouter (inscrire) l 'eleve2 dans classe2Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- classe2enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe2enTrimestres
)
//creer une classe
)
//ajouter (inscrire) l 'eleve1 dans classe3Semestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve3,
- etablissement1,
- classe3enSemestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe3enSemestres
)
periodeBrevetApresTest_1 = getOuCreePeriode(
//inscrire les deux eleves dans le regroupement
//ajouter (inscrire) l 'eleve1 dans regroupement
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- regroupement,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ regroupement
)
//ajouter (inscrire) l 'eleve2 dans regroupement
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- regroupement,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ regroupement
)
//crée un service composé de deux sousservices pour C1
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.textes.TypeActivite
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.IntervalleEnum
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Tests RecapElevePeriodeService
UptodateService uptodateService
MoyenneCalculLauncherService moyenneCalculLauncherService
StructureEnseignementNotesService structureEnseignementNotesService
- EleveAnnuaireService eleveAnnuaireService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
StructureEnseignement classe = null
eleve = creePersonne("111100098720000010")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe)
creeDonneesEleveClasse(eleve, classe)
}
StructureEnseignement classe2 =
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1_2)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe2)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe2)
creeDonneesEleveClasse(eleve, classe2)
- eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve, classe2)
+ proprieteScolariteTestUtilService.desactiveEleveDansStructureEnseignement(eleve, classe2)
testConstruisRecapElevePeriodes()
// Elève n'est plus dans la classe
- eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve, classe)
+ proprieteScolariteTestUtilService.desactiveEleveDansStructureEnseignement(eleve, classe)
testConstruisRecapElevePeriodes()
// Elève a une nouvelle classe
StructureEnseignement classe3 =
localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1_TES1)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve, classe3)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe3)
creeDonneesEleveClasse(eleve, classe3)
testConstruisRecapElevePeriodes()
assertEquals(
"Les reports de l'etablissement courant devrait etre supprimes",
0,
- Report.count()
+ Report.findAllByEtablissement(etablissementCourant).size()
)
}
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.scolarite.StructureEnseignementSts
import org.lilie.services.eliot.textes.TypeActivite
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.PeriodeService
import org.lilie.services.eliot.tableau.Tableau
import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
class TableauDeNotesServiceTests extends GrailsUnitTestCase {
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
MoyenneCalculLauncherService moyenneCalculLauncherService
AnneeScolaireService anneeScolaireService
- EleveAnnuaireService eleveAnnuaireService
PeriodeService periodeService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
InitPeriodeTestService initPeriodeTestService
TableauDeNotesService tableauDeNotesService
periodeService.creePeriodesNotationPourStructureEnseignement(classe2)
eleve1 = creePersonne("111100098720000010", "A", "B")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe1)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe1)
eleve2 = creePersonne("111101478000110000", "B", "A")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe2)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe2)
regroupement = creeRegroupement([classe1, classe2])
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, regroupement)
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, regroupement)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, regroupement)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, regroupement)
Service service = creeService(regroupement)
params)
verrouillePeriode(classe2, t3)
- eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve2, regroupement)
+ proprieteScolariteTestUtilService.desactiveEleveDansStructureEnseignement(eleve2, regroupement)
moyenneCalculLauncherService.calculeToutesMoyennes()
import org.lilie.services.eliot.notes.ResultatEleveSousServicePeriode
import org.lilie.services.eliot.notes.ResultatClasseSousServicePeriode
import org.lilie.services.eliot.notes.DirtyMoyenne
-import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
/**
* Tests de MoyenneService
UptodateService uptodateService
InfoCalculMoyennesClasseService infoCalculMoyennesClasseService
StructureEnseignementNotesService structureEnseignementNotesService
- EleveAnnuaireService eleveAnnuaireService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
Date dateEvaluation1 = new Date(111, 1, 1)
Date dateCreation1 = new Date(111, 1, 1)
classe.save(failOnError: true)
eleve1 = creePersonne("111100098720000010")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve1, classe)
eleve2 = creePersonne("11110147800011")
- eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve2, classe)
//get periode de notation
periodeT1 = initDonneesNotesTestService.getOuCreePeriode(
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes.resultat
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.test.PopulationTestMatiere
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
-import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
-import org.lilie.services.eliot.annuaire.Fonction
-import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
import org.lilie.services.eliot.test.PopulationTestActeur
InitDonneesNotesTestService initDonneesNotesTestService
InitPeriodeTestService initPeriodeTestService
NotesDirtyMoyenneService notesDirtyMoyenneService
- AnneeScolaireService anneeScolaireService
ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
StructureEnseignementNotesService structureEnseignementNotesService
//getMatiere
matiere1 = localInitDonneesCommunesTestService.
getMatiere(PopulationTestMatiere.FRANCAIS)
+
matiere2 = localInitDonneesCommunesTestService.
getMatiere(PopulationTestMatiere.MATH)
//get ModaliteMatiere
- modaliteMatiere1 = creeModaliteMatiere(
- "code1",
- "libelle1",
- etablissement1)
- modaliteMatiere2 = creeModaliteMatiere(
- "code2",
- "libelle2",
- etablissement1)
+ modaliteMatiere1 = creeModaliteMatiere("code1", "libelle1", etablissement1)
+ modaliteMatiere2 = creeModaliteMatiere("code2","libelle2", etablissement1)
//creer une classe
classe1enTrimestres = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
)
+
structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
classe1enTrimestres.save(failOnError: true)
//recuperer un enseignant2
enseignant2 = localInitDonneesCommunesTestService.
getAutorite(PopulationTestActeur.ENSEIGNANT_2)
+
//creer un service nomal (pas de sousservices) et un serviceParent(composé de 2 sousServices)
service = initDonneesNotesTestService.creeService(matiere1, classe1enTrimestres)
serviceParent = initDonneesNotesTestService.creeService(matiere2, classe1enTrimestres)
eleve1 = creePersonne("111100098720000010")
eleve2 = creePersonne("1000002540000001")
- ProprietesScolarite propretesScolarite = creeProprietesScolarite()
- creePersonneProprietesScolarite(eleve1, propretesScolarite)
- creePersonneProprietesScolarite(eleve2, propretesScolarite)
-
//ajouter (inscription) les deux eleves eleve1 et eleve2 au classe1Trimestre1
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe1enTrimestres
)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(
eleve2,
- etablissement1,
- classe1enTrimestres,
- anneeScolaireService.anneeScolaireEnCours(),
- null,
- true
+ classe1enTrimestres
)
//get periode de notation
periodeT1_1 = initDonneesNotesTestService.getOuCreePeriode(
initPeriodeTestService.t1, classe1enTrimestres)
+
periodeT2_1 = initDonneesNotesTestService.getOuCreePeriode(
initPeriodeTestService.t2, classe1enTrimestres)
//creation des sous services pour la periode T1
sousServiceT1_1 = creeSousService(serviceParent, modaliteMatiere1, 2, initPeriodeTestService.t1)
sousServiceT1_2 = creeSousService(serviceParent, modaliteMatiere2, 3, initPeriodeTestService.t1)
-
-
}
protected void tearDown() {
periodeT2_1,
enseignement2)
-
-
assertNotNull("""Le dirtyMoyenne qui correspond à l'eleve1-enseignement1-periodeT1_1
n'a pas été marqué""", dME1)
}
- /* marqueChangementsSousServices(List<Autorite> eleves,
- StructureEnseignement classe,
- Service service,
- List<SousService> sousServices,
- List<Periode> periodes) */
-
void testMarqueChangementSousServices() {
assertNotNull("""Le dirtyMoyenne qui correspond à l'eleve1-sousServiceT1_2-periodeT1_1
n'a pas été marqué""", dM2)
-
}
- //marqueChangementsService(List<Autorite> eleves, Service service, List<Periode> periodes)
void testMarqueChangementsService() {
assertNotNull("""Le dirtyMoyenne qui correspond à l'eleve2-ServiceParent-periodeT1_1
n'a pas été marqué""", dM4)
-
}
/**
* Crée une personne (eleve)
- * idExterne l'idExterne de la personne
- * @return personne l'eleve
* @author mjao
*/
private Personne creePersonne(String idExterne) {
return personne
}
- /**
- * Crée une ProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private ProprietesScolarite creeProprietesScolarite() {
-
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- etablissement: etablissement1
- )
- proprietesScolarite.save(failOnError: true)
-
- if (proprietesScolarite.hasErrors()) {
- println(proprietesScolarite.errors)
- }
-
- return proprietesScolarite
-
- }
-
- /**
- * Crée une PersonneProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private PersonneProprietesScolarite creePersonneProprietesScolarite(
- Personne personne,
- ProprietesScolarite proprietesScolarite
- ) {
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
-
- personne: personne,
- proprietesScolarite: creeProprietesScolarite(),
- estActive: true
-
- )
- personneProprietesScolarite.save(failOnError: true)
-
- return personneProprietesScolarite
- }
/**
* get un dirtyMoyenne d'enseignement
- * eleve l'eleve
- * periode la periode
- * enseignement l'enseignement
- * @return dirtyMoyenne
* @author mjao
*/
DirtyMoyenne findDirtyMoyenneEnseignement(Autorite eleve,
}
return dirtyMoyenne
}
+
/**
* get un dirtyMoyenne de sousServices
- * eleve l'eleve
- * periode la periode
- * enseignement l'enseignement
- * @return dirtyMoyenne
* @author mjao
*/
DirtyMoyenne findDirtyMoyenneSousService(Autorite eleve,
/**
* get un dirtyMoyenne d'un service
- * eleve l'eleve
- * periode la periode
- * enseignement l'enseignement
- * @return dirtyMoyenne
- *
- *
* @author mjao
*/
DirtyMoyenne findDirtyMoyenneService(Autorite eleve,
/**
* Creation d'une modalité Matiere attaché à un sous-service
- * @param sousservice sous-service attaché à la modalité matiere
- * @param code le code de la modaliteMatire
- * @param libelle le libelle de la modalitematiere
- * @param etablissement l'etablissement
- * @return modalité matiere
* @author mjao
*/
private ModaliteMatiere creeModaliteMatiere(String code,
String libelle,
Etablissement etablissement) {
+
ModaliteMatiere modaliteMatiere = new ModaliteMatiere(
code: code,
libelle: libelle,
etablissement: etablissement
-
)
modaliteMatiere.save(flush: true)
+
if (modaliteMatiere.hasErrors()) {
println(modaliteMatiere.errors)
}
/**
* Crée un sous-service
- * @return regroupment une structure d'enseignement
* @author mjao
*/
private SousService creeSousService(Service service,
}
return sousService
-
}
}
import grails.converters.JSON
import org.lilie.services.eliot.scolarite.parametrages.niveau.ScolariteNiveauGeneralService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.EliotConstantes
import org.hibernate.exception.ConstraintViolationException
import org.lilie.services.eliot.notification.parametrage.NotificationParametrageService
import org.lilie.services.eliot.notification.parametrage.NotificationParametrageEtablissement
import grails.converters.JSON
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.notification.parametrage.NotificationFonctionParametrage
import org.lilie.services.eliot.sms.SmsFournisseurService
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.SessionUtils
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.notification.parametrage.PreferencePersonneEtablissement
import org.lilie.services.eliot.scolarite.page.ScolaritePage
import org.lilie.services.eliot.annuaire.Fonction
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.securite.AutorisationException
import grails.converters.JSON
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteArbre
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnaliteParams
import org.lilie.services.eliot.securite.fonctionnalite.saisie.FonctionnalitePersonneParams
import org.lilie.services.eliot.scolarite.fonction.FonctionAnnuaireService
import org.lilie.services.eliot.scolarite.page.ScolaritePage
-import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
/**
* @author bahj , othe
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.scolarite.ScolariteFonctionnalites
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.scolarite.page.ScolaritePage
class ParametrageCalendrierAnnuelController extends AbstractScolariteController {
}
def criteria = ProprietesScolarite.createCriteria()
List<ProprietesScolarite> psResult = criteria.list() {
- eq("etablissement", etab)
if (structure) {
eq("structureEnseignement", structure)
+ } else {
+ eq("etablissement", etab)
}
if (fonction) {
eq("fonction", fonction)
users.each {user ->
PersonneProprietesScolarite.findAllByPersonne(user).each {
PersonneProprietesScolarite pps ->
+
+ ProprietesScolarite ps = pps.proprietesScolarite
+
AnnuaireConsultationProfilInfo acpi = new AnnuaireConsultationProfilInfo()
acpi.idExterne = user.autorite.idExterne
acpi.nom = user.nom
acpi.prenom = user.prenom
acpi.dateNaissance = user.dateNaissance
acpi.actif = pps.estActive
- acpi.etablissement = pps.proprietesScolarite?.etablissement
- acpi.structure = pps.proprietesScolarite?.structureEnseignement
- acpi.structureActive = pps.proprietesScolarite?.structureEnseignement?.actif ?: false
- acpi.isResponsableStructure = pps.proprietesScolarite?.responsableStructureEnseignement ?: false
- acpi.fonction = pps.proprietesScolarite?.fonction
- acpi.anneeScolaire = pps.proprietesScolarite?.anneeScolaire
- acpi.profil = pps.proprietesScolarite
+ acpi.etablissement = ps?.structureEnseignement ? ps.structureEnseignement.etablissement : ps?.etablissement
+ acpi.structure = ps?.structureEnseignement
+ acpi.structureActive = ps?.structureEnseignement?.actif ?: false
+ acpi.isResponsableStructure = ps?.responsableStructureEnseignement ?: false
+ acpi.fonction = ps?.fonction
+ acpi.anneeScolaire = ps?.anneeScolaire
+ acpi.profil = ps
+
result << acpi
}
}
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+
+
+package org.lilie.services.eliot.textes
+
+import org.lilie.services.eliot.test.InitDonneesCommunesTestTextesService
+import org.lilie.services.eliot.test.PopulationTestActeur
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.scolarite.ServiceService
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
+import org.lilie.services.eliot.test.PopulationTestClasse
+import org.lilie.services.eliot.scolarite.Matiere
+
+import org.lilie.services.eliot.test.PopulationTestMatiere
+import org.lilie.services.eliot.scolarite.ModaliteCours
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.test.InitStructureEnseignementTestService
+import org.lilie.services.eliot.test.PopulationTestGroupe
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
+import org.lilie.services.eliot.scolarite.enseignement.EnseignementMisAjourRapport
+import org.lilie.services.eliot.applications.textes.ActiviteParams
+import org.lilie.services.eliot.applications.textes.CreeChapitreInfo
+import org.lilie.services.eliot.textes.activite.TextesActiviteService
+
+/**
+ * Tests d'intégration de la classe CahierIncorporationService
+ * @author jtra
+ */
+class CahierIncorporationServiceTests extends GroovyTestCase {
+
+ InitDonneesCommunesTestTextesService initDonneesCommunesTestTextesService
+ TextesCahierDeTextesService textesCahierDeTextesService
+ TextesActiviteService textesActiviteService
+ TextesChapitreService textesChapitreService
+ CahierIncorporationService cahierIncorporationService
+ ServiceService serviceService
+ DistantStructureEnseignementService distantStructureEnseignementService
+ org.lilie.services.eliot.scolarite.matiere.MatiereService matiereService
+ InitStructureEnseignementTestService initStructureEnseignementTestService
+ org.lilie.services.eliot.scolarite.enseignement.EnseignementService enseignementService
+
+ // Cahiers utilisés par les tests
+ CahierDeTextes cahierServiceClasse1Enseignant1 = null
+ CahierDeTextes cahierServiceClasse1Enseignant2 = null
+ CahierDeTextes cahierServiceClasse1GroupeAEnseignant1 = null
+ CahierDeTextes cahierServiceClasse1GroupeBEnseignant2 = null
+ CahierDeTextes cahierServiceClasse1Enseignant1AutreModalite = null
+ CahierDeTextes cahierServiceClasse2Enseignant1 = null
+ CahierDeTextes cahierServiceClasse2GroupeAEnseignant1 = null
+ CahierDeTextes cahierServiceGroupeClasses1Et2Enseignant1 = null
+ CahierDeTextes cahierPrive = null
+
+ /**
+ * Initialisation du jeu de données utilisé par les tests (structures
+ * enseignements, services, enseignements, cahier de textes)
+ */
+ void setUp() {
+
+ // Initialisation des structures d'enseignement de test
+ initStructureEnseignementTestService.initialiseStructuresEnseignementDeTest()
+
+ // Récupération de la structure CLASSE_1
+ StructureEnseignement structureClasse1 =
+ initDonneesCommunesTestTextesService.getClasse(
+ PopulationTestClasse.HORS_ANNUAIRE_CLASSE_1
+ )
+
+ // Récupération de la structure CLASSE_1_GROUPE_A
+ StructureEnseignement structureClasse1GroupeA =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_A
+ )
+
+ // Récupération de la structure CLASSE_1_GROUPE_B
+ StructureEnseignement structureClasse1GroupeB =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_1_GROUPE_B
+ )
+
+ // Récupération de la structure CLASSE_2
+ StructureEnseignement structureClasse2 =
+ initDonneesCommunesTestTextesService.getClasse(
+ PopulationTestClasse.HORS_ANNUAIRE_CLASSE_2
+ )
+
+ // Récupération de la structure CLASSE_2_GROUPE_A
+ StructureEnseignement structureClasse2GroupeA =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_CLASSE_2_GROUPE_A
+ )
+
+ // Récupération de la structure GROUPE_CLASSES_1_ET_2
+ StructureEnseignement structureGroupeClasses1Et2 =
+ initDonneesCommunesTestTextesService.getGroupe(
+ PopulationTestGroupe.HORS_ANNUAIRE_GROUPE_CLASSES1_ET_2
+ )
+
+ // Récupération de la matière 1
+ Matiere matiere = initDonneesCommunesTestTextesService.getMatiere(
+ PopulationTestMatiere.MATH
+ )
+
+ // Récupération de la modalité par défaut
+ ModaliteCours modaliteCoursDefaut =
+ initDonneesCommunesTestTextesService.getModaliteTestCG()
+
+ // Récupération d'une autre modalité
+ ModaliteCours modaliteCoursAutre =
+ initDonneesCommunesTestTextesService.getModaliteTestTP()
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant2 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1_2
+ )
+
+ // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 1)
+ cahierServiceClasse1Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1 modalité par défaut (pour l'enseignant 2)
+ cahierServiceClasse1Enseignant2 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant2.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1_GROUPE_A (pour l'enseignant 1)
+ cahierServiceClasse1GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1GroupeA,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1_GROUPE_B (pour l'enseignant 2)
+ cahierServiceClasse1GroupeBEnseignant2 = creeCahierServiceEtDonneesScolarite(
+ structureClasse1GroupeB,
+ (Autorite) securiteSessionEnseignant2.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_1 autre modalité (pour l'enseignant 1)
+ cahierServiceClasse1Enseignant1AutreModalite = creeCahierServiceEtDonneesScolarite(
+ structureClasse1,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursAutre
+ )
+
+ // Création du cahier de service de CLASSE_2
+ cahierServiceClasse2Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse2,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de CLASSE_2_GROUPE_A
+ cahierServiceClasse2GroupeAEnseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureClasse2GroupeA,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création du cahier de service de GROUPE_CLASSES_1_ET_2
+ cahierServiceGroupeClasses1Et2Enseignant1 = creeCahierServiceEtDonneesScolarite(
+ structureGroupeClasses1Et2,
+ (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ matiere,
+ modaliteCoursDefaut
+ )
+
+ // Création d'un cahier privé
+ cahierPrive = textesCahierDeTextesService.creerCahierDeTextesPrive(
+ securiteSessionEnseignant1,
+ 'cahier privé',
+ 'description',
+ null,
+ null,
+ null
+ )
+ }
+
+ void testGetFilsCompatiblesIncorporationInfo() {
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ // Incorpore cahierServiceClasse1GroupeAEnseignant1 dans cahierServiceClasse1Enseignant1
+ cahierIncorporationService.incorporeCahierDans(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ // Ajoute un chapitre dans cahierServiceClasse1Enseignant1AutreModalite
+ textesChapitreService.creeChapitre(
+ securiteSessionEnseignant1,
+ new CreeChapitreInfo(
+ nom: 'chapitre',
+ description: 'description',
+ auteur: (Autorite) securiteSessionEnseignant1.defaultAutorite,
+ cahierDeTextes: cahierServiceClasse1Enseignant1AutreModalite
+ )
+ )
+
+ List<CahierIncorporationInfo> filsCompatiblesIncorporationInfo =
+ cahierIncorporationService.getFilsCompatiblesIncorporationInfo(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ assertEquals(
+ "Il doit y avoir 2 cahiers compatibles pour l'incorporation",
+ 2,
+ filsCompatiblesIncorporationInfo.size()
+ )
+
+ // Vérification des infos pour cahierServiceClasse1GroupeAEnseignant1
+ CahierIncorporationInfo cahierIncorporeInfo =
+ (CahierIncorporationInfo) filsCompatiblesIncorporationInfo.find {
+ it.id == cahierServiceClasse1GroupeAEnseignant1.id
+ }
+ assertNotNull(cahierIncorporeInfo)
+ assertEquals(cahierIncorporeInfo.idParent, cahierServiceClasse1Enseignant1.id)
+ assertTrue(cahierIncorporeInfo.estVide)
+ assertTrue(cahierIncorporeInfo.estIncorpore)
+
+ // Vérification des infos pour cahierServiceClasse1Enseignant1AutreModalite
+ CahierIncorporationInfo cahierNonVideInfo =
+ (CahierIncorporationInfo) filsCompatiblesIncorporationInfo.find {
+ it.id == cahierServiceClasse1Enseignant1AutreModalite.id
+ }
+
+ assertNotNull(cahierNonVideInfo)
+ assertEquals(cahierNonVideInfo.idParent, cahierServiceClasse1Enseignant1.id)
+ assertFalse(cahierNonVideInfo.estVide)
+ assertFalse(cahierNonVideInfo.estIncorpore)
+ }
+
+ void testFindCahiersParentsIncorporationCompatibles() {
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse1Enseignant1
+ ),
+ [
+ cahierServiceClasse1Enseignant1AutreModalite
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse1Enseignant2
+ ),
+ []
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse1GroupeAEnseignant1
+ ),
+ [
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1AutreModalite
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse1GroupeBEnseignant2
+ ),
+ [
+ cahierServiceClasse1Enseignant2
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse1Enseignant1AutreModalite
+ ),
+ [
+ cahierServiceClasse1Enseignant1
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse2Enseignant1
+ ),
+ []
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceClasse2GroupeAEnseignant1
+ ),
+ [
+ cahierServiceClasse2Enseignant1
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierServiceGroupeClasses1Et2Enseignant1
+ ),
+ []
+ )
+ )
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersParentsIncorporationCompatibles(
+ cahierPrive
+ ),
+ []
+ )
+ )
+
+ // TOTEST: Vérifier après incorporations
+ }
+
+ void testFindCahiersIncorporablesPotentiels() {
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse1Enseignant1
+ ),
+ [
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1AutreModalite
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse1Enseignant2
+ ),
+ [
+ cahierServiceClasse1GroupeBEnseignant2
+ ]
+ )
+ )
+
+ try {
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ assertTrue(
+ "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+ try {
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse1GroupeBEnseignant2
+ )
+ assertTrue(
+ "Un cahier de groupe ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse1Enseignant1AutreModalite
+ ),
+ [
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1GroupeAEnseignant1
+ ]
+ )
+ )
+
+ assertTrue(
+ equalsCollectionCdt(
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierServiceClasse2Enseignant1
+ ),
+ [
+ cahierServiceClasse2GroupeAEnseignant1
+ ]
+ )
+ )
+
+ try {
+ cahierIncorporationService.findCahiersCompatiblesPourIncorporationDans(
+ cahierPrive
+ )
+ assertTrue(
+ "Un cahier privé ne peut pas incorporer d'autres cahiers",
+ false
+ )
+ }
+ catch (IllegalArgumentException e) {
+ // Comportement attendu
+ }
+
+ // TOTEST : Vérification après incorporations
+ }
+
+ void testEstIncorporableDans() {
+ assertFalse(
+ "Un cahier ne doit pas pouvoir être incorporé dans lui-même",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier de classe ne doit pouvoit être incorporé dans un " +
+ "cahier de groupe",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
+ "autre cahier de groupe",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1GroupeBEnseignant2
+ )
+ )
+
+ assertFalse(
+ "Un cahier de groupe ne doit pas pouvoir être incorporé dans un " +
+ "autre cahier de groupe",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1GroupeBEnseignant2,
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ assertTrue(
+ "Le groupe 1 de la classe 1 doit pouvoir être incorporé dans " +
+ "la classe 1",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier privé n'est pas incorporable",
+ cahierIncorporationService.estIncorporableDans(
+ cahierPrive,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "On ne peut rien incorporer dans un cahier privé",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierPrive
+ )
+ )
+
+ assertTrue(
+ "On doit pouvoir incorporer des cahiers de classe associés à la " +
+ "même structure, au même enseignant, et qui diffère par leur " +
+ "modalité cours",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1AutreModalite
+ )
+ )
+
+ assertTrue(
+ "On doit pouvoir incorporer des cahiers de classe associés à la " +
+ "même structure, au même enseignant, et qui diffère par leur " +
+ "modalité cours",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1AutreModalite,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "On ne doit pas pouvoir incorporer des cahiers de classes différentes",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse2Enseignant1
+ )
+ )
+
+ assertFalse(
+ "On ne doit pas pouvoir incorporer des cahiers d'enseignants différents",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant2
+ )
+ )
+
+ assertFalse(
+ "Le groupe CLASSE_2_GROUPE_A est incompatible pour l'incorporation " +
+ "avec la classe CLASSE_1",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse2GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un groupe associé à plusieurs classes ne peut pas être incorporé",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceGroupeClasses1Et2Enseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ // Incorpore CLASSE_1_GROUPE_A dans CLASSE_1
+ cahierIncorporationService.incorporeCahierDans(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ assertFalse(
+ "Un cahier incorporé ne doit plus être incorporable",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+ )
+
+ // Ajout d'une activité dans le cahier CLASSE_2_GROUPE_A
+ textesActiviteService.creeActivite(
+ securiteSessionEnseignant1,
+ new ActiviteParams(
+ cahierDeTextes: cahierServiceClasse2GroupeAEnseignant1,
+ titre: 'titre',
+ description: 'description',
+ contexteActivite: ContexteActivite.findByCode(
+ ContexteActivite.CODE_CLASSE
+ ),
+ auteur: (Autorite) securiteSessionEnseignant1.defaultAutorite
+ )
+ )
+
+ assertFalse(
+ "Un cahier non-vide ne doit pas être incorporable",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse2GroupeAEnseignant1,
+ cahierServiceClasse2Enseignant1
+ )
+ )
+
+ assertFalse(
+ "Un cahier incorporant ne doit pas être incorporable",
+ cahierIncorporationService.estIncorporableDans(
+ cahierServiceClasse1Enseignant1,
+ cahierServiceClasse1Enseignant1AutreModalite
+ )
+ )
+
+ // TOTEST : Vérifier que des cahiers d'années différentes ne peuvent pas être incorporés l'un dans l'autre
+ }
+
+ void testEstIncorpore() {
+
+ // Récupération de la session de sécurité de l'enseignant 1
+ SecuriteSession securiteSessionEnseignant1 =
+ initDonneesCommunesTestTextesService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1
+ )
+
+ assertFalse(
+ "Initialement, le cahier ne doit pas être incorporé",
+ cahierIncorporationService.estIncorpore(
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ // Incorporation du cahier
+ cahierIncorporationService.incorporeCahierDans(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ cahierServiceClasse1Enseignant1
+ )
+
+ assertTrue(
+ "Après incorporation, le cahier doit être incorporé",
+ cahierIncorporationService.estIncorpore(
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+
+ // Désincorporation du cahier
+ cahierIncorporationService.desincorporeCahier(
+ securiteSessionEnseignant1,
+ cahierServiceClasse1GroupeAEnseignant1,
+ )
+
+ assertFalse(
+ "Après désincoporation, le cahier ne doit plus être incorporé",
+ cahierIncorporationService.estIncorpore(
+ cahierServiceClasse1GroupeAEnseignant1
+ )
+ )
+ }
+
+ void testLanceIncorporationAuto() {
+ // A ecrire
+ }
+
+ /**
+ * Création d'un cahier de textes de service, et création du service et de
+ * l'enseignement associé si nécessaire
+ * @return le cahier de service créé
+ */
+ private CahierDeTextes creeCahierServiceEtDonneesScolarite(StructureEnseignement structureEnseignement,
+ Autorite enseignant,
+ Matiere matiere,
+ ModaliteCours modaliteCours) {
+ // Création du service
+ Service service = serviceService.insertUpdateService(
+ structureEnseignement, // Structure enseignement
+ matiere, // matière
+ modaliteCours, // modalite cours
+ 2, // nbHeures (non pertinent pour le test)
+ false
+ )
+
+ // Création de l'enseignement et de cahier de textes corresponadants
+ EnseignementMisAjourRapport enseignementMisAjourRapport =
+ enseignementService.insertUpdateEnseignement(
+ DefaultSecuriteSessionFactory.
+ getEliotTempsSecuriteSessionForCodePorteurENT(
+ structureEnseignement.etablissement.codePorteurENT
+ ),
+ service,
+ enseignant,
+ -1 // Non pertinent pour le test
+ )
+
+ return enseignementMisAjourRapport.cahierDeTextes
+ }
+
+ /**
+ * Teste si 2 collections de cahiers de textes sont identiques (i.e. elles
+ * contiennent les mêmes cahier de textes)
+ * @param c1 une collection de cahiers
+ * @param c2 une collection de cahiers
+ * @return <code>true</code> si les 2 collections sont identiques,
+ * <code>false</code> sinon
+ */
+ private boolean equalsCollectionCdt(Collection c1,
+ Collection c2) {
+ return c1.containsAll(c2) && c2.containsAll(c1)
+ }
+}