- affichage des moyennes précédentes et des rangs dans Synthèse et Tableau de notes
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.scolarite.IntervalleEnum
+import org.lilie.services.eliot.scolarite.Periode
/**
* Ancêtre abstrait pour les controleurs devant supporter des menus extjs
/**
* Retourne libellé de la période
- * @param periode
- * @return String
* @author bper
*/
- String getTypePeriodeLibelle(TypePeriode typePeriode) {
- if (typePeriode == null) {
- return null
- }
- String libelle = null
- if (typePeriode.nature == NaturePeriode.NOTATION) {
- switch (typePeriode.intervalle) {
- case IntervalleEnum.S1:
- libelle = message(code: 'periode.semestre.premiere.libelle', default: '1er semestre')
- break
- case IntervalleEnum.S2:
- libelle = message(code: 'periode.semestre.deuxieme.libelle', default: '2ème semestre')
- break
- case IntervalleEnum.T1:
- libelle = message(code: 'periode.trimestre.premiere.libelle', default: '1er trimestre')
- break
- case IntervalleEnum.T2:
- libelle = message(code: 'periode.trimestre.deuxieme.libelle', default: '2ème trimestre')
- break
- case IntervalleEnum.T3:
- libelle = message(code: 'periode.trimestre.troisieme.libelle', default: '3ème trimestre')
- break
- case IntervalleEnum.ANNEE:
- libelle = message(code: 'periode.annee.libelle', default: 'Année')
- break
- }
+ protected String getPeriodeLibelle(Periode periode,
+ PeriodeLibelleMode mode = PeriodeLibelleMode.COMPLET) {
- } else {
- libelle = typePeriode.libelle
- }
- return libelle
+ return getTypePeriodeLibelle(periode?.typePeriode, mode)
}
/**
- * Retourne le libellé court de la période
- * @param periode
- * @return String
+ * Retourne libellé du type de période
* @author bper
*/
- String getTypePeriodeLibelleCourt(TypePeriode typePeriode) {
+ String getTypePeriodeLibelle(TypePeriode typePeriode,
+ PeriodeLibelleMode mode = PeriodeLibelleMode.COMPLET) {
+
if (typePeriode == null) {
return null
}
+
+ String modeSuffixe = ".${mode.toString().toLowerCase()}"
+
String libelle = null
+
if (typePeriode.nature == NaturePeriode.NOTATION) {
switch (typePeriode.intervalle) {
case IntervalleEnum.S1:
- libelle = message(code: 'periode.semestre.premiere.libelle.court', default: '1er semestre')
+ libelle = message(code: 'periode.semestre.premiere.libelle' + modeSuffixe)
break
case IntervalleEnum.S2:
- libelle = message(code: 'periode.semestre.deuxieme.libelle.court', default: '2ème semestre')
+ libelle = message(code: 'periode.semestre.deuxieme.libelle' + modeSuffixe)
break
case IntervalleEnum.T1:
- libelle = message(code: 'periode.trimestre.premiere.libelle.court', default: '1er trimestre')
+ libelle = message(code: 'periode.trimestre.premiere.libelle' + modeSuffixe)
break
case IntervalleEnum.T2:
- libelle = message(code: 'periode.trimestre.deuxieme.libelle.court', default: '2ème trimestre')
+ libelle = message(code: 'periode.trimestre.deuxieme.libelle' + modeSuffixe)
break
case IntervalleEnum.T3:
- libelle = message(code: 'periode.trimestre.troisieme.libelle.court', default: '3ème trimestre')
+ libelle = message(code: 'periode.trimestre.troisieme.libelle' + modeSuffixe)
break
case IntervalleEnum.ANNEE:
- libelle = message(code: 'periode.annee.libelle.court', default: 'Année')
+ libelle = message(code: 'periode.annee.libelle' + modeSuffixe)
break
}
-
} else {
libelle = typePeriode.libelle
}
+
return libelle
}
ficheEleveNotesMarchallerService.marchalleInfoBulletin(bulletin, noteFormateur)
result.periodesPrecedentes.each {
- it.libelle = getTypePeriodeLibelleCourt(it.typePeriode)
+ it.libelle = getPeriodeLibelle(it, PeriodeLibelleMode.COURT)
it.remove('typePeriode')
}
--- /dev/null
+package org.lilie.services.eliot
+
+/**
+ * @author bper
+ */
+public enum PeriodeLibelleMode {
+ COMPLET,
+ COURT,
+ ABREGE
+}
\ No newline at end of file
--- /dev/null
+package org.lilie.services.eliot.notes
+
+import org.lilie.services.eliot.scolarite.Personne
+
+/**
+ * @author agia
+ */
+class PreferenceUtilisateurNotes {
+
+ Long id
+ Personne utilisateur
+ Boolean rangs
+ Boolean moyennesPrecedentes
+
+ static constraints = {
+ utilisateur(nullable:false)
+ }
+
+ static mapping = {
+ table 'entnotes.preference_utilisateur_notes'
+ id column: 'id',
+ generator: 'sequence',
+ params: [sequence: 'entnotes.preference_utilisateur_notes_id_seq']
+ utilisateur column: 'personne_id'
+ moyennesPrecedentes column: 'moyennes_precedentes'
+ version true
+ }
+
+ String toString() {
+ return """PreferenceUtilisateurNotes
+ {id=$id,utilisateur=$utilisateur,rangs=$rangs,moyennesPrecedentes=$moyennesPrecedentes}"""
+ }
+}
BigDecimal moyenne // moyenne générale calculée lors de MAJ des notes
NoteTextuelle noteTextuelle
+ Integer rang
+
static belongsTo = [
eleve: Autorite,
periode: Periode
periode nullable: false
moyenne nullable: true
noteTextuelle nullable: true
+ rang nullable: true
}
static mapping = {
return false
}
}
-
+
/**
* Return true si la saisie des notes et des appréciations et bloquée pour
# message cahier de textes services
eliot.textes.description.import = Cahier de textes cr\u00e9\u00e9 \u00e0 l'import emploi du temps
-#libellés des périodes
-periode.trimestre.premiere.libelle=1er trimestre
-periode.trimestre.deuxieme.libelle=2\u00e8me trimestre
-periode.trimestre.troisieme.libelle=3\u00e8me trimestre
-periode.semestre.premiere.libelle=1er semestre
-periode.semestre.deuxieme.libelle=2\u00e8me semestre
-periode.annee.libelle=Ann\u00e9e
-
eliot.mois.janvier=Janvier
eliot.mois.fevrier=F\u00e9vrier
eliot.mois.mars=Mars
eliot.libelle.nature.NOTATION=Notation
eliot.libelle.nature.EXAMEN=Examen
+
+#libellés des périodes
+periode.semestre.premiere.libelle.complet=1er semestre
+periode.semestre.deuxieme.libelle.complet=2\u00e8me semestre
+periode.trimestre.premiere.libelle.complet=1er trimestre
+periode.trimestre.deuxieme.libelle.complet=2\u00e8me trimestre
+periode.trimestre.troisieme.libelle.complet=3\u00e8me trimestre
+periode.annee.libelle.complet=Ann\u00e9e
+
periode.semestre.premiere.libelle.court=1er S
periode.semestre.deuxieme.libelle.court=2\u00e8me S
periode.trimestre.premiere.libelle.court=1er T
periode.trimestre.troisieme.libelle.court=3\u00e8me T
periode.annee.libelle.court=Ann\u00e9e
+periode.semestre.premiere.libelle.abrege=S1
+periode.semestre.deuxieme.libelle.abrege=S1
+periode.trimestre.premiere.libelle.abrege=T1
+periode.trimestre.deuxieme.libelle.abrege=T2
+periode.trimestre.troisieme.libelle.abrege=T3
+periode.annee.libelle.abrege=A
+
etat.libelle.EN_ATTENTE=En attente
etat.libelle.EN_COURS=En cours
etat.libelle.TERMINE=Termin\u00e9
package org.lilie.services.eliot.notes.resultat.bulletin
-import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.Periode
-import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.scolarite.SousService
-import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
-import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
-import org.lilie.services.eliot.notes.AppreciationEleveEnseignementPeriode
-import org.lilie.services.eliot.notes.ResultatClasseServicePeriode
-import org.lilie.services.eliot.notes.ResultatEleveSousServicePeriode
-import org.lilie.services.eliot.notes.ResultatClasseSousServicePeriode
-import org.lilie.services.eliot.notes.NoteTextuelle
import org.lilie.services.eliot.notes.resultat.synthese.SyntheseClasse
import org.lilie.services.eliot.notes.resultat.synthese.SyntheseEleve
-import org.lilie.services.eliot.notes.TypeAvis
-import org.lilie.services.eliot.notes.AvisElevePeriode
+import org.lilie.services.eliot.notes.*
+import org.lilie.services.eliot.scolarite.*
/**
* Regroupe l'ensemble des informations d'un bulletin de notes
bulletin: this,
service: service,
resultatEleveServicePeriode: getResultatEleveServicePeriode(service),
+ resultatEleveServiceXmestrePrecedents: getResultatEleveServiceXmestrePrecedents(service),
resultatEleveEnseignementPeriodes: getResultatEleveEnseignementPeriodes(
service
),
appreciationEleveEnseignementPeriodes:
- getAppreciationEleveEnseignementPeriodes(service)
+ getAppreciationEleveEnseignementPeriodes(service)
)
// Si l'élève n'a ni la moyenne ni les appreciations pour le service
service.sousServices.each {SousService sousService ->
BulletinSousServiceResultat sousServiceResultat =
- getBulletinSousServiceResultat(
- sousService,
- serviceResultat,
- ayantNotesOrApprs
- )
+ getBulletinSousServiceResultat(
+ sousService,
+ serviceResultat,
+ ayantNotesOrApprs
+ )
if (sousServiceResultat) {
allBulletinSousServiceResultat << sousServiceResultat
if (sousServiceATraiter) {
BulletinSousServiceResultat sousServiceResultat =
- new BulletinSousServiceResultat(sousService: sousService)
+ new BulletinSousServiceResultat(sousService: sousService)
// Résultats de l'élève pour sous-service
sousServiceResultat.resultatEleveSousServicePeriode =
getResultatEleveSousServicePeriode(serviceResultat, sousService)
+ sousServiceResultat.resultatEleveSousServiceXmestrePrecedents =
+ getResultatEleveSousServiceXmestrePrecedents(serviceResultat, sousService.modaliteMatiere)
+
// Si l'élève n'a de moyenne pour le sous-service
// le BulletinSousServiceResultat n'est pas retenu
boolean skipBulletinSousServiceResultat = ayantNotesOrApprs &&
resultatEleveServicePeriodes?.find { it.service.id == service.id }
}
+ private List<ResultatEleveServicePeriode> getResultatEleveServiceXmestrePrecedents(Service service) {
+ return (List<ResultatEleveServicePeriode>) syntheseEleve.
+ resultatEleveServiceXmestrePrecedents?.findAll { it.service.id == service.id }
+ }
+
private List<ResultatEleveEnseignementPeriode> getResultatEleveEnseignementPeriodes(Service service) {
return (List<ResultatEleveEnseignementPeriode>) syntheseEleve.
resultatEleveEnseignementPeriodes?.findAll {
}
}
+ private List<ResultatEleveSousServicePeriode> getResultatEleveSousServiceXmestrePrecedents(BulletinServiceResultat serviceResultat,
+ ModaliteMatiere modaliteMatiere) {
+
+ List<ResultatEleveServicePeriode> resultatEleveServiceXmestrePrecedents =
+ serviceResultat.resultatEleveServiceXmestrePrecedents
+
+ return (List<ResultatEleveSousServicePeriode>) resultatEleveServiceXmestrePrecedents*.
+ resultatsEleveSousServicePeriode?.flatten()?.findAll {
+ it.sousService.modaliteMatiere.id == modaliteMatiere.id
+ }
+ }
+
private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(BulletinServiceResultat serviceResultat,
SousService sousService) {
return (ResultatClasseSousServicePeriode) serviceResultat.
import org.lilie.services.eliot.notes.TypeAvis
import org.lilie.services.eliot.notes.AvisElevePeriode
import org.lilie.services.eliot.applications.absences.PriseEnCompteMotif
+import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
/**
* @author bper
*/
List<NoteTextuelle> recupereAnnotations(SyntheseEleve syntheseEleve) {
Set<NoteTextuelle> notes = new HashSet<NoteTextuelle>()
- syntheseEleve?.resultatEleveServicePeriodes?.each {
+
+ List<ResultatEleveServicePeriode> resultatEleveServicePeriodes =
+ syntheseEleve?.resultatEleveServicePeriodes ? syntheseEleve?.resultatEleveServicePeriodes : []
+ List<ResultatEleveServicePeriode> resultatEleveServiceXmestrePrecedents =
+ syntheseEleve?.resultatEleveServiceXmestrePrecedents ? syntheseEleve?.resultatEleveServiceXmestrePrecedents : []
+
+ List<ResultatEleveServicePeriode> resultatEleveServicePeriodeList = []
+ resultatEleveServicePeriodeList.addAll(resultatEleveServicePeriodes)
+ resultatEleveServicePeriodeList.addAll(resultatEleveServiceXmestrePrecedents)
+
+ resultatEleveServicePeriodeList?.each {
if (it.noteTextuelle) {
notes.add(it.noteTextuelle)
}
}
}
}
+
return notes.toList().sort { it.code }
}
}
List<ResultatEleveEnseignementPeriode> resultatEleveEnseignementPeriodes
List<AppreciationEleveEnseignementPeriode> appreciationEleveEnseignementPeriodes
List<BulletinSousServiceResultat> sousServiceResultats
+
+ List<ResultatEleveServicePeriode> resultatEleveServiceXmestrePrecedents
}
SousService sousService
ResultatEleveSousServicePeriode resultatEleveSousServicePeriode
ResultatClasseSousServicePeriode resultatClasseSousServicePeriode
+
+ List<ResultatEleveSousServicePeriode> resultatEleveSousServiceXmestrePrecedents
}
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.Periode
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.postgresql.util.PSQLException
import org.lilie.services.eliot.utils.HibernateSessionService
class AppreciationClasseEnseignementPeriodeService {
HibernateSessionService hibernateSessionService
-
+
static transactional = true
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param classe
- * @param enseignement
- * @param periode
- * @return AppreciationClasseEnseignementPeriode
* @author bper
*/
AppreciationClasseEnseignementPeriode internalFindOrCree(StructureEnseignement classe,
- Enseignement enseignement,
- Periode periode) {
+ Enseignement enseignement,
+ Periode periode) {
if (!classe || !enseignement || !periode) {
return null
}
if (!res) {
res = new AppreciationClasseEnseignementPeriode(
- classe: classe,
- enseignement: enseignement,
- periode: periode
+ classe: classe,
+ enseignement: enseignement,
+ periode: periode
)
save(res)
}
/**
* Retourne le résultat unique. Si une des clés (classe,enseignement,periode)
* est null, retourne null.
- * @param classe
- * @param enseignement
- * @param periode
- * @return AppreciationClasseEnseignementPeriode
* @author bper
*/
AppreciationClasseEnseignementPeriode internalFind(StructureEnseignement classe,
- Enseignement enseignement,
- Periode periode) {
+ Enseignement enseignement,
+ Periode periode) {
if (!classe || !enseignement || !periode) {
return null
}
/**
* Enregistre un résultat.
- * @param res
- * @return AppreciationClasseEnseignementPeriode
* @author bper
*/
AppreciationClasseEnseignementPeriode save(AppreciationClasseEnseignementPeriode app) {
- if (app) {
- if (!app.save(flush:true) || app.hasErrors()) {
- throw new SauvegardeEchoueException(app)
- }
- }
+ app.save(failOnError: true)
return app
}
/**
- * Enregistre l'appreciation générale d'un classe
- * @param app
- * @param appreciation
- * @author msan
- */
+ * Enregistre l'appreciation générale d'un classe
+ * @author msan
+ */
AppreciationClasseEnseignementPeriode internalSaveAppreciation(AppreciationClasseEnseignementPeriode app,
- String appreciation) {
+ String appreciation) {
app.appreciation = appreciation
save(app)
return app
}
- /**
+ /**
* Retourne la liste résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param classes
- * @param enseignements
- * @param periodes
- * @return List<AppreciationClasseEnseignementPeriode>
* @author bper
*/
List<AppreciationClasseEnseignementPeriode> internalFindAll(List<StructureEnseignement> classes,
- List<Enseignement> enseignements,
- List<Periode> periodes,
- List<NaturePeriode> naturePeriodes) {
+ List<Enseignement> enseignements,
+ List<Periode> periodes,
+ List<NaturePeriode> naturePeriodes) {
if (classes != null && classes.isEmpty()) {
return []
}
/**
* True si au moins une appreciation not null existe pour la période sélectionnée
- * @param periode
- * @return
*/
Boolean internalAppreciationExistePourPeriode(Periode periode) {
return AppreciationClasseEnseignementPeriode.createCriteria().get {
/**
* Supprime appreciations par enseignements
- * @param enseignements
* @author msan
*/
void internalSupprimeParEnseignements(List<Enseignement> enseignements) {
try {
AppreciationClasseEnseignementPeriode.withSession { session ->
session.createQuery("delete AppreciationClasseEnseignementPeriode a where a.enseignement in (:enseignements)").
- setParameterList('enseignements', enseignements).
- executeUpdate()
+ setParameterList('enseignements', enseignements).
+ executeUpdate()
}
} catch (PSQLException e) {
log.error(e) // on log l'exception - probablement l'accès concurrent
/**
* Supprime appreciations par periodes
- * @param periodes
* @author msan
*/
void internalSupprimeParPeriodes(List<Periode> periodes) {
try {
AppreciationClasseEnseignementPeriode.withSession { session ->
session.createQuery("delete AppreciationClasseEnseignementPeriode a where a.periode in (:periodes)").
- setParameterList('periodes', periodes).
- executeUpdate()
+ setParameterList('periodes', periodes).
+ executeUpdate()
}
} catch (PSQLException e) {
log.error(e) // on log l'exception - probablement l'accès concurrent
*/
void internalSupprimeToutes() {
AppreciationClasseEnseignementPeriode.withSession { session ->
- session.createQuery("delete AppreciationClasseEnseignementPeriode a").
- executeUpdate()
- }
+ session.createQuery("delete AppreciationClasseEnseignementPeriode a").
+ executeUpdate()
+ }
}
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.notes.ResultatClassePeriode
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.ArgumentUtils
/**
* Retourne le résultat unique. Si une des clés (classe,periode)
* est null, retourne null.
- * @param classe
- * @param periode
- * @return ResultatClassePeriode
* @author bper
*/
ResultatClassePeriode internalFind(StructureEnseignement classe,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param classe
- * @param periode
- * @return ResultatClassePeriode
* @author bper
*/
ResultatClassePeriode internalFindOrCree(StructureEnseignement classe,
/**
* Retourne la liste des résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param classes
- * @param periodes
- * @return List < ResultatClassePeriode >
* @author bper
*/
List<ResultatClassePeriode> internalFindAll(List<StructureEnseignement> classes,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des nouveaux résultats.
- * @param classes
- * @param periodes
- * @return List < ResultatClassePeriode >
* @author bper
*/
List<ResultatClassePeriode> internalFindOrCreeAll(List<StructureEnseignement> classes,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatClassePeriode >
* @author bper
*/
List<ResultatClassePeriode> saveAll(List<ResultatClassePeriode> ress) {
/**
* Enregistre un résultat
- * @param res
- * @return ResultatClassePeriode
* @author bper
*/
ResultatClassePeriode save(ResultatClassePeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Enregistre les moyennes (moyenne, moyenneMax, moyenneMin)
* d'une classe sur une période
- * @param classe
- * @param periode
- * @param moyenne
- * @param moyenneMax
- * @param moyenneMin
- * @return ResultatClassePeriode
* @author bper
*/
ResultatClassePeriode internalSaveMoyennes(StructureEnseignement classe,
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.notes.ResultatClasseServicePeriode
import org.lilie.services.eliot.scolarite.TypePeriode
import org.hibernate.FetchMode
/**
* Retourne le résultat unique. Si une des clés (classe,service,periode)
* est null, retourne null.
- * @param classe
- * @param service
- * @param periode
- * @return ResultatClasseServicePeriode
* @author bper
*/
ResultatClasseServicePeriode internalFind(StructureEnseignement classe,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param classe
- * @param service
- * @param periode
- * @return ResultatClasseServicePeriode
* @author bper
*/
ResultatClasseServicePeriode internalFindOrCree(StructureEnseignement classe,
/**
* Retourne la liste des résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param classes
- * @param services
- * @param periodes
- * @return List < ResultatClasseServicePeriode >
* @author bper
*/
List<ResultatClasseServicePeriode> internalFindAll(List<StructureEnseignement> classes,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des résultats créés.
- * @param classes
- * @param services
- * @param periodes
- * @return List < ResultatClasseServicePeriode >
* @author bper
*/
List<ResultatClasseServicePeriode> internalFindOrCreeAll(List<StructureEnseignement> classes,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatClasseServicePeriode >
* @author bper
*/
List<ResultatClasseServicePeriode> saveAll(List<ResultatClasseServicePeriode> ress) {
/**
* Enregistre un résultat.
- * @param res
- * @return ResultatClasseServicePeriode
*/
ResultatClasseServicePeriode save(ResultatClasseServicePeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Enregistre les moyennes (moyenne, moyenneMax, moyenneMin)
* d'une classe pour un service sur une période
- * @param classe
- * @param service
- * @param periode
- * @param moyenne
- * @param moyenneMax
- * @param moyenneMin
- * @return ResultatClasseServicePeriode
* @author bper
*/
ResultatClasseServicePeriode internalSaveMoyennes(StructureEnseignement classe,
/**
* Resultat pur les périodes de notation
- * @param structureEnseignement
- * @param service
- * @return List < ResultatClasseServicePeriode >
* @author msan
* @author bper
*/
/**
* Supprime résultats par service
- * @param service
* @autor msan
*/
void internalSupprimeParService(Service service) {
/**
* Positionne la moyenne
- * @param res
- * @param moyenne
* @param msan
*/
void internalSetMoyenne(ResultatClasseServicePeriode res,
}
/**
- *
- * @param service
- * @param typePeriode
- * @return
* @author msan
*/
List<ResultatClasseServicePeriode> internalFindAllByServiceAndTypePeriode(
/**
* Supprime tous les résultats correspondants au classes et services donnés.
- * @param classes
- * @param services
* @author bper
*/
void internalSupprimeByClassesAndServices(List<StructureEnseignement> classes,
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Periode
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.hibernate.FetchMode
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.ArgumentUtils
* Supprime les résultats par service et modalité matière.
* Les résultats pour sous-service sont supprimé aussi que les résultats
* pour le service parent si necessaire.
- * @param service
- * @param modaliteMatiere
* @author msan
*/
void internalSupprimeByServiceAndModalite(Service service,
/**
* Prends tous les résultats RCSP et attache eux aux RCSSP
- * @param service
- * @param sousService
- * @param typePeriode
* @author msan
*/
void internalAcquiersResultats(Service service, SousService sousService,
/**
* Cherche ou crée les résultats
- * @param classe
- * @param sousServices
- * @return
*/
List<ResultatClasseSousServicePeriode> internalFindOrCreeAll(StructureEnseignement classe,
List<SousService> sousServices) {
/**
* Enregistre une liste des résultats
- * @param ress
- * @return
* @author msan
*/
List<ResultatClasseSousServicePeriode> saveAll(List<ResultatClasseSousServicePeriode> ress) {
* @param res
* @return ResultatClasseSousServicePeriode
*/
- ResultatClasseSousServicePeriode save(ResultatClasseSousServicePeriode res)
- throws SauvegardeEchoueException {
+ ResultatClasseSousServicePeriode save(ResultatClasseSousServicePeriode res) {
// Il n'y a pas besoin de gérér la concurrence car la méthode n'est utilisée
// que par le job de calcul des moyennes.
- if (res) {
- if (!res.save(flush:true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+
+ res.save(failOnError: true)
+
return res
}
/**
* Cherche les résultats
- * @param classe
- * @param sousServices
- * @return
* @author msan
*/
List<ResultatClasseSousServicePeriode> internalFindAll(StructureEnseignement classe,
/**
* Cherche le résultat
- * @param classe
- * @param sousService
- * @return
* @author msan
*/
ResultatClasseSousServicePeriode internalFind(StructureEnseignement classe,
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
* Attention! Retourne le résultat uniquement si le service est évaluable
- * @param classe
- * @param service
- * @param periode
- * @return ResultatClasseSousServicePeriode
* @author bper
*/
ResultatClasseSousServicePeriode internalFindOrCree(StructureEnseignement classe,
/**
* Cherche résultat parent
- * @param classe
- * @param sousService
* @return
*/
private ResultatClasseServicePeriode internalGetResParent(StructureEnseignement classe,
/**
* Positionne la moyenne
- * @param res
- * @param moyenne
* @author msan
*/
void internalSetMoyenne(ResultatClasseSousServicePeriode res,
/**
* Enregistre les moyennes (moyenne, moyenneMax, moyenneMin)
* d'une classe pour un sous-service
- * @param classe
- * @param sousService
- * @param moyenne
- * @param moyenneMax
- * @param moyenneMin
- * @return ResultatClasseSousServicePeriode
* @author msan
*/
ResultatClasseSousServicePeriode internalSaveMoyennes(StructureEnseignement classe,
/**
* Resultat d'un classe et sous-services pour les Xmestres
- * @param classe
- * @param service
- * @return
* @author msan
*/
List<ResultatClasseSousServicePeriode> internalFindAllForXmestres(StructureEnseignement classe,
/**
* Supprime tous les résultats d'un sous-service
- * @param sousService
* @author msan
*/
void internalSupprimeBySousService(SousService sousService, StructureEnseignement classe) {
/**
* Suypprime tous les resultats correspondant aux clsses et sous-services
* passés en paramètres.
- * @param classes
- * @param sousServices
* @author bper
*/
void internalSupprimeByClassesAndSousServices(List<StructureEnseignement> classes,
/**
* Passe les résultats d'un sous-service à l'autre
- * @param ancienSS
- * @param nouvelSS
*/
void internalPasseResultats(SousService ancienSS, SousService nouvelSS, List<StructureEnseignement> classes) {
List<ResultatClasseSousServicePeriode> classeRes = ResultatClasseSousServicePeriode.withCriteria {
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.ArgumentUtils
/**
* Retourne le résultat unique. Si une des clés (enseignement,periode)
* est null, retourne null.
- * @param enseignement
- * @param periode
- * @return ResultatEnseignementPeriode
* @author bper
*/
ResultatEnseignementPeriode internalFind(Enseignement enseignement,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param enseignement
- * @param periode
- * @return ResultatEnseignementPeriode
* @author bper
*/
ResultatEnseignementPeriode internalFindOrCree(Enseignement enseignement,
/**
* Retourne la liste résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param enseignements
- * @param periodes
- * @return List < ResultatEnseignementPeriode >
* @author bper
*/
List<ResultatEnseignementPeriode> internalFindAll(List<Enseignement> enseignements,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des résultats créés.
- * @param enseignements
- * @param periodes
- * @return List < ResultatEnseignementPeriode >
* @author bper
*/
List<ResultatEnseignementPeriode> internalFindOrCreeAll(List<Enseignement> enseignements,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatEnseignementPeriode >
* @author bper
*/
List<ResultatEnseignementPeriode> saveAll(List<ResultatEnseignementPeriode> ress) {
/**
* Enregistre un résultat.
- * @param res
- * @return ResultatEnseignementPeriode
* @author bper
*/
ResultatEnseignementPeriode save(ResultatEnseignementPeriode res) {
" [$res.enseignement] [$res.periode] [$res.moyenne]")
}
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Supprime résultats par service
- * @param service
* @autor msan
*/
void internalSupprimeParService(Service service) {
/**
* Supprime resultats pour les enseignements
- * @param enseignements
* @author msan
*/
void internalSupprimeParEnseignements(List<Enseignement> enseignements) {
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.notes.exception.PeriodeVerrouilleException
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.postgresql.util.PSQLException
import org.lilie.services.eliot.utils.HibernateSessionService
/**
* Cherche les apppreciations pour un eleve, une periode et une liste des
* services
- * @param eleve
- * @param periode
- * @param services
- * @return
*/
Map<Service, List<String>> internalFindAll(Personne eleve,
Periode periode,
/**
* Enregistre l'appreciation
- * @param eleve
- * @param periode
- * @param enseignement
- * @param appreciation
* @param correctionParDirecteur true s'il s'agit d'une correction par
* le directeur qui peut saisir meme dans les periodes verouilles
- * @return ResultatEleveEnseignementPeriode
* @author msan
* @author bper
*/
return app
}
- /**
+ /**
* Enregistre une appreciation.
- * @param res
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
AppreciationEleveEnseignementPeriode save(AppreciationEleveEnseignementPeriode app) {
- if (app) {
- if (!app.save(flush:true) || app.hasErrors()) {
- throw new SauvegardeEchoueException(app)
- }
- }
+ app.save(failOnError: true)
return app
}
/**
* Retourne l'appreciation qui existe dans la BBD, si elle n'existe pas crée
* une nouvelle instance.
- * @param eleve
- * @param enseignement
- * @param periode
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
AppreciationEleveEnseignementPeriode internalFindOrCree(Autorite eleve,
if (!app) {
app = new AppreciationEleveEnseignementPeriode(
- eleve: eleve,
- enseignement: enseignement,
- periode: periode
+ eleve: eleve,
+ enseignement: enseignement,
+ periode: periode
)
save(app)
}
/**
* Retourne l'appreciation unique. Si une des clés (eleve,enseignement,periode)
* est null, retourne null.
- * @param eleve
- * @param enseignement
- * @param periode
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
AppreciationEleveEnseignementPeriode internalFind(Autorite eleve,
/**
* Retourne la liste des appreciations. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param eleves
- * @param enseignements
- * @param periodes
- * @return List<AppreciationEleveEnseignementPeriode>
* @author bper
*/
List<AppreciationEleveEnseignementPeriode> internalFindAll(List<Autorite> eleves,
/**
* True si au moins une appreciation not null existe pour la période sélectionnée
- * @param periode
* @return
*/
Boolean internalAppreciationExistePourPeriode(Periode periode) {
/**
* Supprime appreciations par enseignements
- * @param enseignements
* @author msan
*/
void internalSupprimeParEnseignements(List<Enseignement> enseignements) {
try {
AppreciationEleveEnseignementPeriode.withSession { session ->
session.createQuery("delete AppreciationEleveEnseignementPeriode a where a.enseignement in (:enseignements)").
- setParameterList('enseignements', enseignements).
- executeUpdate()
+ setParameterList('enseignements', enseignements).
+ executeUpdate()
}
} catch (PSQLException e) {
log.error(e) // on log l'exception - probablement l'accès concurrent
/**
* Supprime appreciations par periodes
- * @param periodes
* @author msan
*/
void internalSupprimeParPeriodes(List<Periode> periodes) {
try {
AppreciationEleveEnseignementPeriode.withSession { session ->
session.createQuery("delete AppreciationEleveEnseignementPeriode a where a.periode in (:periodes)").
- setParameterList('periodes', periodes).
- executeUpdate()
+ setParameterList('periodes', periodes).
+ executeUpdate()
}
} catch (PSQLException e) {
log.error(e) // on log l'exception - probablement l'accès concurrent
/**
* Supprime toutes les appréciations des élèves pour les enseignements donnés.
- * @param eleves
- * @param enseignements
* @author msan
* @author bper
*/
ArgumentUtils.verifieArgumentNotNull('eleves',eleves)
ArgumentUtils.verifieArgumentNotNull('enseignements',enseignements)
-
+
if (enseignements.isEmpty() || eleves.isEmpty()) {
return
}
*/
void internalSupprimeToutes() {
AppreciationEleveEnseignementPeriode.withSession { session ->
- session.createQuery("delete AppreciationEleveEnseignementPeriode a").
- executeUpdate()
- }
+ session.createQuery("delete AppreciationEleveEnseignementPeriode a").
+ executeUpdate()
+ }
}
-
+
}
import org.lilie.services.eliot.notes.exception.PeriodeVerrouilleException
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.utils.HibernateSessionService
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.AutorisationException
*/
private AppreciationElevePeriode internalSaveAppreciation(Autorite eleve,
Periode periode,
- String appreciation)
- throws SauvegardeEchoueException {
+ String appreciation) {
if (!eleve) {
throw new IllegalArgumentException("Le paramètre {eleve} ne doit pas etre null")
* @author msan
*/
AppreciationElevePeriode save(AppreciationElevePeriode app) {
- if (app) {
- if (!app.save(flush: true) || app.hasErrors()) {
- throw new SauvegardeEchoueException(app)
- }
- }
+ app.save(failOnError: true)
return app
}
void saveAppreciations(SecuriteSession securiteSession,
Map<Personne, String> mapEleveAppreciation,
Periode periode)
- throws AutorisationException, SauvegardeEchoueException, PeriodeVerrouilleException {
+ throws AutorisationException, PeriodeVerrouilleException {
// La classe qui correspond à la période donnée
StructureEnseignement classe = periode.classe
/**
* Retourne la liste des résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param eleves
- * @param periodes
- * @return List < AppreciationElevePeriode >
* @author bper
*/
List<AppreciationElevePeriode> internalFindAll(List<Autorite> eleves,
/**
* True si au moins une appreciation not null existe pour la période sélectionnée
- * @param periode
* @return
*/
Boolean internalAppreciationExistePourPeriode(Periode periode) {
/**
* Supprime appreciations par periodes
- * @param periodes
* @author msan
*/
void internalSupprimeParPeriodes(List<Periode> periodes) {
/**
* Compte le nombre d'appreciations d'un elve dans les classes donnees
- * @param eleve
- * @param classesEleve
* @return Un map periodeId -> compte d'appreciations
*/
Map<Long, Long> compteAppreciationsParPeriode(Personne eleve,
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.Periode
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
/**
* Retourne le résultat unique. Si une des clés (eleve,enseignement,periode)
* est null, retourne null.
- * @param eleve
- * @param enseignement
- * @param periode
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
ResultatEleveEnseignementPeriode internalFind(Autorite eleve,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param eleve
- * @param enseignement
- * @param periode
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
ResultatEleveEnseignementPeriode internalFindOrCree(Autorite eleve,
/**
* Retourne la liste résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param eleves
- * @param enseignements
- * @param periodes
- * @return List < ResultatEleveEnseignementPeriode >
* @author bper
*/
List<ResultatEleveEnseignementPeriode> internalFindAll(List<Autorite> eleves,
/**
* Retourne la liste de résultats.
- * @param enseignements
- * @param periodes
- * @return List < ResultatEleveEnseignementPeriode >
* @author msan
*/
List<ResultatEleveEnseignementPeriode> internalFindAll(List<Enseignement> enseignements,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des résultats créés.
- * @param eleves
- * @param enseignements
- * @param periodes
- * @return List < ResultatEleveEnseignementPeriode >
* @author bper
*/
List<ResultatEleveEnseignementPeriode> internalFindOrCreeAll(List<Autorite> eleves,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatEleveEnseignementPeriode >
* @author bper
*/
List<ResultatEleveEnseignementPeriode> saveAll(List<ResultatEleveEnseignementPeriode> ress) {
/**
* Enregistre un résultat.
- * @param res
- * @return ResultatEleveEnseignementPeriode
* @author bper
*/
ResultatEleveEnseignementPeriode save(ResultatEleveEnseignementPeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Mis à jour de la moyenne pour REE
* O(n) = 3 requêtes max
- * @param eleve
- * @param enseignement
- * @param periode
- * @return
* @author msan
* @author bper
*/
/**
* Supprime tous les resultats d'un service
- * @param service
* @author msan
*/
void internalSupprimeParService(Service service) {
/**
* Supprime resultats pour les enseignements
- * @param enseignements
* @author msan
*/
void internalSupprimmeByEnseignements(List<Enseignement> enseignements) {
/**
* Cherche tous les résultats de Xmestres pour un élève et un enseignement.
* Les resultats sont tries par l'ordre des periodes.
- * @param eleve
- * @param enseignement
- * @param classe
- * @return
* @author msan
* @author bper
*/
/**
* Supprime tous les résultats des élèves pour les enseignements donnés.
- * @param enseignements
- * @param eleves
* @author msan
* @author bper
*/
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
package org.lilie.services.eliot.notes.resultat.eleve
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.notes.ResultatElevePeriode
/**
* Retourne le résultat unique. Si une des clés (eleve,periode)
* est null, retourne null.
- * @param eleve
- * @param periode
- * @return ResultatElevePeriode
* @author bper
*/
ResultatElevePeriode internalFind(Autorite eleve,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param eleve
- * @param periode
- * @return ResultatElevePeriode
* @author bper
*/
ResultatElevePeriode internalFindOrCree(Autorite eleve,
/**
* Retourne la liste des résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param eleves
- * @param periodes
- * @return List < ResultatElevePeriode >
* @author bper
*/
List<ResultatElevePeriode> internalFindAll(List<Autorite> eleves,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des nouveaux résultats.
- * @param eleves
- * @param periodes
- * @return List < ResultatElevePeriode >
* @author bper
*/
List<ResultatElevePeriode> internalFindOrCreeAll(List<Autorite> eleves,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatElevePeriode >
* @author bper
*/
List<ResultatElevePeriode> saveAll(List<ResultatElevePeriode> ress) {
/**
* Enregistre un résultat
- * @param res
- * @return ResultatElevePeriode
* @author bper
*/
ResultatElevePeriode save(ResultatElevePeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Enregistre la moyenne générale d'un élève sur une période pour
* une année scolaire
- * @param eleve
- * @param periode
- * @param moyenne
- * @return ResultatElevePeriode
* @author bper
*/
ResultatElevePeriode internalSaveMoyenne(Autorite eleve,
Periode periode,
- Moyenne moyenne)
- throws SauvegardeEchoueException {
+ Moyenne moyenne) {
if (log.isDebugEnabled()) {
log.debug("El [${eleve.id}] [$periode] [$moyenne]")
/**
* Retourn les résultats d'un élève pour les Semestres et les Trimestres.
* Les resultats sont tries par l'ordre des periodes.
- * @param eleve
- * @param classe
- * @return List<ResultatElevePeriode>
* @author bper
*/
List<ResultatElevePeriode> internalFindAllForXmestres(Autorite eleve,
/**
* Retourne le résultat unique. Si une des clés (classe,service,periode)
* est null, retourne null.
- * @param eleve
- * @param service
- * @param periode
- * @return ResultatEleveServicePeriode
* @author bper
*/
ResultatEleveServicePeriode internalFind(Autorite eleve,
/**
* Retourne le résultat qui existe dans la BBD, s'il n'existe pas crée
* une nouvelle instance.
- * @param eleve
- * @param service
- * @param periode
- * @return ResultatEleveServicePeriode
* @author bper
*/
ResultatEleveServicePeriode internalFindOrCree(Autorite eleve,
/**
* Retourne la liste des résultats. Les paramètres avec les valeurs null ne sont pas
* prises en compte. Si une des listes est vide, renvoie la liste vide.
- * @param eleves
- * @param services
- * @param periodes
- * @param naturePeriodes
- * @return List<ResultatEleveServicePeriode>
* @author bper
*/
List<ResultatEleveServicePeriode> internalFindAll(List<Autorite> eleves,
/**
* Retourne la liste des résultats des services evaluables d'un élève
* pour une période donnée.
- * @param eleve
- * @param periode
- * @return List<ResultatEleveServicePeriode>
* @author bper
*/
List<ResultatEleveServicePeriode> internalFindAllByEleveAndPeriode(Autorite eleve,
/**
* Retourne les résultats qui existent dans la base, les résultats manquants
* sont completés par des résultats créés.
- * @param eleves
- * @param services
- * @param periodes
- * @return List < ResultatEleveServicePeriode >
* @author bper
*/
List<ResultatEleveServicePeriode> internalFindOrCreeAll(List<Autorite> eleves,
/**
* Enregistre tous les résultats.
- * @param ress liste des résultats
- * @return List < ResultatEleveServicePeriode >
* @author bper
*/
List<ResultatEleveServicePeriode> saveAll(List<ResultatEleveServicePeriode> ress) {
/**
* Enregistre un résultat.
- * @param res
- * @return ResultatEleveServicePeriode
*/
ResultatEleveServicePeriode save(ResultatEleveServicePeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Resultat d'un élève et service pour les périodes de notations.
* Les resultats sont tries par l'ordre des periodes.
- * @param eleve
- * @param services
- * @param classe
- * @return
* @author msan
* @author bper
*/
/**
* Enregistre la moyenne d'un élève pour un service sur une période
- * @param eleve
- * @param service
- * @param periode
- * @param moyenne
- * @return
* @author bper
*/
ResultatEleveServicePeriode internalSaveMoyenne(Autorite eleve,
/**
* Supprime les résultats par service
- * @param service
* @author msan
*/
void internalSupprimeByService(Service service) {
/**
* Supprime tous les résultats des élèves pour les services donnés.
- * @param eleves
- * @param services
- * @author msan
* @author bper
*/
void internalSupprimeByElevesAndServices(List<Autorite> eleves,
}
/**
- *
- * @param service
- * @param typePeriode
- * @return
* @author msan
*/
List<ResultatEleveServicePeriode> internalFindAllByServiceAndTypePeriode(
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.hibernate.FetchMode
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.utils.HibernateSessionService
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.ArgumentUtils
* Supprime les résultats par service et modalité matière.
* Les résultats pour sous-service sont supprimé aussi que les résultats
* pour le service parent si necessaire.
- * @param service
- * @param modaliteMatiere
* @author msan
*/
void internalSupprimeParServiceEtModalite(Service service, ModaliteMatiere modaliteMatiere) {
/**
* Prends tous les résultats RESP et attache eux aux RESSP
- * @param service
- * @param sousService
- * @param typePeriode
* @author msan
*/
void internalAcquiersResultats(Service service, SousService sousService,
/**
* Cherche ou crée les résultats
- * @param classe
- * @param eleves
- * @param sousServices
- * @return
*/
List<ResultatEleveSousServicePeriode> internalFindOrCreeAll(StructureEnseignement classe,
List<Autorite> eleves,
/**
* Cherche les résultats
- * @param eleves
- * @param sousServices
- * @return
*/
List<ResultatEleveSousServicePeriode> internalFindAll(List<Autorite> eleves,
List<SousService> sousServices,
/**
* Enregistre une liste des résultats
- * @param ress
- * @return
*/
List<ResultatEleveSousServicePeriode> saveAll(List<ResultatEleveSousServicePeriode> ress) {
return ress.collect {save(it)}
/**
* Enregistre un résultat.
- * @param res
- * @return ResultatEleveSousServicePeriode
*/
ResultatEleveSousServicePeriode save(ResultatEleveSousServicePeriode res) {
- if (res) {
- if (!res.save(flush: true) || res.hasErrors()) {
- throw new SauvegardeEchoueException(res)
- }
- }
+ res.save(failOnError: true)
return res
}
/**
* Enregistre la moyenne d'un élève pour un service sur une période
- * @param eleve
- * @param service
- * @param periode
- * @param moyenne
- * @return
* @author msan
*/
ResultatEleveSousServicePeriode internalSaveMoyenne(Autorite eleve,
* Retourne le résultat unique. Si une des clés (classe,service,periode)
* est null, retourne null.
* Attention! Retourne le résultat uniquement si le sous-service est évaluable
- * @param eleve
- * @param sous -service
- * @param resParent
- * @return
* @author msan
*/
ResultatEleveSousServicePeriode internalFind(Autorite eleve,
/**
* Resultat d'un élève et sous-services pour les Xmestres d'une classe.
* Les resultats sont tries par l'ordre des periodes.
- * @param eleve
- * @param sousService
- * @return
* @author msan
* @author bper
*/
/**
* Supprime tous les résultats d'un sous-service
- * @param sousService
* @author msan
*/
void internalSupprimeBySousService(SousService sousService, List<Autorite> eleves = null) {
/**
* Supprime tous les résultats des élèves pour les sous-services donnés.
- * @param eleves
- * @param sousService
* @author msan
* @author bper
*/
/**
* Passe les résultats d'un sous-service à l'autre
- * @param ancienSS
- * @param nouvelSS
*/
void internalPasseResultats(SousService ancienSS, SousService nouvelSS, List<Autorite> eleves) {
List<ResultatEleveSousServicePeriode> eleveRes = ResultatEleveSousServicePeriode.withCriteria {
class SyntheseClasse {
StructureEnseignement classe
ResultatClassePeriode resultatClassePeriode
- List<ResultatClassePeriode> resultatClasseXmestres
List<Service> services
List<ResultatClasseServicePeriode> resultatClasseServicePeriodes
+
+ List<ResultatClassePeriode> resultatClasseXmestrePrecedents
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
package org.lilie.services.eliot.notes.resultat.synthese
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.notes.NotesDroitService
import org.lilie.services.eliot.scolarite.Service
NotesDroitService notesDroitService
ResultatClasseServicePeriodeService resultatClasseServicePeriodeService
ResultatClassePeriodeService resultatClassePeriodeService
-
+
/**
* Retourne SyntheseClasse d'une classe sur une période
* Si services=null => les resultatClasseServicePeriodes sont retournés pour tout les services
- * @param securiteSession
- * @param classe
- * @param services
- * @param periode
- * @return SyntheseClasse
- * @throws AutorisationException
* @author bper
*/
SyntheseClasse internalConstruisSyntheseClasse(StructureEnseignement classe,
List<Service> services,
- Periode periode) throws AutorisationException {
-
+ Periode periode) {
SyntheseClasse syntheseClasse = new SyntheseClasse()
syntheseClasse.classe = classe
syntheseClasse.resultatClassePeriode =
resultatClassePeriodeService.
- internalFind(classe, periode)
-
- if (periode.isPeriodeAnnee()) {
- List<Periode> periodeXmestres = classe.periodes.findAll {it.isPeriodeXmestre()} as List
- syntheseClasse.resultatClasseXmestres = resultatClassePeriodeService.
- internalFindAll([classe], periodeXmestres, null)
- }
+ internalFind(classe, periode)
syntheseClasse.resultatClasseServicePeriodes =
resultatClasseServicePeriodeService.
- internalFindAll([classe], services, [periode], null)
+ internalFindAll([classe], services, [periode], null)
- return syntheseClasse
- }
+ if (periode.isPeriodeNotation()) {
+ List<Periode> periodePrecedentes = periode.getPeriodesPrecedentes()
+ syntheseClasse.resultatClasseXmestrePrecedents =
+ resultatClassePeriodeService.
+ internalFindAll([classe], periodePrecedentes, null)
+ }
+ return syntheseClasse
+ }
}
package org.lilie.services.eliot.notes.resultat.synthese
-import org.lilie.services.eliot.notes.ResultatElevePeriode
-import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
-import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.notes.AppreciationElevePeriode
-import org.lilie.services.eliot.notes.AppreciationEleveEnseignementPeriode
+import org.lilie.services.eliot.notes.*
/**
* Regroupe les resultats (moyennes, apreciation) d'un élève sur une Période
Personne eleve
ResultatElevePeriode resultatElevePeriode
AppreciationElevePeriode appreciationElevePeriode
- List<ResultatElevePeriode> resultatEleveXmestres
List<Service> services
List<ResultatEleveServicePeriode> resultatEleveServicePeriodes
List<AppreciationEleveEnseignementPeriode> appreciationEleveEnseignementPeriodes
List<ResultatEleveEnseignementPeriode> resultatEleveEnseignementPeriodes
+
+ List<ResultatElevePeriode> resultatEleveXmestrePrecedents
List<ResultatEleveServicePeriode> resultatEleveServiceXmestrePrecedents
}
/**
* Retourne la liste des SyntheseEleve pour les élèves d'une classe
- * @param classe
- * @param periode
- * @param securiteSession
- * @throws AutorisationException
- * @return List < NotesLigneSyntheseInfo >
* @author bper
*/
List<SyntheseEleve> construisAllSyntheseEleveForClasse(SecuriteSession securiteSession,
// Récupère les informations sur les élèves (actifs & inactifs)
StructureEnseignementElevesListes elevesListes =
- eleveAnnuaireService.findStructureEnseignementElevesListes(
- securiteSession,
- classe
- )
+ eleveAnnuaireService.findStructureEnseignementElevesListes(
+ securiteSession,
+ classe
+ )
+
+ List<Periode> periodes = [periode]
- // Dans le cas de période "Année" on récupère aussi les resultats de Xmestres
- List<Periode> periodeXmestres = []
- if (periode.isPeriodeAnnee()) {
- periodeXmestres = classe.periodes.findAll {it.isPeriodeXmestre()} as List
+ if (periode.isPeriodeNotation()) {
+ periodes.addAll(periode.getPeriodesPrecedentes())
}
- List<Periode> periodes = periodeXmestres << periode
List<AppreciationElevePeriode> appreciationElevePeriodes =
- appreciationElevePeriodeService.internalFindAll(
- elevesListes.eleves*.autorite, periodes, null)
+ appreciationElevePeriodeService.internalFindAll(
+ elevesListes.eleves*.autorite, periodes, null)
List<ResultatElevePeriode> resultatElevePeriodes =
- resultatElevePeriodeService.internalFindAll(
- elevesListes.eleves*.autorite, periodes, null)
+ resultatElevePeriodeService.internalFindAll(
+ elevesListes.eleves*.autorite, periodes, null)
List<ResultatEleveServicePeriode> resultatEleveServicePeriodes =
- resultatEleveServicePeriodeService.internalFindAll(
- elevesListes.eleves*.autorite, services, [periode], null)
+ resultatEleveServicePeriodeService.internalFindAll(
+ elevesListes.eleves*.autorite, services, [periode], null)
List<Enseignement> enseignements = []
services.each {Service service ->
}
List<ResultatEleveEnseignementPeriode> resultatEleveEnseignementPeriodes =
- resultatEleveEnseignementPeriodeService.internalFindAll(
- elevesListes.eleves*.autorite, enseignements, [periode], null)
+ resultatEleveEnseignementPeriodeService.internalFindAll(
+ elevesListes.eleves*.autorite, enseignements, [periode], null)
List<AppreciationEleveEnseignementPeriode> appreciationEleveEnseignementPeriodes =
- appreciationEleveEnseignementPeriodeService.internalFindAll(
- elevesListes.eleves*.autorite, enseignements, [periode], null)
+ appreciationEleveEnseignementPeriodeService.internalFindAll(
+ elevesListes.eleves*.autorite, enseignements, [periode], null)
List<SyntheseEleve> syntheseEleves = []
it.eleve.id == eleve.autorite.id && it.periode.id == periode.id
}
- if (periode.isPeriodeAnnee()) {
- syntheseEleve.resultatEleveXmestres = resultatElevePeriodes.findAll {
- it.eleve.id == eleve.autorite.id && it.periode.isPeriodeXmestre()
- }
+ syntheseEleve.resultatEleveXmestrePrecedents = resultatElevePeriodes.findAll {
+ it.eleve.id == eleve.autorite.id && it.periode.id != periode.id
}
syntheseEleve.resultatEleveServicePeriodes = resultatEleveServicePeriodes.findAll {
/**
* Retourne la SyntheseEleve pour une liste des services
- * @param securiteSession
- * @param elevePersonne
- * @param services
- * @param periode
- * @return SyntheseEleve
- * @throws AutorisationException
* @author bper
*/
SyntheseEleve construisSyntheseEleve(SecuriteSession securiteSession,
resultatElevePeriodeService.internalFind(
elevePersonne.autorite, periode)
+ syntheseEleve.resultatEleveXmestrePrecedents = []
+ periode.getPeriodesPrecedentes()?.each{ Periode periodePrecedente ->
+ syntheseEleve.resultatEleveXmestrePrecedents.add(
+ resultatElevePeriodeService.internalFind(
+ elevePersonne.autorite, periodePrecedente
+ )
+ )
+ }
+
syntheseEleve.resultatEleveServicePeriodes =
resultatEleveServicePeriodeService.internalFindAll(
[elevePersonne.autorite], services, [periode], null)
return classe.periodes.find {it.isPeriodeXmestre() && it.ordre == ordre}
}
+ public String getNomPeriodePrecedente(String libelleTypePeriode){
+ switch (libelleTypePeriode){
+ case 'T1':
+ return '1er T.'
+ break
+ case 'T2':
+ return '2ème T.'
+ break
+ case 'T3':
+ return '3ème T.'
+ break
+ case 'S1':
+ return '1er S.'
+ break
+ case 'S2':
+ return '2ème T.'
+ break
+ }
+ }
+
}
--- /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="bper">
+ <comment>
+ Mise à NULL de tous les rangs calculés afin qu'ils soient recalculés en tenant compte de la précision
+ </comment>
+
+ <sql>
+ UPDATE entnotes.resultat_eleve_service_periode
+ SET rang = null, nb_eleves = null
+ </sql>
+
+ </changeSet>
+
+</databaseChangeLog>
--- /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="agia">
+ <comment>
+ Création de la table 'preference_utilisateur_notes'
+ </comment>
+
+ <createTable tableName="preference_utilisateur_notes" schemaName="entnotes">
+ <column name="id" type="bigint">
+ <constraints primaryKey="true"/>
+ </column>
+ <column name="personne_id" type="bigint">
+ <constraints nullable="false"/>
+ </column>
+ <column name="rangs" type="boolean">
+ <constraints nullable="false"/>
+ </column>
+ <column name="moyennes_precedentes" type="boolean">
+ <constraints nullable="false"/>
+ </column>
+ <column name="version" type="integer">
+ <constraints nullable="false"/>
+ </column>
+ </createTable>
+
+ <createSequence sequenceName="preference_utilisateur_notes_id_seq"
+ schemaName="entnotes"/>
+
+ <addForeignKeyConstraint baseTableSchemaName="entnotes"
+ baseTableName="preference_utilisateur_notes"
+ baseColumnNames="personne_id"
+ constraintName="fk_preference_utilisateur_notes_personne_id"
+ referencedTableSchemaName="ent"
+ referencedTableName="personne"
+ referencedColumnNames="id" />
+
+ <addDefaultValue schemaName="entnotes"
+ tableName="preference_utilisateur_notes"
+ columnName="rangs"
+ defaultValueBoolean="false"/>
+ <addDefaultValue schemaName="entnotes"
+ tableName="preference_utilisateur_notes"
+ columnName="moyennes_precedentes"
+ defaultValueBoolean="false"/>
+
+ <createIndex
+ schemaName="entnotes"
+ tableName="preference_utilisateur_notes"
+ indexName="idx_preference_utilisateur_notes_personne_id"
+ unique="true" >
+ <column name="personne_id" />
+ </createIndex>
+
+ </changeSet>
+
+
+ <changeSet id="2" author="bper">
+ <comment>
+ Ajout de colonne 'rang' dans la table 'entnotes.resultat_eleve_periode'
+ </comment>
+
+ <addColumn schemaName="entnotes" tableName="resultat_eleve_periode">
+ <column name="rang" type="int" >
+ <constraints nullable="true" />
+ </column>
+ </addColumn>
+
+ </changeSet>
+
+</databaseChangeLog>
<include
file="changelogs/scolarite/annuaire_interface/2013-04-24-0027499.xml"/>
<include file="changelogs/scolarite/2013-04-19-0026845.xml"/>
+ <include file="changelogs/scolarite/2013-04-18-0027183.xml"/>
+ <include file="changelogs/scolarite/2013-04-22-0027416.xml"/>
</databaseChangeLog>
import org.lilie.services.eliot.AbstractEliotController
import org.lilie.services.eliot.menu.MenuInfo
import org.lilie.services.eliot.EliotConstantes
-import org.lilie.services.eliot.scolarite.IntervalleEnum
-import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.scolarite.Periode
import javax.servlet.http.HttpServletResponse
import org.lilie.services.eliot.impression.ImpressionMoteurService
import org.lilie.services.eliot.notes.notes.NoteTextuelleService
import grails.converters.JSON
import org.lilie.services.eliot.ExceptionHandler
-import org.lilie.services.eliot.scolarite.NaturePeriode
/**
* classe abstraite pour définir les controlleurs de note
return result
}
- /**
- * Retourne le libellé court de la période
- * @param periode
- * @return String
- * @author onic
- */
- protected String getTypePeriodeLibelleCourt(TypePeriode typePeriode) {
- if (typePeriode == null) {
- return null
- }
- String libelle = null
- if (typePeriode.nature == NaturePeriode.NOTATION) {
- switch (typePeriode.intervalle) {
- case IntervalleEnum.S1:
- libelle = message(code: 'periode.semestre.premiere.libelleCourt', default: 'S1')
- break
- case IntervalleEnum.S2:
- libelle = message(code: 'periode.semestre.deuxieme.libelleCourt', default: 'S2')
- break
- case IntervalleEnum.T1:
- libelle = message(code: 'periode.trimestre.premiere.libelleCourt', default: 'T1')
- break
- case IntervalleEnum.T2:
- libelle = message(code: 'periode.trimestre.deuxieme.libelleCourt', default: 'T2')
- break
- case IntervalleEnum.T3:
- libelle = message(code: 'periode.trimestre.troisieme.libelleCourt', default: 'T3')
- break
- case IntervalleEnum.ANNEE:
- libelle = message(code: 'periode.annee.libelleCourt', default: 'A')
- break
- }
- } else {
- libelle = typePeriode.libelle
- }
- return libelle
- }
-
- /**
- * Retourne le libellé de la période pour l'affichage dans les graphiques
- * @param periode
- * @return String
- * @author onic
- */
- protected String getTypePeriodeLibelleGraphe(TypePeriode typePeriode) {
- if (typePeriode == null) {
- return null
- }
- String libelle = null
- if (typePeriode.nature == NaturePeriode.NOTATION) {
- switch (typePeriode.intervalle) {
- case IntervalleEnum.S1:
- libelle = message(code: 'periode.semestre.premiere.libelleGraphe', default: '1er Sem')
- break
- case IntervalleEnum.S2:
- libelle = message(code: 'periode.semestre.deuxieme.libelleGraphe', default: '2nd Sem')
- break
- case IntervalleEnum.T1:
- libelle = message(code: 'periode.trimestre.premiere.libelleGraphe', default: '1er Trim')
- break
- case IntervalleEnum.T2:
- libelle = message(code: 'periode.trimestre.deuxieme.libelleGraphe', default: '2ème Trim')
- break
- case IntervalleEnum.T3:
- libelle = message(code: 'periode.trimestre.troisieme.libelleGraphe', default: '3ème Trim')
- break
- case IntervalleEnum.ANNEE:
- libelle = message(code: 'periode.annee.libelleGraphe', default: 'Année')
- break
- }
- } else {
- libelle = typePeriode.libelle
- }
- return libelle
- }
-
- /**
- * Trie les périodes (trimestre1, trimestre2, trimestre3, année, examens triés...)
- * @param periodes
- * @return periodes triées
- * @author msan
- */
- protected List<Periode> triePeriodes(List<Periode> periodes) {
- periodes.sort { Periode a, Periode b ->
- if (a.typePeriode.isNotation()) {
- if (b.typePeriode.isNotation()) {
- return a.ordre <=> b.ordre // A et B Notation = trie par ordre
- } else {
- return -1 // A = Notation = a est première
- }
- } else if (b.typePeriode.isNotation()) {
- return 1 // B = Notation = b est première
- } else { // A et B examen - trie par dateDebut
- return a.dateDebut <=> b.dateDebut
- }
- }
- return periodes
- }
-
/**
* Vérifie si la période est publiée pour tous les profils sauf
* ENSEIGNANT, DOC, EDU, CTR, Admin Local et DIRECTEUR
import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
import org.lilie.services.eliot.notes.notes.tableaudenotes.*
import org.lilie.services.eliot.droits.Action
+import org.lilie.services.eliot.PeriodeLibelleMode
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
/**
* Controller commun de Saisie et Consultation de Tableau de Notes
EnseignementService enseignementService
TableauNotesSportService tableauNotesSportService
NotesStructureEnseignementService notesStructureEnseignementService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
static final NoteFormateur NF_PAR_DEFAUT = new NoteFormateur()
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
Autorite enseignant = enseignantConsulte ?: securiteSession.defaultAutorite
List<TypePeriodeInfo> typePeriodeInfos = null
+ List<TypePeriode> typePeriodePrecedents = []
List<TableauDeNotesLigne> tdnLignes = null
List<Evaluation> evaluations = []
String appreciation = ''
Boolean periodesDefinis = true
Enseignement enseignement = null
Boolean isMatiereEPS = false
+ Map<BigDecimal, Integer> rangs = [:]
// charge la liste des services d'enseignant loggué
List<Service> services = notesServiceService.
if (service) {
// charge periodes si service défini
- typePeriodeInfos = getTypePeriodeInfos(service)
+
+ List<TypePeriode> typePeriodes = getTypePeriodes(service)
+
+ typePeriodeInfos = getTypePeriodeInfos(service, typePeriodes)
// renseigne id de typePeriode en cours
if (typePeriodeId == null) {
appreciation =
(tdn.allAppreciationClasseEnseignementPeriode?.size() > 0) ?
tdn.allAppreciationClasseEnseignementPeriode.first().appreciation : null
+
+ if (typePeriode.isNotation()) {
+ typePeriodePrecedents = getTypePeriodePrecedents(typePeriodes, typePeriode)
+ }
+
+ rangs = calculeRangs(tdn)
}
// Les sous-service correspondant au type de période ou au type de période équivalent
isMatiereEPS = service.choisiPourSport
}
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
resultat.enseignementId = enseignement?.id
resultat.moyennesAjour = moyennesAjour
resultat.dateDernierCalculMoyennes = dateDernierCalculMoyennes
resultat.isServiceDeRegroupement = service?.structureEnseignement?.isRegroupement()
resultat.services = services
resultat.typePeriodeInfos = typePeriodeInfos
- resultat.tdnLignes = tdnLignes.collect {toMap(it)} as JSON
+ resultat.tdnLignes = tdnLignes.collect {toMap(it, rangs)} as JSON
resultat.evaluationInfos = evaluations.collect {toMap(it, sousServices)} as JSON
resultat.sousServicesNonEvaluables = sousServices && !sousServices.any {it.evaluable}
resultat.consultation = consultation
resultat = ajouteAnnotations(resultat)
resultat.isMatiereEPS = isMatiereEPS
+ resultat.typePeriodePrecedents = typePeriodePrecedents.collect {
+ [
+ id: it.id,
+ libelle: getTypePeriodeLibelle(it, PeriodeLibelleMode.COURT)
+ ]
+ } as JSON
+
+ resultat.affichage = [
+ moyennesPrecedentes: pref?.moyennesPrecedentes ?: false,
+ rangs: pref?.rangs ?: false
+ ]
+
return resultat
}
+
+ private Map<BigDecimal, Integer> calculeRangs(TableauDeNotes tdn) {
+ List<BigDecimal> valeurs = tdn.lignes*.resultat*.moyenne*.find {it != null}
+
+ BigDecimal precision = etablissementCourant().etablissementNotes.precision
+
+ return calculationService.calculeRangs(valeurs, precision)
+ }
+
+
/**
- * Recupere les évaluations d'un prof + service + typePeriode
- * @param enseignant
- * @param service
- * @param typePeriode
- * @return
+ * Récupère les évaluations d'un prof + service + typePeriode
*/
private List<Evaluation> getEvaluations(Autorite enseignant,
Service service,
TypePeriode typePeriode) {
- List<Evaluation> evaluations = []
- if (typePeriode?.isAnnee()) {
- // Pour la période "année" les évaluations correspondant aux types
- // de périodes de notation
- List<TypePeriode> typePeriodeXmestres =
- notesTypePeriodeService.findAllXmestreForService(
- securiteSession,
- service,
- TypeIntervalleEnum.TRIMESTRE)
-
- evaluations = typePeriodeXmestres.collect {
- Evaluation evaluation = new Evaluation()
- evaluation.id = it.id
- evaluation.titre = getTypePeriodeLibelle(it)
- evaluation.coefficient = 1
- evaluation.noteMaxPossible = 20
- evaluation.publiable = true
- return evaluation
- }
- } else {
- // Pour d'autres périodes les évaluations sont les devoirs saisis par les profs
- evaluations = notesEvaluationService.findAllEvaluations(
+
+ List<Evaluation> evaluations = notesEvaluationService.findAllEvaluations(
securiteSession,
service,
typePeriode,
enseignant,
etablissementCourant())
- }
+
evaluations.sort()
+
return evaluations
}
+
/**
* Recupere la liste de typePeriode pour un service.
* La période en cours est aussi marqué.
- * @param service
- * @return
*/
- private List<TypePeriodeInfo> getTypePeriodeInfos(Service service) {
+ private List<TypePeriodeInfo> getTypePeriodeInfos(Service service,
+ List<TypePeriode> typePeriodes) {
List<TypePeriodeInfo> typePeriodeInfos = []
- // Liste des périodes évaluables du service
- List<TypePeriode> typePeriodes = notesTypePeriodeService.
- findAllTypePeriodeForService(
- securiteSession,
- service,
- true
- )
-
// Récupère la pemiere période en cours du service
Periode periodeEnCours = service.relPeriodeServices.find {
it.periode.isPeriodeEnCours() && it.evaluable && it.periode.isPeriodeXmestre()
getTypePeriodeEquivalent(typePeriodeEnCours)
}
- // Enlève les types de période equivanlents
- typePeriodes = notesTypePeriodeService.excludeTypePeriodesEquivalents(
- typePeriodes,
- TypeIntervalleEnum.TRIMESTRE)
-
// Crée dtos + marque période en cours
typePeriodeInfos = typePeriodes.collect {
TypePeriodeInfo typePeriodeInfo = new TypePeriodeInfo()
return typePeriodeInfos
}
+
+ private List<TypePeriode> getTypePeriodes(Service service) {
+ // Liste des périodes évaluables du service
+ List<TypePeriode> typePeriodes = notesTypePeriodeService.
+ findAllTypePeriodeForService(
+ securiteSession,
+ service,
+ true
+ )
+
+ // Enlève les types de période equivanlents
+ typePeriodes = notesTypePeriodeService.excludeTypePeriodesEquivalents(
+ typePeriodes,
+ TypeIntervalleEnum.TRIMESTRE)
+
+ return typePeriodes
+ }
+
+
+ private List<TypePeriode> getTypePeriodePrecedents(List<TypePeriode> typePeriodes,
+ TypePeriode typePeriode) {
+
+ typePeriodes = notesTypePeriodeService.trieTypePeriodes(typePeriodes)
+
+ Integer i = typePeriodes.indexOf(typePeriode)
+
+ return (i == 0) ? [] : typePeriodes[0..i-1]
+ }
+
+
/**
* Converteur pour TableauDeNotesLigne
- * @param ligne
- * @return
*/
- protected Map toMap(TableauDeNotesLigne ligne) {
+ protected Map toMap(TableauDeNotesLigne ligne, Map<BigDecimal, Integer> rangs) {
Map map = [
eleveNomAffichage: ligne.eleve?.nomAffichage(),
eleveId: ligne.eleve?.id,
classe: ligne.classe?.code,
actif: ligne.actif
]
- if (ligne.periode?.isPeriodeAnnee()) {
- ligne.resultats?.each {
- if (it.periode.typePeriode.isAnnee()) {
- map["moyenne"] = it.getValeurAffichage()
- } else {
- TypePeriode typePeriode = it.periode.typePeriode
- TypePeriode typePeriodeEquiv = notesTypePeriodeService.
- getTypePeriodeEquivalent(typePeriode)
- map["note_${typePeriode.id}"] = it.getValeurAffichage()
- if (typePeriodeEquiv) {
- map["note_${typePeriodeEquiv.id}"] = it.getValeurAffichage()
- }
- }
- }
- } else {
- ligne.notes?.each {
- map["note_${it.evaluation.id}"] = it.getValeur()
+
+ ligne.notes?.each {
+ map."note_${it.evaluation.id}" = it.getValeur()
+ }
+
+ if (ligne.resultat) {
+ map["moyenne"] = ligne.resultat.getValeurAffichage()
+ map["rang"] = rangs.get(ligne.resultat.moyenne)
+ }
+
+ ligne.resultatsXmestresPrecedents?.each {
+ TypePeriode typePeriode = it.periode.typePeriode
+ TypePeriode typePeriodeEquiv = notesTypePeriodeService.
+ getTypePeriodeEquivalent(typePeriode)
+
+ map["moyennePeriodePrecedente${typePeriode.id}"] = it.getValeurAffichage()
+
+ if (typePeriodeEquiv) {
+ map["moyennePeriodePrecedente${typePeriodeEquiv.id}"] = it.getValeurAffichage()
}
}
+
return map
}
// Colonnes "Xmestre"
typePeriodeXmestres.each {TypePeriode typePeriode ->
- ResultatEleveEnseignementPeriode resultatXmestre = ligneTDN.resultats.find {
+ ResultatEleveEnseignementPeriode resultatXmestre = ligneTDN.resultatsXmestresPrecedents.find {
it.periode.typePeriode.id == typePeriode.id ||
it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
}
import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
import org.lilie.services.eliot.notes.AvisElevePeriode
import org.lilie.services.eliot.notes.TypeAvis
+import org.lilie.services.eliot.PeriodeLibelleMode
/**
* @author bper
[
'code':"moyenneEleve_${periodePrecedente.id}",
'libelle': controller.
- getTypePeriodeLibelleGraphe(periodePrecedente.typePeriode)
+ getPeriodeLibelle(periodePrecedente, PeriodeLibelleMode.COURT)
]
})
}
[
'code':"moyenneEleve",
'libelle': avecPeriodesPrecedentes ?
- controller.
- getTypePeriodeLibelleGraphe(bulletin.periode.typePeriode)
+ controller.getPeriodeLibelle(bulletin.periode, PeriodeLibelleMode.COURT)
: null
// on n'envoie pas le libelle si on n'affiche pas les periodes
// precedentes, pour indiquer au FO, qu'il faut utiliser le
if (classe) {
// La liste des période dans combo triée
- List<Periode> periodes = triePeriodes(classe.periodes.toList())
+ List<Periode> periodes = classe.periodes.toList().sort()
+
periodeInfos = periodes.collect {
new PeriodeInfo(
idPeriode: it.id,
if (classe) {
// La liste des période dans combo triée
- List<Periode> periodes = triePeriodes(classe.periodes.toList())
+ List<Periode> periodes = classe.periodes.toList().sort()
// Période sélectionnée ou la période en cours
periode = (periodeId != null) ? Periode.get(periodeId) :
classe)
// Liste de période de la classe sélectionnée
- List<Periode> periodes = triePeriodes(classe.periodes as List)
+ List<Periode> periodes = classe.periodes.toList().sort()
+
periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
periodeInfos = periodes.collect {
new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
eleves = listeEleves(securiteSession, classe)
// Liste de période de la classe sélectionnée
- List<Periode> periodes = triePeriodes(classe.periodes as List)
+ List<Periode> periodes = classe.periodes.toList().sort()
periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
periodeInfos = periodes.collect {
new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
package org.lilie.services.eliot.notes.consultation
import grails.converters.JSON
securiteSession,
classe)
- List<Periode> periodes = triePeriodes(classe.periodes as List)
+ List<Periode> periodes = classe.periodes.toList().sort()
Periode periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
List<Periode> periodeInfos = periodes.collect {
new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
SecuriteSession securiteSession = SessionUtils.securiteSession(session)
Long idService = Long.valueOf(params.idService)
Service service = Service.get(idService)
- List<Periode> periodes = notesPeriodeService.getPeriodesPourService(securiteSession, service)
- //Trie les périodes (trimestre1, trimestre2, trimestre3, année, examens triés...)
- periodes = triePeriodes(periodes)
+ List<Periode> periodes = notesPeriodeService.getPeriodesPourService(securiteSession, service).sort()
List periodeInfos = periodes.collect {Periode periode ->
PeriodeInfo periodeInfo = new PeriodeInfo()
periodeInfo.idPeriode = periode.id
Long idClasse = Long.valueOf(params.idClasse)
StructureEnseignement classe = StructureEnseignement.get(idClasse)
List<Periode> periodes = notesPeriodeService.getPeriodesPourClasse(
- securiteSession, classe)
-
- //Trie les périodes (trimestre1, trimestre2, trimestre3, année, examens triés...)
- periodes = triePeriodes(periodes)
+ securiteSession, classe).sort()
List<PeriodeInfo> periodeInfos = periodes.collect {Periode periode ->
PeriodeInfo periodeInfo = new PeriodeInfo()
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes.domaine
import org.lilie.services.eliot.notes.AbstractNotesController
+import grails.converters.JSON
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
-/**
- * Le contyrolleur utilisé pour enregistrer les appreciations des élève
- * dans la table de synthèse
- * @author bper
- */
-class ResultatElevePeriodeController extends AbstractNotesController {
+class PreferenceUtilisateurNotesController extends AbstractNotesController {
+
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
+
+ def enregistre = {
+
+ Map resultat = tryCatch{
+ Boolean rangs = params.rangs ? Boolean.valueOf(params.rangs) : null
+ Boolean moyennesPrecedentes =
+ params.moyennesPrecedentes ? Boolean.valueOf(params.moyennesPrecedentes) : null
+
+ PreferenceUtilisateurNotesParams pref =
+ new PreferenceUtilisateurNotesParams(
+ rangs: rangs,
+ moyennesPrecedentes: moyennesPrecedentes
+ )
+
+ preferenceUtilisateurNotesService.metAJourPreferenceUtilisateur(getSecuriteSession(),
+ pref)
+ }
-// NotesDroitService notesDroitService
-// ResultatElevePeriodeService resultatElevePeriodeService
-//
-// /**
-// * Enregistre les appreciations générales des élève pour une periode
-// * @author bper
-// */
-// def enregistrerAppreciations = {AppreciationsElevesPeriodeCommand command ->
-// Map result = getResultIfInvalidCommand(command)
-// if (!result) {
-// result = tryCatch({
-// notesDroitService.verifieAutorisationByEtablissement(
-// securiteSession,
-// etablissementCourant(),
-// Action.MODIFICATION,
-// [RoleEnum.DIRECTEUR,RoleEnum.ENSEIGNANT, RoleEnum.DOCUMENTALISTE, RoleEnum.EDUCATION]
-// )
-// SecuriteSession securiteSession = getSecuriteSession()
-// Periode periode = Periode.get(command.idPeriode)
-// Map mapEleveAppreciation = command.getMapEleveAppreciation()
-// resultatElevePeriodeService.saveAppreciations(
-// securiteSession,mapEleveAppreciation,periode)
-// })
-// }
-// render result as JSON
-// }
+ render resultat as JSON
+ }
}
--- /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.notes.domaine
+
+/**
+ * @author agia
+ */
+class PreferenceUtilisateurNotesParams {
+
+ Boolean rangs
+ Boolean moyennesPrecedentes
+
+}
import org.lilie.services.eliot.urllabel.UrlLabelInfo
import org.lilie.services.eliot.notes.report.ReportTraitementService
import org.lilie.services.eliot.notes.report.ReportService
+import org.lilie.services.eliot.PeriodeLibelleMode
/**
* Cette classe représente le controlleur de la vue de "Services" dans menu
if (natureChoisie == NaturePeriode.EXAMEN) {
List<Periode> periodesEx = periodes.findAll {
it.typePeriode.nature == NaturePeriode.EXAMEN
- }
- periodesEx = triePeriodes(periodesEx)
+ }.sort()
+
periodesEx.each { Periode periode ->
ClassePeriodeInfo periodeInfo = creeClassePeriodeInfo(periode)
periodesExamen << periodeInfo
}
} else if (natureChoisie == NaturePeriode.NOTATION) {
+
List<Periode> periodesNot = periodes.findAll {
it.typePeriode.nature == NaturePeriode.NOTATION
- }
- periodesNot = triePeriodes(periodesNot)
+ }.sort()
+
periodesNot.each { Periode periode ->
periodesNotation << new ClassePeriodeInfo(
idTypePeriode: periode.typePeriode.id,
- libelle: getTypePeriodeLibelleCourt(periode.typePeriode)
+ libelle: getTypePeriodeLibelle(periode.typePeriode, PeriodeLibelleMode.ABREGE)
)
}
}
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.notes.resultat.eleve.AppreciationEleveEnseignementPeriodeService
import org.lilie.services.eliot.scolarite.SousService
+import org.lilie.services.eliot.PeriodeLibelleMode
/**
* Appréciations saisie par l'enseignant pour les élèves d'un service
Map result = prepareBaseModele(Page.SAISIE_APPRECIATIONS,
service?.structureEnseignement.code,
service?.matiere.codeGestion,
- getTypePeriodeLibelleCourt(typePeriode),
+ getTypePeriodeLibelle(typePeriode, PeriodeLibelleMode.ABREGE),
serviceId,
typePeriodeId
)
JSON.use(SaisieConseilDeClasseConfig.toString()) {
result.nomStructure = service?.structureEnseignement.code
result.nomMatiere = service?.matiere.codeGestion
- result.nomPeriodeCourt = getTypePeriodeLibelleCourt(typePeriode)
+ result.nomPeriodeCourt = getTypePeriodeLibelle(typePeriode, PeriodeLibelleMode.ABREGE)
result.nomPeriode = getTypePeriodeLibelle(typePeriode)
result.serviceId = serviceId
result.typePeriodeId = typePeriodeId
}
// Les périodes de la classe
- List<Periode> periodes = triePeriodes(classe.periodes as List)
+ List<Periode> periodes = classe.periodes.toList().sort()
+
periodeInfos = periodes.collect {
new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
return (sousServiceId != null) ? "s${serviceId}ss${sousServiceId}" : "s${serviceId}"
}
-
+
/**
* @author bper
*/
}
Map map = [
- personneId: syntheseEleve.eleve?.id,
- id: syntheseEleve.eleve.autorite?.id,
- nomAffichage: syntheseEleve.eleve?.nomAffichage(),
- moyenne: syntheseEleve.resultatElevePeriode?.getValeurAffichage(),
- appreciationGenerale: syntheseEleve.appreciationElevePeriode?.appreciation,
- colonnesGrisees: colonnesGrisees,
- actif: syntheseEleve?.actif,
+ personneId: syntheseEleve.eleve?.id,
+ id: syntheseEleve.eleve.autorite?.id,
+ nomAffichage: syntheseEleve.eleve?.nomAffichage(),
+ moyenne: syntheseEleve.resultatElevePeriode?.getValeurAffichage(),
+ appreciationGenerale: syntheseEleve.appreciationElevePeriode?.appreciation,
+ colonnesGrisees: colonnesGrisees,
+ actif: syntheseEleve?.actif,
+ rang: syntheseEleve.resultatElevePeriode?.rang
]
def cle = null
// Les moyenne des périodes de notation
- syntheseEleve?.resultatEleveXmestres?.each {
- cle = getCleMoyenneService("periode_${it.periode.id}")
- map.put((cle), it.getValeurAffichage())
+ syntheseEleve?.resultatEleveXmestrePrecedents?.each {
+ map.put("moyennePeriodePrecedente${it.periode.id}", it.getValeurAffichage())
}
syntheseEleve.resultatEleveServicePeriodes.each {
// Les moyennes générales
Map moyenne = [
- nomAffichage: "Moyenne",
- moyenne: syntheseClasse.resultatClassePeriode?.moyenne
+ nomAffichage: "Moyenne",
+ moyenne: syntheseClasse.resultatClassePeriode?.moyenne
]
Map moyenneMax = [
- nomAffichage: "Moyenne Max.",
- moyenne: syntheseClasse.resultatClassePeriode?.moyenneMax]
+ nomAffichage: "Moyenne Max.",
+ moyenne: syntheseClasse.resultatClassePeriode?.moyenneMax]
Map moyenneMin = [
- nomAffichage: "Moyenne Min.",
- moyenne: syntheseClasse.resultatClassePeriode?.moyenneMin
+ nomAffichage: "Moyenne Min.",
+ moyenne: syntheseClasse.resultatClassePeriode?.moyenneMin
]
def cle = null
// Les moyennes de Xmestres
- syntheseClasse.resultatClasseXmestres?.each {
- cle = getCleMoyenneService("periode_${it.periode.id}")
+ syntheseClasse.resultatClasseXmestrePrecedents?.each {
+ cle = "moyennePeriodePrecedente${it.periode.id}"
moyenne.put((cle), it.moyenne)
moyenneMax.put((cle), it.moyenneMax)
moyenneMin.put((cle), it.moyenneMin)
import org.lilie.services.eliot.notes.impression.synthese.ImpressionSyntheseService
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+import org.lilie.services.eliot.PeriodeLibelleMode
/**
* Cette classe représente le controleur de
BulletinService bulletinService
PeriodeService periodeService
ImpressionSyntheseService impressionSyntheseService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
)
)
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
Map result = wrapResultat {
Synthese synthese = null
Boolean appreciationModifiable = false
Boolean moyennesAjour = true
Date dateDernierCalculMoyennes = null
Periode periode = null
+ List<Periode> periodesPrecedentes = []
// Récupère la liste des classes
List<StructureEnseignement> classes = notesStructureEnseignementService.
findAllClasseForUtilisateur(
- securiteSession,
- etablissementCourant(),
- Action.CONSULTATION)
+ securiteSession,
+ etablissementCourant(),
+ Action.CONSULTATION)
classes.sort {a, b -> cc.compare(a.code, b.code)}
if (classe) {
// La liste des période dans combo triée
- List<Periode> periodes = triePeriodes(classe.periodes.toList())
+ List<Periode> periodes = classe.periodes.toList().sort()
+
periodeInfos = periodes.collect {
new PeriodeInfo(
idPeriode: it.id,
// Période sélectionnée ou la période en cours
periode = (periodeId != null) ? Periode.get(periodeId) :
periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre() }
+
if (periode) {
// Période selectionnée
periodeId = periode.id
dateDernierCalculMoyennes = synthese.dateDernierCalculMoyennes
// Les services et les sous-services qui correspondent aux colonnes de la synthèse
- serviceInfos = getServiceInfos(synthese.syntheseClasse.services, periode, classe)
+ serviceInfos = getServiceInfos(synthese.syntheseClasse.services, periode)
+
+ if (periode.isPeriodeNotation()) {
+ periodesPrecedentes = periode.getPeriodesPrecedentes()
+ }
}
}
result.syntheseEleves = synthese?.syntheseEleves as JSON
result.syntheseClasses = synthese?.syntheseClasse as JSON
result.verrouille = periode ? periode.verrouille : true
+
+ result.periodesPrecedentes = periodesPrecedentes.collect {
+ [
+ id: it.id,
+ libelle: getTypePeriodeLibelle(it.typePeriode, PeriodeLibelleMode.COURT)
+ ]
+ } as JSON
+
+ result.affichage = [
+ moyennesPrecedentes: pref?.moyennesPrecedentes ?: false,
+ rangs: pref?.rangs ?: false
+ ]
}
result = ajouteAnnotations(result)
Periode periode = Periode.get(jsonParams.periodeId)
DonneesPourExportCSV donnees =
- prepareDonneesPourExportCSV(securiteSession, classe, periode)
+ prepareDonneesPourExportCSV(securiteSession, classe, periode)
sendCsvFile(response, donnees, "Synthese_${classe.code}_${periode.libelle}")
}
/**
* Prepare donnees pour l'export CSV
- * @param securiteSession
- * @param classe
- * @param periode
- * @return
*/
private DonneesPourExportCSV prepareDonneesPourExportCSV(
- SecuriteSession securiteSession, StructureEnseignement classe, Periode periode) {
+ SecuriteSession securiteSession, StructureEnseignement classe, Periode periode) {
DonneesPourExportCSV donnees = new DonneesPourExportCSV()
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
+ List<Periode> periodesPrecedentes = periode?.getPeriodesPrecedentes()
+
// Récupère la synthese
Synthese synthese = syntheseService.construisSynthese(securiteSession, classe, periode)
List ligneEnteteEns = [message(code: 'eliot.notes.libelle.enseignants', default: 'Enseignants')]
List ligneEnteteCoeff = [message(code: 'eliot.notes.libelle.coeff', default: 'Coeff.')]
- List colonneMaps = getServiceInfos(synthese.syntheseClasse.services, periode, classe)
+ List colonneMaps = getServiceInfos(synthese.syntheseClasse.services, periode)
List<Map> syntheseEleveMaps =
- synthese.syntheseEleves.collect {SaisieSyntheseConfig.convertForSyntheseEleve(it)}
+ synthese.syntheseEleves.collect {SaisieSyntheseConfig.convertForSyntheseEleve(it)}
List<Map> syntheseClasseMaps =
- SaisieSyntheseConfig.convertForSyntheseClasse(synthese.syntheseClasse)
+ SaisieSyntheseConfig.convertForSyntheseClasse(synthese.syntheseClasse)
List<Map> ligneMaps = []
ligneMaps.addAll(syntheseEleveMaps)
}
}
- // Ajoute la colonne "Moy." et "Appréciations générales"
+ if (pref?.moyennesPrecedentes == true && periode?.isPeriodeNotation()){
+ periodesPrecedentes?.each{ Periode periodePrecedente ->
+ donnees.colonnes << message(
+ code: periodeService.getNomPeriodePrecedente(periodePrecedente.typePeriode?.libelle)
+ )
+ }
+ }
+
+ // Ajoute la colonne "Moy."
donnees.colonnes << message(
code: 'eliot.notes.libelle.moyenneCourt',
default: 'Moy.'
)
+
+ if (pref?.rangs == true){
+ // Ajoute la colonne de rang si l'option a été cochée
+ donnees.colonnes << message(
+ code: 'eliot.notes.libelle.rang',
+ default: 'Rang'
+ )
+ }
+
+ // Ajoute la colonne "Appréciations générales"
donnees.colonnes << message(
code: 'eliot.notes.libelle.appreciationsGenerales',
default: 'Appréciations générales'
)
ligneMaps.eachWithIndex {Map map, Integer i ->
+ // moy. prec.
+ if (pref?.moyennesPrecedentes == true && periode?.isPeriodeNotation()){
+ for (int j = 0; j < periodesPrecedentes?.size(); ++j){
+ def moyennePrecedente = map.get("moyennePeriodePrecedente${periodesPrecedentes[j].id}")
+ lignes.get(i) << nf.format(moyennePrecedente)
+ }
+ }
+ // moyenne
lignes.get(i) << nf.format(map.moyenne)
+ // rang
+ if (pref?.rangs == true){
+ lignes.get(i) << map.rang
+ }
+ // appréciation
lignes.get(i) << map.appreciationGenerale
}
/**
* Construis une liste des Maps correspondant aux Services et SousServices
- * @param services
- * @param periode
- * @return
* @author bper
*/
private List getServiceInfos(List<Service> services,
- Periode periode,
- StructureEnseignement classe) {
- List serviceInfos = []
+ Periode periode) {
+ List colonnes = []
String moy = message(code: 'eliot.notes.libelle.moyenneCourt', default: 'Moy.')
services?.each {Service service ->
sousServices.each {SousService sousService ->
if (sousService.typePeriode == periode.typePeriode && sousService.evaluable) {
def idCompose = SaisieSyntheseConfig.getIdCompose(service.id, sousService.id)
- serviceInfos << [
+ colonnes << [
id: service.id,
idCompose: idCompose,
lblMatiere: service.matiere.codeGestion,
}
}
def idCompose = SaisieSyntheseConfig.getIdCompose(service.id)
- serviceInfos << [
+ colonnes << [
id: service.id,
idCompose: idCompose,
lblMatiere: service.matiere.codeGestion,
]
}
- // Si c'est la période "Année" on affiche les moyennes générales de chaque Xmestre
- if (periode.isPeriodeAnnee()) {
- String lblMatiere = message(
- code: 'eliot.notes.libelle.moyennesGenerales',
- default: 'Moy. générales'
- )
- List<Periode> periodeXmestres = classe.periodes.findAll {it.isPeriodeXmestre()} as List
- periodeXmestres = triePeriodes(periodeXmestres)
- periodeXmestres.each {
- def idCompose = SaisieSyntheseConfig.getIdCompose("periode_${it.id}")
- serviceInfos << [
- id: -1,
- idCompose: idCompose,
- lblMatiere: lblMatiere,
- enseignants: [],
- coeff: 1,
- sousServiceCode: getTypePeriodeLibelleCourt(it.typePeriode),
- isOption: false,
- isSousService: false
- ]
- }
- }
-
- return serviceInfos
+ return colonnes
}
/**
/**
* Calcul des données pour l'impression de la sytnhèse
- * @param securiteSession
- * @param params
- * @return
*/
private SyntheseImpression donneesTableauSynthese(SecuriteSession securiteSession, Map params) {
notesDroitService.verifieAutorisationByEtablissement(
Synthese synthese = syntheseService.construisSynthese(securiteSession, classe, periode)
// Crée la syntheseImpression
- return construisTableauImpression(synthese)
+ return construisTableauImpression(synthese, securiteSession)
}
/**
* Convertion de l'objet synthese vers un objet capable d'être imprimé
- * @param synthese
- * @return
*/
- private SyntheseImpression construisTableauImpression(Synthese synthese) {
+ private SyntheseImpression construisTableauImpression(Synthese synthese,
+ SecuriteSession securiteSession) {
SyntheseImpression tab =
- impressionSyntheseService.construisTableauImpression(synthese)
+ impressionSyntheseService.construisTableauImpression(synthese, securiteSession)
// i18n-isation des données du tableau
tab.periode = getTypePeriodeLibelle(synthese?.periode?.typePeriode)
if (it instanceof CelluleTypePeriode) {
CelluleTypePeriode moyenne = (CelluleTypePeriode) it
- moyenne.entete1 = getTypePeriodeLibelleCourt(moyenne.typePeriode)
+ moyenne.entete1 = getTypePeriodeLibelle(moyenne.typePeriode, PeriodeLibelleMode.ABREGE)
}
if (it instanceof CelluleI18n) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
+
breadCrumbsInfo << new BreadCrumbsItemInfo(
codeLabel: 'notes.menu.saisie.titrePrincipal'
)
+
breadCrumbsInfo << new BreadCrumbsItemInfo(
codeLabel: 'notes.menu.saisie.synthese.titrePrincipal'
)
return breadCrumbsInfo
-
}
-
}
\ No newline at end of file
eliot.notes.libelle.adresse=Adresse
eliot.notes.libelle.cpVille=Cp - Ville
-periode.trimestre.premiere.libelle=1er trimestre
-periode.trimestre.deuxieme.libelle=2ème trimestre
-periode.trimestre.troisieme.libelle=3ème trimestre
-periode.semestre.premiere.libelle=1er semestre
-periode.semestre.deuxieme.libelle=2ème semestre
-periode.annee.libelle=Année
-periode.trimestre.premiere.libelleCourt=T1
-periode.trimestre.deuxieme.libelleCourt=T2
-periode.trimestre.troisieme.libelleCourt=T3
-periode.semestre.premiere.libelleCourt=S1
-periode.semestre.deuxieme.libelleCourt=S2
-periode.annee.libelleCourt=A
-periode.trimestre.premiere.libelleGraphe=1er Trim
-periode.trimestre.deuxieme.libelleGraphe=2ème Trim
-periode.trimestre.troisieme.libelleGraphe=3ème Trim
-periode.semestre.premiere.libelleGraphe=1er Sem
-periode.semestre.deuxieme.libelleGraphe=2nd Sem
-periode.annee.libelleGraphe=Année
+eliot.notes.libelle.affichage=Affichage
+eliot.notes.libelle.moyennesPrecedentes=Moyennes précédentes
+eliot.notes.libelle.rang=Rang
groupePeriode.notation=Notation
groupePeriode.examen=Examen
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.applications.absences.PriseEnCompteMotif
-import org.lilie.services.eliot.impression.BulletinOptions
/**
* Service de requetage de notes pour le publipostage - bulletins et releves
*/
-// TOREFACT : à fusionner avec NotesImpressionService ?
-// TOREFACT : mantis 0014203
+// TOREFACT : à fusionner avec NotesImpressionService ? mantis 0014203
class ImpressionRequetageBulletinReleveService {
static transactional = true
eleveImpressionInfo.setPeriodeFin(periode.dateFin)
if (lireBulletin) {
- // Récupère le bulletin de la période demandée
- Bulletin bulletin = bulletinService.construisBulletin(
- securiteSession,
- eleve,
- periode)
- // Récupère le bulletin des périodes précédentes
- Bulletin bulletinPeriodePrecedente1 = null
- Bulletin bulletinPeriodePrecedente2 = null
- Bulletin bulletinPeriodePrecedente3 = null
+ Periode periodePrecedente1 = null
+ Periode periodePrecedente2 = null
+ Periode periodePrecedente3 = null
if (periode.isPeriodeNotation()) {
List<Periode> periodePrecedentes = periode.getPeriodesPrecedentes()
- Periode periodePrecedente1 = periodePrecedentes.size() > 0 ? periodePrecedentes.get(0) : null
- Periode periodePrecedente2 = periodePrecedentes.size() > 1 ? periodePrecedentes.get(1) : null
- Periode periodePrecedente3 = periodePrecedentes.size() > 2 ? periodePrecedentes.get(2) : null
-
- bulletinPeriodePrecedente1 = periodePrecedente1 ?
- bulletinService.construisBulletin(securiteSession, eleve, periodePrecedente1) : null
-
- bulletinPeriodePrecedente2 = periodePrecedente2 ?
- bulletinService.construisBulletin(securiteSession, eleve, periodePrecedente2) : null
-
- bulletinPeriodePrecedente3 = periodePrecedente3 ?
- bulletinService.construisBulletin(securiteSession, eleve, periodePrecedente3) : null
+ periodePrecedente1 = periodePrecedentes.size() > 0 ? periodePrecedentes.get(0) : null
+ periodePrecedente2 = periodePrecedentes.size() > 1 ? periodePrecedentes.get(1) : null
+ periodePrecedente3 = periodePrecedentes.size() > 2 ? periodePrecedentes.get(2) : null
}
+ // Récupère le bulletin de la période demandée
+ Bulletin bulletin = bulletinService.construisBulletin(
+ securiteSession,
+ eleve,
+ periode)
+
BulletinOptionsPersonnalise bulletinOptionsPersonnalise =
impressionBulletinOptionsService.getParametreOptions(
templateDocument,
)
return bulletinToTableauImpressionInfo(bulletin,
- bulletinPeriodePrecedente1,
- bulletinPeriodePrecedente2,
- bulletinPeriodePrecedente3,
+ periodePrecedente1,
+ periodePrecedente2,
+ periodePrecedente3,
bulletinOptionsPersonnalise)
}
* @author bper
*/
TableauImpressionInfo bulletinToTableauImpressionInfo(Bulletin bulletin,
- Bulletin bulletinPeriodePrecedente1,
- Bulletin bulletinPeriodePrecedente2,
- Bulletin bulletinPeriodePrecedente3,
+ Periode periodePrecedente1,
+ Periode periodePrecedente2,
+ Periode periodePrecedente3,
BulletinOptionsPersonnalise bulletinOptionsPersonnalise
) {
getNoteFormateur()
// moyennes generales
- if (bulletinPeriodePrecedente1){
- tab.nomPeriodePrecedente1 = getNomMoyennePrecedente(bulletinPeriodePrecedente1.periode?.typePeriode?.libelle)
- tab.moyennePrec1 = nf.format(bulletinPeriodePrecedente1.syntheseEleve?.resultatElevePeriode?.moyenne)
+ if (periodePrecedente1){
+ tab.nomPeriodePrecedente1 = periodeService.getNomPeriodePrecedente(periodePrecedente1.typePeriode?.libelle)
+ BigDecimal moyennePrec1 = null
+ bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente1){
+ moyennePrec1 = it.moyenne
+ }
+ }
+ tab.moyennePrec1 = nf.format(moyennePrec1)
}
- if (bulletinPeriodePrecedente2){
- tab.nomPeriodePrecedente2 = getNomMoyennePrecedente(bulletinPeriodePrecedente2.periode?.typePeriode?.libelle)
- tab.moyennePrec2 = nf.format(bulletinPeriodePrecedente2.syntheseEleve?.resultatElevePeriode?.moyenne)
+ if (periodePrecedente2){
+ tab.nomPeriodePrecedente2 = periodeService.getNomPeriodePrecedente(periodePrecedente2.typePeriode?.libelle)
+ BigDecimal moyennePrec2 = null
+ bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente2){
+ moyennePrec2 = it.moyenne
+ }
+ }
+ tab.moyennePrec2 = nf.format(moyennePrec2)
}
- if (bulletinPeriodePrecedente3){
- tab.nomPeriodePrecedente3 = getNomMoyennePrecedente(bulletinPeriodePrecedente3.periode?.typePeriode?.libelle)
- tab.moyennePrec3 = nf.format(bulletinPeriodePrecedente3.syntheseEleve?.resultatElevePeriode?.moyenne)
+ if (periodePrecedente3){
+ tab.nomPeriodePrecedente3 = periodeService.getNomPeriodePrecedente(periodePrecedente3.typePeriode?.libelle)
+ BigDecimal moyennePrec3 = null
+ bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente3){
+ moyennePrec3 = it.moyenne
+ }
+ }
+ tab.moyennePrec3 = nf.format(moyennePrec3)
}
tab.moyenneClasse = nf.format(bulletin.syntheseClasse.resultatClassePeriode?.moyenne)
tab.moyenneEleve = nf.format(bulletin.syntheseEleve.resultatElevePeriode?.moyenne)
// recupére l'info filtré. services sans notes ou appreciations ne sont pas retenues
List<BulletinServiceResultat> bulletinServiceResultats = bulletin.getServiceResultats(true)
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente1 =
- bulletinPeriodePrecedente1 ? bulletinPeriodePrecedente1.getServiceResultats(true) : null
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente2 =
- bulletinPeriodePrecedente2 ? bulletinPeriodePrecedente2.getServiceResultats(true) : null
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente3 =
- bulletinPeriodePrecedente3 ? bulletinPeriodePrecedente3.getServiceResultats(true) : null
// services
tab.lignesTableau = []
bulletinServiceResultats?.each {BulletinServiceResultat bsr ->
tab.lignesTableau << construitMatiereImpressionInfo(bsr,
nf,
- bulletinServiceResultatsPeriodePrecedente1,
- bulletinServiceResultatsPeriodePrecedente2,
- bulletinServiceResultatsPeriodePrecedente3)
+ periodePrecedente1,
+ periodePrecedente2,
+ periodePrecedente3
+ )
}
List<NoteTextuelle> noteTextuelleList = []
noteTextuelleList.addAll(bulletin.annotationsUtilisees)
- if (bulletinOptionsPersonnalise?.moyennePrec1){
- bulletinPeriodePrecedente1.annotationsUtilisees?.each{
- if (!noteTextuelleList.contains(it)){
- noteTextuelleList = noteTextuelleList.plus(bulletinPeriodePrecedente1.annotationsUtilisees)
- }
- }
- }
- if (bulletinOptionsPersonnalise?.moyennePrec2){
- bulletinPeriodePrecedente2.annotationsUtilisees?.each{
- if (!noteTextuelleList.contains(it)){
- noteTextuelleList = noteTextuelleList.plus(bulletinPeriodePrecedente2.annotationsUtilisees)
- }
- }
- }
- if (bulletinOptionsPersonnalise?.moyennePrec3){
- bulletinPeriodePrecedente3.annotationsUtilisees?.each{
- if (!noteTextuelleList.contains(it)){
- noteTextuelleList = noteTextuelleList.plus(bulletinPeriodePrecedente3.annotationsUtilisees)
- }
- }
- }
tab.allNoteTextuelleImpression = construisNoteTextuelleInfo(
noteTextuelleList)
*/
MatiereImpressionInfo construitMatiereImpressionInfo(BulletinServiceResultat bsr,
NoteFormateur nf,
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente1,
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente2,
- List<BulletinServiceResultat> bulletinServiceResultatsPeriodePrecedente3) {
+ Periode periodePrecedente1,
+ Periode periodePrecedente2,
+ Periode periodePrecedente3) {
MatiereImpressionInfo mii = new MatiereImpressionInfo()
Service service = bsr.service
collect {it.appreciation}?.join(', ')
// moyennes
- BulletinServiceResultat bsrPeriodePrecedente1 = null
- bulletinServiceResultatsPeriodePrecedente1.each{
- if (it.service == service){
- bsrPeriodePrecedente1 = it
- mii.moyennePrec1 = nf.format(it.resultatEleveServicePeriode?.getValeurAffichage())
+ bsr.resultatEleveServiceXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente1){
+ mii.moyennePrec1 = nf.format(it.getValeurAffichage())
}
}
- BulletinServiceResultat bsrPeriodePrecedente2 = null
- bulletinServiceResultatsPeriodePrecedente2.each{
- if (it.service == service){
- bsrPeriodePrecedente2 = it
- mii.moyennePrec2 = nf.format(it.resultatEleveServicePeriode?.getValeurAffichage())
+ bsr.resultatEleveServiceXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente2){
+ mii.moyennePrec2 = nf.format(it.getValeurAffichage())
}
}
- BulletinServiceResultat bsrPeriodePrecedente3 = null
- bulletinServiceResultatsPeriodePrecedente3.each{
- if (it.service == service){
- bsrPeriodePrecedente3 = it
- mii.moyennePrec3 = nf.format(it.resultatEleveServicePeriode?.getValeurAffichage())
+ bsr.resultatEleveServiceXmestrePrecedents?.each{
+ if (it.periode == periodePrecedente3){
+ mii.moyennePrec3 = nf.format(it.getValeurAffichage())
}
}
mii.moyenneEleve = nf.format(bsr.resultatEleveServicePeriode?.getValeurAffichage())
bsr.sousServiceResultats.each {BulletinSousServiceResultat bssr ->
mii.sousMatieres << construitSousMatiereImpressionInfo(bssr,
nf,
- bsrPeriodePrecedente1,
- bsrPeriodePrecedente2,
- bsrPeriodePrecedente3)
+ periodePrecedente1,
+ periodePrecedente2,
+ periodePrecedente3)
}
} else {
// Si pas de sous-services, le nb de notes sera affiché pour le service.
*/
SousMatiereImpressionInfo construitSousMatiereImpressionInfo(BulletinSousServiceResultat bssr,
NoteFormateur nf,
- BulletinServiceResultat bsrPeriodePrecedente1,
- BulletinServiceResultat bsrPeriodePrecedente2,
- BulletinServiceResultat bsrPeriodePrecedente3) {
+ Periode periodePrecedente1,
+ Periode periodePrecedente2,
+ Periode periodePrecedente3) {
SousMatiereImpressionInfo smii = new SousMatiereImpressionInfo()
smii.libelle = sousService.modaliteMatiere.libelle
smii.coeff = COEFF_NF.format(sousService.coeff)
- bsrPeriodePrecedente1?.sousServiceResultats?.each{
- if (it.sousService?.modaliteMatiere?.id == sousService?.modaliteMatiere?.id){
- smii.moyennePrec1 = nf.format(it.resultatEleveSousServicePeriode?.getValeurAffichage())
+ bssr?.resultatEleveSousServiceXmestrePrecedents?.each{
+ if (it.resultatEleveServicePeriode?.periode == periodePrecedente1){
+ smii.moyennePrec1 = nf.format(it.getValeurAffichage())
}
- }
- bsrPeriodePrecedente2?.sousServiceResultats?.each{
- if (it.sousService?.modaliteMatiere?.id == sousService?.modaliteMatiere?.id){
- smii.moyennePrec2 = nf.format(it.resultatEleveSousServicePeriode?.getValeurAffichage())
+ if (it.resultatEleveServicePeriode?.periode == periodePrecedente2){
+ smii.moyennePrec2 = nf.format(it.getValeurAffichage())
}
- }
- bsrPeriodePrecedente3?.sousServiceResultats?.each{
- if (it.sousService?.modaliteMatiere?.id == sousService?.modaliteMatiere?.id){
- smii.moyennePrec3 = nf.format(it.resultatEleveSousServicePeriode?.getValeurAffichage())
+ if (it.resultatEleveServicePeriode?.periode == periodePrecedente3){
+ smii.moyennePrec3 = nf.format(it.getValeurAffichage())
}
}
return noteInfos
}
- private String getNomMoyennePrecedente(String libelleTypePeriode){
- switch (libelleTypePeriode){
- case 'T1':
- return '1er T.'
- break
- case 'T2':
- return '2ème T.'
- break
- case 'T3':
- return '3ème T.'
- break
- case 'S1':
- return '1er S.'
- break
- case 'S2':
- return '2ème T.'
- break
- }
- }
}
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
-import org.lilie.services.eliot.notes.notes.EtablissementNotesService
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+import org.lilie.services.eliot.notes.impression.NotesImpressionService
+import org.lilie.services.eliot.scolarite.PeriodeService
/**
* Ce service permet de convertir un objet Synthese en objet SyntheseImpression
private static final POSITION_MOYENNE = 9999
LocalPersonneService localPersonneService
- EtablissementNotesService etablissementNotesService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
+ NotesImpressionService notesImpressionService
+ PeriodeService periodeService
- public SyntheseImpression construisTableauImpression(Synthese synthese) {
+ public SyntheseImpression construisTableauImpression(Synthese synthese,
+ SecuriteSession securiteSession) {
SyntheseImpression tab = new SyntheseImpression(
classe: synthese?.classe?.code,
etablissement: synthese?.classe?.etablissement?.nomAffichage
)
- tab.data = construitTableau(synthese)
+ tab.data = construitTableau(synthese, securiteSession)
return tab
}
* @param synthese
* @return
*/
- private List<CelluleTableau> construitTableau(Synthese synthese) {
+ private List<CelluleTableau> construitTableau(Synthese synthese,
+ SecuriteSession securiteSession) {
NoteFormateur nf =
synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
synthese.syntheseEleves.each { SyntheseEleve syntheseEleve ->
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
long index = 1
syntheseEleve.services.each { Service service ->
String nomsEnseignants = libelleListeEnseignants(enseignants)
+ Periode periodeDeSynthese = synthese.periode
+
// rechercher des sous-services
List<SousService> sousServices = service.getSousServices(
- synthese.periode.typePeriode
+ periodeDeSynthese.typePeriode
)
if (sousServices) {
}
- if (synthese.periode.isPeriodeAnnee()) {
-
+ if (periodeDeSynthese.isPeriodeAnnee() &&
+ pref?.moyennesPrecedentes == true) {
preparePeriodeAnnee(tableau, syntheseEleve, synthese)
}
+ if (pref?.moyennesPrecedentes == true &&
+ periodeDeSynthese.typePeriode?.isNotation() &&
+ !periodeDeSynthese.isPeriodeAnnee()){
+ periodeDeSynthese.getPeriodesPrecedentes()?.each{ Periode periodePrecedente ->
+ tableau << getCelluleI18nMoyennePrecedente(syntheseEleve, synthese, periodePrecedente)
+ }
+ }
+
tableau << getCelluleI18n(syntheseEleve, synthese)
+
+ Integer rangInteger = syntheseEleve.resultatElevePeriode?.rang
+ String rang = rangInteger ? rangInteger.toString() : ""
+ if (pref?.rangs == true){
+ tableau << getCelluleI18nRang(synthese, syntheseEleve, rang)
+ }
}
}
SyntheseEleve syntheseEleve,
Synthese synthese) {
NoteFormateur nf =
- synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
+ synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
Integer colonne = 1
synthese.classe.getXmestres().each { Periode periode ->
ResultatClassePeriode resClasse =
- synthese.syntheseClasse.resultatClasseXmestres.find {
+ synthese.syntheseClasse.resultatClasseXmestrePrecedents.find {
it.periode.id == periode.id
}
- ResultatElevePeriode resXmestre = syntheseEleve.resultatEleveXmestres.find {
+ ResultatElevePeriode resXmestre = syntheseEleve.resultatEleveXmestrePrecedents.find {
it.periode.id == periode.id
}
long index) {
String appreciation = syntheseEleve.appreciationElevePeriode?.appreciation
NoteFormateur nf =
- synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
+ synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
new CelluleTableau(
enteteLigne: syntheseEleve.eleve.nomAffichage(),
String appreciation = syntheseEleve.appreciationElevePeriode?.appreciation
NoteFormateur nf =
- synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
+ synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
new CelluleTypePeriode(
enteteLigne: syntheseEleve.eleve.nomAffichage(),
)
}
+ private CelluleI18n getCelluleI18nMoyennePrecedente(SyntheseEleve syntheseEleve,
+ Synthese synthese,
+ Periode periodePrecedente) {
+ String appreciation = syntheseEleve.appreciationElevePeriode?.appreciation
+
+ NoteFormateur nf =
+ synthese.classe.etablissement.etablissementNotes.getNoteFormateur()
+
+ ResultatElevePeriode resultatEleveXmestrePrecedent =
+ (ResultatElevePeriode)syntheseEleve?.resultatEleveXmestrePrecedents?.find{
+ it.periode == periodePrecedente
+ }
+
+ ResultatClassePeriode resultatClasseXmestrePrecedent =
+ (ResultatClassePeriode)synthese.syntheseClasse?.resultatClasseXmestrePrecedents?.find{
+ it.periode == periodePrecedente
+ }
+
+ new CelluleI18n(
+ enteteLigne: syntheseEleve.eleve.nomAffichage(),
+ entete1: periodeService.getNomPeriodePrecedente(periodePrecedente.typePeriode?.libelle),
+ entete2: "",
+ entete3: "",
+ entete4: "",
+ finLigne: appreciation ? appreciation : "",
+ index: POSITION_MOYENNE,
+ valeur: nf.format(resultatEleveXmestrePrecedent?.getValeurAffichage()),
+ pied1: nf.format(resultatClasseXmestrePrecedent?.moyenne),
+ pied2: nf.format(resultatClasseXmestrePrecedent?.moyenneMin),
+ pied3: nf.format(resultatClasseXmestrePrecedent?.moyenneMax)
+ )
+ }
+
+ private CelluleI18n getCelluleI18nRang(Synthese synthese,
+ SyntheseEleve syntheseEleve,
+ String rang) {
+ String appreciation = syntheseEleve.appreciationElevePeriode?.appreciation
+
+ new CelluleI18n(
+ enteteLigne: syntheseEleve.eleve.nomAffichage(),
+ entete1: 'eliot.notes.libelle.rang',
+ entete2: "",
+ entete3: "",
+ entete4: "",
+ finLigne: appreciation ? appreciation : "",
+ index: POSITION_MOYENNE,
+ valeur: rang,
+ pied1: "",
+ pied2: "",
+ pied3: ""
+ )
+ }
+
private void prepareSousServices(long index,
NoteFormateur nf,
Service service,
private ResultatEleveEnseignementPeriode findResultatElevePeriode(TableauDeNotesLigne ligneTDN, TypePeriode typePeriode) {
- return ligneTDN.resultats.find {
+ return ligneTDN.resultatsXmestresPrecedents.find {
it.periode.typePeriode.id == typePeriode.id ||
it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
}
private ResultatEleveEnseignementPeriode findResultatElevePeriode(TableauDeNotesLigne ligneTDN, TypePeriode typePeriode) {
- return ligneTDN.resultats.find {
+ return ligneTDN.resultatsXmestresPrecedents.find {
it.periode.typePeriode.id == typePeriode.id ||
it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
}
/**
- * @param eleve
* @return les notes d'un élève
*/
List<Note> getNotesForEleve(Personne eleve) {
}
/**
- * @param eleve
* @return les résultats d'un élève
*/
List<ResultatEleveEnseignementPeriode> getResultatsForEleve(Personne eleve) {
}
/**
- * @param eleve
* @return les appreciations d'un élève
*/
List<AppreciationEleveEnseignementPeriode> getAppreciationsForEleve(Personne eleve) {
Periode periode
List<Note> notes
ResultatEleveEnseignementPeriode resultat // ResultatEleveEnseignementPeriode de la période choisie
- List<ResultatEleveEnseignementPeriode> resultats // ResultatEleveEnseignementPeriode de toutes les périodes
+ List<ResultatEleveEnseignementPeriode> resultatsXmestresPrecedents = [] // Resultat de toutes les périodes
String appreciation
}
/**
* Construis le tableau de notes
- * @param securiteSession
- * @param service
- * @param periode
- * @param enseignant
- * @return TableauDeNotes
- * @throws AutorisationException
- * @throws IllegalArgumentException
* @author bper
*/
TableauDeNotes construisTableauDeNotes(SecuriteSession securiteSession,
List<Evaluation> evaluations = []
CalcMoyennesInfo calcInfo = new CalcMoyennesInfo()
- if (typePeriode.isAnnee()) {
- calcInfo = notesDirtyMoyenneService.internalVerifieMoyennesAjour(
- enseignement.service.structureEnseignement
- )
- }
- else {
+ calcInfo = notesDirtyMoyenneService.internalVerifieMoyennesAjour(
+ enseignement.service.structureEnseignement
+ )
+
+ if (!typePeriode.isAnnee()) {
// Récupère les évaluations pour l'ensemble des périodes
evaluations = notesEvaluationService.
internalFindAllEvaluationByEnseignementAndPeriode(
/**
* Vérifie que l'utilisateur a l'autorisation de construire un tableau de notes
* pour cet enseignement
- * @param securiteSession
- * @param enseignement
* @throws AutorisationException si l'utilisateur n'a pas l'autorisation
*/
private void verifieAutorisationConstruisTableauDeNotes(SecuriteSession securiteSession,
/**
* Vérifie que l'utilisateur a l'autorisation d'enregistrer un tableau de notes
* pour cet enseignement
- * @param securiteSession
- * @param enseignement
- * @throws AutorisationException si l'utilisateur n'a pas l'autorisation
*/
private void verifieAutorisationEnregistreTableauDeNotes(SecuriteSession securiteSession,
Enseignement enseignement) {
/**
* Crée les lignes d'un tableau de notes
- * @param enseignement
- * @param elevesListes
- * @param typePeriode
- * @param notes
- * @return
*/
List<TableauDeNotesLigne> creeTableauDeNotesLignes(Enseignement enseignement,
StructureEnseignementElevesListes elevesListes,
/**
* Crée une ligne de tableau de notes
- * @param eleve
- * @param actif
- * @param enseignement
- * @param typePeriode
- * @param notes
- * @param resultats
- * @param appreciations
- * @return une ligne de tableau de notes
*/
private TableauDeNotesLigne creeTableauDeNotesLigne(Personne eleve,
Boolean actif,
// Collecte les notes de l'élève
ligne.notes = donneesEleves.getNotesForEleve(eleve)
- // Collecte les résultats de l'élève
- ligne.resultats = donneesEleves.getResultatsForEleve(eleve)
-
- // Résultat correspondant à la période de la ligne
- ligne.resultat = (ResultatEleveEnseignementPeriode) ligne.resultats.find {
- it.periode.id == ligne.periode.id
+ donneesEleves.getResultatsForEleve(eleve)?.each {
+ if (it.periode.id == ligne.periode.id) {
+ ligne.resultat = it // Il ne doit en avoir qu'un
+ } else {
+ ligne.resultatsXmestresPrecedents << it
+ }
}
// Appréciation de l'élève
/**
* Récupère toutes les données de l'ensemble des élèves d'un tableau de notes
- * @param enseignement
- * @param elevesListes
- * @param typePeriode
- * @param periodesDuTDN
- * @param evaluations
- * @return
*/
private TableauDeNotesDonneesEleves calculeDonneesEleves(Enseignement enseignement,
StructureEnseignementElevesListes elevesListes,
)
}
+ List<Periode> periodesPrecedentes =
+ typePeriode.isNotation() ? (List) periodesDuTDN*.getPeriodesPrecedentes().flatten() : []
+
// Récupère les resultats des élèves pour l'enseignement
List<ResultatEleveEnseignementPeriode> resultats =
resultatEleveEnseignementPeriodeService.internalFindAll(
elevesListes.eleves*.autorite,
[enseignement],
- periodesDuTDN,
+ (List) (periodesDuTDN + periodesPrecedentes),
null
)
/**
* Retourne pour 1 élève, dans un tableau de notes, la classe qui doit être
* prise en compte et si l'élève est actif dans cette classe
- * @param service
- * @param eleve
- * @param actif
- * @return
*/
private TableauDeNotesEleveClasse calculeEleveClassePourTableauDeNotesLigne(Service service,
Personne eleve,
/**
* Retourne l'appréciation d'un élève pour un tableau de notes
- * @param eleve
- * @param donneesEleves
- * @param periode
- * @param enseignement
- * @return
*/
private AppreciationEleveEnseignementPeriode calculeAppreciationEleve(Personne eleve,
TableauDeNotesDonneesEleves donneesEleves,
* @param typePeriode le type de période du tableau de notes
* @return la liste des périodes qui doivent être utilisées pour construire
* un tableau de notes, avec la logique suivante :
- * Si typePeriode = ANNEE => retourne toutes les périodes du services
- * SINON => retourne toutes les périodes du services ayant le typePeriode
+ * toutes les périodes du services ayant le typePeriode
* fournit ou un typePeriode équivalent
* @author jtra
*/
service
)
- if (typePeriode.isAnnee()) {
- return periodesDuService // On prend toutes les périodes
- }
-
return notesPeriodeService.filtrePeriodesParTypeEquivalent(
periodesDuService,
typePeriode
/**
* Enregistre les informations saisies dans le tableau de notes
- * @param securiteSession
- * @param params
* @author bper
* @author msan
*/
/**
* Enregistre une lige de tableau de note -
* une liste des notes et l'appreciation d'un eleve
- * @param ligne
- * @param elevesListes
- * @param typePeriode
- * @param enseignement
- * @param mapPeriodeEleves
- * @param mapPeriodeModaliteMatieres
- * @param mapEleveClasse
* @param correctionParDirecteur true s'il s'agit d'une correction par
* le directeur qui peut saisir meme dans les periodes verouilles
*/
/**
* Invalide les moyennes correspondant à un tableau de notes modifié
- * @param securiteSession
- * @param periode
- * @param enseignement
- * @param mapPeriodeModaliteMatieres
- * @param eleveAutorites
*/
private def marqueDirtyMoyenneTableauDeNotes(SecuriteSession securiteSession,
Periode periode,
/**
* Enregistre l'appréciation globale d'un tableau de notes
- * @param securiteSession
- * @param typePeriode
- * @param enseignement
- * @param appreciation
* @param correctionParDirecteur true s'il s'agit d'une correction par
* le directeur qui peut saisir meme dans les periodes verouilles
*/
/**
* Regroupe les données du tableau de notes pour affcher sur le graphique
- * @param securiteSession
- * @param tdn
- * @param eleve
* @return List < TableauDeNotesGraphData > les données affiché sur le graph
* @author bper
*/
// Les résultats de tous les élèves de la classe/groupe
List<ResultatEleveEnseignementPeriode> resClasses = []
tdn.lignes.each {
- if (it.resultats){
- resClasses.addAll(it.resultats)
+ if (it.resultatsXmestresPrecedents){
+ resClasses.addAll(it.resultatsXmestresPrecedents)
}
}
// Les types de période de l'élève
- List<TypePeriode> typePeriodes = tdnLigneEleve.resultats.collect {
+ List<TypePeriode> typePeriodes = tdnLigneEleve.resultatsXmestresPrecedents.collect {
it.periode.typePeriode
}
// Moyenne de l'élève
ResultatEleveEnseignementPeriode resEleve =
- (ResultatEleveEnseignementPeriode) tdnLigneEleve.resultats.find {
+ (ResultatEleveEnseignementPeriode) tdnLigneEleve.resultatsXmestresPrecedents.find {
it.periode.typePeriode == typePeriode
}
tdnGraphData.noteEleve = resEleve.moyenne
/**
* Construis la liste des récapitulatifs du tableau de notes pour un élève
- * @param securiteSession
- * @param eleve
- * @param service
- * @param enseignant
- * @return List < TableauDeNotesRecapEleve >
* @author bper
*/
List<TableauDeNotesRecapEleve> construisTableauDeNotesRecapEleves(SecuriteSession securiteSession,
/**
* Construis un recapitulatif pour un eleve et un typePeriode
- * @param securiteSession
- * @param enseignement
- * @param typePeriode
* @param recaps le recap est place dans recaps si l'eleve est present
* dans le tableau de notes pour pour le typePeriode donne
* @return
/**
* Recupere toutes les modalite matieres qui se trouvent dans une ligne de TDN
- * @param tdnLigneEleve
- * @return
*/
private List<ModaliteMatiere> findAllModaliteMatiere(TableauDeNotesLigne tdnLigneEleve) {
List<ModaliteMatiere> modaliteMatieres = []
/**
* Calcule les moyennes de modalite matieres dans une ligne de TDN
- * @param modaliteMatieres
- * @param tdnLigneEleve
- * @return une map <ModaliteMatiere, Moyenne>
*/
private Map<ModaliteMatiere, Moyenne> calculeMoyenneModaliteMatieres(List<ModaliteMatiere> modaliteMatieres,
TableauDeNotesLigne tdnLigneEleve) {
/**
* Teste qu'un argument est non null
- * @param nomArgument
- * @param valeur
* @throws IllegalArgumentException si l'argument est null
* @author jtra
*/
/**
* Vérifie qu'il existe un enseignement pour un service & un enseignant donné
- * @param service
- * @param enseignant
* @throws IllegalArgumentException si l'enseignant fournit n'est pas affecté
* au service fourni (i.e. cet enseignement n'existe pas)
* @author jtra
return enseignement
}
-
-
}
--- /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.notes.preferences
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+import org.lilie.services.eliot.notes.domaine.PreferenceUtilisateurNotesParams
+
+/**
+ * @author agia
+ */
+class PreferenceUtilisateurNotesService {
+
+ private void creePreferenceUtilisateur(Personne utilisateur,
+ PreferenceUtilisateurNotesParams pref){
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ new PreferenceUtilisateurNotes(
+ utilisateur: utilisateur,
+ rangs: (pref.rangs != null ? pref.rangs : false),
+ moyennesPrecedentes: (pref.moyennesPrecedentes != null ? pref.moyennesPrecedentes : false)
+ )
+
+ preferenceUtilisateurNotes.save(failOnError: true)
+
+ }
+
+ PreferenceUtilisateurNotes getPreferenceUtilisateur(SecuriteSession securiteSession){
+
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ return PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ }
+
+ }
+
+ void metAJourPreferenceUtilisateur(SecuriteSession securiteSession,
+ PreferenceUtilisateurNotesParams pref){
+
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ }
+
+ boolean prefHasNotNullProperties = false
+
+ pref.properties.find{ property, value ->
+ if(["metaClass","class"].find {it == property}) return false // continue
+ if (value != null){
+ prefHasNotNullProperties = true
+ return true // break
+ }
+ return false // continue
+ }
+
+ if (prefHasNotNullProperties){
+ if (preferenceUtilisateurNotes){
+ preferenceUtilisateurNotes.rangs =
+ pref.rangs != null ? pref.rangs : preferenceUtilisateurNotes.rangs
+ preferenceUtilisateurNotes.moyennesPrecedentes =
+ pref.moyennesPrecedentes != null ? pref.moyennesPrecedentes : preferenceUtilisateurNotes.moyennesPrecedentes
+
+ preferenceUtilisateurNotes.save(failOnError: true)
+ } else {
+ creePreferenceUtilisateur(utilisateur, pref)
+ }
+ }
+ }
+
+ void supprimePreferenceUtilisateur(SecuriteSession securiteSession){
+
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ }
+
+ if (preferenceUtilisateurNotes){
+ preferenceUtilisateurNotes.delete()
+ }
+
+ }
+
+}
securiteSession,
parametresSelectionPublipostage,
etablissement)
- break
}
}
}
}
+ /**
+ * Calcule les rangs des valeurs numériques en fontion de la précision.
+ * Les valeurs égales (compte tenu de la précision) ont le meme rang,
+ * le rand suivant est incrémenté de nombre des valeurs égales.
+ * Si la précision est null la méthode n'en tient pas compte.
+ * @author bper
+ */
+ Map<BigDecimal, Integer> calculeRangs(List<BigDecimal> valeurs, BigDecimal precision = null) {
+
+ List<BigDecimal> valeursOrdonnees = valeurs.sort().reverse()
+
+ Map<BigDecimal, Integer> mapValeurRang = [:]
+
+ valeursOrdonnees.eachWithIndex {BigDecimal valeur, Integer i ->
+ BigDecimal valeurPrecedente = (i > 0) ? valeursOrdonnees.getAt(i - 1) : null
+ Integer rangPrecedent = mapValeurRang.get(valeurPrecedente)
+
+ BigDecimal valeurArrondie = (precision == null) ? valeur : arroundi(valeur, precision)
+ BigDecimal valeurPrecedenteArrondie = (precision == null) ? valeurPrecedente : arroundi(valeurPrecedente, precision)
+
+ Integer rang = (valeurArrondie == valeurPrecedenteArrondie) ? rangPrecedent : i + 1
+ mapValeurRang.put(valeur, rang)
+ }
+
+ return mapValeurRang
+ }
+
+ /**
+ * Arrondi une valeur numérique avec la précision et mode d'arrondi donnés.
+ * @author bper
+ */
+ BigDecimal arroundi(BigDecimal valeur,
+ BigDecimal precision,
+ RoundingMode roundingMode = RoundingMode.HALF_UP) {
+
+ if (valeur == null) {
+ return valeur
+ }
+
+ return valeur.divide(precision).setScale(0,roundingMode).multiply(precision)
+ }
}
import org.lilie.services.eliot.notes.ResultatEnseignementPeriode
import org.lilie.services.eliot.notes.notes.NotesNoteService
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.notes.ResultatElevePeriode
+import org.hibernate.SessionFactory
/**
* Calculs des moyennes
CalculationService calculationService
LocalStructureEnseignementService localStructureEnseignementService
- def sessionFactory
+ SessionFactory sessionFactory
static transactional = true
traiteMoyennesClasseSousService(setBag)
traiteMoyennesEleveEnseignement(setBag)
traiteMoyennesEleveService(setBag)
- traiteRangsEleveService(securiteSession, setBag)
+ traiteRangsEleveService(setBag)
traiteMoyennesEleve(setBag)
traiteMoyennesStructureEnseignement(setBag) // classe ou groupe
traiteMoyennesClasseService(setBag)
+ traiteRangsEleveClasse(setBag)
traiteMoyennesClasse(setBag)
}
/**
* Mis à jour de moyenne_eleve_enseignement.
- * @param eleve
- * @param enseignement
- * @param periode
* @author msan
* @author bper
*/
/**
* Calcule la moyenne annuelle de l'élève pour un enseignement.
- * @param eleve
- * @param enseignement
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveEnseignementAnnee(Autorite eleve,
/**
* Calcule la moyenne d'un élève pour un enseignement et
* une période donnés (sauf l'année).
- * @param eleve
- * @param enseignement
- * @param periode
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveEnseignementAvecSousServices(Autorite eleve,
/**
* Calcule la moyenne d'un élève pour un enseignement et
* une période donnés (sauf l'année).
- * @param eleve
- * @param enseignement
- * @param periode
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveEnseignement(Autorite eleve,
* Mis à jour de moyenne_eleve.
* C'est une moyenne d'élève sur tous les services
* pour la période changée et la période d'année.
- * @param eleve
- * @param periode
* @author msan
* @author bper
*/
/**
* Calcule la moyenne générale sur l'année d'un élève. La moyenne retournée est
* une moyenne arithmétique des moyennes générales des Xmestres.
- * @param eleve
- * @param classe La classe dont les périodes sont prise en compte dans le calcul
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveAnnee(Autorite eleve, Periode periode) {
/**
* Calcule la moyenne générale d'un élève sur une période donnée (sauf l'année).
- * @param eleve
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleve(Autorite eleve, Periode periode) {
* Mis à jour de moyenne_eleve_service.
* C'est une moyenne d'élève sur un service pour la période changée
* et la période d'année.
- * @param eleve
- * @param service
- * @param periode
* @author msan
* @author bper
*/
/**
* Calcule la moyenne d'un élève pour un service avec des sous-services et
* une période de n'import quel type.
- * @param eleve
- * @param service
- * @param periode
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveServiceAvecSousServices(Autorite eleve,
/**
* Calcule la moyenne annuelle d'un élève pour un service.
- * @param eleve
- * @param service
- * @param periode
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveServiceAnnee(Autorite eleve,
/**
* Calcule la moyenne d'un élève pour un service une période sauf la période année.
- * @param eleve
- * @param service
- * @param periode
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveService(Autorite eleve,
/**
* Met à jour la moyenne d'un élève pour un sous-service sur une période.
- * @param eleve
- * @param sousService
- * @param periode
* @author msan
* @author bper
*/
/**
* Calcule la moyenne annuelle d'un élève pour un sous-service.
- * @param eleve
- * @param service
- * @param sousService
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveSousServiceAnnee(Autorite eleve,
/**
* Calcule la moyenne d'un élève pour un sous-service sur une période (sauf l'année).
- * @param eleve
- * @param sousService
- * @return La moyenne calculée
* @author bper
*/
private Moyenne calculeMoyenneEleveSousService(Autorite eleve,
* Mis à jour de moyenne_classe_service.
* C'est une moyenne d'une classe sur un service pour la période changée
* et la période d'année.
- * @param classe
- * @param service
- * @param periode
* @author msan
* @author bper
*/
moyenneMin)
}
+ /**
+ * @author bper
+ */
+ private void majRangsEleveClasse(StructureEnseignement classe,
+ List<Autorite> eleves,
+ Periode periode) {
+
+ List<ResultatElevePeriode> resultats =
+ resultatElevePeriodeService.internalFindAll(eleves, [periode], null)
+
+ List<ResultatElevePeriode> resultatsNotes = resultats.findAll {it.moyenne != null}
+
+ BigDecimal precision = classe.etablissement.etablissementNotes.precision
+
+ Map<BigDecimal, Integer> mapMoyenneRang =
+ calculationService.calculeRangs(resultatsNotes*.moyenne, precision)
+
+ resultatsNotes.each {
+ it.rang = mapMoyenneRang.get(it.moyenne)
+ }
+
+ (resultats - resultatsNotes).each {
+ it.rang = null
+ }
+
+ resultats*.save(failOnError: true)
+
+ sessionFactory.currentSession.flush()
+ }
+
/**
* Mis à jour de moyenne_classe.
* C'est une moyenne d'une classe sur tous les services pour la période changée
* et la période d'année.
- * @param classe
- * @param periode
* @author msan
* @author bper
*/
/**
* Mis à jour de moyenne_structure_enseignement.
* C'est une moyenne d'une structure d'enseignement pour un enseignement et une periode
- * @param enseignement
- * @param periode
* @author msan
*/
private void majMoyenneStructureEnseignement(Enseignement enseignement,
/**
* Traitement des moyennes EleveSousService
- * @param setBag
* @author msan
* @author bper
*/
/**
* Traitement des moyennes ClasseSousService
- * @param setBag
* @author msan
* @author bper
*/
/**
* Traitement des moyennes EleveEnseignement
- * @param setBag
* @author msan
* @author bper
*/
/**
* Traitement des moyennes EleveEnseignement
- * @param setBag
* @author msan
*/
private void traiteMoyennesStructureEnseignement(DirtyMoyenneSetBag setBag) {
/**
* Traitement des moyennes EleveService
- * @param setBag
* @author msan
* @author bper
*/
}
}
- private void traiteRangsEleveService(SecuriteSession securiteSession,
- DirtyMoyenneSetBag setBag) {
+ private void traiteRangsEleveService(DirtyMoyenneSetBag setBag) {
setBag.classeServiceDMSet.each { DirtyMoyenne dm ->
Periode periode = dm.periode
List<Autorite> eleves = setBag.eleves
- majRangsEleveService(securiteSession, eleves, service, periode)
+ majRangsEleveService(eleves, service, periode)
}
}
- private void majRangsEleveService(SecuriteSession securiteSession,
- List<Autorite> eleves,
+ private void majRangsEleveService(List<Autorite> eleves,
Service service,
Periode periode) {
List<ResultatEleveServicePeriode> resultats = resultatEleveServicePeriodeService.
internalFindAll(eleves, [service], [periode], null)
- List<ResultatEleveServicePeriode> resultatsNotes = []
-
if (service.isEvaluable(periode)) {
- Integer nbElevesNotesPourService = 0
- List<Integer> moyennesDuServiceDePeriode = []
-
- resultats.each{ ResultatEleveServicePeriode resultat ->
- if (resultat.moyenne){
- nbElevesNotesPourService++
- moyennesDuServiceDePeriode.add(resultat.moyenne)
- resultatsNotes.add(resultat)
- }
- }
- List<Integer> moyennesDuServiceDePeriodeOrdonnees =
- moyennesDuServiceDePeriode.sort().reverse()
-
- // Calcul du rang pour chaque moyenne du service et de la période donnés
- Map<Integer, BigDecimal> rangMoyenne = [:]
- Integer rang = 1
- Integer ecart = 1
- for (int i = 0; i < moyennesDuServiceDePeriodeOrdonnees.size(); ++i){
- // calcul du rang
- if (i == 0){
- rangMoyenne.put(rang, moyennesDuServiceDePeriodeOrdonnees.get(i))
- } else {
- if (moyennesDuServiceDePeriodeOrdonnees.get(i) == moyennesDuServiceDePeriodeOrdonnees.get(i - 1)){
- rangMoyenne.put(rang, moyennesDuServiceDePeriodeOrdonnees.get(i))
- ecart++
- } else {
- rang = rang + ecart
- rangMoyenne.put(rang, moyennesDuServiceDePeriodeOrdonnees.get(i))
- ecart = 1
- }
- }
- // mise à jour du rang dans le résultat
- resultats*.rang = null
- resultatsNotes.each{ ResultatEleveServicePeriode resultatDuServiceDePeriode ->
- resultatDuServiceDePeriode.rang =
- rangMoyenne.find{it.value == resultatDuServiceDePeriode.moyenne}?.key
- }
+ List<ResultatEleveServicePeriode> resultatsNotes = resultats.findAll {it.moyenne != null}
+
+ BigDecimal precision =
+ service.structureEnseignement.etablissement.etablissementNotes.precision
+
+ Map<BigDecimal, Integer> mapMoyenneRang =
+ calculationService.calculeRangs(resultatsNotes*.moyenne, precision)
+
+ resultatsNotes.each {
+ it.rang = mapMoyenneRang.get(it.moyenne)
+ it.nbEleves = resultatsNotes.size()
}
- // mise à jour du nombre d'élèves notés pour le service pour la période donnés
- resultatsNotes*.nbEleves = nbElevesNotesPourService
+ (resultats - resultatsNotes).each {
+ it.rang = null
+ it.nbEleves = null
+ }
} else {
resultats*.rang = null
+ resultats*.nbEleves = null
}
- resultatEleveServicePeriodeService.saveAll(resultats)
+ resultats*.save(failOnError: true)
+
+ sessionFactory.currentSession.flush()
}
/**
* Traitement des moyennes Eleve
- * @param setBag
* @author msan
* @author bper
*/
/**
* Traitement des moyennes ClasseService
- * @param setBag
* @author msan
* @author bper
*/
}
}
+ /**
+ * @author bper
+ */
+ private void traiteRangsEleveClasse(DirtyMoyenneSetBag setBag) {
+ setBag.classeDMSet.each { DirtyMoyenne dm ->
+ majRangsEleveClasse(dm.classe, setBag.eleves, dm.periode)
+ }
+ }
+
/**
* Traitement des moyennes Classe
- * @param setBag
* @author msan
* @author bper
*/
/**
* Mis à jour des moyennes pour une classe a un sous-service
- * @param classe
- * @param sousService
* @author msan
* @author bper
*/
package org.lilie.services.eliot.notes.resultat
import org.lilie.services.eliot.notes.DirtyMoyenne
-import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.Periode
import org.hibernate.FetchMode
import org.lilie.services.eliot.ArgumentUtils
import org.lilie.services.eliot.notes.scolarite.NotesSousServiceService
-import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
/**
* Service pour marquer que les données source d'une moyenne ont chagé.
<g:render template="/saisie/modele"/>
<g:javascript>
- eliot.notes.saisie.synthese.Modele.libelle.imprimer= '${g.message(code: "eliot.notes.libelle.imprimerTdn")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.icon.imprimer = '${resource(dir: 'images', file: 'printpreview.png')?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.comboClasse= '${g.message(code: "eliot.notes.libelle.comboClasse")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.comboPeriode= '${g.message(code: "eliot.notes.libelle.comboPeriode")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.enregistrer= '${g.message(code: "eliot.notes.libelle.enregistrer")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.annuler= '${g.message(code: "eliot.notes.libelle.annuler")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.nomEleve= '${g.message(code: "eliot.notes.libelle.nomEleve")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.moyenne= '${g.message(code: "eliot.notes.libelle.moyenneCourt")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.appreciation= '${g.message(code: "eliot.notes.libelle.appreciationsGenerales")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.matiere= '${g.message(code: "eliot.notes.libelle.matiere")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.sousMatiere= '${g.message(code: "eliot.notes.libelle.sousMatiere")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.enseignants= '${g.message(code: "eliot.notes.libelle.enseignants")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.eleve= '${g.message(code: "eliot.notes.libelle.eleve")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.coeff= '${g.message(code: "eliot.notes.libelle.coeff")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.isOption= '${g.message(code: "eliot.notes.libelle.isOption")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.conseilDeClasse= '${g.message(code: "eliot.notes.libelle.conseilDeClasse")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.appreciationClasse= '${g.message(code: "eliot.notes.libelle.apprClasse")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.noteMaxMoyenneClasse= '${g.message(code: "eliot.notes.libelle.noteMaxMoyenneClasse")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.noteMinMoyenneClasse= '${g.message(code: "eliot.notes.libelle.noteMinMoyenneClasse")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.moyenneEleve= '${g.message(code: "eliot.notes.conseilDeClasse.libelle.moyenneEleve")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.libelle.moyenneClasse= '${g.message(code: "eliot.notes.libelle.moyenneClasse")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.graph = '${g.message(code: "eliot.notes.libelle.graph")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.fermer = '${g.message(code: "eliot.notes.libelle.fermer")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.libelle.afficherLesPeriodesPrecedents = '${g.message(code: "eliot.notes.graph.libelle.afficherLesPeriodesPrecedents")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.messages.appreciationModifieEnCours = '${g.message(code: "eliot.notes.message.appreciationModifieEnCours")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.messages.appreciationModifieSucces = '${g.message(code: "eliot.notes.message.appreciationModifieSucces")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.messages.appreciationModifieEchou = '${g.message(code: "eliot.notes.message.appreciationModifieEchou")?.encodeAsJavaScript()}';
- eliot.notes.Modele.messages.loading= '${g.message(code: "eliot.notes.message.loading")}';
- eliot.notes.saisie.synthese.Modele.messages.attention= '${g.message(code: "eliot.notes.libelle.attention")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.messages.saisieSyntheseAlert= '${g.message(code: "eliot.notes.message.saisieNoteAlert")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.messages.confirmationQuitterSaisieSynthese= '${g.message(code: "eliot.notes.message.confirmationQuitterSaisieNote")?.encodeAsJavaScript()}';
- eliot.notes.saisie.synthese.Modele.messages.tblNotesGraphEchou = '${g.message(code: "eliot.notes.message.erreurInconnue")?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.url.getSyntheseCsv = '${createLink(controller: 'saisieSynthese', action: 'getSyntheseCsv')}';
- eliot.notes.saisie.synthese.Modele.url.urlSaveAppreciationGenerale = '${createLink(controller: 'appreciationElevePeriode', action: 'enregistrerAppreciations')}';
- eliot.notes.saisie.synthese.Modele.url.urlConseilDeClasse = '${createLink(controller: 'saisieConseilDeClasse')}';
- eliot.notes.saisie.synthese.Modele.url.urlAppreciationClasse = '${createLink(controller: 'consultationAppreciationsClasse')}';
- eliot.notes.saisie.synthese.Modele.url.urlHeartBeat = '${createLink(controller: 'heartBeat')}';
- eliot.notes.saisie.synthese.Modele.url.urlGraphTblNotes = '${createLink(controller: 'saisieSynthese', action: 'graph')}';
-
- eliot.notes.saisie.synthese.Modele.icon.enregistrer = '${resource(dir: 'images', file: 'enregistrer.gif')}';
- eliot.notes.saisie.synthese.Modele.icon.annuler = '${resource(dir: 'images', file: 'undo.gif')}';
- eliot.notes.saisie.synthese.Modele.icon.coenseignement = '${resource(dir: 'images', file: 'group.gif')}';
- eliot.notes.saisie.synthese.Modele.icon.conseilDeClasse = '${resource(dir: 'images/skin', file: 'house.png')}';
- eliot.notes.saisie.synthese.Modele.icon.appreciationClasse = '${resource(dir: 'images/skin', file: 'database_edit.png')}';
- eliot.notes.saisie.synthese.Modele.icon.graph = '${resource(dir: 'images', file: 'graph.png')?.encodeAsJavaScript()}';
-
- eliot.notes.saisie.synthese.Modele.data.periodeId = '${periodeId}';
- eliot.notes.saisie.synthese.Modele.data.classeId = '${classeId}';
- eliot.notes.saisie.synthese.Modele.data.appreciationModifiable = ${appreciationModifiable ?: false};
-
- eliot.notes.saisie.synthese.Modele.data.listeStructureEnseignements = ${classeInfos ?: '[]'};
- eliot.notes.saisie.synthese.Modele.data.periodeInfos = ${periodeInfos ?: '[]'};
- eliot.notes.saisie.synthese.Modele.data.serviceInfos = ${serviceInfos ?: '[]'};
- eliot.notes.saisie.synthese.Modele.data.syntheseLignes = ${syntheseEleves ?: '[]'};
- eliot.notes.saisie.synthese.Modele.data.moyenneLignes = ${syntheseClasses ?: '[]'};
+ eliot.notes.saisie.synthese.Modele.libelle.imprimer= '${g.message(code: "eliot.notes.libelle.imprimerTdn")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.icon.imprimer = '${resource(dir: 'images', file: 'printpreview.png')?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.comboClasse= '${g.message(code: "eliot.notes.libelle.comboClasse")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.comboPeriode= '${g.message(code: "eliot.notes.libelle.comboPeriode")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.enregistrer= '${g.message(code: "eliot.notes.libelle.enregistrer")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.annuler= '${g.message(code: "eliot.notes.libelle.annuler")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.nomEleve= '${g.message(code: "eliot.notes.libelle.nomEleve")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.moyenne= '${g.message(code: "eliot.notes.libelle.moyenneCourt")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.appreciation= '${g.message(code: "eliot.notes.libelle.appreciationsGenerales")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.matiere= '${g.message(code: "eliot.notes.libelle.matiere")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.sousMatiere= '${g.message(code: "eliot.notes.libelle.sousMatiere")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.enseignants= '${g.message(code: "eliot.notes.libelle.enseignants")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.eleve= '${g.message(code: "eliot.notes.libelle.eleve")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.coeff= '${g.message(code: "eliot.notes.libelle.coeff")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.isOption= '${g.message(code: "eliot.notes.libelle.isOption")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.conseilDeClasse= '${g.message(code: "eliot.notes.libelle.conseilDeClasse")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.appreciationClasse= '${g.message(code: "eliot.notes.libelle.apprClasse")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.noteMaxMoyenneClasse= '${g.message(code: "eliot.notes.libelle.noteMaxMoyenneClasse")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.noteMinMoyenneClasse= '${g.message(code: "eliot.notes.libelle.noteMinMoyenneClasse")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.moyenneEleve= '${g.message(code: "eliot.notes.conseilDeClasse.libelle.moyenneEleve")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.moyenneClasse= '${g.message(code: "eliot.notes.libelle.moyenneClasse")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.graph = '${g.message(code: "eliot.notes.libelle.graph")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.fermer = '${g.message(code: "eliot.notes.libelle.fermer")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.afficherLesPeriodesPrecedents = '${g.message(code: "eliot.notes.graph.libelle.afficherLesPeriodesPrecedents")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.libelle.affichage = '${g.message(code: "eliot.notes.libelle.affichage")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.moyennesPrecedentes = '${g.message(code: "eliot.notes.libelle.moyennesPrecedentes")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.libelle.rang = '${g.message(code: "eliot.notes.libelle.rang")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.messages.appreciationModifieEnCours = '${g.message(code: "eliot.notes.message.appreciationModifieEnCours")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.appreciationModifieSucces = '${g.message(code: "eliot.notes.message.appreciationModifieSucces")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.appreciationModifieEchou = '${g.message(code: "eliot.notes.message.appreciationModifieEchou")?.encodeAsJavaScript()}';
+ eliot.notes.Modele.messages.loading= '${g.message(code: "eliot.notes.message.loading")}';
+ eliot.notes.saisie.synthese.Modele.messages.attention= '${g.message(code: "eliot.notes.libelle.attention")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.saisieSyntheseAlert= '${g.message(code: "eliot.notes.message.saisieNoteAlert")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.confirmationQuitterSaisieSynthese= '${g.message(code: "eliot.notes.message.confirmationQuitterSaisieNote")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.tblNotesGraphEchou = '${g.message(code: "eliot.notes.message.erreurInconnue")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.messages.enregistrePreferenceUtilisateurEchec= '${g.message(code: "eliot.notes.message.erreurInconnue")?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.url.getSyntheseCsv = '${createLink(controller: 'saisieSynthese', action: 'getSyntheseCsv')}';
+ eliot.notes.saisie.synthese.Modele.url.urlSaveAppreciationGenerale = '${createLink(controller: 'appreciationElevePeriode', action: 'enregistrerAppreciations')}';
+ eliot.notes.saisie.synthese.Modele.url.urlConseilDeClasse = '${createLink(controller: 'saisieConseilDeClasse')}';
+ eliot.notes.saisie.synthese.Modele.url.urlAppreciationClasse = '${createLink(controller: 'consultationAppreciationsClasse')}';
+ eliot.notes.saisie.synthese.Modele.url.urlHeartBeat = '${createLink(controller: 'heartBeat')}';
+ eliot.notes.saisie.synthese.Modele.url.urlGraphTblNotes = '${createLink(controller: 'saisieSynthese', action: 'graph')}';
+ eliot.notes.saisie.synthese.Modele.url.enregistrePreferenceUtilisateur = '${createLink(controller: 'preferenceUtilisateurNotes', action: 'enregistre')}';
+
+ eliot.notes.saisie.synthese.Modele.icon.enregistrer = '${resource(dir: 'images', file: 'enregistrer.gif')}';
+ eliot.notes.saisie.synthese.Modele.icon.annuler = '${resource(dir: 'images', file: 'undo.gif')}';
+ eliot.notes.saisie.synthese.Modele.icon.coenseignement = '${resource(dir: 'images', file: 'group.gif')}';
+ eliot.notes.saisie.synthese.Modele.icon.conseilDeClasse = '${resource(dir: 'images/skin', file: 'house.png')}';
+ eliot.notes.saisie.synthese.Modele.icon.appreciationClasse = '${resource(dir: 'images/skin', file: 'database_edit.png')}';
+ eliot.notes.saisie.synthese.Modele.icon.graph = '${resource(dir: 'images', file: 'graph.png')?.encodeAsJavaScript()}';
+
+ eliot.notes.saisie.synthese.Modele.data.periodeId = '${periodeId}';
+ eliot.notes.saisie.synthese.Modele.data.classeId = '${classeId}';
+ eliot.notes.saisie.synthese.Modele.data.appreciationModifiable = ${appreciationModifiable ?: false};
+
+ eliot.notes.saisie.synthese.Modele.data.listeStructureEnseignements = ${classeInfos ?: '[]'};
+ eliot.notes.saisie.synthese.Modele.data.periodeInfos = ${periodeInfos ?: '[]'};
+ eliot.notes.saisie.synthese.Modele.data.serviceInfos = ${serviceInfos ?: '[]'};
+ eliot.notes.saisie.synthese.Modele.data.syntheseLignes = ${syntheseEleves ?: '[]'};
+ eliot.notes.saisie.synthese.Modele.data.moyenneLignes = ${syntheseClasses ?: '[]'};
eliot.notes.saisie.synthese.Modele.data.verrouille = ${verrouille != null ? verrouille : 'undefined'};
eliot.notes.saisie.synthese.Modele.data.moyennesAjour = ${moyennesAjour != null ? moyennesAjour : 'undefined'};
eliot.notes.saisie.synthese.Modele.data.messageMoyennesNonAJour = '${g.message(code: "eliot.notes.message.MoyennesNonAJour", args: [dateDernierCalculMoyennes])?.encodeAsJavaScript()}';
+ eliot.notes.saisie.synthese.Modele.data.affichage.moyennesPrecedentes = ${affichage.moyennesPrecedentes};
+ eliot.notes.saisie.synthese.Modele.data.affichage.rangs = ${affichage.rangs};
+
+ eliot.notes.saisie.synthese.Modele.data.periodesPrecedentes = ${periodesPrecedentes};
+
</g:javascript>
%{--Sources de bouton d'export des données--}%
eliot.notes.saisie.tableauDeNotes.Modele.libelle.selectionMeilleuresNotesEPS = "${g.message(code: "eliot.notes.libelle.selectionMeilleuresNotesEPS")?.encodeAsJavaScript()}";
eliot.notes.saisie.tableauDeNotes.Modele.libelle.confirmation = "${g.message(code: "eliot.notes.libelle.confirmation")?.encodeAsJavaScript()}";
+ eliot.notes.saisie.tableauDeNotes.Modele.libelle.affichage = '${g.message(code: "eliot.notes.libelle.affichage")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.tableauDeNotes.Modele.libelle.moyennesPrecedentes = '${g.message(code: "eliot.notes.libelle.moyennesPrecedentes")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.tableauDeNotes.Modele.libelle.rang = '${g.message(code: "eliot.notes.libelle.rang")?.encodeAsJavaScript()}';
+
eliot.notes.saisie.tableauDeNotes.Modele.libelle.fermer = '${g.message(code: "eliot.notes.libelle.fermer")?.encodeAsJavaScript()}';
eliot.notes.saisie.tableauDeNotes.Modele.libelle.noteMaxMoyenneClasse= '${g.message(code: "eliot.notes.libelle.noteMaxMoyenneClasse")?.encodeAsJavaScript()}';
eliot.notes.saisie.tableauDeNotes.Modele.url.urlHeartBeat = '${createLink(controller: 'heartBeat')}';
eliot.notes.saisie.tableauDeNotes.Modele.url.urlBrevetEpsTblNotes = '${createLink(controller: 'saisieTableauDeNotes', action: 'brevetEps')}';
eliot.notes.saisie.tableauDeNotes.Modele.url.urlEnregistreSelectionBrevetEps = '${createLink(controller: 'saisieTableauDeNotes', action: 'enregistreSelectionBrevetEps')}';
+ eliot.notes.saisie.tableauDeNotes.Modele.url.enregistrePreferenceUtilisateur = '${createLink(controller: 'preferenceUtilisateurNotes', action: 'enregistre')}';
eliot.notes.saisie.tableauDeNotes.Modele.icon.enregistrer = '${resource(dir: 'images', file: 'enregistrer.gif')}';
eliot.notes.saisie.tableauDeNotes.Modele.icon.annuler = '${resource(dir: 'images', file: 'undo.gif')}';
eliot.notes.saisie.tableauDeNotes.Modele.messages.confirmationEnregistrementBrevetEPS= '${g.message(code: "eliot.notes.message.confirmationEnregistrementBrevetEPS")?.encodeAsJavaScript()}';
eliot.notes.saisie.tableauDeNotes.Modele.messages.brevetEpsNotesSelectionneesSucces= '${g.message(code: "eliot.notes.message.brevetEpsNotesSelectionneesSucces")?.encodeAsJavaScript()}';
eliot.notes.saisie.tableauDeNotes.Modele.messages.brevetEpsNotesSelectionneesEchec= '${g.message(code: "eliot.notes.message.brevetEpsNotesSelectionneesEchec")?.encodeAsJavaScript()}';
+ eliot.notes.saisie.tableauDeNotes.Modele.messages.enregistrePreferenceUtilisateurEchec= '${g.message(code: "eliot.notes.message.erreurInconnue")?.encodeAsJavaScript()}';
eliot.notes.Modele.messages.chargementImpressionMaskText= '${g.message(code: "eliot.notes.message.chargementImpressionMaskText")?.encodeAsJavaScript()}';
eliot.notes.saisie.tableauDeNotes.Modele.data.periodesDefinis = ${periodesDefinis != null ? periodesDefinis : true};
eliot.notes.saisie.tableauDeNotes.Modele.data.isMatiereEPS = ${isMatiereEPS};
+ eliot.notes.saisie.tableauDeNotes.Modele.data.affichage.moyennesPrecedentes = ${affichage.moyennesPrecedentes};
+ eliot.notes.saisie.tableauDeNotes.Modele.data.affichage.rangs = ${affichage.rangs};
+
+ eliot.notes.saisie.tableauDeNotes.Modele.data.typePeriodePrecedents = ${typePeriodePrecedents};
+
// Liste des services
<g:each var="service" in="${services}">
eliot.notes.saisie.tableauDeNotes.Modele.data.serviceInfos.push({
--- /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.notes
+
+import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
+import org.lilie.services.eliot.test.PopulationTestActeur
+
+import grails.test.GrailsUnitTestCase
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.notes.domaine.PreferenceUtilisateurNotesParams
+
+/**
+ * @author agia
+ */
+class PreferenceUtilisateurNotesServiceTests extends GrailsUnitTestCase{
+
+ SecuriteSession securiteSession
+ LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
+
+ protected void setUp() {
+ super.setUp()
+
+ securiteSession = localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1)
+ }
+
+ void testCreePreferenceUtilisateur() {
+ /* initialisation */
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotesParams pref =
+ new PreferenceUtilisateurNotesParams(
+ rangs: true,
+ moyennesPrecedentes: true
+ )
+ /* */
+
+ /* appel de la méthode à tester */
+ preferenceUtilisateurNotesService.creePreferenceUtilisateur(utilisateur,
+ pref)
+ /* */
+
+ /* vérifications */
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ eq('rangs', true)
+ eq('moyennesPrecedentes', true)
+ }
+
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ n'ont pas été créées en base""", preferenceUtilisateurNotes)
+ /* */
+ }
+
+ void testGetPreferenceUtilisateur() {
+ /* initialisation */
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ new PreferenceUtilisateurNotes(
+ utilisateur: utilisateur,
+ rangs: true,
+ moyennesPrecedentes: true
+ )
+
+ preferenceUtilisateurNotes.save()
+
+ PreferenceUtilisateurNotes initialisationResultat =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ eq('rangs', true)
+ eq('moyennesPrecedentes', true)
+ }
+
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été créées""", initialisationResultat)
+ /* */
+
+ /* appel de la méthode à tester */
+ PreferenceUtilisateurNotes resultat =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+ /* */
+
+ /* vérifications */
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été trouvée""", resultat)
+
+ assertEquals("""Les préférences de l'utilisateur $utilisateur concernant
+ l'affichage des rangs ne sont pas correctes""",
+ true,
+ resultat.rangs)
+ assertEquals("""Les préférences de l'utilisateur $utilisateur concernant
+ l'affichage des moyennes précédentes ne sont pas correctes""",
+ true,
+ resultat.moyennesPrecedentes)
+ /* */
+ }
+
+ void testMetAJourPreferenceUtilisateur() {
+ /* initialisation */
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ new PreferenceUtilisateurNotes(
+ utilisateur: utilisateur,
+ rangs: false,
+ moyennesPrecedentes: true
+ )
+
+ preferenceUtilisateurNotes.save()
+
+ PreferenceUtilisateurNotes initialisationResultat =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ eq('rangs', false)
+ eq('moyennesPrecedentes', true)
+ }
+
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été créées""", initialisationResultat)
+
+ PreferenceUtilisateurNotesParams pref =
+ new PreferenceUtilisateurNotesParams(
+ rangs: true,
+ moyennesPrecedentes: false
+ )
+ /* */
+
+ /* appel de la méthode à tester */
+ preferenceUtilisateurNotesService.metAJourPreferenceUtilisateur(securiteSession,
+ pref)
+ /* */
+
+ /* vérifications */
+ PreferenceUtilisateurNotes resultat =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ eq('rangs', true)
+ eq('moyennesPrecedentes', false)
+ }
+
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été mises à jour""", resultat)
+ /* */
+ }
+
+ void testSupprimePreferenceUtilisateur() {
+ /* initialisation */
+ Personne utilisateur = (Personne) securiteSession.getPersonne()
+
+ PreferenceUtilisateurNotes preferenceUtilisateurNotes =
+ new PreferenceUtilisateurNotes(
+ utilisateur: utilisateur,
+ rangs: false,
+ moyennesPrecedentes: true
+ )
+
+ preferenceUtilisateurNotes.save()
+
+ PreferenceUtilisateurNotes initialisationResultat =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ eq('rangs', false)
+ eq('moyennesPrecedentes', true)
+ }
+
+ assertNotNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été créées""", initialisationResultat)
+ /* */
+
+ /* appel de la méthode à tester */
+ preferenceUtilisateurNotesService.supprimePreferenceUtilisateur(securiteSession)
+ /* */
+
+ /* vérifications */
+ PreferenceUtilisateurNotes resultat =
+ PreferenceUtilisateurNotes.createCriteria().get{
+ eq('utilisateur', utilisateur)
+ }
+
+ assertNull("""Les préférences d'affichage pour les synthèses et tableaux de notes
+ de l'utilisateur $utilisateur n'ont pas été supprimées""", resultat)
+ /* */
+ }
+
+}
Date dateCreation2 = new Date(111,2,1)
Etablissement etablissement1 = null
- StructureEnseignement classe1enTrimestres = null
+ StructureEnseignement classe = null
//les matieres des services
Matiere matiere1 = null
ModaliteMatiere modaliteMatiere1 = null
ModaliteMatiere modaliteMatiere2 = null
- Periode periodeT1_1 = null
- Periode periodeT2_1 = null
- Periode periodeT3_1 = null
- Periode periode_Annee = null
+ Periode periodeT1 = null
+ Periode periodeT2 = null
+ Periode periodeT3 = null
+ Periode periodeAnnee = null
Service serviceNormal = null
Service serviceParent = null
private final noteSS1_T2_E1 = 45
private final noteSS2_T2_E1 = 50
private final noteSS1_T3_E1 = 15
- private final noteSS2_T3_E1= 35
+ private final noteSS2_T3_E1 = 35
// les valeurs numeriques des notes associés aux sousServices et l'eleve2 pour chaque periode
private final noteSS1_T1_E2 = 46
private final noteSS1_T2_E2 = 12
private final noteSS2_T2_E2 = 48
private final noteSS1_T3_E2 = 15
- private final noteSS2_T3_E2= 35
+ private final noteSS2_T3_E2 = 35
- private final noteMax =50
+ private final noteMax = 50
static final int precision = 2
protected void setUp() {
PopulationTestActeur.ELEVE_2_CLASSE_1)
//get Structure Enseignement
- classe1enTrimestres = localInitDonneesCommunesTestService.getClasse(
+ classe = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
)
- structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
- classe1enTrimestres.save()
+ structureEnseignementNotesService.setTypeIntervalle(classe, TypeIntervalleEnum.TRIMESTRE)
+ classe.save(failOnError: true)
//get periode de notation
- periodeT1_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t1, classe1enTrimestres)
+ periodeT1 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t1, classe)
- periodeT2_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t2, classe1enTrimestres
+ periodeT2 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t2, classe
)
- periodeT3_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t3, classe1enTrimestres
+ periodeT3 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t3, classe
)
- periode_Annee= initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.annee, classe1enTrimestres)
+ periodeAnnee= initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.annee, classe)
//creer un serviceNormal et un serviceParent
- serviceNormal = initDonneesNotesTestService.creeService(matiere1,classe1enTrimestres)
- serviceParent = initDonneesNotesTestService.creeService(matiere2,classe1enTrimestres)
+ serviceNormal = initDonneesNotesTestService.creeService(matiere1,classe)
+ serviceParent = initDonneesNotesTestService.creeService(matiere2,classe)
//creer les sousServices
//creer des sous-services associés au serviceParent
serviceParent.addToEnseignements(enseignement2)
//creer les evaluations attachés aux serviceNormal
- eval_SN_T1 = creeEvaluation([periodeT1_1],enseignement1,dateCreation1,dateEvaluation1)
- eval_SN_T2 = creeEvaluation([periodeT2_1],enseignement1,dateCreation1,dateEvaluation1)
- eval_SN_T3 = creeEvaluation([periodeT3_1],enseignement1,dateCreation1,dateEvaluation1)
+ eval_SN_T1 = creeEvaluation([periodeT1],enseignement1,dateCreation1,dateEvaluation1)
+ eval_SN_T2 = creeEvaluation([periodeT2],enseignement1,dateCreation1,dateEvaluation1)
+ eval_SN_T3 = creeEvaluation([periodeT3],enseignement1,dateCreation1,dateEvaluation1)
//******creer les evaluations attachés au serviceParent (sousServices)
//evaluation attachée au sousService1 pour la periode T
- eval_SS1_T1 = creeEvaluation([periodeT1_1],enseignement2,dateCreation1,dateEvaluation1)
+ eval_SS1_T1 = creeEvaluation([periodeT1],enseignement2,dateCreation1,dateEvaluation1)
eval_SS1_T1.modaliteMatiere = modaliteMatiere1
- eval_SS1_T1.save()
+ eval_SS1_T1.save(failOnError: true)
//evaluation attachée au sousService2 pour la periode T1
- eval_SS2_T1 = creeEvaluation([periodeT1_1],enseignement2,dateCreation2,dateEvaluation2)
+ eval_SS2_T1 = creeEvaluation([periodeT1],enseignement2,dateCreation2,dateEvaluation2)
eval_SS2_T1.modaliteMatiere = modaliteMatiere2
- eval_SS2_T1.save()
+ eval_SS2_T1.save(failOnError: true)
//evaluation attachée au sousService1 pour la periode T2
- eval_SS1_T2 = creeEvaluation([periodeT2_1],enseignement2,dateCreation1,dateEvaluation1)
+ eval_SS1_T2 = creeEvaluation([periodeT2],enseignement2,dateCreation1,dateEvaluation1)
eval_SS1_T2.modaliteMatiere = modaliteMatiere1
- eval_SS1_T2.save()
+ eval_SS1_T2.save(failOnError: true)
//evaluation attachée au sousService2 pour la periode T2
- eval_SS2_T2 = creeEvaluation([periodeT2_1],enseignement2,dateCreation2,dateEvaluation2)
+ eval_SS2_T2 = creeEvaluation([periodeT2],enseignement2,dateCreation2,dateEvaluation2)
eval_SS2_T2.modaliteMatiere = modaliteMatiere2
- eval_SS2_T2.save()
+ eval_SS2_T2.save(failOnError: true)
//evaluation attachée au sousService1 pour la periode T3
- eval_SS1_T3 = creeEvaluation([periodeT3_1],enseignement2,dateCreation1,dateEvaluation1)
+ eval_SS1_T3 = creeEvaluation([periodeT3],enseignement2,dateCreation1,dateEvaluation1)
eval_SS1_T3.modaliteMatiere = modaliteMatiere1
- eval_SS1_T3.save()
+ eval_SS1_T3.save(failOnError: true)
//evaluation attachée au sousService2 pour la periode T3
- eval_SS2_T3 = creeEvaluation([periodeT3_1],enseignement2,dateCreation2,dateEvaluation2)
+ eval_SS2_T3 = creeEvaluation([periodeT3],enseignement2,dateCreation2,dateEvaluation2)
eval_SS2_T3.modaliteMatiere = modaliteMatiere2
- eval_SS2_T3.save()
+ eval_SS2_T3.save(failOnError: true)
//*****Creer les notes des services pour les eleves(eleve1,eleve2)
//creer les notes attachées au ServiceNormal pour l'eleve 1 et pour les 3 periodes T1,T2,T3
protected void tearDown() {
super.tearDown()
}
+
void testConstruisSynthese() {
// Le securité session d'un enseignant
SecuriteSession securiteSessionEnseignant =
List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
List<SousService> sousServices = [sousServiceT1_1, sousServiceT1_2]
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement2,
- sousServices.collect { it.modaliteMatiere }
- )
+ classe.periodes.each {Periode periode ->
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement1,
+ null
+ )
+
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement2,
+ sousServices.collect { it.modaliteMatiere }
+ )
+ }
moyenneCalculLauncherService.calculeToutesMoyennes()
//Appeler la methode à tester
Synthese synthese = syntheseService.construisSynthese(securiteSessionEnseignant,
- classe1enTrimestres,
- periodeT1_1)
+ classe,
+ periodeT1)
//recuperer le resultatEleve Periode pour l'eleve1 et periodeT1
- ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
+ ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
//recuperer le resultatEleve Periode pour l'eleve2 et periodeT1
- ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve2.autorite, periodeT1_1)
+ ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve2.autorite, periodeT1)
//recuperer le resultatEleveServicePeriode pour eleve1,serviceNormal et periode T1
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode1 =
- getResultatEleveServicePeriode(periodeT1_1, serviceNormal, eleve1.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve1.autorite)
//recuperer le resultatEleveServicePeriode pour eleve2,serviceNormal et periode T1
ResultatEleveServicePeriode resultatEleveServiceNormalPeriode2 =
- getResultatEleveServicePeriode(periodeT1_1, serviceNormal, eleve2.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceNormal, eleve2.autorite)
//recuperer le resultatEleveServicePeriode pour eleve1,serviceParent et periode T1
ResultatEleveServicePeriode resultatEleveServiceParentPeriode1 =
- getResultatEleveServicePeriode(periodeT1_1, serviceParent, eleve1.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceParent, eleve1.autorite)
//recuperer le resultatEleveServicePeriode pour eleve2,serviceParent et periode T1
ResultatEleveServicePeriode resultatEleveServiceParentPeriode2 =
- getResultatEleveServicePeriode(periodeT1_1, serviceParent, eleve2.autorite)
+ getResultatEleveServicePeriode(periodeT1, serviceParent, eleve2.autorite)
//recuperer le resultatClassePeriode
- ResultatClassePeriode resultatClassePeriode = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT1_1)
+ ResultatClassePeriode resultatClassePeriode = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT1)
//recuperer le resultatClasseServicePeriode qui est attaché au serviceNormal pour la periode T1
ResultatClasseServicePeriode resultatClasseServiceNormalPeriode =
- getResultatClasseServicePeriode(periodeT1_1 ,serviceNormal ,classe1enTrimestres)
+ getResultatClasseServicePeriode(periodeT1 ,serviceNormal, classe)
//recuperer le resultatClasseServicePeriode qui est attaché au serviceParent pour la periode T1
ResultatClasseServicePeriode resultatClasseServiceParentPeriode =
- getResultatClasseServicePeriode(periodeT1_1 ,serviceParent ,classe1enTrimestres)
-
-
+ getResultatClasseServicePeriode(periodeT1 ,serviceParent, classe)
//verifier que la classe et la periode sont bien recuperés dans la synthese
assertEquals("la classe recuperé dans la synthese n'est pas correcte",
- synthese.classe.id ,classe1enTrimestres.id)
+ synthese.classe.id, classe.id)
assertEquals("la periode recuperé dans la synthese n'est pas correcte",
- synthese.periode.id ,periodeT1_1.id)
+ synthese.periode.id, periodeT1.id)
//verifier que la liste syntheseEleves et not-null
assertNotNull("La liste synthesEleves ne doit pas etre null", synthese.syntheseEleves)
//verifier que la classe est bien recuperée dans syntheseClasse
assertEquals("la classe recuperéé dans syntheseClasse n'est pas correcte",
- syntheseClasse.classe.id, classe1enTrimestres.id)
+ syntheseClasse.classe.id, classe.id)
//verifier que le resultatClassePeriode est bien recuperée dans syntheseClasse
assertEquals("le resultatClassePeriode recuperéé dans syntheseClasse n'est pas correct",
resultatClasseServiceParentPeriode1.id, resultatClasseServiceParentPeriode.id)
+ // Teste la remonté des résultats des périodes précédentes
+ synthese = syntheseService.construisSynthese(securiteSessionEnseignant,
+ classe,
+ periodeT3)
+
+ List<ResultatClassePeriode> resultatClasseXmestrePrecedents =
+ synthese.syntheseClasse.resultatClasseXmestrePrecedents
+
+ assertTrue(
+ "Les résultats de classe des xmestres précédentes ne contiennent pas ceux des périodes T1 et T2" ,
+ resultatClasseXmestrePrecedents.size() == 2 &&
+ resultatClasseXmestrePrecedents*.periode*.id.contains(periodeT1.id) &&
+ resultatClasseXmestrePrecedents*.periode*.id.contains(periodeT2.id)
+ )
+
+ syntheseEleve1 = synthese.syntheseEleves.find {it.eleve.id == eleve1.id}
+
+ List<ResultatElevePeriode> resultatEleveXmestrePrecedents =
+ syntheseEleve1.resultatEleveXmestrePrecedents
+
+ assertTrue(
+ "Les résultats de l'élève 1 des xmestres précédentes ne contiennent pas ceux des périodes T1 et T2" ,
+ resultatEleveXmestrePrecedents.size() == 2 &&
+ resultatEleveXmestrePrecedents*.periode*.id.contains(periodeT1.id) &&
+ resultatEleveXmestrePrecedents*.periode*.id.contains(periodeT2.id)
+ )
}
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
- * @return evaluation
* @author mjao
*/
private Evaluation creeEvaluation(List<Periode> periodes ,
}
/**
* Crée une note
- * @param eleve
- * @param evaluation qui correspond à l'eleve
- * @param valeur : la valeur numerique de note
* @author mjao
*/
private Note creeNote(Autorite eleve,
}
/**
* Crée un sous-service
- *@return regroupment une structure d'enseignement
* @author mjao
*/
private SousService creeSousService(Service service,
/**
* 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,
/**
* get un ResultatClasseServicePeriode
- * @param periode
- * @param service
- *@param classe
* @author mjao
*/
private ResultatClasseServicePeriode getResultatClasseServicePeriode(
/**
* crée un ResultatEleveServicePeriode
- * @param periode
- * @param service
- *@param eleve
* @author mjao
*/
private ResultatEleveServicePeriode getResultatEleveServicePeriode(
assertEquals(
"L'eleve n'a pas les resultas pour toutes les périodes",
- 5, // (T1, T2, T3, Brevet, Anneé)
- tableauDeNotesLigne.resultats.size()
+ 3, // (T1, T2, T3)
+ tableauDeNotesLigne.resultatsXmestresPrecedents.size()
)
//Verifer la recuperation de la bonne classe
//verifer le calcul de moyenne
BigDecimal moyenneAnnee = (valeurNoteT1 + valeurNoteT2 + valeurNoteT3) / 3
- ResultatEleveEnseignementPeriode result =
- (ResultatEleveEnseignementPeriode) tableauDeNotesLigne.resultats.find {
- it.periode == periodeAnnee_1
- }
-
assertEquals(
"La moyenne d'annee n'est pas correct",
moyenneAnnee,
- result.moyenne
+ tableauDeNotesLigne.resultat.moyenne
)
//Tester le cas d'une periode de type notation
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes.resultat
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.test.InitPeriodeTestService
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
-import org.lilie.services.eliot.notes.resultat.MoyenneService
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.scolarite.RelPeriodeService
-import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
import java.math.RoundingMode
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.notes.resultat.UptodateService
import org.lilie.services.eliot.scolarite.SousService
import org.lilie.services.eliot.scolarite.ModaliteMatiere
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.TypePeriode
-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.notes.resultat.InfoCalculMoyennesClasseService
import org.lilie.services.eliot.test.PopulationTestClasse
-import org.lilie.services.eliot.notes.resultat.CalculationService
import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
-import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
import org.lilie.services.eliot.textes.TypeActivite
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
import org.lilie.services.eliot.notes.Evaluation
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
/**
* Tests de MoyenneService
InitDonneesNotesTestService initDonneesNotesTestService
InitPeriodeTestService initPeriodeTestService
MoyenneService moyenneService
- NotesPeriodeService notesPeriodeService
ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
AnneeScolaireService anneeScolaireService
UptodateService uptodateService
InfoCalculMoyennesClasseService infoCalculMoyennesClasseService
StructureEnseignementNotesService structureEnseignementNotesService
+ EleveAnnuaireService eleveAnnuaireService
Date dateEvaluation1 = new Date(111, 1, 1)
Date dateCreation1 = new Date(111, 1, 1)
Date dateCreation2 = new Date(111, 2, 1)
Etablissement etablissement1 = null
- StructureEnseignement classe1enTrimestres = null
+ StructureEnseignement classe = null
Matiere matiere1 = null
Matiere matiere2 = null
ModaliteMatiere modaliteMatiere1 = null
ModaliteMatiere modaliteMatiere2 = null
- Periode periodeT1_1 = null
- Periode periodeT2_1 = null
- Periode periodeT3_1 = null
- Periode periode_Annee = null
+ Periode periodeT1 = null
+ Periode periodeT2 = null
+ Periode periodeT3 = null
+ Periode periodeAnnee = null
Service service = null
Service serviceParent = null
Note note_SS2_T2_E1 = null
//la note de sousService1 pour la periode T3,eleve1
Note note_SS1_T3_E1 = null
- //la note de sousService1 pour la periode T3,eleve1 // eleve1 =
- // localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ELEVE_1_CLASSE_1)
+ //la note de sousService1 pour la periode T3,eleve1
Note note_SS2_T3_E1 = null
//les notes attachés au sousServices pour l'eleve2
- //la note de sousService1 pour la periode T1 , eleve2
+ //la note de sousService1 pour la periode T1, eleve2
Note note_SS1_T1_E2 = null
- //la note de sousService2 pour la periode T1,eleve2
+ //la note de sousService2 pour la periode T1, eleve2
Note note_SS2_T1_E2 = null
- //la note de sousService2 pour la periode T2 ,eleve2
+ //la note de sousService2 pour la periode T2, eleve2
Note note_SS1_T2_E2 = null
- //la note de sousService2 pour la periode T2,eleve2
+ //la note de sousService2 pour la periode T2, eleve2
Note note_SS2_T2_E2 = null
- //la note de sousService1 pour la periode T3,eleve2
+ //la note de sousService1 pour la periode T3, eleve2
Note note_SS1_T3_E2 = null
- //la note de sousService1 pour la periode T3,eleve2
+ //la note de sousService1 pour la periode T3, eleve2
Note note_SS2_T3_E2 = null
// les valeurs numeriques de deux notes notés par l'enseignant 1 pour la periode T1
// get matiere
matiere1 = localInitDonneesCommunesTestService.
getMatiere(PopulationTestMatiere.FRANCAIS)
+
matiere2 = localInitDonneesCommunesTestService.
getMatiere(PopulationTestMatiere.ANGLAIS)
+
matiere3 = localInitDonneesCommunesTestService.
getMatiere(PopulationTestMatiere.MATH)
"code1",
"libelle1",
etablissement1)
+
modaliteMatiere2 = creeModaliteMatiere(
"code2",
"libelle2",
anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
//creer une classe
- classe1enTrimestres = localInitDonneesCommunesTestService.getClasse(
+ classe = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_SANS_ELEVES
)
- structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
- classe1enTrimestres.save()
-
- eleve1 = creePersonne("111100098720000010")
- ProprietesScolarite propretesScolarite = creeProprietesScolarite()
+ structureEnseignementNotesService.setTypeIntervalle(classe, TypeIntervalleEnum.TRIMESTRE)
+ classe.save(failOnError: true)
- PersonneProprietesScolarite personneProprietesScolarites =
- creePersonneProprietesScolarite(
- eleve1,
- propretesScolarite
- )
+ eleve1 = creePersonne("111100098720000010")
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe)
eleve2 = creePersonne("11110147800011")
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe)
- creePersonneProprietesScolarite(
- eleve2,
- creeProprietesScolarite()
+ //get periode de notation
+ periodeT1 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t1,
+ classe
)
- //ajouter (inscription) les deux eleves eleve1 et eleve2 au classe1Trimestre1
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- null,
- null,
- true
+ periodeT2 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t2,
+ classe
)
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve2,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
-
- //get periode de notation
- periodeT1_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t1, classe1enTrimestres)
- periodeT2_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t2, classe1enTrimestres
+ periodeT3 = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.t3,
+ classe
)
- periodeT3_1 = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.t3, classe1enTrimestres
+
+ periodeAnnee = initDonneesNotesTestService.getOuCreePeriode(
+ initPeriodeTestService.annee,
+ classe
)
- periode_Annee = initDonneesNotesTestService.getOuCreePeriode(
- initPeriodeTestService.annee, classe1enTrimestres)
//creer un service
- service = initDonneesNotesTestService.creeService(matiere1, classe1enTrimestres)
- serviceParent = initDonneesNotesTestService.creeService(matiere3, classe1enTrimestres)
- serviceOptionnel = initDonneesNotesTestService.creeService(matiere2, classe1enTrimestres)
+ service = initDonneesNotesTestService.creeService(matiere1, classe)
+ serviceParent = initDonneesNotesTestService.creeService(matiere3, classe)
+ serviceOptionnel = initDonneesNotesTestService.creeService(matiere2, classe)
//recuperer des enseignants
Autorite enseignant1 = localInitDonneesCommunesTestService.
getAutorite(PopulationTestActeur.ENSEIGNANT_1)
+
Autorite enseignant2 = localInitDonneesCommunesTestService.
getAutorite(PopulationTestActeur.ENSEIGNANT_9_1)
//Creer les evaluations pour le test
//creer deux evaluations attachés à l'enseignement1 pendant la periode T1
- evalT1_1_1 = creeEvaluation([periodeT1_1], enseignement1, dateCreation1, dateEvaluation1)
- evalT1_2_1 = creeEvaluation([periodeT1_1], enseignement1, dateCreation2, dateEvaluation2)
+ evalT1_1_1 = creeEvaluation([periodeT1], enseignement1, dateCreation1, dateEvaluation1)
+ evalT1_2_1 = creeEvaluation([periodeT1], enseignement1, dateCreation2, dateEvaluation2)
//creer deux evaluations attachés à l'enseignement1 pendant la periode T2
- evalT2_1_1 = creeEvaluation([periodeT2_1], enseignement1, dateCreation1, dateEvaluation1)
- evalT2_2_1 = creeEvaluation([periodeT2_1], enseignement1, dateCreation2, dateEvaluation2)
+ evalT2_1_1 = creeEvaluation([periodeT2], enseignement1, dateCreation1, dateEvaluation1)
+ evalT2_2_1 = creeEvaluation([periodeT2], enseignement1, dateCreation2, dateEvaluation2)
//creer deux evaluations attachés à l'enseignement1 pendant la periode T1
- evalT3_1_1 = creeEvaluation([periodeT3_1], enseignement1, dateCreation1, dateEvaluation1)
- evalT3_2_1 = creeEvaluation([periodeT3_1], enseignement1, dateCreation2, dateEvaluation2)
+ evalT3_1_1 = creeEvaluation([periodeT3], enseignement1, dateCreation1, dateEvaluation1)
+ evalT3_2_1 = creeEvaluation([periodeT3], enseignement1, dateCreation2, dateEvaluation2)
//creer les deux notes attachés aux deux evaluations qui correspondent à lenseignement 1 pour la periode T1
noteT1_1_1 = creeNote(eleve1, evalT1_1_1, valeurNote1_1_1)
InfoCalculMoyennesClasse infoCalculMoyennesClasse =
new InfoCalculMoyennesClasse(
- classe: classe1enTrimestres,
+ classe: classe,
calculEnCours: false,
dateDebutCalcul: new Date(111, 1, 10)
)
- infoCalculMoyennesClasse.save()
+
+ infoCalculMoyennesClasse.save(failOnError: true)
Note note11 = noteT1_1_1 // cree dans startup
Note note12 = noteT1_2_1 // cree dans startup
Note note21 = noteT1_1_E2 // cree dans startup
Note note22 = creeNote(eleve2, evalT1_2_1, valeurNoteEnsPer_2_2)
- uptodateService.marqueDirtyEleves(
- securiteSessionEnseignant,
- [eleve1.autorite, eleve2.autorite],
- periodeT1_1,
- enseignement1,
- null
- )
+ marqueDirtyMoyenneEleves()
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
// Appeler la methode majMoyenne pour tester quelle sont les moyennes qui sont recalculés
moyenneService.majMoyennes(
securiteSessionEnseignant,
- classe1enTrimestres,
+ classe,
infoCalculMoyennesClasse.dateDebutCalcul)
Map moyenneEnsPerPrevue = calculeMoyenneEnseignementPeriode(
note22)
ResultatEnseignementPeriode resultatEnseignementPeriode =
- getResultatEnseignementPeriode(periodeT1_1, enseignement1)
+ getResultatEnseignementPeriode(periodeT1, enseignement1)
assertNotNull("Moyenne EnseignementPeriode n'a pas ete enregistree",
resultatEnseignementPeriode)
+
assertEquals("Moyenne EnseignementPeriode n'est pas comme prevu",
moyenneEnsPerPrevue.moyenne,
resultatEnseignementPeriode.moyenne)
+
assertEquals("Moyenne Min EnseignementPeriode n'est pas comme prevu",
moyenneEnsPerPrevue.moyenneMin,
resultatEnseignementPeriode.moyenneMin)
+
assertEquals("Moyenne Max EnseignementPeriode n'est pas comme prevu",
moyenneEnsPerPrevue.moyenneMax,
resultatEnseignementPeriode.moyenneMax)
* @param note22 eleve 2, evaluation 2
* @return
*/
- Map calculeMoyenneEnseignementPeriode(Note note11, Note note12, Note note21,
+ Map calculeMoyenneEnseignementPeriode(Note note11,
+ Note note12,
+ Note note21,
Note note22) {
BigDecimal moyenneEleve1 =
(note11.valeurNumerique / noteMax * 20 + note12.valeurNumerique / noteMax * 20) / 2.0
+
BigDecimal moyenneEleve2 =
(note21.valeurNumerique / noteMax * 20 + note22.valeurNumerique / noteMax * 20) / 2.0
+
return [
moyenne: (moyenneEleve1 + moyenneEleve2) / 2.0,
moyenneMin: [moyenneEleve1, moyenneEleve2].min(),
//Dans ce test , on va tester le recalcul de moyennes et la mise à jour de uptodate
//dans le cas ou le service est attaché à une seule enseignement
- TypeIntervalleEnum type = periodeT1_1.typeIntervalle
+ TypeIntervalleEnum type = periodeT1.typeIntervalle
SecuriteSession securiteSessionEnseignant = getSecuriteSession(
PopulationTestActeur.ENSEIGNANT_1)
BigDecimal moyenneClasseT3 = (moyenneT3_E1 + moyenneT3_E2).divide(2, precision, RoundingMode.HALF_UP)
BigDecimal moyenneClasseAnnuel = (moyenneAnnuel_E1 + moyenneAnnuel_E2).divide(2, precision, RoundingMode.HALF_UP)
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
-
+ marqueDirtyMoyenneEleves()
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
-
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
-
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement1)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode2 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT2_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT2, enseignement1)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode3 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT3_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT3, enseignement1)
//Tester le recalcul des moyennes dans ResultatEleveEnseignementPeriode1
moyenneT3_E1, resultatEleveEnseignementPeriode3.moyenne)
//Tester le recalcul de moyenne dans ResultatElevePeriode
- ResultatElevePeriode resultElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
assertEquals("la moyenne dans Resultat-Eleve-Periode T1 n'est pas correct",
moyenneT1_E1, resultElevePeriode1.moyenne)
moyenneAnnuel_E1, resultElevePeriode4.moyenne)
// Tester le recalcul de moyenne dans ResultatEleveServicePeriode
- ResultatEleveServicePeriode resultatEleveServicePeriode1 = getResultatEleveServicePeriode(periodeT1_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode2 = getResultatEleveServicePeriode(periodeT2_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode3 = getResultatEleveServicePeriode(periodeT3_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode4 = getResultatEleveServicePeriode(periode_Annee, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode1 = getResultatEleveServicePeriode(periodeT1, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode2 = getResultatEleveServicePeriode(periodeT2, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode3 = getResultatEleveServicePeriode(periodeT3, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode4 = getResultatEleveServicePeriode(periodeAnnee, service, eleve1)
assertEquals("la moyenne pour le Resultat Eleve-Service-Periode T1 n'est pas correct",
moyenneT1_E1, resultatEleveServicePeriode1.moyenne)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
+ et la période ${periodeT1?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode1?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
+ et la période ${periodeT1?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode1?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
+ et la période ${periodeT2?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode2?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
+ et la période ${periodeT2?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode2?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
+ et la période ${periodeT3?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode3?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
+ et la période ${periodeT3?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode3?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode4?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode4?.nbEleves)
//Tester le recalcul de moyenne et la mise a jour de uptodate dans ResultatClassePeriode
- ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT1_1)
- ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT2_1)
- ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT3_1)
- ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periode_Annee)
+ ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT1)
+ ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT2)
+ ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT3)
+ ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeAnnee)
assertEquals("la moyenne pour le Resultat-Classe-Periode T1 n'est pas correcte",
moyenneClasseT1, resultatClassePeriode1.moyenne)
moyenneClasseAnnuel, resultatClassePeriode4.moyenne)
// Tester le recalcul de moyenne et la mise a jour de uptodate dans ResultatClasseServicePeriode
- ResultatClasseServicePeriode resultatClasseServicePeriode1 = getResultatClasseServicePeriode(periodeT1_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode2 = getResultatClasseServicePeriode(periodeT2_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode3 = getResultatClasseServicePeriode(periodeT3_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode4 = getResultatClasseServicePeriode(periode_Annee, service, classe1enTrimestres)
+ ResultatClasseServicePeriode resultatClasseServicePeriode1 = getResultatClasseServicePeriode(periodeT1, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode2 = getResultatClasseServicePeriode(periodeT2, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode3 = getResultatClasseServicePeriode(periodeT3, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode4 = getResultatClasseServicePeriode(periodeAnnee, service, classe)
assertEquals("la moyenne pour le Resultat Classe-Service-Periode T1 n'est pas correct",
moyenneClasseT1, resultatClasseServicePeriode1.moyenne)
assertEquals("la moyenne pour le Resultat Classe-Service-Periode Annee n'est pas correct",
moyenneClasseAnnuel, resultatClasseServicePeriode4.moyenne)
}
+
+
/**
* Tester la mise à jour des moyennes lorsqu'un service est attaché à deux enseignements
* @author mjao
//dans le cas ou le service est attaché à deux enseignements
//creer deux evaluations attachés à l'enseignement2 pendant la periode T1
- evalT1_1_2 = creeEvaluation([periodeT1_1], enseignement2, dateCreation1, dateEvaluation1)
- evalT1_2_2 = creeEvaluation([periodeT1_1], enseignement2, dateCreation2, dateEvaluation2)
+ evalT1_1_2 = creeEvaluation([periodeT1], enseignement2, dateCreation1, dateEvaluation1)
+ evalT1_2_2 = creeEvaluation([periodeT1], enseignement2, dateCreation2, dateEvaluation2)
//creer deux evaluations attachés à l'enseignement2 pendant la periode T2
- evalT2_1_2 = creeEvaluation([periodeT2_1], enseignement2, dateCreation1, dateEvaluation1)
- evalT2_2_2 = creeEvaluation([periodeT2_1], enseignement2, dateCreation2, dateEvaluation2)
+ evalT2_1_2 = creeEvaluation([periodeT2], enseignement2, dateCreation1, dateEvaluation1)
+ evalT2_2_2 = creeEvaluation([periodeT2], enseignement2, dateCreation2, dateEvaluation2)
//creer deux evaluations attachés à l'enseignement2 pendant la periode T2
- evalT3_1_2 = creeEvaluation([periodeT3_1], enseignement2, dateCreation1, dateEvaluation1)
- evalT3_2_2 = creeEvaluation([periodeT3_1], enseignement2, dateCreation2, dateEvaluation2)
+ evalT3_1_2 = creeEvaluation([periodeT3], enseignement2, dateCreation1, dateEvaluation1)
+ evalT3_2_2 = creeEvaluation([periodeT3], enseignement2, dateCreation2, dateEvaluation2)
//creer les deux notes attachés aux deux evaluations qui correspondent à lenseignement 2 pour la periode T1
noteT1_1_2 = creeNote(eleve1, evalT1_1_2, valeurNote1_1_2)
BigDecimal moyenneClasseT3 = (moyenneT3_E1 + moyenneT3_E2).divide(2, precision, RoundingMode.HALF_UP)
BigDecimal moyenneClasseAnnuel = (moyenneAnnuel_E1 + moyenneAnnuel_E2).divide(2, precision, RoundingMode.HALF_UP)
+ marqueDirtyMoyenneEleves()
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
-
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement2,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement2,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement2,
- null
- )
-
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a testet
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
//Tester les ResultatEleveEnseignementPeriode qui correspondent à l'enseignement 1
//Tester le recalcul des moyennes
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT1_1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement1)
assertEquals("la note qui correspond à l'enseignement 1 pour la periode T1 n'est pas correct",
moyenneEnseignant_1_T1, resultatEleveEnseignementPeriodeT1_1.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT2_1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT2_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT2, enseignement1)
assertEquals("la note qui correspond à l'enseignement 1 pour la periode T2 n'est pas correct",
moyenneEnseignant_1_T2, resultatEleveEnseignementPeriodeT2_1.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT3_1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT3_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT3, enseignement1)
assertEquals("la note qui correspond à l'enseignement 1 pour la periode T3 n'est pas correct",
moyenneEnseignant_1_T3, resultatEleveEnseignementPeriodeT3_1.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeAnnee_1 =
- getResultatEleveEnseignementPeriode(eleve1, periode_Annee, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeAnnee, enseignement1)
assertEquals("la note qui correspond à l'enseignement 1 pour la periode Annee n'est pas correct",
moyenneEnseignant_1_annee, resultatEleveEnseignementPeriodeAnnee_1.moyenne)
//Tester les ResultatEleveEnseignementPeriode qui correspondent à l'enseignement 2
//Tester le recalcul des moyennes
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT1_2 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT1_1, enseignement2)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement2)
assertEquals("la note qui correspond à l'enseignement 2 pour la periode T1 n'est pas correct",
moyenneEnseignant_2_T1, resultatEleveEnseignementPeriodeT1_2.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT2_2 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT2_1, enseignement2)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT2, enseignement2)
assertEquals("la note qui correspond à l'enseignement 2 pour la periode T2 n'est pas correct",
moyenneEnseignant_2_T2, resultatEleveEnseignementPeriodeT2_2.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeT3_2 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT3_1, enseignement2)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT3, enseignement2)
assertEquals("la note qui correspond à l'enseignement 2 pour la periode T3 n'est pas correct",
moyenneEnseignant_2_T3, resultatEleveEnseignementPeriodeT3_2.moyenne)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriodeAnnee_2 =
- getResultatEleveEnseignementPeriode(eleve1, periode_Annee, enseignement2)
+ getResultatEleveEnseignementPeriode(eleve1, periodeAnnee, enseignement2)
assertEquals("la note qui correspond à l'enseignement 2 pour la periode Annee n'est pas correct",
moyenneEnseignant_2_annee, resultatEleveEnseignementPeriodeAnnee_2.moyenne)
//Tester le recalcul de moyenne dans ResultatElevePeriode
- ResultatElevePeriode resultElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
assertEquals("la moyenne dans Resultat-Eleve-Periode T1 n'est pas correct",
moyenneT1_E1, resultElevePeriode1.moyenne)
moyenneAnnuel_E1, resultElevePeriode4.moyenne)
// Tester le recalcul de moyenne dans ResultatEleveServicePeriode
- ResultatEleveServicePeriode resultatEleveServicePeriode1 = getResultatEleveServicePeriode(periodeT1_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode2 = getResultatEleveServicePeriode(periodeT2_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode3 = getResultatEleveServicePeriode(periodeT3_1, service, eleve1)
- ResultatEleveServicePeriode resultatEleveServicePeriode4 = getResultatEleveServicePeriode(periode_Annee, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode1 = getResultatEleveServicePeriode(periodeT1, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode2 = getResultatEleveServicePeriode(periodeT2, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode3 = getResultatEleveServicePeriode(periodeT3, service, eleve1)
+ ResultatEleveServicePeriode resultatEleveServicePeriode4 = getResultatEleveServicePeriode(periodeAnnee, service, eleve1)
assertEquals("la moyenne pour le Resultat Eleve-Service-Periode T1 n'est pas correct",
moyenneT1_E1, resultatEleveServicePeriode1.moyenne)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
+ et la période ${periodeT1?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode1?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
+ et la période ${periodeT1?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode1?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
+ et la période ${periodeT2?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode2?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
+ et la période ${periodeT2?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode2?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
+ et la période ${periodeT3?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode3?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
+ et la période ${periodeT3?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode3?.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
1, resultatEleveServicePeriode4?.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
2, resultatEleveServicePeriode4?.nbEleves)
//Tester le recalcul de moyenne et la mise a jour de uptodate dans ResultatClassePeriode
- ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT1_1)
- ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT2_1)
- ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT3_1)
- ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periode_Annee)
+ ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT1)
+ ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT2)
+ ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT3)
+ ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeAnnee)
assertEquals("la moyenne pour le Resultat-Classe-Periode T1 n'est pas correct",
moyenneClasseT1, resultatClassePeriode1.moyenne)
moyenneClasseAnnuel, resultatClassePeriode4.moyenne)
//Testet le recalcul de moyennes dans resultatClasseServicePeriode1
- ResultatClasseServicePeriode resultatClasseServicePeriode1 = getResultatClasseServicePeriode(periodeT1_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode2 = getResultatClasseServicePeriode(periodeT2_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode3 = getResultatClasseServicePeriode(periodeT3_1, service, classe1enTrimestres)
- ResultatClasseServicePeriode resultatClasseServicePeriode4 = getResultatClasseServicePeriode(periode_Annee, service, classe1enTrimestres)
+ ResultatClasseServicePeriode resultatClasseServicePeriode1 = getResultatClasseServicePeriode(periodeT1, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode2 = getResultatClasseServicePeriode(periodeT2, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode3 = getResultatClasseServicePeriode(periodeT3, service, classe)
+ ResultatClasseServicePeriode resultatClasseServicePeriode4 = getResultatClasseServicePeriode(periodeAnnee, service, classe)
assertEquals("la moyenne pour le Resultat Classe-Service-Periode T1 n'est pas correct",
moyenneClasseT1, resultatClasseServicePeriode1.moyenne)
}
//changer les coefficient de service normal pour chaque periode
- RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1_1, service)
- RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2_1, service)
- RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3_1, service)
+ RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1, service)
+ RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2, service)
+ RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3, service)
rel1.coeff = 2
rel2.coeff = 3
rel3.coeff = 1
PopulationTestActeur.ENSEIGNANT_1)
//creer une evaluation attachés au service optionnel
- evalOPtionnel1 = creeEvaluation([periodeT1_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel2 = creeEvaluation([periodeT2_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel3 = creeEvaluation([periodeT3_1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel1 = creeEvaluation([periodeT1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel2 = creeEvaluation([periodeT2], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel3 = creeEvaluation([periodeT3], enseignement3, dateCreation1, dateEvaluation1)
//les valeurs des notes optionnelles
noteOp_1 = 40
BigDecimal moyenneAnnuel = (moyenneT1 + moyenneT2 + moyenneT3).divide(3, precision, RoundingMode.HALF_UP)
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
-
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement3,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement3,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement3,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
-
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ marqueDirtyMoyenneEleves()
+
+ infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
- ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
assertEquals("la note de l'eleve pour la periode T1 n'est pas correcte",
moyenneT1, resultatElevePeriode1.moyenne)
PopulationTestActeur.ENSEIGNANT_1)
//changer les coefficient de service normal pour chaque periode
- RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1_1, service)
- RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2_1, service)
- RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3_1, service)
+ RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1, service)
+ RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2, service)
+ RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3, service)
rel1.coeff = 2
rel2.coeff = 3
rel3.coeff = 1
}
//creer les evaluations attachés au service optionnel
- evalOPtionnel1 = creeEvaluation([periodeT1_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel2 = creeEvaluation([periodeT2_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel3 = creeEvaluation([periodeT3_1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel1 = creeEvaluation([periodeT1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel2 = creeEvaluation([periodeT2], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel3 = creeEvaluation([periodeT3], enseignement3, dateCreation1, dateEvaluation1)
//chnager les notes optionnelles pour que la moyenne depasse 20
noteOp_1 = 45
BigDecimal moyenneT2 = (noteSN_T2 * 3 + noteSO_T2 * 3).divide(3, precision, RoundingMode.HALF_UP) // moy = 23.20
BigDecimal moyenneT3 = (noteSN_T3 * 1 + noteSO_T3 * 3).divide(1, precision, RoundingMode.HALF_UP) //moy = 23
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
+ marqueDirtyMoyenneEleves()
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement3,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement3,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement3,
- null
- )
-
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
BigDecimal moyenneAnnuel = (moyenneT1 + moyenneT2 + moyenneT3).divide(3, precision, RoundingMode.HALF_UP)//moy =21.67
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
- ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
assertEquals("la note de l'eleve pour la periode T1 doit etre egale à 20",
20, resultatElevePeriode1.moyenne)
PopulationTestActeur.ENSEIGNANT_1)
//changer les coefficient de service normal pour chaque periode
- RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1_1, service)
- RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2_1, service)
- RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3_1, service)
+ RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1, service)
+ RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2, service)
+ RelPeriodeService rel3 = RelPeriodeService.findByPeriodeAndService(periodeT3, service)
rel1.coeff = 2
rel2.coeff = 3
rel3.coeff = 1
}
//creer les evaluations attachés au service optionnel
- evalOPtionnel1 = creeEvaluation([periodeT1_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel2 = creeEvaluation([periodeT2_1], enseignement3, dateCreation1, dateEvaluation1)
- evalOPtionnel3 = creeEvaluation([periodeT3_1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel1 = creeEvaluation([periodeT1], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel2 = creeEvaluation([periodeT2], enseignement3, dateCreation1, dateEvaluation1)
+ evalOPtionnel3 = creeEvaluation([periodeT3], enseignement3, dateCreation1, dateEvaluation1)
//changer les notes optionnelles pour que la moyenne de service optionnelle soit inferieur à 10
noteOp_1 = 20
BigDecimal moyenneT2 = (noteSN_T2 * 3).divide(3, precision, RoundingMode.HALF_UP)
BigDecimal moyenneT3 = (noteSN_T3 * 1).divide(1, precision, RoundingMode.HALF_UP)
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
+ marqueDirtyMoyenneEleves()
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
-
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
- ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultatElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultatElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultatElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
assertEquals("la note de l'eleve pour la periode T1 n'est pas correcte",
moyenneT1, resultatElevePeriode1.moyenne)
assertEquals("la note de l'eleve pour la periode T3 n'est pas correcte",
moyenneT3, resultatElevePeriode3.moyenne)
-
-
}
/**
serviceParent.addToSousServices(sousServiceAnnee2)
//Evaluation attaché à l'enseignement 4 ,sousService1 ,periode T1
- eval_SS1_1 = creeEvaluation([periodeT1_1], enseignement4, dateCreation1, dateEvaluation1)
+ eval_SS1_1 = creeEvaluation([periodeT1], enseignement4, dateCreation1, dateEvaluation1)
eval_SS1_1.modaliteMatiere = modaliteMatiere1
- eval_SS1_1.save()
+ eval_SS1_1.save(failOnError: true)
//Evaluation attaché à l'enseignement 4 ,sousService2 ,periode T1
- eval_SS2_1 = creeEvaluation([periodeT1_1], enseignement4, dateCreation2, dateEvaluation2)
+ eval_SS2_1 = creeEvaluation([periodeT1], enseignement4, dateCreation2, dateEvaluation2)
eval_SS2_1.modaliteMatiere = modaliteMatiere2
- eval_SS2_1.save()
+ eval_SS2_1.save(failOnError: true)
//Evaluation attaché à l'enseignement 4 ,sousService1 ,periode T1
- eval_SS1_2 = creeEvaluation([periodeT2_1], enseignement4, dateCreation1, dateEvaluation1)
+ eval_SS1_2 = creeEvaluation([periodeT2], enseignement4, dateCreation1, dateEvaluation1)
eval_SS1_2.modaliteMatiere = modaliteMatiere1
- eval_SS1_2.save()
+ eval_SS1_2.save(failOnError: true)
//Evaluation attaché à l'enseignement 4 ,sousService2 ,periode T1
- eval_SS2_2 = creeEvaluation([periodeT2_1], enseignement4, dateCreation2, dateEvaluation2)
+ eval_SS2_2 = creeEvaluation([periodeT2], enseignement4, dateCreation2, dateEvaluation2)
eval_SS2_2.modaliteMatiere = modaliteMatiere2
- eval_SS2_2.save()
+ eval_SS2_2.save(failOnError: true)
//Evaluation attaché à l'enseignement 4 ,sousService1 ,periode T3
- eval_SS1_3 = creeEvaluation([periodeT3_1], enseignement4, dateCreation1, dateEvaluation1)
+ eval_SS1_3 = creeEvaluation([periodeT3], enseignement4, dateCreation1, dateEvaluation1)
eval_SS1_3.modaliteMatiere = modaliteMatiere1
- eval_SS1_3.save()
+ eval_SS1_3.save(failOnError: true)
//Evaluation attaché à l'enseignement 4 ,sousService2 ,periode T3
- eval_SS2_3 = creeEvaluation([periodeT3_1], enseignement4, dateCreation2, dateEvaluation2)
+ eval_SS2_3 = creeEvaluation([periodeT3], enseignement4, dateCreation2, dateEvaluation2)
eval_SS2_3.modaliteMatiere = modaliteMatiere2
- eval_SS2_3.save()
+ eval_SS2_3.save(failOnError: true)
//créer les notes des sous services attachés au serviceParent et eleve 1
note_SS1_T1_E1 = creeNote(eleve1, eval_SS1_1, valeurNoteSS1_T1_E1)
BigDecimal moyenne_classe_T3 = (moyenne_T3_E1 + moyenne_T3_E2).divide(2, precision, RoundingMode.HALF_UP)
BigDecimal moyenne_classe_Annuel = (moyenne_Annuel_E1 + moyenne_Annuel_E2).divide(2, precision, RoundingMode.HALF_UP)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
- List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
- List<SousService> sousServices1 = [sousServiceT1_1, sousServiceT1_2]
- List<SousService> sousServices2 = [sousServiceT2_1, sousServiceT2_2]
- List<SousService> sousServices3 = [sousServiceT3_1, sousServiceT3_2]
-
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement1,
- null
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement1,
- null
- )
- List<ModaliteMatiere> listModalites = sousServices1.collect { it.modaliteMatiere }
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT1_1,
- enseignement4,
- sousServices1.collect { it.modaliteMatiere }
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT2_1,
- enseignement4,
- sousServices2.collect { it.modaliteMatiere }
- )
- uptodateService.marqueDirtyEleves(securiteSessionEnseignant,
- eleves,
- periodeT3_1,
- enseignement4,
- sousServices3.collect { it.modaliteMatiere }
- )
+ marqueDirtyMoyenneEleves()
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
-
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
//***Les resultatsEleveServiceParentPeriode pour l'eleve 1
// Recuperer le resultatEleveServicePeriode pour la periode T1 ,eleve1 et serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode1 =
- getResultatEleveServicePeriode(periodeT1_1, serviceParent, eleve1)
+ getResultatEleveServicePeriode(periodeT1, serviceParent, eleve1)
// Recuperer le resultatEleveServicePeriode pour la periode T2, eleve1 et serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode2 =
- getResultatEleveServicePeriode(periodeT2_1, serviceParent, eleve1)
+ getResultatEleveServicePeriode(periodeT2, serviceParent, eleve1)
// Recuperer le resultatEleveServicePeriode pour la periode T3, eleve1 et serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode3 =
- getResultatEleveServicePeriode(periodeT3_1, serviceParent, eleve1)
+ getResultatEleveServicePeriode(periodeT3, serviceParent, eleve1)
// Recuperer le resultatEleveServicePeriode pour la periode Annee, eleve1 et serviceParent
ResultatEleveServicePeriode resultatEleveServiceParentPeriode4 =
- getResultatEleveServicePeriode(periode_Annee, serviceParent, eleve1)
+ getResultatEleveServicePeriode(periodeAnnee, serviceParent, eleve1)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
- 1, resultatEleveServiceParentPeriode1?.rang)
+ et la période ${periodeT1?.typePeriode?.libelle}""",
+ 1, resultatEleveServiceParentPeriode1.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT1_1?.typePeriode?.libelle}""",
- 2, resultatEleveServiceParentPeriode1?.nbEleves)
+ et la période ${periodeT1?.typePeriode?.libelle}""",
+ 2, resultatEleveServiceParentPeriode1.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
- 2, resultatEleveServiceParentPeriode2?.rang)
+ et la période ${periodeT2?.typePeriode?.libelle}""",
+ 2, resultatEleveServiceParentPeriode2.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT2_1?.typePeriode?.libelle}""",
- 2, resultatEleveServiceParentPeriode2?.nbEleves)
+ et la période ${periodeT2?.typePeriode?.libelle}""",
+ 2, resultatEleveServiceParentPeriode2.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
- 1, resultatEleveServiceParentPeriode3?.rang)
+ et la période ${periodeT3?.typePeriode?.libelle}""",
+ 1, resultatEleveServiceParentPeriode3.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periodeT3_1?.typePeriode?.libelle}""",
- 2, resultatEleveServiceParentPeriode3?.nbEleves)
+ et la période ${periodeT3?.typePeriode?.libelle}""",
+ 2, resultatEleveServiceParentPeriode3.nbEleves)
assertEquals("""le rang de l'élève d'id ${eleve1?.id} n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
- 2, resultatEleveServiceParentPeriode4?.rang)
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
+ 2, resultatEleveServiceParentPeriode4.rang)
assertEquals("""le nombre d'élèves n'est pas correct
pour le service ${service?.matiere?.libelleLong}
- et la période ${periode_Annee?.typePeriode?.libelle}""",
+ et la période ${periodeAnnee?.typePeriode?.libelle}""",
2, resultatEleveServiceParentPeriode4?.nbEleves)
moyenne_SP_T3_E1, resultatEleveServiceParentPeriode3.moyenne)
//recuperer les resultatsEleveServiceParentPeriode pour l'eleve1 et pour chaque periode (T1,T2,T3 ,Annee)
- ResultatElevePeriode resultElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1_1)
- ResultatElevePeriode resultElevePeriode111 = ResultatElevePeriode.findByEleveAndPeriode(eleve2.autorite, periodeT1_1)
- ResultatElevePeriode resultElevePeriode2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2_1)
- ResultatElevePeriode resultElevePeriode3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3_1)
- ResultatElevePeriode resultElevePeriode4 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periode_Annee)
+ ResultatElevePeriode resultatEleve1T1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
+ ResultatElevePeriode resultatEleve1T2 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT2)
+ ResultatElevePeriode resultatEleve1T3 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT3)
+ ResultatElevePeriode resultatEleve1Annee = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeAnnee)
+
+ assertEquals(
+ "Le rang général de l'élève 1 n'est pas correcte pour la période T1",
+ 1,
+ resultatEleve1T1.rang)
+
+ assertEquals(
+ "Le rang général de l'élève 1 n'est pas correcte pour la période T2",
+ 2,
+ resultatEleve1T2.rang)
+
+ assertEquals(
+ "Le rang général de l'élève 1 n'est pas correcte pour la période T3",
+ 1,
+ resultatEleve1T3.rang)
+
+ assertEquals(
+ "Le rang général de l'élève 1 n'est pas correcte pour l'annnée",
+ 1,
+ resultatEleve1Annee.rang)
+
//tester le calcul des moyennes dans les resultatsElevePeriode pour chaque periode (T1,T2,T3,Annee)
assertEquals("la moyenne de l'eleve1 pour la periode T1 n'est pas correcte",
- moyenne_T1_E1, resultElevePeriode1.moyenne)
+ moyenne_T1_E1, resultatEleve1T1.moyenne)
assertEquals("la note de l'eleve1 pour la periode T2 n'est pas correcte",
- moyenne_T2_E1, resultElevePeriode2.moyenne)
+ moyenne_T2_E1, resultatEleve1T2.moyenne)
assertEquals("la note de l'eleve1 pour la periode T3 n'est pas correcte",
- moyenne_T3_E1, resultElevePeriode3.moyenne)
+ moyenne_T3_E1, resultatEleve1T3.moyenne)
assertEquals("la note de l'eleve1 pour la periode Annee n'est pas correcte",
- moyenne_Annuel_E1, resultElevePeriode4.moyenne)
+ moyenne_Annuel_E1, resultatEleve1Annee.moyenne)
//Recuperer les ResultatsClasseSousServicePeriode
//Recuperer les ResultatsClassePeriode
//Tester le recalcul de moyenne et la mise a jour de uptodate dans ResultatClassePeriode
- ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT1_1)
- ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT2_1)
- ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT3_1)
- ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periode_Annee)
+ ResultatClassePeriode resultatClassePeriode1 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT1)
+ ResultatClassePeriode resultatClassePeriode2 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT2)
+ ResultatClassePeriode resultatClassePeriode3 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeT3)
+ ResultatClassePeriode resultatClassePeriode4 = ResultatClassePeriode.findByClasseAndPeriode(classe, periodeAnnee)
assertEquals("la moyenne dans le Resultat-Classe-Periode T1 n'est pas correcte",
moyenne_classe_T1, resultatClassePeriode1.moyenne)
//Recuperer les ResultatsClasseServicePeriode pour le ServiceParent et pour chaque periode
ResultatClasseServicePeriode resultatClasseServiceParentPeriode1 =
- getResultatClasseServicePeriode(periodeT1_1, serviceParent, classe1enTrimestres)
+ getResultatClasseServicePeriode(periodeT1, serviceParent, classe)
//Recuperer les ResultatsClasseServicePeriode pour le ServiceParent et pour chaque periode
ResultatClasseServicePeriode resultatClasseServiceParentPeriode2 =
- getResultatClasseServicePeriode(periodeT2_1, serviceParent, classe1enTrimestres)
+ getResultatClasseServicePeriode(periodeT2, serviceParent, classe)
//Recuperer les ResultatsClasseServicePeriode pour le ServiceParent et pour chaque periode
ResultatClasseServicePeriode resultatClasseServiceParentPeriode3 =
- getResultatClasseServicePeriode(periodeT3_1, serviceParent, classe1enTrimestres)
+ getResultatClasseServicePeriode(periodeT3, serviceParent, classe)
//Tester le calcul de moyennes dans les resultatsClasseServiceParentPeriode
assertEquals("la moyenne dans le Resultat-Classe-ServiceParent-Periode T1 n'est pas correcte",
InfoCalculMoyennesClasse infoCalculMoyennesClasse =
new InfoCalculMoyennesClasse(
- classe: classe1enTrimestres,
+ classe: classe,
calculEnCours: false,
dateDebutCalcul: new Date(111, 1, 10)
)
- infoCalculMoyennesClasse.save()
+ infoCalculMoyennesClasse.save(failOnError: true)
DirtyMoyenne DirtyMoyenne_EL1 =
- new DirtyMoyenne(eleve1.autorite, enseignement1, periodeT1_1)
+ new DirtyMoyenne(eleve1.autorite, enseignement1, periodeT1)
DirtyMoyenne_EL1.dateChangement = new Date(110, 2, 1)
- DirtyMoyenne_EL1.save()
+ DirtyMoyenne_EL1.save(failOnError: true)
DirtyMoyenne DirtyMoyenne_EL2 =
- new DirtyMoyenne(eleve2.autorite, enseignement1, periodeT1_1)
+ new DirtyMoyenne(eleve2.autorite, enseignement1, periodeT1)
DirtyMoyenne_EL2.dateChangement = new Date(112, 2, 1)
- DirtyMoyenne_EL2.save()
+ DirtyMoyenne_EL2.save(failOnError: true)
// Récupère et supprime (si existe) les résultats afin de vérifier
// s'ils seront recréés lors de calcul des moyennes
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement1)
if (resultatEleveEnseignementPeriode1) {
resultatEleveEnseignementPeriode1.delete(flush: true)
}
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode2 =
- getResultatEleveEnseignementPeriode(eleve2, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve2, periodeT1, enseignement1)
if (resultatEleveEnseignementPeriode2) {
resultatEleveEnseignementPeriode1.delete(flush: true)
}
- infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
+ infoCalculMoyennesClasseService.creeVerrou(classe)
// Appeller la methode majMoyenne pour tester quelle sont les moyennes qui sont recalculés
moyenneService.majMoyennes(
securiteSessionEnseignant,
- classe1enTrimestres,
+ classe,
infoCalculMoyennesClasse.dateDebutCalcul)
resultatEleveEnseignementPeriode1 =
- getResultatEleveEnseignementPeriode(eleve1, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement1)
resultatEleveEnseignementPeriode2 =
- getResultatEleveEnseignementPeriode(eleve2, periodeT1_1, enseignement1)
+ getResultatEleveEnseignementPeriode(eleve2, periodeT1, enseignement1)
//verifier que le resultatEleveEnseignementPeriode1 est nulle
assertNull("Le resultatEleveEnseignementPeriode1 n'est pas null",
}
/**
- * Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
- * @return evaluation
+ * Crée une evaluation attachée a une periode
* @author mjao
*/
private Evaluation creeEvaluation(List<Periode> periodes,
Enseignement enseignement,
Date dateCreation,
Date dateEvaluation) {
+
Evaluation evaluation = new Evaluation(
enseignement: enseignement,
dateCreation: dateCreation,
enseignement.service.structureEnseignement.etablissement),
ramenerSur20: true
)
- evaluation.save(flush: true)
- if (evaluation.hasErrors()) {
- println(evaluation.errors)
- }
- return evaluation
+ evaluation.save(flush: true, failOnError: true)
+
+ return evaluation
}
- /**
- * Crée une note
- * @param eleve
- * @param evaluation qui correspond à l'eleve
- * @param valeur : la valeur numerique de note
- * @author mjao
- */
+
+
private Note creeNote(Personne eleve,
Evaluation evaluation,
BigDecimal valeur) {
evaluation: evaluation,
valeurNumerique: valeur
)
- note.save(flush: true)
- if (note.hasErrors()) {
- println(note.errors)
- }
+
+ note.save(flush: true, failOnError: true)
+
return note
}
- /**
- * creer un ResultatEleveEnseignementPeriode
- * @param periode
- * @param eleve
- * @param enseignement
- * @author mjao
- */
- private ResultatEleveEnseignementPeriode creeResultatEleveEnseignementPeriode(
- Autorite eleve,
- Periode periode,
- Enseignement enseignement) {
- ResultatEleveEnseignementPeriode resultat = new ResultatEleveEnseignementPeriode(
- periode: periode,
- eleve: eleve,
- enseignement: enseignement,
- uptodate: false
- )
- resultat.save(flush: true)
- return resultat
+ private ResultatEleveServicePeriode getResultatEleveServicePeriode(Periode periode,
+ Service service,
+ Personne eleve) {
+ ResultatEleveServicePeriode resultatEleveServicePeriode =
+ ResultatEleveServicePeriode.createCriteria().get {
+ eq('eleve', eleve.autorite)
+ eq('periode', periode)
+ eq('service', service)
+ }
+ return resultatEleveServicePeriode
}
- /**
- * crée un ResultatEleveServicePeriode
- * @param periode
- * @param service
- * @param eleve
- * @author mjao
- */
- private ResultatEleveServicePeriode creeResultatEleveServicePeriode(
- Periode periode,
- Service service,
- Autorite eleve) {
- ResultatEleveServicePeriode resultat = new ResultatEleveServicePeriode(
- periode: periode,
- service: service,
- eleve: eleve,
- uptodate: false
- )
- resultat.save(flush: true)
+ private ResultatEleveEnseignementPeriode getResultatEleveEnseignementPeriode(Personne eleve,
+ Periode periode,
+ Enseignement enseignement) {
- return resultat
- }
- /**
- * crée un ResultatEleveServicePeriode
- * @param periode
- * @param service
- * @param eleve
- * @author mjao
- */
- private ResultatEleveServicePeriode getResultatEleveServicePeriode(
- Periode periode,
- Service service,
- Personne eleve) {
- def criteria = ResultatEleveServicePeriode.createCriteria()
- ResultatEleveServicePeriode resultatEleveServicePeriode = criteria.get {
- and {
- eq('eleve', eleve.autorite)
- eq('periode', periode)
- eq('service', service)
- }
- }
- return resultatEleveServicePeriode
- }
- /**
- * get un ResultatEleveEnseignementPeriode
- * @param periode
- * @param eleve
- * @param enseignement
- * @author mjao
- */
- private ResultatEleveEnseignementPeriode getResultatEleveEnseignementPeriode(
- Personne eleve,
- Periode periode,
- Enseignement enseignement) {
- def criteria = ResultatEleveEnseignementPeriode.createCriteria()
- ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode = criteria.get {
- and {
- eq('eleve', eleve.autorite)
- eq('periode', periode)
- eq('enseignement', enseignement)
- }
+ ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode =
+ ResultatEleveEnseignementPeriode.createCriteria().get {
+ eq('eleve', eleve.autorite)
+ eq('periode', periode)
+ eq('enseignement', enseignement)
}
+
return resultatEleveEnseignementPeriode
}
- /**
- * crée un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
- * @author mjao
- */
- private ResultatClasseServicePeriode creeResultatClasseServicePeriode(
- Periode periode,
- Service service,
- StructureEnseignement classe) {
- ResultatClasseServicePeriode resultat = new ResultatClasseServicePeriode(
- periode: periode,
- service: service,
- classe: classe,
- uptodate: false
- )
- resultat.save(flush: true)
- return resultat
- }
- /**
- * get un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
- * @author mjao
- */
- private ResultatClasseServicePeriode getResultatClasseServicePeriode(
- Periode periode,
- Service service,
- StructureEnseignement classe) {
- def criteria = ResultatClasseServicePeriode.createCriteria()
- ResultatClasseServicePeriode resultatClasseServicePeriode = criteria.get {
- and {
+
+
+ private ResultatClasseServicePeriode getResultatClasseServicePeriode(Periode periode,
+ Service service,
+ StructureEnseignement classe) {
+
+ ResultatClasseServicePeriode resultatClasseServicePeriode =
+ ResultatClasseServicePeriode.createCriteria().get {
eq('classe', classe)
eq('periode', periode)
eq('service', service)
- }
}
+
+ return resultatClasseServicePeriode
}
- /* crée un ResultatClassPeriode
- * @param periode
- * @param service
- *@param classe
- * @author mjao
- */
-
- private ResultatEnseignementPeriode getResultatEnseignementPeriode(
- Periode periode,
- Enseignement enseignement) {
- def criteria = ResultatEnseignementPeriode.createCriteria()
- ResultatEnseignementPeriode resultat = criteria.get {
- and {
- eq('periode', periode)
- eq('enseignement', enseignement)
- }
+
+ private ResultatEnseignementPeriode getResultatEnseignementPeriode(Periode periode,
+ Enseignement enseignement) {
+
+ ResultatEnseignementPeriode resultat = ResultatEnseignementPeriode.createCriteria().get {
+ eq('periode', periode)
+ eq('enseignement', enseignement)
}
- return resultat
- }
- private ResultatElevePeriode creeResultatElevePeriode(
- Periode periode,
- Autorite eleve) {
- ResultatElevePeriode resultat = new ResultatElevePeriode(
- periode: periode,
- eleve: eleve,
- uptodate: false
- )
- resultat.save(flush: true)
return resultat
}
- /* crée un ResultatClassPeriode
- * @param periode
- * @param service
- *@param classe
- * @author mjao
- */
- private ResultatClassePeriode creeResultatClassePeriode(
- Periode periode,
- StructureEnseignement classe) {
- ResultatClassePeriode resultat = new ResultatClassePeriode(
- periode: periode,
- classe: classe,
- uptodate: false
- )
- resultat.save(flush: true)
- return resultat
- }
- /**
- * Crée un sous-service
- * @return regroupment une structure d'enseignement
- * @author mjao
- */
private SousService creeSousService(Service service,
ModaliteMatiere modaliteMatiere,
BigDecimal coeff,
evaluable: true
)
- sousService.save(flush: true)
-
- if (sousService.hasErrors()) {
- println(sousService.errors)
- }
+ sousService.save(flush: true, failOnError: true)
return sousService
-
}
- /**
- * 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)
- }
+ modaliteMatiere.save(flush: true, failOnError: true)
return modaliteMatiere
}
- /**
- * Creation d'une resultatEleveSousServicePeriode
- * @param result le resultatEleveServicePeriode(resultatParent)
- * @param sousService le sousService
- * @author mjao
- */
- private ResultatEleveSousServicePeriode creeResultatEleveSousServicePeriode(
- ResultatEleveServicePeriode result,
- SousService sousService) {
- ResultatEleveSousServicePeriode resultat = new ResultatEleveSousServicePeriode(
- resultatEleveServicePeriode: result,
- sousService: sousService
- )
- resultat.save()
-
- if (resultat.hasErrors()) {
- println(resultat.errors)
- }
-
- return resultat
- }
-
- /**
- * get resultatEleveSousServicePeriode
- * @param result le resultatEleveServicePeriode(resultatParent)
- * @param sousService le sousService
- * @author mjao
- */
- private ResultatEleveSousServicePeriode getResultatEleveSousServicePeriode(
- ResultatEleveServicePeriode result,
- SousService sousService) {
+ private ResultatEleveSousServicePeriode getResultatEleveSousServicePeriode(ResultatEleveServicePeriode result,
+ SousService sousService) {
ResultatEleveSousServicePeriode resultat = ResultatEleveSousServicePeriode.
- findBySousServiceAndResultatEleveServicePeriode(
- sousService,
- result)
+ findBySousServiceAndResultatEleveServicePeriode(sousService, result)
return resultat
}
- /**
- * Creation d'une resultatClasseSousServicePeriode
- * @param result le resultatEleveServicePeriode(resultatParent)
- * @param sousService le sousService
- * @author mjao
- */
- private ResultatClasseSousServicePeriode creeResultatClasseSousServicePeriode(
- ResultatClasseServicePeriode result,
- SousService sousService) {
-
- ResultatClasseSousServicePeriode resultat =
- new ResultatClasseSousServicePeriode(
- resultatClasseServicePeriode: result,
- sousService: sousService
- )
- resultat.save()
- if (resultat.hasErrors()) {
- println(resultat.errors)
- }
-
- return resultat
- }
-
- /**
- * get resultatClasseSousServicePeriode
- * @param result le resultatEleveServicePeriode(resultatParent)
- * @param sousService le sousService
- * @author mjao
- */
- private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(
- ResultatClasseServicePeriode result,
- SousService sousService) {
+ private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(ResultatClasseServicePeriode result,
+ SousService sousService) {
ResultatClasseSousServicePeriode resultat =
ResultatClasseSousServicePeriode.findBySousServiceAndResultatClasseServicePeriode(
type: Autorite.TYPE_ACTEUR,
idExterne: idExterne
)
- autorite.save()
- if (autorite.hasErrors()) {
- println(autorite.errors)
- }
+ autorite.save(failOnError: true)
Personne personne = new Personne(
nom: "Michal",
autorite: autorite,
etablissementRattachement: etablissement1
)
- personne.save()
- if (personne.hasErrors()) {
- println(personne.errors)
- }
- return personne
- }
+ personne.save(failOnError: true)
- /**
- * Crée une ProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private ProprietesScolarite creeProprietesScolarite() {
+ return personne
+ }
- 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
- }
+ void marqueDirtyMoyenneEleves() {
- /**
- * Crée une PersonneProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private PersonneProprietesScolarite creePersonneProprietesScolarite(
- Personne personne,
- ProprietesScolarite proprietesScolarite
- ) {
+ SecuriteSession securiteSessionEnseignant = getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1)
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
+ List<Autorite> eleves = [eleve1.autorite, eleve2.autorite]
- personne: personne,
- proprietesScolarite: creeProprietesScolarite(),
- estActive: true
+ classe.periodes.each {Periode periode ->
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement1,
+ null
+ )
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement2,
+ null
)
- personneProprietesScolarite.save()
- return personneProprietesScolarite
- }
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement3,
+ null
+ )
+ uptodateService.marqueDirtyEleves(
+ securiteSessionEnseignant,
+ eleves,
+ periode,
+ enseignement4,
+ [modaliteMatiere1, modaliteMatiere2]
+ )
+ }
+ }
}
PopulationTestClasse.CLASSE_1
)
structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
- classe1enTrimestres.save()
+ classe1enTrimestres.save(failOnError: true)
//recuperer un enseignant1
enseignant1 = localInitDonneesCommunesTestService.
type: Autorite.TYPE_ACTEUR,
idExterne: idExterne
)
- autorite.save()
+ autorite.save(failOnError: true)
if (autorite.hasErrors()) {
println(autorite.errors)
autorite: autorite,
etablissementRattachement: etablissement1
)
- personne.save()
+ personne.save(failOnError: true)
if (personne.hasErrors()) {
println(personne.errors)
}
fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
etablissement: etablissement1
)
- proprietesScolarite.save()
+ proprietesScolarite.save(failOnError: true)
if (proprietesScolarite.hasErrors()) {
println(proprietesScolarite.errors)
estActive: true
)
- personneProprietesScolarite.save()
+ personneProprietesScolarite.save(failOnError: true)
return personneProprietesScolarite
}
--- /dev/null
+package org.lilie.services.eliot.notes
+
+import grails.plugin.spock.UnitSpec
+import org.lilie.services.eliot.notes.resultat.CalculationService
+
+/**
+ * @author bper
+ */
+class CalculationServiceSpec extends UnitSpec {
+
+ CalculationService calculationService
+
+ def setup() {
+ calculationService = new CalculationService()
+ }
+
+ def 'calculeRangs'() {
+
+ expect:
+ calculationService.calculeRangs(valeurs, precision) == resultat
+
+ where:
+ valeurs | precision | resultat
+ [1.0, 2.0, 3.0, 4.0, 5.0] | 1 | [5.0: 1, 4.0: 2, 3.0: 3, 2.0: 4, 1.0: 5]
+ [2.0, 4.0, 3.0, 1.0, 5.0] | 1 | [5.0: 1, 4.0: 2, 3.0: 3, 2.0: 4, 1.0: 5]
+ [2.5, 4.2, 3.7, 1.9, 5.9] | 1 | [5.9: 1, 4.2: 2, 3.7: 2, 2.5: 4, 1.9: 5]
+ [2.5, 4.2, 3.7, 1.9, 5.9] | 0.1 | [5.9: 1, 4.2: 2, 3.7: 3, 2.5: 4, 1.9: 5]
+ [2.5, 4.2, 3.7, 1.9, 5.9] | 10 | [5.9: 1, 4.2: 2, 3.7: 2, 2.5: 2, 1.9: 2]
+ }
+}
this.moyenneClasseView.observeTblNotesView(this.tblNotesView);
this.moyenneClasseView.observeTblNotesHeaderView(this.tblNotesHeaderView);
+ this.moyenneClasseView.observeTblNotesController(this.tblNotesController);
this.tblNotesView.observeMoyenneClasseView(this.moyenneClasseView);
this.tblNotesView.observeTblNotesHeaderView(this.tblNotesHeaderView);
this.tblNotesHeaderView.observeTblNotesView(this.tblNotesView);
actionAnnulerModifNotes: 'actionAnnulerModifNotes',
actionChangeAppreciation: 'actionChangeAppreciation',
actionScrollBar: 'actionScrollBar',
+ actionColumnHidden: 'actionColumnHidden',
actionOuvrirConseilDeClasse: 'actionOuvrirConseilDeClasse',
actionOuvrirAppreciationClasse: 'actionOuvrirAppreciationClasse',
actionOuvrirGraphWindow: 'actionOuvrirGraphWindow',
- eleveChange: 'eleveChange'
+ eleveChange: 'eleveChange',
+ afficheMoyennesPrecedentes: 'afficheMoyennesPrecedentes',
+ afficheRang: 'afficheRang'
},
composantId:{
attention: undefined,
saisieSyntheseAlert: undefined,
confirmationQuitterSaisieSynthese: undefined,
- tblNotesGraphEchou: undefined
+ tblNotesGraphEchou: undefined,
+ enregistrePreferenceUtilisateurEchec: undefined
},
url:{
urlAppreciationClasse: undefined,
urlGraphTblNotes: undefined,
urlHeartBeat: undefined,
- getSyntheseCsv: undefined
+ getSyntheseCsv: undefined,
+ enregistrePreferenceUtilisateur: undefined
},
libelle: {
imprimer : undefined,
fermer: undefined,
- afficherLesPeriodesPrecedents: undefined
+ afficherLesPeriodesPrecedents: undefined,
+
+ affichage: undefined,
+ moyennesPrecedentes: undefined,
+ rang: undefined
},
icon: {
moyennesAjour: undefined,
messageMoyennesNonAJour: undefined,
- verrouille: undefined
+ verrouille: undefined,
+
+ affichage: {
+ moyennesPrecedentes: undefined,
+ rangs: undefined
+ },
+
+ periodesPrecedentes: []
}
};
\ No newline at end of file
dataIndex: column.dataIndex,
width: column.width,
align: column.align,
- locked: column.locked
+ locked: column.locked,
+ hidden: column.hidden
};
if (column.colonneDeNotes === true) {
);
},
+ observeTblNotesController : function(view) {
+ view.addListener(
+ this.Constantes.eventId.actionColumnHidden,
+ function(index, hidden) {
+ this.hideColumn(index, hidden);
+ },
+ this
+ );
+ },
+
/**
* Met à jours la position du scroll
* @param scrollLeft Position du scroll horizontal
setScrollBarPosition : function(scrollLeft) {
var scroller = this.moyenneClasseGrid.getView().scroller;
scroller.dom.scrollLeft = scrollLeft;
+ },
+
+ hideColumn: function(index, hidden) {
+ this.moyenneClasseGrid.getColumnModel().setHidden(index, hidden);
}
});
\ No newline at end of file
* @param periodesPrecedentesExistent
* @param periodes
*/
- this.Constantes.eventId.actionOuvrirGraphWindow
+ this.Constantes.eventId.actionOuvrirGraphWindow,
+
+ /**
+ * Demande de masquer / afficher des colonnes
+ * @event
+ * @param index index de la colonne
+ * @param hidden indique si la colonne est masquée
+ */
+ this.Constantes.eventId.actionColumnHidden
);
{name: 'id', type: 'int'},
{name: 'personneId', type: 'int'},
{name: 'moyenne', type: 'string'},
+ {name: 'rang', type: 'string'},
{name: 'appreciationGenerale', type: 'string'},
{name: 'colonnesGrisees'},
{name: 'actif'}
];
+ for (var i = 0; i < this.ConfigServeur.data.periodesPrecedentes.length; i++) {
+ var periode = this.ConfigServeur.data.periodesPrecedentes[i];
+
+ fieldLigneDeNotes.push({
+ name: 'moyennePeriodePrecedente' + periode.id,
+ type: 'string'
+ });
+ }
+
var nbService = storeService.getCount();
var serviceData = storeService.data;
*/
observeTblNotesView: function(tblNotesView) {
+ this.columnsDescription = tblNotesView.columnsDescription;
this.tblNotesView = tblNotesView;
tblNotesView.addListener(
},
this);
+ toolbarView.addListener(
+ this.Constantes.eventId.afficheMoyennesPrecedentes,
+ function(checked) {
+ this.afficheMoyennesPrecedentes(checked);
+ },
+ this);
+
+ toolbarView.addListener(
+ this.Constantes.eventId.afficheRang,
+ function(checked) {
+ this.afficheRang(checked);
+ },
+ this);
+
},
activeBoutonExport : function() {
this.ConfigServeur.messages.tblNotesGraphEchou
);
},
+ scope : this
+ });
+ },
+
+ hideColumn: function(index, hidden) {
+ this.fireEvent(this.Constantes.eventId.actionColumnHidden, index, hidden);
+ },
+
+ afficheMoyennesPrecedentes: function(checked) {
+
+ eliot.notes.Messages.resetMessages();
+
+ for (var i = 0; i < this.columnsDescription.periodePrecedenteIndexes.length; i++) {
+ var periodePrecedenteIndex = this.columnsDescription.periodePrecedenteIndexes[i];
+ this.hideColumn(periodePrecedenteIndex, !checked);
+ }
+
+ Ext.Ajax.request({
+
+ url : this.ConfigServeur.url.enregistrePreferenceUtilisateur,
+
+ params : {
+ moyennesPrecedentes: checked
+ },
+
+ success : function(response, request) {
+
+ },
+
+ failure : function() {
+ eliot.notes.Messages.showErreur(
+ this.ConfigServeur.messages.enregistrePreferenceUtilisateurEchec);
+ },
+
+ scope : this
+ });
+ },
+
+ afficheRang: function(checked) {
+
+ eliot.notes.Messages.resetMessages();
+
+ if (this.columnsDescription.rangIndex != null) {
+ this.hideColumn(this.columnsDescription.rangIndex, !checked);
+ }
+
+ Ext.Ajax.request({
+
+ url : this.ConfigServeur.url.enregistrePreferenceUtilisateur,
+
+ params : {
+ rangs: checked
+ },
+
+ success : function(response, request) {
+
+ },
+
+ failure : function() {
+ eliot.notes.Messages.showErreur(
+ this.ConfigServeur.messages.enregistrePreferenceUtilisateurEchec);
+ },
+
scope : this
});
}
+
});
}
}
+ columnHeaderCol = {
+ header: '',
+ width: 0,
+ childCols: []
+ };
+ columnHeaderCols.push(columnHeaderCol);
+
+ // Périodes précédentes
+ for (var i = 0; i < this.ConfigServeur.data.periodesPrecedentes.length; i++) {
+ var periode = this.ConfigServeur.data.periodesPrecedentes[i];
+
+ column = {
+ colonneDeNotes: true,
+ colonnePeriodePrecedente: true,
+ header: periode.libelle,
+ dataIndex: 'moyennePeriodePrecedente' + periode.id,
+ width: 60,
+ sortable: false,
+ align:'center',
+ hidden: !this.ConfigServeur.data.affichage.moyennesPrecedentes,
+ renderer: eliot.notes.commun.Utils.getNoteRenderer({
+ bold: false,
+ annotationRenderer: this.annotationRenderer.createDelegate(this)
+ })
+ };
+
+ columnsTblNotes.push(column);
+ columnHeaderCol.childCols.push(column);
+ columnHeaderCol.width += column.width;
+ }
+
// Moyenne
column = {
colonneDeNotes: true,
})
};
columnsTblNotes.push(column);
- columnHeaderCol = {
- header: '',
- width: column.width,
- childCols: [column]
+ columnHeaderCol.childCols.push(column);
+ columnHeaderCol.width += column.width;
+
+
+ // Rang
+ column = {
+ colonneRang: true,
+ header: this.ConfigServeur.libelle.rang,
+ dataIndex: 'rang',
+ width: 60,
+ sortable: false,
+ align:'center',
+ hidden: !this.ConfigServeur.data.affichage.rangs
};
- columnHeaderCols.push(columnHeaderCol);
+ columnsTblNotes.push(column);
+ columnHeaderCol.childCols.push(column);
+ columnHeaderCol.width += column.width;
// Appréciations
column = {
columnHeaderCol.width = columnHeaderCol.width + column.width;
columnHeaderCol.childCols.push(column);
+
+ var periodePrecedenteIndexes = [];
+ for (var i = 0; i < columnsTblNotes.length; i ++) {
+ var column = columnsTblNotes[i];
+
+ if (column.colonnePeriodePrecedente == true) {
+ periodePrecedenteIndexes.push(i);
+ }
+ }
+
+ var rangIndex = null;
+ for (var i = 0; i < columnsTblNotes.length; i ++) {
+ var column = columnsTblNotes[i];
+
+ if (column.colonneRang == true) {
+ rangIndex = i;
+ }
+ }
+
return {
columns: columnsTblNotes,
- headerColumns: columnHeaderCols
+ headerColumns: columnHeaderCols,
+ periodePrecedenteIndexes: periodePrecedenteIndexes,
+ rangIndex: rangIndex
};
},
this.ouvrirGraphWindow(data, periodesPrecedentesExistent, periodes);
},
this);
+
+ observe.addListener(
+ this.Constantes.eventId.actionColumnHidden,
+ function(index, hidden) {
+ this.hideColumn(index, hidden);
+ },
+ this);
},
/**
});
}
}
+ },
+
+ hideColumn: function(index, hidden) {
+ this.tblNotesGrid.getColumnModel().setHidden(index, hidden);
}
});
\ No newline at end of file
* Ouvre le graph
* @event actionOuvrirGraphWindow
*/
- this.Constantes.eventId.actionOuvrirGraphWindow
+ this.Constantes.eventId.actionOuvrirGraphWindow,
+
+ /**
+ * Affiche les moyennes précédentes
+ * @event
+ * @param checked
+ */
+ this.Constantes.eventId.afficheMoyennesPrecedentes,
+
+ /**
+ * Affiche le rang
+ * @event
+ * @param checked
+ */
+ this.Constantes.eventId.afficheRang
);
var toolbarItems = [];
disabled: desactiveBouton
});
+ this.btnAffichage = this.creeBtnAffichage(desactiveBouton);
toolbarItems.push(
this.btnGraph,
+ this.btnAffichage,
this.btnEnregistrer,
this.btnAnnuler,
this.btnImprimer,
});
},
+ creeBtnAffichage: function(desactiveBouton) {
+ button = new Ext.Button({
+ xtype: 'tbbutton',
+ text: this.ConfigServeur.libelle.affichage,
+ style:'margin-top: 3px;margin-left: 25px',
+ disabled: desactiveBouton,
+ menu: [
+ {
+ xtype: 'menucheckitem',
+ text: this.ConfigServeur.libelle.moyennesPrecedentes,
+ checked: this.ConfigServeur.data.affichage.moyennesPrecedentes,
+ cls: 'x-btn-icon',
+ listeners: {
+ checkchange: function(item, checked) {
+ this.fireEvent(
+ this.Constantes.eventId.afficheMoyennesPrecedentes, checked);
+ },
+ scope: this
+ }
+ },
+ {
+ xtype: 'menucheckitem',
+ text: this.ConfigServeur.libelle.rang,
+ checked: this.ConfigServeur.data.affichage.rangs,
+ cls: 'x-btn-icon',
+ listeners: {
+ checkchange: function(item, checked) {
+ this.fireEvent(
+ this.Constantes.eventId.afficheRang, checked);
+ },
+ scope: this
+ }
+ }
+
+ ]
+ });
+
+ return button;
+ },
+
/**
* Observe le controlleur tableau de note
* @param tblNotesController
this.moyenneClasseController.observeStoreTblNotes(this.tblNotesController.tblNotesStore);
this.moyenneClasseView.observeTblNotesView(this.tblNotesView);
+ this.moyenneClasseView.observeTblNotesController(this.tblNotesController);
this.tblNotesController.storeMoyenneClasse = this.moyenneClasseController.storeMoyenneClasse;
tblNotesDesactive : 'tblNotesDesactive',
actionCreerDevoir : 'actionCreerDevoir',
actionScrollBar : 'actionScrollBar',
+ actionColumnHidden : 'actionColumnHidden',
actionHide : 'actionHide',
actionOuvrirAppreciations: 'actionOuvrirAppreciations',
actionOuvrirGraphWindow: 'actionOuvrirGraphWindow',
eleveChange: 'eleveChange',
actionOuvrirBrevetEPSWindow: 'actionOuvrirBrevetEPSWindow',
actionCalculerMoySelectionAuto: 'actionCalculerMoySelectionAuto',
- actionEnregistrerSelection: 'actionEnregistrerSelection'
+ actionEnregistrerSelection: 'actionEnregistrerSelection',
+ afficheMoyennesPrecedentes: 'afficheMoyennesPrecedentes',
+ afficheRang: 'afficheRang'
}
};
\ No newline at end of file
confirmationEnregistrementBrevetEPS: undefined,
brevetEpsNotesSelectionneesSucces: undefined,
brevetEpsNotesSelectionneesEchec: undefined,
- selectionNoteAlert: undefined
+ selectionNoteAlert: undefined,
+ enregistrePreferenceUtilisateurEchec: undefined
},
url:{
urlListeService : undefined,
getSaisieTableauDeNotesCsv: undefined,
getConsultationTableauDeNotesCsv: undefined,
urlBrevetEpsTblNotes: undefined,
- urlEnregistreSelectionBrevetEps: undefined
+ urlEnregistreSelectionBrevetEps: undefined,
+ enregistrePreferenceUtilisateur: undefined
},
libelle : {
comboService : undefined,
classe: undefined,
typeActivite: undefined,
selectionMeilleuresNotesEPS : undefined,
- confirmation: undefined
+ confirmation: undefined,
+
+ affichage: undefined,
+ moyennesPrecedentes: undefined,
+ rang: undefined
},
icon : {
enregistrer : undefined,
messageMoyennesNonAJour: undefined,
periodesDefinis: undefined,
- isMatiereEPS: undefined
+ isMatiereEPS: undefined,
+
+ affichage: {
+ moyennesPrecedentes: undefined,
+ rangs: undefined
+ },
+
+ typePeriodePrecedents: []
}
};
\ No newline at end of file
nomFields.push(nomField);
}
+ for (var i = 0; i < this.ConfigServeur.data.typePeriodePrecedents.length; i++) {
+ var periode = this.ConfigServeur.data.typePeriodePrecedents[i];
+ nomFields.push('moyennePeriodePrecedente' + periode.id);
+ }
+
nomField = this.moyenneField.name;
nomFields.push(nomField);
dataIndex : column.dataIndex,
width : column.width,
align: column.align,
- locked: column.locked
+ locked: column.locked,
+ hidden: column.hidden
};
if (column.isNote) {
);
},
+ observeTblNotesController : function(view) {
+ view.addListener(
+ this.Constantes.eventId.actionColumnHidden,
+ function(index, hidden) {
+ this.hideColumn(index, hidden);
+ },
+ this
+ );
+ },
+
/**
* Met à jours la position de scroll du grid tableau de notes
* @param scrollLeft Position du scroll horizontal
setScrollBarPosition : function(scrollLeft) {
var scroller = this.moyenneClasseGrid.getView().scroller;
scroller.dom.scrollLeft = scrollLeft;
+ },
+
+ hideColumn: function(index, hidden) {
+ this.moyenneClasseGrid.getColumnModel().setHidden(index, hidden);
}
+
});
\ No newline at end of file
* Ouvre la fenêtre de Graph
* @event actionOuvrirGraphWindow
*/
- this.Constantes.eventId.actionOuvrirGraphWindow
+ this.Constantes.eventId.actionOuvrirGraphWindow,
+
+ /**
+ * Demande de masquer / afficher des colonnes
+ * @event
+ * @param index index de la colonne
+ * @param hidden indique si la colonne est masquée
+ */
+ this.Constantes.eventId.actionColumnHidden
);
this.listeEvaluationInfo = [];
// Crée la liste des fields
this.fields = [
- {name: 'actif'}
+ {name: 'actif'},
+ {name: 'rang', type: 'string'}
];
+
+ for (var i = 0; i < this.ConfigServeur.data.typePeriodePrecedents.length; i++) {
+ var periode = this.ConfigServeur.data.typePeriodePrecedents[i];
+
+ this.fields.push({
+ name: 'moyennePeriodePrecedente' + periode.id,
+ type: 'string'
+ });
+ }
+
this.fields.push(
this.idEleveIdField,
this.verrouilleField,
// Calcule la moyenne générale d'un élève
var moyenneEleve = this.calculerMoyennesEleve(record);
record.set(this.moyenneField.name, moyenneEleve);
+
+ this.updateRang()
},
+ applyPrecision: function(note) {
+ return eliot.notes.commun.Utils.formatNumber(
+ note, eliot.notes.ConfigServeur.data.precision, false);
+ },
+
+ updateRang: function() {
+ var applyPrecision = this.applyPrecision.createDelegate(this);
+ var records = [];
+
+ this.tblNotesStore.each(function(record) {
+ var m = record.get('moyenne');
+ if ((m !== null) && (m !== '') && (!isNaN(m))) {
+ records.push(record);
+ }
+ else {
+ record.set('rang', null);
+ }
+ });
+
+ records.sort(function(r1, r2) {
+ var m1 = applyPrecision(r1.get('moyenne'));
+ var m2 = applyPrecision(r2.get('moyenne'));
+ return m2 - m1;
+ });
+
+ var lastRang = null;
+ var lastM = null;
+ for (var i = 0; i < records.length; i++) {
+ var record = records[i];
+ var rang = lastRang;
+ var m = applyPrecision(record.get('moyenne'));
+
+ if (m != lastM) {
+ rang = i + 1;
+ }
+ lastM = m;
+ lastRang = rang;
+
+ record.set('rang', rang);
+ }
+
+ },
/**
* Calcule les moyennes pour un élève
observeTblNotesView :function(tblNotesView) {
this.tblNotesView = tblNotesView;
+ this.columnsDescription = tblNotesView.columnsDescription;
+
tblNotesView.addListener(
this.Constantes.eventId.actionChangeNote,
function(record, change, evaluationField) {
this.ouvreGraphWindow();
},
this);
+
+ toolbarView.addListener(
+ this.Constantes.eventId.afficheMoyennesPrecedentes,
+ function(checked) {
+ this.afficheMoyennesPrecedentes(checked);
+ },
+ this);
+
+ toolbarView.addListener(
+ this.Constantes.eventId.afficheRang,
+ function(checked) {
+ this.afficheRang(checked);
+ },
+ this);
},
this.ConfigServeur.messages.tblNotesGraphEchou
);
},
+ scope : this
+ });
+ },
+
+ hideColumn: function(index, hidden) {
+ this.fireEvent(this.Constantes.eventId.actionColumnHidden, index, hidden);
+ },
+
+ afficheMoyennesPrecedentes: function(checked) {
+
+ eliot.notes.Messages.resetMessages();
+
+ for (var i = 0; i < this.columnsDescription.periodePrecedenteIndexes.length; i++) {
+ var periodePrecedenteIndex = this.columnsDescription.periodePrecedenteIndexes[i];
+ this.hideColumn(periodePrecedenteIndex, !checked);
+ }
+
+ Ext.Ajax.request({
+
+ url : this.ConfigServeur.url.enregistrePreferenceUtilisateur,
+
+ params : {
+ moyennesPrecedentes: checked
+ },
+
+ success : function(response, request) {
+
+ },
+
+ failure : function() {
+ eliot.notes.Messages.showErreur(
+ this.ConfigServeur.messages.enregistrePreferenceUtilisateurEchec);
+ },
+
+ scope : this
+ });
+ },
+
+ afficheRang: function(checked) {
+
+ eliot.notes.Messages.resetMessages();
+
+ if (this.columnsDescription.rangIndex != null) {
+ this.hideColumn(this.columnsDescription.rangIndex, !checked);
+ }
+
+ Ext.Ajax.request({
+
+ url : this.ConfigServeur.url.enregistrePreferenceUtilisateur,
+
+ params : {
+ rangs: checked
+ },
+
+ success : function(response, request) {
+
+ },
+
+ failure : function() {
+ eliot.notes.Messages.showErreur(
+ this.ConfigServeur.messages.enregistrePreferenceUtilisateurEchec);
+ },
+
scope : this
});
}
+
});
\ No newline at end of file
this.modaliteMatieres.length > 0) ? true : false;
// Crée le Template pour l'entetes de la colonne "élèves"
- var enteteEleveTmpl = new Ext.Template(
+ var enteteEleveTmpl = isPeriodeAnnee ?
+ new Ext.Template("{eleve}") :
+ new Ext.Template(
"<P align=right>",
"{titre}<br/>",
!hasModaliteMatieres ? null : "{modaliteMatiere}<br/>",
});
}
+ // Périodes précédentes
+ for (var i = 0; i < this.ConfigServeur.data.typePeriodePrecedents.length; i++) {
+ var periode = this.ConfigServeur.data.typePeriodePrecedents[i];
+
+ columns.push({
+ colonnePeriodePrecedente: true,
+ header: periode.libelle,
+ dataIndex: 'moyennePeriodePrecedente' + periode.id,
+ width: 60,
+ sortable: false,
+ align:'center',
+ hidden: !this.ConfigServeur.data.affichage.moyennesPrecedentes,
+ renderer: eliot.notes.commun.Utils.getNoteRenderer({
+ bold: false,
+ annotationRenderer: this.annotationRenderer.createDelegate(this)
+ }),
+ isNote: true
+ });
+ }
+
columns.push({
- header : enteteNoteTmpl.apply({
- titre: this.ConfigServeur.libelle.moyenneCourt
- }),
+ header : this.ConfigServeur.libelle.moyenneCourt,
dataIndex : cfg.tblNotesController.moyenneField.name,
width : 60,
sortable : false,
isMoyenne: true
});
+ // Rang
+ columns.push({
+ colonneRang: true,
+ header: this.ConfigServeur.libelle.rang,
+ dataIndex: 'rang',
+ width: 60,
+ sortable: false,
+ align:'center',
+ hidden: !this.ConfigServeur.data.affichage.rangs
+ });
+
var appreciationEditor = new Ext.form.TextArea({
grow : true,
height : 100,
renderer: eliot.notes.commun.Utils.textRenderer
});
+ var periodePrecedenteIndexes = [];
+ for (var i = 0; i < columns.length; i ++) {
+ var column = columns[i];
+
+ if (column.colonnePeriodePrecedente == true) {
+ periodePrecedenteIndexes.push(i);
+ }
+ }
+
+ var rangIndex = null;
+ for (var i = 0; i < columns.length; i ++) {
+ var column = columns[i];
+
+ if (column.colonneRang == true) {
+ rangIndex = i;
+ }
+ }
+
+ this.columnsDescription = {
+ periodePrecedenteIndexes: periodePrecedenteIndexes,
+ rangIndex: rangIndex
+ };
+
// Initialiser les colonnes du tableau service
this.columnModel = new Ext.ux.grid.LockingColumnModel({
defaults :
}
},
this);
+
+ observe.addListener(
+ this.Constantes.eventId.actionColumnHidden,
+ function(index, hidden) {
+ this.hideColumn(index, hidden);
+ },
+ this);
+
},
/**
});
}
}
+ },
+
+ hideColumn: function(index, hidden) {
+ this.tblNotesGrid.getColumnModel().setHidden(index, hidden);
}
});
\ No newline at end of file
* Ouvre la popup de gestion des notes d'EPS pour le brevet
* @event actionOuvrirBrevetEPSWindow
*/
- this.Constantes.eventId.actionOuvrirBrevetEPSWindow
+ this.Constantes.eventId.actionOuvrirBrevetEPSWindow,
+
+ /**
+ * Affiche les moyennes précédentes
+ * @event
+ * @param checked
+ */
+ this.Constantes.eventId.afficheMoyennesPrecedentes,
+
+ /**
+ * Affiche le rang
+ * @event
+ * @param checked
+ */
+ this.Constantes.eventId.afficheRang
);
this.toolbar.add(
this.btnGraph,
+ this.btnAffichage,
this.btnEnregistrer,
this.btnAnnuler,
this.btnImprimer, // othe : voir fiche 11362 - le modèle n'existe pas !
this.toolbar.add(
this.btnGraph,
+ this.btnAffichage,
this.btnImprimer, // othe : voir fiche 11362 - le modèle n'existe pas !
this.boutonExport);
}
this.toolbar.add(
this.btnAppreciations,
this.btnGraph,
+ this.btnAffichage,
this.btnEnregistrer,
this.btnAnnuler,
this.btnImprimer, // othe : voir fiche 11362 - le modèle n'existe pas !
this.btnImprimer.enable();
this.btnAppreciations.enable();
this.btnGraph.enable();
+ this.btnAffichage.enable();
this.btnImprimer.enable();
if ((!this.ConfigServeur.data.isPeriodeAnnee) && (this.ConfigServeur.data.sousServicesNonEvaluables !== true)) {
this.btnCreer.enable();
});
this.boutonExport = config.boutonExporter;
+
+ this.btnAffichage = this.creeBtnAffichage();
+ },
+
+ creeBtnAffichage: function() {
+ button = new Ext.Button({
+ xtype: 'tbbutton',
+ text: this.ConfigServeur.libelle.affichage,
+ style:'margin-top: 3px;margin-left: 25px',
+ disabled: true,
+ menu: [
+ {
+ xtype: 'menucheckitem',
+ text: this.ConfigServeur.libelle.moyennesPrecedentes,
+ checked: this.ConfigServeur.data.affichage.moyennesPrecedentes,
+ cls: 'x-btn-icon',
+ listeners: {
+ checkchange: function(item, checked) {
+ this.fireEvent(
+ this.Constantes.eventId.afficheMoyennesPrecedentes, checked);
+ },
+ scope: this
+ }
+ },
+ {
+ xtype: 'menucheckitem',
+ text: this.ConfigServeur.libelle.rang,
+ checked: this.ConfigServeur.data.affichage.rangs,
+ cls: 'x-btn-icon',
+ listeners: {
+ checkchange: function(item, checked) {
+ this.fireEvent(
+ this.Constantes.eventId.afficheRang, checked);
+ },
+ scope: this
+ }
+ }
+
+ ]
+ });
+ return button;
},
/**