Long id
Personne utilisateur
- Boolean rangs
- Boolean moyennesPrecedentes
+ Boolean rangs = true
+ Boolean moyennesPrecedentes = true
static constraints = {
utilisateur(nullable:false)
Boolean evaluable = Boolean.FALSE
static belongsTo = [
- service: Service,
- modaliteMatiere: ModaliteMatiere
+ service: Service,
+ modaliteMatiere: ModaliteMatiere
]
static constraints = {
static mapping = {
table('ent.sous_service')
id column: 'id',
- generator: 'sequence',
- params: [sequence: 'ent.sous_service_id_seq']
+ generator: 'sequence',
+ params: [sequence: 'ent.sous_service_id_seq']
coeff column: 'coeff'
modaliteMatiere column: 'modalite_matiere_id'
+++ /dev/null
-package org.lilie.services.eliot.export.tableaux
-
-/**
- * Contient les infos affichées dans l'entete et dans le pied de chaque colonne
- * @author bper
- */
-class ColonneImpression extends Expando {
- // Indique si la colonne est visible
- Boolean visible = true
-
- // Indique si ce titre à une largeur particulière
- Integer largeur
-
- // Sous-colonnes
- List<ColonneImpression> sousColonnes = []
-
- /**
- * Set les propriétés dynamiques qui contiennent les infos de l'entete
- * de la colonne (Exemples: Matière, Professeur, etc.)
- * @param num
- * @param value
- */
- void setEntete(Integer num, def value) {
- this.("entete$num") = TableauImpression.format(value)
- }
-
- /**
- * Set les propriétés dynamiques qui contiennent les infos du pied
- * de la colonne (Exemples: Moyenne, Moyenne Max, Note Max, etc.)
- * @param num
- * @param value
- */
- void setPied(Integer num, def value) {
- this.("pied$num") = TableauImpression.format(value)
- }
-
- /**
- * Calcule la largeur de la colonne en nombre de colonnes
- * @return
- */
- Integer getLargeur() {
- if (visible) {
- if (largeur) {
- return largeur
- }
- else {
- if (sousColonnes.size() < 2) {
- return 1
- } else {
- return sousColonnes.size()
- }
- }
- } else {
- return 0
- }
- }
-}
+++ /dev/null
-package org.lilie.services.eliot.export.tableaux
-
-/**
- * Contient les infos affichées dans les cellules de tableau
- * @author bper
- */
-class LigneImpression extends Expando {
-
- private Integer num = 1
-
- /**
- * Crée ou met à jour une propriété dynamique avec la valeur donnée qui
- * correspond à une cellule de tableau
- * @param num - numéro de la colonne
- * @param value - valeur de cellule
- */
- void setCol(Integer num, def value) {
- this.("col$num") = TableauImpression.format(value)
- }
-
- /**
- * Crée une propriété dynamique avec la valeur donnée qui
- * correspond à une cellule de tableau
- * @param value - valeur de cellule
- */
- void addCol(def value) {
- this.("col$num") = TableauImpression.format(value)
- num++
- }
-}
+++ /dev/null
-package org.lilie.services.eliot.export.tableaux
-
-/**
- * @author bper
- */
-class TableauDeNotesImpression extends TableauImpression {
- String periode
- String etablissement
- String service
- String enseignant
-}
+++ /dev/null
-package org.lilie.services.eliot.export.tableaux
-
-import java.text.SimpleDateFormat
-
-/**
- * @author bper
- */
-class TableauImpression {
-
- // format de date
- private static final SimpleDateFormat FORMAT_DATE =
- new SimpleDateFormat("dd/MM/yyyy",Locale.FRANCE)
-
- List<ColonneImpression> colonnes = []
- List<LigneImpression> lignes = []
-
- /**
- * Formate les donnée affichées dans le tableau
- * @param value
- * @return
- */
- static String format(def value) {
- if (value == null) {return ""}
- if (value instanceof Date) {
- value = FORMAT_DATE.format(value)
- }
- return value.toString()
- }
-}
+++ /dev/null
-package org.lilie.services.eliot.export.tableaux
-
-/**
- * @author bper
- */
-class TableauSyntheseImpression extends TableauImpression {
- String periode
- String etablissement
- String classe
-}
findStructureEnseignementNotesByStructureEnseignement(structureEnseignement)
structureEnseignementNotes.typeIntervalle = typeIntervalle
- structureEnseignementNotes.save(flush: true)
+ structureEnseignementNotes.save(flush: true, failOnError: true)
}
structureEnseignementNotes.brevetSerie = brevetSerie
structureEnseignementNotes.datePublicationBrevet = datePublicationBrevet
- structureEnseignementNotes.save(flush: true)
+ structureEnseignementNotes.save(flush: true, failOnError: true)
}
findStructureEnseignementNotesByStructureEnseignement(structureEnseignement)
structureEnseignementNotes.brevetSerie = brevetSerie
- structureEnseignementNotes.save(flush: true)
+ structureEnseignementNotes.save(flush: true, failOnError: true)
}
findStructureEnseignementNotesByStructureEnseignement(structureEnseignement)
structureEnseignementNotes.datePublicationBrevet = datePublicationBrevet
- structureEnseignementNotes.save(flush: true)
+ structureEnseignementNotes.save(flush: true, failOnError: true)
}
}
String toString() {
- return isNumerique() ? valeurNumerique?.toString() : valeurTextuelle?.code
+ return getValeurAffichage()
+ }
+
+ def getValeur() {
+ return isNumerique() ? valeurNumerique : valeurTextuelle
}
String getValeurAffichage() {
- return this.toString()
+ return getValeur()?.toString()
}
}
// Vérifie typeIntervalle,deux types sont autorisés : TRIMESTRE et SEMESTERE
if (typeIntervalle != TypeIntervalleEnum.TRIMESTRE &&
- typeIntervalle != TypeIntervalleEnum.SEMESTRE) {
+ typeIntervalle != TypeIntervalleEnum.SEMESTRE) {
throw new IllegalArgumentException("Le type d'intervalle doit etre ${TypeIntervalleEnum.TRIMESTRE} ou ${TypeIntervalleEnum.SEMESTRE}")
}
// Création de nouvelle période
Periode periode = new Periode(
- typePeriode: tp[intervalle],
- classe: struct
+ typePeriode: tp[intervalle],
+ classe: struct
)
// Sauvgarde avec la géstion des accès concurrents
return classe.periodes.find {it.isPeriodeXmestre() && it.ordre == ordre}
}
- public String getNomPeriodePrecedente(String libelleTypePeriode){
+ /**
+ * Code court I18n de periode
+ * @param libelleTypePeriode
+ * @return
+ */
+ public String getPeriodeCodeCourt(String libelleTypePeriode){
switch (libelleTypePeriode){
case 'T1':
- return '1er T.'
+ return 'periode.trimestre.premiere.libelle.court'
break
case 'T2':
- return '2ème T.'
+ return 'periode.trimestre.deuxieme.libelle.court'
break
case 'T3':
- return '3ème T.'
+ return 'periode.trimestre.troisieme.libelle.court'
break
case 'S1':
- return '1er S.'
+ return 'periode.semestre.premiere.libelle.court'
break
case 'S2':
- return '2ème T.'
+ return 'periode.semestre.deuxieme.libelle.court'
break
+ default:
+ return libelleTypePeriode
}
}
+ /**
+ * Nom court I18n de periode - DEPRECATED. Utilisez getPeriodeCodeCourt et internalisation au lieu.
+ * @param libelleTypePeriode
+ * @return
+ * @deprecated Utilisez getPeriodeCodeCourt et i18n au lieu.
+ */
+ public String getPeriodeNomCourt(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 S'
+ break
+ default:
+ return libelleTypePeriode
+ }
+ }
}
--- /dev/null
+package org.lilie.services.eliot.tableau
+
+/**
+ * @author bper
+ */
+class Cellule {
+ Boolean isCodeI18n = false
+ String valeur = ''
+
+ void traduisI18n(Closure message) {
+ if (isCodeI18n) {
+ valeur = message(valeur)
+ isCodeI18n = false
+ }
+ }
+}
--- /dev/null
+package org.lilie.services.eliot.tableau
+
+/**
+ * @author bper
+ */
+class Ligne {
+ private TreeMap<Integer, Cellule> cellules = new TreeMap()
+
+ Cellule getCellule(Integer colIndex) {
+ return cellules.get(colIndex)
+ }
+
+ void setCellule(Integer colIndex, Cellule cellule) {
+ cellules.put(colIndex, cellule)
+ }
+
+ void eachCelluleWithIndex(Closure closure) {
+ cellules.each {k, v -> closure(v, k)}
+ }
+
+ List<Integer> getAllColIndex() {
+ return cellules.keySet().toList().sort()
+ }
+
+ void traduisI18n(Closure message) {
+ cellules.each {k, v -> v.traduisI18n(message)}
+ }
+
+}
--- /dev/null
+package org.lilie.services.eliot.tableau
+
+/**
+ * @author bper
+ */
+class Tableau {
+ private TreeMap<Integer, Ligne> entetes = new TreeMap()
+ private TreeMap<Integer, Ligne> lignes = new TreeMap()
+ private TreeMap<Integer, Ligne> pieds = new TreeMap()
+
+ Ligne getLigneEntete(Integer rowIndex) {
+ return entetes.get(rowIndex)
+ }
+
+ Ligne getLigne(Integer rowIndex) {
+ return lignes.get(rowIndex)
+ }
+
+ Ligne getLignePied(Integer rowIndex) {
+ return pieds.get(rowIndex)
+ }
+
+ void setLigneEntete(Integer rowIndex, Ligne ligne) {
+ entetes.put(rowIndex, ligne)
+ }
+
+ void setLigne(Integer rowIndex, Ligne ligne) {
+ lignes.put(rowIndex, ligne)
+ }
+
+ void setLignePied(Integer rowIndex, Ligne ligne) {
+ pieds.put(rowIndex, ligne)
+ }
+
+ Cellule getCelluleEntete(Integer rowIndex, Integer colIndex) {
+ return getLigneEntete(rowIndex)?.getCellule(colIndex)
+ }
+
+ Cellule getCellule(Integer rowIndex, Integer colIndex) {
+ return getLigne(rowIndex)?.getCellule(colIndex)
+ }
+
+ Cellule getCellulePied(Integer rowIndex, Integer colIndex) {
+ return getLignePied(rowIndex)?.getCellule(colIndex)
+ }
+
+ void setCelluleEntete(Integer rowIndex, Integer colIndex, Cellule cellule) {
+ Ligne ligneEntete = getLigneEntete(rowIndex)
+ if (!ligneEntete) {
+ ligneEntete = new Ligne()
+ setLigneEntete(rowIndex, ligneEntete)
+ }
+ ligneEntete.setCellule(colIndex, cellule)
+ }
+
+ void setCellule(Integer rowIndex, Integer colIndex, Cellule cellule) {
+ Ligne ligne = getLigne(rowIndex)
+ if (!ligne) {
+ ligne = new Ligne()
+ setLigne(rowIndex, ligne)
+ }
+ ligne.setCellule(colIndex, cellule)
+ }
+
+ void setCellulePied(Integer rowIndex, Integer colIndex, Cellule cellule) {
+ Ligne lignePied = getLignePied(rowIndex)
+ if (!lignePied) {
+ lignePied = new Ligne()
+ setLignePied(rowIndex, lignePied)
+ }
+ lignePied.setCellule(colIndex, cellule)
+ }
+
+ void eachLigneEnteteWithIndex(Closure closure) {
+ entetes.each {k, v -> closure(v, k)}
+ }
+
+ void eachLigneWithIndex(Closure closure) {
+ lignes.each {k, v -> closure(v, k)}
+ }
+
+ void eachLignePiedWithIndex(Closure closure) {
+ pieds.each {k, v -> closure(v, k)}
+ }
+
+ void traduisI18n(Closure message) {
+ entetes.each {k, v -> v.traduisI18n(message)}
+ lignes.each {k, v -> v.traduisI18n(message)}
+ pieds.each {k, v -> v.traduisI18n(message)}
+ }
+}
/**
* Get ou crée typePeriode
- * @param etablissement
- * @param libelle
- * @param intervalle
- * @param nature
- * @return
* @author msan
*/
private TypePeriode getOuCreeTypePeriode(Etablissement etablissement,
this.precision = precision ?: DEFAULT_PRECISION
}
+ BigDecimal getPrecision() {
+ return this.precision
+ }
+
void setDecimalSeparator(String decimalSeparator) {
this.decimalSeparator = decimalSeparator ?: DEFAULT_DECIMAL_SEPARATOR
}
}
String format(Moyenne moyenne) {
+ if (moyenne == null) {
+ return ''
+ }
if (moyenne.isNumerique()) {
return format(moyenne.valeurNumerique)
} else {
package org.lilie.services.eliot.notes
+import org.lilie.services.eliot.notes.impression.tdn.ImpressionTdnService
+import org.lilie.services.eliot.notes.impression.tdn.OptionsImpressionParams
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.scolarite.SousService
-import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.TypePeriodeService
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.export.tableaux.ColonneImpression
-import org.lilie.services.eliot.export.tableaux.LigneImpression
-import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
import org.lilie.services.eliot.export.DonneesPourExportCSV
import org.lilie.services.eliot.utils.NoteFormateur
import org.lilie.services.eliot.scolarite.Enseignement
-import org.lilie.services.eliot.export.tableaux.TableauDeNotesImpression
-import org.lilie.services.eliot.notes.resultat.Moyenne
import grails.converters.JSON
import org.lilie.services.eliot.notes.domaine.TypePeriodeInfo
import org.lilie.services.eliot.notes.notes.NotesEvaluationService
import org.lilie.services.eliot.notes.resultat.CalculationService
-import org.lilie.services.eliot.notes.resultat.MoyenneService
-import org.lilie.services.eliot.notes.resultat.NoteInfo
import org.lilie.services.eliot.notes.saisie.TableauDeNotesGraphComposant
import org.lilie.services.eliot.notes.scolarite.NotesServiceService
import org.lilie.services.eliot.notes.scolarite.NotesSousServiceService
-import org.lilie.services.eliot.notes.scolarite.NotesStructureEnseignementService
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
+import org.lilie.services.eliot.impression.constantes.TemplateDocumentEnum
+import org.lilie.services.eliot.impression.donnees.DonneesOptions
+import org.lilie.services.eliot.notes.export.tableaudenotes.TableauDeNotesExportService
+import org.lilie.services.eliot.impression.donnees.tdn.TableauDeNotesImpression
/**
* Controller commun de Saisie et Consultation de Tableau de Notes
NotesEvaluationService notesEvaluationService
NotesSousServiceService notesSousServiceService
TypePeriodeService typePeriodeService
- LocalPersonneService localPersonneService
- MoyenneService moyenneService
CalculationService calculationService
EnseignementService enseignementService
TableauNotesSportService tableauNotesSportService
- NotesStructureEnseignementService notesStructureEnseignementService
PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
+ ImpressionTdnService impressionTdnService
+ TableauDeNotesExportService tableauDeNotesExportService
static final NoteFormateur NF_PAR_DEFAUT = new NoteFormateur()
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
if (service) {
// charge periodes si service défini
- List<TypePeriode> typePeriodes = getTypePeriodes(service)
+ List<TypePeriode> typePeriodes = notesTypePeriodeService.
+ getTypePeriodes(securiteSession, service)
typePeriodeInfos = getTypePeriodeInfos(service, typePeriodes)
tdn.allAppreciationClasseEnseignementPeriode.first().appreciation : null
if (typePeriode.isNotation()) {
- typePeriodePrecedents = getTypePeriodePrecedents(typePeriodes, typePeriode)
+ typePeriodePrecedents = notesTypePeriodeService.getTypePeriodePrecedents(typePeriodes, typePeriode)
}
rangs = calculeRangs(tdn)
}
PreferenceUtilisateurNotes pref =
- preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
resultat.enseignementId = enseignement?.id
resultat.moyennesAjour = moyennesAjour
private Map<BigDecimal, Integer> calculeRangs(TableauDeNotes tdn) {
- List<BigDecimal> valeurs = tdn.lignes*.resultat*.moyenne*.find {it != null}
+ List<BigDecimal> valeurs = tdn.lignes*.resultat*.moyenne
BigDecimal precision = etablissementCourant().etablissementNotes.precision
TypePeriode typePeriode) {
List<Evaluation> evaluations = notesEvaluationService.findAllEvaluations(
- securiteSession,
- service,
- typePeriode,
- enseignant,
- etablissementCourant())
+ securiteSession,
+ service,
+ typePeriode,
+ enseignant,
+ etablissementCourant())
evaluations.sort()
}
- 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
*/
/**
* Converteur pour Personne
- * @param personne
- * @return
*/
protected Map toMap(Personne personne) {
return [id: personne.autorite?.id, libelle: personne.nomAffichage()]
}
- /**
- * Transforme le TableauDeNotes en TableauDeNotesImpression
- * @param tdn
- * @return TableauDeNotesImpression
- * @author bper
- */
- protected TableauDeNotesImpression construisTableauDeNotesImpression(TableauDeNotes tdn) {
-
- // La colonne "Classe" pour les rergroupement
- ColonneImpression colClasse = construitColonneClasse(tdn)
-
- // Colonne "Elèves"
- ColonneImpression colEleve = construitColonneEleve()
-
- // Colonne "Appréciation"
- ColonneImpression colAppr = construitColonneAppreciation(tdn)
-
- // Les colonnes du tableau (devoirs ou périodes)
- List<ColonneImpression> colonnes = []
-
- // Les lignes du tableau
- List<LigneImpression> lignes = []
-
- StructureEnseignement structureEnseignement =
- tdn.enseignement.service.structureEnseignement
-
- NoteFormateur nf = structureEnseignement.etablissement.etablissementNotes.
- getNoteFormateur()
-
- if (tdn.typePeriode.isAnnee()) {
- // Pour la période "année" affiche les moyennes des périodes
- construitTableauDeNotesImpressionPeriodeAnnee(tdn, colonnes, colClasse, lignes, nf)
- }
- else {
- // Pour d'autres périodes affiche les notes de devoirs
- construitTableauDeNotesImpressionAutresPeriodes(tdn, colonnes, colClasse, lignes, nf)
- }
-
- TableauDeNotesImpression tdni = new TableauDeNotesImpression()
- tdni.service = tdn.enseignement.service.libelle
- tdni.periode = getTypePeriodeLibelle(tdn.typePeriode)
- tdni.etablissement = structureEnseignement.etablissement.nomAffichage
- Personne enseignant = localPersonneService.findPersonneByAutorite(
- tdn.enseignement.enseignant
- )
- tdni.enseignant = enseignant.nomAffichageInitiales()
-
- if (colClasse) {
- tdni.colonnes << colClasse
- }
- tdni.colonnes << colEleve
- tdni.colonnes.addAll(colonnes)
- tdni.colonnes << colAppr
-
- tdni.lignes = lignes
-
- return tdni
- }
-
- private def construitTableauDeNotesImpressionAutresPeriodes(TableauDeNotes tdn,
- List<ColonneImpression> colonnes,
- ColonneImpression colClasse,
- List<LigneImpression> lignes,
- NoteFormateur nf) {
- List<SousService> sousServices =
- tdn.enseignement.service.getSousServices(tdn.typePeriode)
-
- // Regroupe les notes des élève pour calcul de moyenne de la classe
- Map<Evaluation, List<BigDecimal>> evalNotes = [:]
- tdn.evaluations.each {evalNotes.put(it, [])}
-
- // Regroupe les moyennes des sous-services de tous les élèves
- Map<SousService, List<BigDecimal>> sousServiceMoyennes = [:]
- sousServices.each {sousServiceMoyennes.put(it, [])}
-
- // Les moyennes générales de tous les élèves
- List<BigDecimal> moyennes = []
-
- // Création des lignes du TDN
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
- LigneImpression ligne = new LigneImpression()
-
- // Colonne "Classe"
- if (colClasse) {
- ligne.addCol(ligneTDN.classe.code)
- }
-
- // Colonne "Elèves"
- ligne.addCol(ligneTDN.eleve.nomAffichage())
-
- // Colonnes "Evaluation"
- tdn.evaluations.each {Evaluation evaluation ->
- Note note = ligneTDN.notes.find {it.evaluation.id == evaluation.id}
- evalNotes.get(evaluation) << note?.valeurNumerique
- ligne.addCol(NF_PAR_DEFAUT.format(note?.valeur))
- }
-
- // Les colonnes "Moy. sous-matière"
- List<NoteInfo> moyEleveSousServices = []
- sousServices.each {SousService sousService ->
- List<Note> notes = ligneTDN.notes.findAll {
- it.evaluation.modaliteMatiere.id == sousService.modaliteMatiere.id
- }
- Moyenne moySousService = calculationService.calculeMoyenneNotesPonderee(notes)
- ligne.addCol(nf.format(moySousService))
- if (moySousService?.isNumerique()) {
- sousServiceMoyennes.get(sousService) << moySousService.valeurNumerique
- }
- moyEleveSousServices << new NoteInfo(
- moySousService,
- sousService.coeff,
- false
- )
- }
-
- // La colonne "Moyenne"
- Moyenne moyenne = moyEleveSousServices ?
- calculationService.calculeMoyennePonderee(moyEleveSousServices) :
- calculationService.calculeMoyenneNotesPonderee(ligneTDN.notes)
- ligne.addCol(nf.format(moyenne))
- if (moyenne?.isNumerique()) {
- moyennes << moyenne.valeurNumerique
- }
-
- // Colonne "Appréciation"
- ligne.addCol(ligneTDN.appreciation)
-
- lignes << ligne
- }
-
- // Création des colonnes
- tdn.evaluations.each {Evaluation evaluation ->
- // Les notes de tous les élèves pour l'évaluation
- List<BigDecimal> notes = evalNotes.get(evaluation)
- colonnes << construitColonnesAutresPeriodes(evaluation, notes, nf)
- }
-
- // Les colonnes "sous-matière"
- sousServices.each {
- colonnes << construitColonneSousMatiere(it, sousServiceMoyennes, nf)
- }
-
- // La colonne "Moyenne"
- colonnes << construitColonneMoyenne(moyennes, nf)
- }
-
- private def construitTableauDeNotesImpressionPeriodeAnnee(TableauDeNotes tdn,
- List<ColonneImpression> colonnes,
- ColonneImpression colClasse,
- List<LigneImpression> lignes,
- NoteFormateur nf) {
- List<TypePeriode> typePeriodeXmestres =
- notesTypePeriodeService.findAllXmestreForService(
- securiteSession,
- tdn.enseignement.service,
- TypeIntervalleEnum.TRIMESTRE
- )
-
- // Collecte les moyennes des élèves groupées par type de période,
- // ultilisé pour calculer les moyennes de la classe affichées en pied du tableau
- Map<TypePeriode, List> typePeriodeMoyennes = [:]
- typePeriodeXmestres.each {typePeriodeMoyennes.put(it, [])}
- typePeriodeMoyennes.put(tdn.typePeriode, [])
-
- // Création des lignes du TDN
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
- LigneImpression ligne = new LigneImpression()
-
- // Colonne "Classe"
- if (colClasse) {
- ligne.addCol(ligneTDN.classe.code)
- }
-
- // Colonne "Elèves"
- ligne.addCol(ligneTDN.eleve.nomAffichage())
-
- // Colonnes "Xmestre"
- typePeriodeXmestres.each {TypePeriode typePeriode ->
- ResultatEleveEnseignementPeriode resultatXmestre = ligneTDN.resultatsXmestresPrecedents.find {
- it.periode.typePeriode.id == typePeriode.id ||
- it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
- }
-
- ligne.addCol(nf.format(resultatXmestre?.getValeurAffichage()))
- typePeriodeMoyennes.get(typePeriode) << resultatXmestre?.moyenne
- }
-
- // Colonne "Moyenne"
- ligne.addCol(nf.format(ligneTDN.resultat?.getValeurAffichage()))
- typePeriodeMoyennes.get(tdn.typePeriode) << ligneTDN.resultat?.moyenne
-
- // Colonne "Appreciation"
- ligne.addCol(ligneTDN.appreciation)
-
- lignes << ligne
- }
-
- // Création des colonnes du TDN
- typePeriodeXmestres.each {TypePeriode typePeriode ->
- // Les moyennes de tous les élèves pour le type de période Xmestre et
- // un type équivalent
- List<BigDecimal> moyenneXmestres = typePeriodeMoyennes.get(typePeriode)
- colonnes << construitColonnesPeriodeAnnee(typePeriode, moyenneXmestres, nf)
- }
-
- // Les moyenne de tous les élèves pour l'année
- List<BigDecimal> moyenneAnnees = typePeriodeMoyennes.get(tdn.typePeriode)
-
- // La colonne "Moyenne"
- colonnes << construitColonneMoyenne(moyenneAnnees, nf)
- }
-
- private ColonneImpression construitColonnesAutresPeriodes(Evaluation evaluation,
- List<BigDecimal> notes,
- NoteFormateur nf) {
- ColonneImpression colonne = new ColonneImpression()
- colonne.setEntete(1, evaluation.titre)
- colonne.setEntete(2, evaluation.modaliteMatiere?.libelle)
- colonne.setEntete(3, evaluation.dateEvaluation)
- colonne.setEntete(4, COEFF_NF.format(evaluation.noteMaxPossible))
- colonne.setEntete(5, COEFF_NF.format(evaluation.coefficient))
- colonne.setPied(1, nf.format(calculationService.calculeMoyenne(notes)))
- colonne.setPied(2, NF_PAR_DEFAUT.format(calculationService.calculeMin(notes))) // on ne formate pas les notes
- colonne.setPied(3, NF_PAR_DEFAUT.format(calculationService.calculeMax(notes))) // on ne formate pas les notes
- return colonne
- }
-
- private ColonneImpression construitColonneSousMatiere(SousService it,
- Map<SousService, List<BigDecimal>> sousServiceMoyennes,
- NoteFormateur nf) {
- ColonneImpression colSousMatiere = new ColonneImpression()
- colSousMatiere.setEntete(1, message(code: 'eliot.notes.libelle.moyenneCourt'))
- colSousMatiere.setEntete(2, it.modaliteMatiere.code)
- colSousMatiere.setEntete(3, "")
- colSousMatiere.setEntete(4, COEFF_NF.format(20))
- colSousMatiere.setEntete(5, COEFF_NF.format(it.coeff))
- colSousMatiere.setPied(1, nf.format(calculationService.calculeMoyenne(sousServiceMoyennes.get(it))))
- colSousMatiere.setPied(2, nf.format(calculationService.calculeMin(sousServiceMoyennes.get(it))))
- colSousMatiere.setPied(3, nf.format(calculationService.calculeMax(sousServiceMoyennes.get(it))))
- return colSousMatiere
- }
-
- private ColonneImpression construitColonnesPeriodeAnnee(TypePeriode typePeriode,
- List<BigDecimal> moyenneXmestres,
- NoteFormateur nf) {
- ColonneImpression colonne = new ColonneImpression()
- colonne.setEntete(1, getTypePeriodeLibelle(typePeriode))
- colonne.setEntete(2, "")
- colonne.setEntete(3, "")
- colonne.setEntete(4, COEFF_NF.format(20))
- colonne.setEntete(5, COEFF_NF.format(1))
- colonne.setPied(1, nf.format(calculationService.calculeMoyenne(moyenneXmestres)))
- colonne.setPied(2, nf.format(calculationService.calculeMin(moyenneXmestres)))
- colonne.setPied(3, nf.format(calculationService.calculeMax(moyenneXmestres)))
- return colonne
- }
-
- private ColonneImpression construitColonneMoyenne(List<BigDecimal> moyenneAnnees,
- NoteFormateur nf) {
- ColonneImpression colMoy = new ColonneImpression()
- colMoy.setEntete(1, message(code: 'eliot.notes.libelle.moyenneCourt'))
- colMoy.setEntete(2, "")
- colMoy.setEntete(3, "")
- colMoy.setEntete(4, "")
- colMoy.setEntete(5, "")
- colMoy.setPied(1, nf.format(calculationService.calculeMoyenne(moyenneAnnees)))
- colMoy.setPied(2, nf.format(calculationService.calculeMin(moyenneAnnees)))
- colMoy.setPied(3, nf.format(calculationService.calculeMax(moyenneAnnees)))
- return colMoy
- }
-
- private ColonneImpression construitColonneAppreciation(TableauDeNotes tdn) {
- ColonneImpression colAppr = new ColonneImpression()
- colAppr.setEntete(1, message(code: 'eliot.notes.libelle.appreciations'))
- colAppr.setPied(1, message(code: 'eliot.notes.libelle.appreciationClasse'))
- String apprGlobale = tdn.allAppreciationClasseEnseignementPeriode ?
- tdn.allAppreciationClasseEnseignementPeriode.first().appreciation : ""
- colAppr.setPied(2, apprGlobale)
- return colAppr
- }
-
- private ColonneImpression construitColonneEleve() {
- ColonneImpression colEleve = new ColonneImpression()
- colEleve.setEntete(1, message(code: 'eliot.notes.libelle.titre'))
- colEleve.setEntete(2, message(code: 'eliot.notes.libelle.sousMatiere'))
- colEleve.setEntete(3, message(code: 'eliot.notes.libelle.dateEvaluation'))
- colEleve.setEntete(4, message(code: 'eliot.notes.libelle.devoirSur'))
- colEleve.setEntete(5, "${message(code: 'eliot.notes.libelle.eleve')} | ${message(code: 'eliot.notes.libelle.coeff')}")
- colEleve.setPied(1, message(code: 'eliot.notes.libelle.moyennes'))
- colEleve.setPied(2, message(code: 'eliot.notes.libelle.noteMinMoyenneClasse'))
- colEleve.setPied(3, message(code: 'eliot.notes.libelle.noteMaxMoyenneClasse'))
- return colEleve
- }
-
- private ColonneImpression construitColonneClasse(TableauDeNotes tdn) {
- if (tdn.enseignement.service.structureEnseignement.isRegroupement()) {
- ColonneImpression colClasse = new ColonneImpression()
- colClasse.setEntete(1, "")
- colClasse.setEntete(2, "")
- colClasse.setEntete(3, "")
- colClasse.setEntete(4, "")
- colClasse.setEntete(5, message(code: 'eliot.notes.libelle.classe'))
- return colClasse
- } else {
- return null
- }
- }
-
def getTableauDeNotesCsv = {
TableauDeNotes tdn = tableauDeNotesService.construisTableauDeNotes(
securiteSession,
enseignementService.getEnseignement(service, enseignant),
- typePeriode,
+ typePeriode
)
- TableauDeNotesImpression tab = construisTableauDeNotesImpression(tdn)
+ DonneesPourExportCSV donneesCSV = tableauDeNotesExportService.
+ transformeTdnEnDonneesCSV(securiteSession, tdn) {code -> message(code: code)}
- DonneesPourExportCSV donnees = new DonneesPourExportCSV()
+ String nomFichier = "Notes_${service.structureEnseignement.code}" +
+ "_${service.matiere.codeGestion}" +
+ "_${enseignant.nomAffichage().replaceAll(/\s/, '_')}" +
+ "_${typePeriode.libelle}"
- // L'entete du tableau est composé des 5 lignes maximum
- List<List> ligneEntetes = [[], [], [], [], []]
+ sendCsvFile(response, donneesCSV, nomFichier)
+ }
- List<List> ligneEleves = tab.lignes.collect {[]}
- // Le pied du tableau est composé de 3 lignes maximum
- List<List> lignePieds = [[], [], []]
+ /**
+ * Imprime le tableau de notes pour un enseignant
+ */
+ protected void imprimeTabeauDeNotes(def params,
+ Autorite enseignant) {
- tab.colonnes.eachWithIndex {ColonneImpression col, Integer numCol ->
- ligneEntetes.eachWithIndex {List ligneEntete, Integer i ->
- ligneEntete << col."entete${i + 1}"
- }
+ OptionsImpressionParams optionsImpressionParams =
+ new OptionsImpressionParams(
+ notesEtMoyennes: params.notesEtMoyennes ? Boolean.parseBoolean(params.notesEtMoyennes) : null,
+ appreciations: params.appreciations ? Boolean.parseBoolean(params.appreciations) : null
+ )
- lignePieds.eachWithIndex {List lignePied, Integer i ->
- lignePied << col."pied${i + 1}"
- }
+ Service service = Service.get(params.serviceId)
+ TypePeriode typePeriode = TypePeriode.get(params.typePeriodeId)
- tab.lignes.eachWithIndex {LigneImpression ligne, Integer numLigne ->
- ligneEleves.get(numLigne) << ligne."col${numCol + 1}"
- }
- }
+ TableauDeNotes tdn = tableauDeNotesService.construisTableauDeNotes(
+ securiteSession,
+ enseignementService.getEnseignement(
+ service,
+ enseignant
+ ),
+ typePeriode
+ )
- donnees.colonnes = ligneEntetes.get(0)
- if (typePeriode.isAnnee()) {
- donnees.lignes.add(ligneEntetes.get(3))
- donnees.lignes.add(ligneEntetes.get(4))
- } else {
- donnees.lignes.addAll(ligneEntetes.subList(1, 5))
- }
- donnees.lignes.addAll(ligneEleves)
- donnees.lignes.addAll(lignePieds)
+ TableauDeNotesImpression tab =
+ transformeToTableauDeNotesImpression(tdn, optionsImpressionParams)
- String nomFichier = "Notes_${service.structureEnseignement.code}" +
- "_${service.matiere.codeGestion}" +
- "_${enseignant.nomAffichage().replaceAll(/\s/, '_')}" +
- "_${typePeriode.libelle}"
+ TemplateDocumentEnum modele = tdn.typePeriode.isAnnee() ?
+ TemplateDocumentEnum.TABLEAU_NOTES_ANNEE :
+ TemplateDocumentEnum.TABLEAU_NOTES_1
+
+ DonneesOptions donneesOptions = new DonneesOptions(
+ data: [tab],
+ options: optionsImpressionParams.appreciations
+ )
+
+ imprimeDocumentPDF(
+ donneesOptions,
+ modele,
+ response
+ )
+ }
+
+ protected TableauDeNotesImpression transformeToTableauDeNotesImpression(TableauDeNotes tdn,
+ OptionsImpressionParams optionsImpressionParams) {
+
+ TableauDeNotesImpression tab =
+ impressionTdnService.transformeToTableauDeNotesImpression(securiteSession, tdn, optionsImpressionParams) {code ->
+ message(code: code)
+ }
- sendCsvFile(response, donnees, nomFichier)
+ tab.periode = getTypePeriodeLibelle(tdn.typePeriode)
+ return tab
}
}
+++ /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.notes.impression.tdn.ImpressionTdnService
-import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
-import org.lilie.services.eliot.impression.donnees.tdn.TableauDeNotesImpression
-import org.lilie.services.eliot.notes.impression.tdn.OptionsImpressionParams
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
-import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.impression.constantes.TemplateDocumentEnum
-import org.lilie.services.eliot.impression.donnees.DonneesOptions
-
-/**
- * Ancêtre de controlleur spécialisé dans la gestion de l'impression
- * des tableaux de notes.
- * @author othe
- */
-abstract class AbstractTableauDeNotesImpressionController extends AbstractTableauDeNotesController {
-
- ImpressionTdnService impressionTdnService
-
- /**
- * Prépare les données du tableau de notes annuel pour l'impression jasperreport
- * @param tdn
- * @return
- */
- protected TableauDeNotesImpression construitTableauDeNotesAnnee(TableauDeNotes tdn) {
-
- TableauDeNotesImpression tab =
- impressionTdnService.prepareDonneesAnnee(securiteSession, tdn)
-
- tab.periode = getTypePeriodeLibelle(tdn.typePeriode)
- tab.data.each {
-
- if (it instanceof CelluleTypePeriode) {
- CelluleTypePeriode cellule = (CelluleTypePeriode) it
- cellule.entete1 = getTypePeriodeLibelle(cellule.typePeriode)
- }
- }
-
- return tab
- }
-
- /**
- * Prépare les données du tableau de notes par périodes pour l'impression jasperreport
- * @param tdn
- * @return
- */
- protected TableauDeNotesImpression construitTableauDeNotesPeriode(TableauDeNotes tdn) {
-
- TableauDeNotesImpression tab =
- impressionTdnService.prepareDonneesAutrePeriode(securiteSession, tdn)
-
- tab.periode = getTypePeriodeLibelle(tdn.typePeriode)
- tab.data.each {
-
- if (it instanceof CelluleI18n) {
- CelluleI18n cellule = (CelluleI18n) it
- cellule.entete1 = message(code:cellule.entete1)
- }
-
- }
-
- return tab
-
- }
-
- /**
- * Imprime le tableau de notes pour un enseignant
- * @param securiteSession
- * @param params
- * @param enseignant
- */
- protected void imprimeTabeauDeNotes(
- def securiteSession,
- def params,
- Autorite enseignant) {
-
- OptionsImpressionParams optionsImpressionParams =
- new OptionsImpressionParams(
- notesEtMoyennes: params.notesEtMoyennes ? Boolean.parseBoolean(params.notesEtMoyennes) : null,
- appreciations: params.appreciations ? Boolean.parseBoolean(params.appreciations) : null
- )
-
- Service service = Service.get(params.serviceId)
- TypePeriode typePeriode = TypePeriode.get(params.typePeriodeId)
-
- TableauDeNotes tdn = tableauDeNotesService.construisTableauDeNotes(
- securiteSession,
- enseignementService.getEnseignement(
- service,
- enseignant
- ),
- typePeriode,
- optionsImpressionParams.notesEtMoyennes
- )
-
- TableauDeNotesImpression tab
-
- TemplateDocumentEnum modele
- if (tdn.typePeriode.isAnnee()) {
- tab = construitTableauDeNotesAnnee(tdn)
- modele = TemplateDocumentEnum.TABLEAU_NOTES_ANNEE
- } else {
- tab = construitTableauDeNotesPeriode(tdn)
- modele = TemplateDocumentEnum.TABLEAU_NOTES_1
- }
-
- DonneesOptions donneesOptions = new DonneesOptions(
- data: [tab],
- options: optionsImpressionParams.appreciations
- )
-
- imprimeDocumentPDF(
- donneesOptions,
- modele,
- response
- )
- }
-
-}
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.notes.NotesFonction
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
-import org.lilie.services.eliot.notes.AbstractTableauDeNotesImpressionController
+import org.lilie.services.eliot.notes.AbstractTableauDeNotesController
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Consultation des Tableau de Notes (profil directeur)
* @author msan
*/
-class ConsultationTableauDeNotesController extends AbstractTableauDeNotesImpressionController {
+class ConsultationTableauDeNotesController extends AbstractTableauDeNotesController {
+
+ LocalPersonneService localPersonneService
def index = {
Autorite enseignant = Autorite.get(params.enseignantId)
- imprimeTabeauDeNotes(securiteSession, params, enseignant)
+ imprimeTabeauDeNotes(params, enseignant)
}
/**
if (pref?.moyennesPrecedentes == true && periode?.isPeriodeNotation()){
periodesPrecedentes?.each{ Periode periodePrecedente ->
donnees.colonnes << message(
- code: periodeService.getNomPeriodePrecedente(periodePrecedente.typePeriode?.libelle)
+ code: periodeService.getPeriodeCodeCourt(periodePrecedente.typePeriode?.libelle)
)
}
}
import org.lilie.services.eliot.notes.NotesFonction
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
import org.lilie.services.eliot.notes.notes.tableaudenotes.EnregistreTableauDeNotesParams
-import org.lilie.services.eliot.notes.AbstractTableauDeNotesImpressionController
+import org.lilie.services.eliot.notes.AbstractTableauDeNotesController
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
/**
* Cette classe définit le controleur de la vue "tableau de notes" dans menu "Saisie"
* @author othe
* @author bper
*/
-class SaisieTableauDeNotesController extends AbstractTableauDeNotesImpressionController {
+class SaisieTableauDeNotesController extends AbstractTableauDeNotesController {
+
+ LocalPersonneService localPersonneService
/**
* @author msan
Autorite enseignant = (Autorite) securiteSession.defaultAutorite
- imprimeTabeauDeNotes(securiteSession, params, enseignant)
+ imprimeTabeauDeNotes(params, enseignant)
}
/**
eliot.notes.libelle.comboEleve=Élève
eliot.notes.libelle.discipline=Matières
eliot.notes.libelle.eleve=Elèves
+eliot.notes.libelle.eleveCoeff=Elèves | Coeff.
eliot.notes.libelle.eleveNomPrenom=Nom prénom
eliot.notes.libelle.classe=Classe
eliot.notes.libelle.noteMaxBulletin=Max.
--- /dev/null
+package org.lilie.services.eliot.notes.export.tableaudenotes
+
+import org.lilie.services.eliot.export.DonneesPourExportCSV
+
+import org.lilie.services.eliot.tableau.Tableau
+import org.lilie.services.eliot.tableau.Ligne
+import org.lilie.services.eliot.tableau.Cellule
+import org.lilie.services.eliot.annuaire.SecuriteSession
+
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
+
+/**
+ * Export de tableau de notes vers DonneesPourExportCSV
+ * @author msan
+ */
+class TableauDeNotesExportService {
+
+ TableauDeNotesService tableauDeNotesService
+
+ static transactional = false
+
+ /**
+ * Transforme un tableau de notes en données preformatées pour l'export CSV
+ */
+ DonneesPourExportCSV transformeTdnEnDonneesCSV(SecuriteSession securiteSession,
+ TableauDeNotes tableauDeNotes,
+ Closure traducteurMessages) {
+
+ DonneesPourExportCSV donneesCSV = new DonneesPourExportCSV()
+
+ Tableau tableauGenerique = tableauDeNotesService.
+ transformeToSimpleTableau(securiteSession, tableauDeNotes)
+
+ tableauGenerique.traduisI18n(traducteurMessages)
+
+ tableauGenerique.eachLigneEnteteWithIndex {Ligne ligne, Integer rowIndex ->
+ List ligneCSV = []
+ ligne.eachCelluleWithIndex {Cellule cellule, Integer colIndex ->
+ ligneCSV << cellule.valeur
+ }
+
+ if (rowIndex == 1) {
+ donneesCSV.colonnes = ligneCSV
+ } else {
+ donneesCSV.lignes << ligneCSV
+ }
+ }
+
+ tableauGenerique.eachLigneWithIndex {Ligne ligne, Integer rowIndex ->
+ List ligneCSV = []
+ ligne.eachCelluleWithIndex {Cellule cellule, Integer colIndex ->
+ ligneCSV << cellule.valeur
+ }
+ donneesCSV.lignes << ligneCSV
+ }
+
+ tableauGenerique.eachLignePiedWithIndex {Ligne ligne, Integer rowIndex ->
+ List ligneCSV = []
+ ligne.eachCelluleWithIndex {Cellule cellule, Integer colIndex ->
+ ligneCSV << cellule.valeur
+ }
+ donneesCSV.lignes << ligneCSV
+ }
+
+ return donneesCSV
+ }
+}
// moyennes generales
if (periodePrecedente1){
- tab.nomPeriodePrecedente1 = periodeService.getNomPeriodePrecedente(periodePrecedente1.typePeriode?.libelle)
+ // TOREFACT i18n - utilisez getPeriodeCodeCourt + internalisation au lieu
+ tab.nomPeriodePrecedente1 = periodeService.getPeriodeNomCourt(periodePrecedente1.typePeriode?.libelle)
BigDecimal moyennePrec1 = null
bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
if (it.periode == periodePrecedente1){
tab.moyennePrec1 = nf.format(moyennePrec1)
}
if (periodePrecedente2){
- tab.nomPeriodePrecedente2 = periodeService.getNomPeriodePrecedente(periodePrecedente2.typePeriode?.libelle)
+ // TOREFACT i18n - utilisez getPeriodeCodeCourt + internalisation au lieu
+ tab.nomPeriodePrecedente2 = periodeService.getPeriodeNomCourt(periodePrecedente2.typePeriode?.libelle)
BigDecimal moyennePrec2 = null
bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
if (it.periode == periodePrecedente2){
tab.moyennePrec2 = nf.format(moyennePrec2)
}
if (periodePrecedente3){
- tab.nomPeriodePrecedente3 = periodeService.getNomPeriodePrecedente(periodePrecedente3.typePeriode?.libelle)
+ // TOREFACT i18n - utilisez getPeriodeCodeCourt + internalisation au lieu
+ tab.nomPeriodePrecedente3 = periodeService.getPeriodeNomCourt(periodePrecedente3.typePeriode?.libelle)
BigDecimal moyennePrec3 = null
bulletin.syntheseEleve?.resultatEleveXmestrePrecedents?.each{
if (it.periode == periodePrecedente3){
*/
class ImpressionSyntheseService {
- private static final POSITION_MOYENNE = 9999
+ private static final POSITION_MOYENNE_PREC = 2000
+ private static final POSITION_MOYENNE = 3000
+ private static final POSITION_RANG = 4000
private static final POSITION_ABSENCES = 10000
private static final POSITION_RETARDS = 10001
private static final POSITION_DEPARTS_ANTICIPES = 10002
new CelluleI18n(
enteteLigne: syntheseEleve.eleve.nomAffichage(),
- entete1: periodeService.getNomPeriodePrecedente(periodePrecedente.typePeriode?.libelle),
+ entete1: periodeService.getPeriodeCodeCourt(periodePrecedente.typePeriode?.libelle),
entete2: "",
entete3: "",
entete4: "",
finLigne: appreciation ? appreciation : "",
- index: POSITION_MOYENNE,
+ index: POSITION_MOYENNE_PREC,
valeur: nf.format(resultatEleveXmestrePrecedent?.getValeurAffichage()),
pied1: nf.format(resultatClasseXmestrePrecedent?.moyenne),
pied2: nf.format(resultatClasseXmestrePrecedent?.moyenneMin),
entete3: "",
entete4: "",
finLigne: appreciation ? appreciation : "",
- index: POSITION_MOYENNE,
+ index: POSITION_RANG,
valeur: rang,
pied1: "",
pied2: "",
+++ /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.impression.tdn
-
-import org.lilie.services.eliot.notes.Evaluation
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
-import org.lilie.services.eliot.scolarite.SousService
-import org.lilie.services.eliot.notes.Note
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
-import org.lilie.services.eliot.notes.resultat.NoteInfo
-import org.lilie.services.eliot.notes.resultat.CalculationService
-import org.lilie.services.eliot.notes.resultat.Moyenne
-
-/**
- * Permet de lire les notes et moyennes pour le rapport en préparation
- * (reprise du code controlleur d'origine)
- * @author othe
- */
-class CalculMoyenneEvaluation {
-
- // Regroupe les notes des élève pour calcul de moyenne de la classe
- private Map<Evaluation, List<BigDecimal>> evalNotes = [:]
-
- // Regroupe les moyennes des sous-services de tous les élèves
- private Map<SousService, List<BigDecimal>> sousServiceMoyennes = [:]
-
- // Les moyennes générales de tous les élèves
- private List<BigDecimal> moyennes = []
-
- /**
- * Lecture des notes pour un sous-service
- * @param sousService
- * @return
- */
- public List<BigDecimal> getNotesSousService(SousService sousService) {
- return sousServiceMoyennes.get(sousService)
- }
-
- /**
- * lecture des notes par évaluation
- * @param evaluation
- * @return
- */
- public List<BigDecimal> getNotesEvaluation(Evaluation evaluation) {
- return evalNotes.get(evaluation)
- }
-
- /**
- * Lecture des moyennes élèves
- * @return
- */
- public List<BigDecimal> getMoyennesEleve() {
- moyennes
- }
-
- public CalculMoyenneEvaluation(TableauDeNotes tdn, CalculationService calculationService) {
-
- prepareListeNotesEvaluations(tdn)
-
- List<SousService> sousServices = findAllSousServices(tdn)
-
- prepareListeMoyennesSousServices(sousServices)
-
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
-
- tdn.evaluations.each {Evaluation evaluation ->
- Note note = ligneTDN.notes.find {it.evaluation.id == evaluation.id}
- evalNotes.get(evaluation) << note?.valeurNumerique
- }
-
- List<NoteInfo> moyEleveSousServices = []
-
- sousServices.each {SousService sousService ->
-
- List<Note> notes = ligneTDN.notes.findAll {
- it.evaluation.modaliteMatiere.id == sousService.modaliteMatiere.id
- }
-
- Moyenne moySousService = calculationService.calculeMoyenneNotesPonderee(notes)
-
- if (moySousService?.isNumerique()) {
- sousServiceMoyennes.get(sousService) << moySousService.valeurNumerique
- }
-
- moyEleveSousServices << new NoteInfo(
- moySousService,
- sousService.coeff,
- false
- )
- }
-
- // La colonne "Moyenne"
- Moyenne moyenne = moyEleveSousServices ?
- calculationService.calculeMoyennePonderee(moyEleveSousServices) :
- calculationService.calculeMoyenneNotesPonderee(ligneTDN.notes)
-
- if (moyenne?.isNumerique()) {
- moyennes << moyenne.valeurNumerique
- }
-
- }
-
- }
-
- /**
- * Remplit la liste des moyennes de sous service avec la liste des sous-services
- * @param sousServices
- */
- private void prepareListeMoyennesSousServices(List<SousService> sousServices) {
- sousServices.each {sousServiceMoyennes.put(it, [])}
- }
-
- /**
- * Prépare la liste des notes d'évaluations avec la liste des évaluations
- * @param tdn
- */
- private void prepareListeNotesEvaluations(TableauDeNotes tdn) {
- tdn.evaluations.each {evalNotes.put(it, [])}
- }
-
- /**
- * Retrouve la liste des sous-services présent dans le tableau de notes
- * @param tdn
- * @return
- */
- private List<SousService> findAllSousServices(TableauDeNotes tdn) {
- return tdn.enseignement.service.getSousServices(tdn.typePeriode)
- }
-
-
-}
+++ /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.impression.tdn
-
-import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
-import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
-
-/**
- * Gestion des moyennes en fonctions d'une période
- * (reprise du code controlleur d'origine)
- * @author othe
- */
-class CalculMoyennePeriode {
-
- Map<TypePeriode, List<BigDecimal>> typePeriodeMoyennes = [:]
-
- private ResultatEleveEnseignementPeriode findResultatElevePeriode(TableauDeNotesLigne ligneTDN, TypePeriode typePeriode) {
-
- return ligneTDN.resultatsXmestresPrecedents.find {
- it.periode.typePeriode.id == typePeriode.id ||
- it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
- }
- }
-
-
- public CalculMoyennePeriode(List<TypePeriode> typePeriodeXmestres, TableauDeNotes tdn) {
- // initialisation des listes de notes par période
- typePeriodeXmestres.each {typePeriodeMoyennes.put(it, [])}
- typePeriodeMoyennes.put(tdn.typePeriode, [])
-
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
- // Colonnes "Xmestre"
- typePeriodeXmestres.each {TypePeriode typePeriode ->
-
- ResultatEleveEnseignementPeriode resultatXmestre = findResultatElevePeriode(ligneTDN, typePeriode)
- typePeriodeMoyennes.get(typePeriode) << resultatXmestre?.moyenne
-
- }
-
- typePeriodeMoyennes.get(tdn.typePeriode) << ligneTDN.resultat?.moyenne
- }
- }
-
- /**
- * Recherche une liste de notes pour une période
- * @param typePeriode
- * @return
- */
- public List<BigDecimal> get(TypePeriode typePeriode) {
- return (List<BigDecimal>) typePeriodeMoyennes.get(typePeriode)
- }
-
-}
package org.lilie.services.eliot.notes.impression.tdn
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
-import org.lilie.services.eliot.notes.resultat.CalculationService
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
-import org.lilie.services.eliot.utils.NoteFormateur
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.impression.donnees.tdn.TableauDeNotesImpression
-import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
-import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTableau
-import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.notes.Evaluation
-import org.lilie.services.eliot.scolarite.SousService
-import org.lilie.services.eliot.notes.Note
-import org.lilie.services.eliot.utils.EliotFormatter
-import org.lilie.services.eliot.notes.resultat.NoteInfo
-import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
-import org.lilie.services.eliot.notes.resultat.Moyenne
-import org.lilie.services.eliot.notes.notes.EtablissementNotesService
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
+import org.lilie.services.eliot.tableau.Tableau
+import org.lilie.services.eliot.tableau.Ligne
+import org.lilie.services.eliot.tableau.Cellule
/**
* Préparation des objets d'impression pour les tableaux de notes
*/
class ImpressionTdnService {
- static final NoteFormateur NF_PAR_DEFAUT = new NoteFormateur()
- static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
-
LocalPersonneService localPersonneService
- NotesTypePeriodeService notesTypePeriodeService
- CalculationService calculationService
- EtablissementNotesService etablissementNotesService
-
- /**
- * Prépare les données pour un tableau de note sur une année
- * @param securiteSession
- * @param tdn
- * @return
- */
- public TableauDeNotesImpression prepareDonneesAnnee(SecuriteSession securiteSession, TableauDeNotes tdn) {
-
- StructureEnseignement structureEnseignement =
- tdn.enseignement.service.structureEnseignement
-
- NoteFormateur nf = structureEnseignement.etablissement.etablissementNotes.
- getNoteFormateur()
-
- TableauDeNotesImpression tab = new TableauDeNotesImpression(
- classe: structureEnseignement.code,
- etablissement: structureEnseignement.etablissement.nomAffichage,
- enseignant: localPersonneService.findPersonneByAutorite(
- tdn.enseignement.enseignant
- ).nomAffichageInitiales(),
- matiere: tdn.enseignement.service?.matiere?.libelleCourt
- )
-
- construitTableauPeriodeAnnee(
- securiteSession,
- tdn,
- tab,
- nf
- )
-
- tab.appreciationGenerale = tdn.allAppreciationClasseEnseignementPeriode ?
- tdn.allAppreciationClasseEnseignementPeriode.first().appreciation : ""
-
- return tab
-
- }
+ TableauDeNotesService tableauDeNotesService
/**
- * Prépare un tableau de donnée pour une période
- * @param securiteSession
- * @param tdn
- * @return
+ * Transforme le TableauDeNotes en TableauDeNotesImpression
+ * @author bper
*/
- public TableauDeNotesImpression prepareDonneesAutrePeriode(SecuriteSession securiteSession, TableauDeNotes tdn) {
+ public TableauDeNotesImpression transformeToTableauDeNotesImpression(SecuriteSession securiteSession,
+ TableauDeNotes tdn,
+ OptionsImpressionParams optionsImpressionParams,
+ Closure message = {code -> code}) {
StructureEnseignement structureEnseignement =
- tdn.enseignement.service.structureEnseignement
-
- NoteFormateur nf = structureEnseignement.etablissement.etablissementNotes.
- getNoteFormateur()
+ tdn.enseignement.service.structureEnseignement
TableauDeNotesImpression tab = new TableauDeNotesImpression(
classe: structureEnseignement.code,
matiere: tdn.enseignement.service?.matiere?.libelleCourt
)
- construitTableauAutrePeriode(
- tdn,
- tab,
- nf
- )
-
- tab.appreciationGenerale = tdn.allAppreciationClasseEnseignementPeriode ?
- tdn.allAppreciationClasseEnseignementPeriode.first().appreciation : ""
-
- return tab
-
- }
+ tab.appreciationGenerale = tdn.getAppreciationClasse()
-
- private void construitTableauAutrePeriode(TableauDeNotes tdn, TableauDeNotesImpression tab, NoteFormateur nf) {
-
- tdn.evaluations.sort()
-
- List<SousService> sousServices =
- tdn.enseignement.service.getSousServices(tdn.typePeriode)
-
- CalculMoyenneEvaluation listeMoyennes = new CalculMoyenneEvaluation(
+ Tableau tableau = tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession,
tdn,
- calculationService
+ optionsImpressionParams.notesEtMoyennes,
+ optionsImpressionParams.appreciations
)
- // Création des lignes du TDN
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
- long indexEval = 1
- tdn.evaluations.each {Evaluation evaluation ->
+ tableau.traduisI18n(message)
- Note note = ligneTDN.notes.find {it.evaluation.id == evaluation.id}
+ Boolean isAnnee = tdn?.typePeriode?.isAnnee()
- CelluleTableau celluleTableau = new CelluleTableau(
- enteteLigne: ligneTDN.eleve.nomAffichage(),
- entete1: evaluation.titre,
- entete2: evaluation.modaliteMatiere?.libelle,
- entete3: EliotFormatter.format(evaluation.dateEvaluation),
- entete4: COEFF_NF.format(evaluation.noteMaxPossible),
- entete5: COEFF_NF.format(evaluation.coefficient),
- entete6: evaluation.typeActivite.code,
- valeur: NF_PAR_DEFAUT.format(note?.valeur),
- finLigne: ligneTDN.appreciation,
- index: indexEval,
- pied1: nf.format(calculationService.calculeMoyenne(listeMoyennes.getNotesEvaluation(evaluation))),
- pied3: NF_PAR_DEFAUT.format(calculationService.calculeMax(listeMoyennes.getNotesEvaluation(evaluation))), // on ne formatte pas les notes
- pied2: NF_PAR_DEFAUT.format(calculationService.calculeMin(listeMoyennes.getNotesEvaluation(evaluation))) // on ne formatte pas les notes
+ tableau.eachLigneWithIndex {Ligne ligne, Integer rowIndex ->
- )
- tab.data << celluleTableau
- indexEval++
+ List<Integer> allColIndex = ligne.getAllColIndex()
+ Integer colEleveIndex = allColIndex.first()
+ Integer colAppreciationIndex = optionsImpressionParams.appreciations ? allColIndex.last() : null
- }
+ ligne.eachCelluleWithIndex {Cellule cellule, Integer colIndex ->
- // Les colonnes "Moy. sous-matière"
- List<NoteInfo> moyEleveSousServices = []
+ // Eclusion des colonnes "élève" et "appréciation"
+ if (colIndex != colEleveIndex && colIndex != colAppreciationIndex) {
- long index = 1
+ CelluleTableau celluleTableau = new CelluleTableau(
+ enteteLigne: ligne.getCellule(colEleveIndex).valeur,
+ entete1: tableau.getCelluleEntete(1, colIndex).valeur,
+ entete2: !isAnnee ? tableau.getCelluleEntete(2, colIndex).valeur : '',
+ entete3: !isAnnee ? tableau.getCelluleEntete(3, colIndex).valeur : '',
+ entete4: !isAnnee ? tableau.getCelluleEntete(4, colIndex).valeur : '',
+ entete5: !isAnnee ? tableau.getCelluleEntete(5, colIndex).valeur : '',
+ entete6: !isAnnee ? tableau.getCelluleEntete(6, colIndex).valeur : '',
+ valeur: ligne.getCellule(colIndex).valeur,
+ finLigne: colAppreciationIndex ? ligne.getCellule(colAppreciationIndex).valeur : '',
+ index: colIndex,
+ pied1: tableau.getCellulePied(1, colIndex).valeur,
+ pied2: tableau.getCellulePied(2, colIndex).valeur,
+ pied3: tableau.getCellulePied(3, colIndex).valeur
+ )
- sousServices.each {SousService sousService ->
+ tab.data << celluleTableau
- List<Note> notes = ligneTDN.notes.findAll {
- it.evaluation.modaliteMatiere.id == sousService.modaliteMatiere.id
}
-
- Moyenne moySousService = calculationService.calculeMoyenneNotesPonderee(notes)
-
- CelluleI18n celluleSousMatiere = new CelluleI18n(
- enteteLigne: ligneTDN.eleve.nomAffichage(),
- entete1: 'eliot.notes.libelle.moyenneCourt',
- entete2: sousService.modaliteMatiere.code,
- entete3: '',
- entete4: COEFF_NF.format(20),
- entete5: COEFF_NF.format(sousService.coeff),
- valeur: nf.format(moySousService),
- index: 8000 + index,
- finLigne: ligneTDN.appreciation,
- pied1: nf.format(calculationService.calculeMoyenne(listeMoyennes.getNotesSousService(sousService))),
- pied3: nf.format(calculationService.calculeMax(listeMoyennes.getNotesSousService(sousService))),
- pied2: nf.format(calculationService.calculeMin(listeMoyennes.getNotesSousService(sousService)))
- )
-
- index++
-
- tab.data << celluleSousMatiere
-
- moyEleveSousServices << new NoteInfo(
- moySousService,
- sousService.coeff,
- false
- )
-
}
-
- tab.data << construitCelluleColonneMoyenne(
- moyEleveSousServices,
- ligneTDN,
- listeMoyennes.getMoyennesEleve(),
- nf
- )
-
- }
- }
-
- /**
- * ajoute une cellule de la colonne moyenne
- * @param moyEleveSousServices : liste des moyennes de sous-services
- * @param ligneTDN : ligne élève où se trouve la cellule
- * @param moyennes : liste des moyennes
- * @param nf : objet de formatage des notes
- * @return une cellule de tableau
- */
- private CelluleI18n construitCelluleColonneMoyenne(List<NoteInfo> moyEleveSousServices,
- TableauDeNotesLigne ligneTDN,
- List<BigDecimal> moyennes,
- NoteFormateur nf) {
-
- // La colonne "Moyenne"
- Moyenne moyenne = moyEleveSousServices ?
- calculationService.calculeMoyennePonderee(moyEleveSousServices) :
- calculationService.calculeMoyenneNotesPonderee(ligneTDN.notes)
-
- CelluleI18n celluleMoyenne = new CelluleI18n(
- enteteLigne: ligneTDN.eleve.nomAffichage(),
- entete1: 'eliot.notes.libelle.moyenneCourt',
- entete2: '',
- entete3: '',
- entete4: '',
- entete5: '',
- index: 9999,
- valeur: nf.format(moyenne),
- finLigne: ligneTDN.appreciation,
- pied1: nf.format(calculationService.calculeMoyenne(moyennes)),
- pied3: nf.format(calculationService.calculeMax(moyennes)),
- pied2: nf.format(calculationService.calculeMin(moyennes))
-
- )
-
- return celluleMoyenne
- }
-
-
- private ResultatEleveEnseignementPeriode findResultatElevePeriode(TableauDeNotesLigne ligneTDN, TypePeriode typePeriode) {
-
- return ligneTDN.resultatsXmestresPrecedents.find {
- it.periode.typePeriode.id == typePeriode.id ||
- it.periode.typePeriode.intervalle.getIntevalleEquivalent() == typePeriode.intervalle
- }
-
- }
-
- /**
- * Construction du contenu du tableau de note si la période choisit est année
- * @param securiteSession
- * @param tdn
- * @param tab
- * @param nf
- */
- private void construitTableauPeriodeAnnee(SecuriteSession securiteSession, TableauDeNotes tdn, TableauDeNotesImpression tab, NoteFormateur nf) {
-
- List<TypePeriode> typePeriodeXmestres =
- notesTypePeriodeService.findAllXmestreForService(
- securiteSession,
- tdn.enseignement.service,
- TypeIntervalleEnum.TRIMESTRE
- )
-
- CalculMoyennePeriode moyenneParPeriode = new CalculMoyennePeriode(
- typePeriodeXmestres,
- tdn
- )
-
- // Création des lignes du TDN
- tdn.lignes.each {TableauDeNotesLigne ligneTDN ->
-
- // Colonnes "Xmestre"
- long index = 1
-
- typePeriodeXmestres.each {TypePeriode typePeriode ->
-
- ResultatEleveEnseignementPeriode resultatXmestre = findResultatElevePeriode(ligneTDN, typePeriode)
-
- // Les moyennes de tous les élèves pour le type de période Xmestre et
- // un type équivalent
- List<BigDecimal> moyenneXmestres = moyenneParPeriode.get(typePeriode)
-
- CelluleTypePeriode celluleTableau = new CelluleTypePeriode(
- typePeriode: typePeriode,
- enteteLigne: ligneTDN.eleve.nomAffichage(),
- valeur: nf.format(resultatXmestre?.getValeurAffichage()),
- index: index,
- finLigne: ligneTDN.appreciation,
- entete4: COEFF_NF.format(20),
- entete5: COEFF_NF.format(1),
- pied1: nf.format(calculationService.calculeMoyenne(moyenneXmestres)),
- pied2: nf.format(calculationService.calculeMin(moyenneXmestres)),
- pied3: nf.format(calculationService.calculeMax(moyenneXmestres))
-
- )
- index++
-
- tab.data << celluleTableau
- }
- // Les moyenne de tous les élèves pour l'année
- List<BigDecimal> moyenneAnnees = moyenneParPeriode.get(tdn.typePeriode)
-
- CelluleTableau celluleMoyenne = new CelluleTableau(
- entete1: "Moy.",
- enteteLigne: ligneTDN.eleve.nomAffichage(),
- valeur: nf.format(ligneTDN.resultat?.getValeurAffichage()),
- index: 9999,
- finLigne: ligneTDN.appreciation,
- entete4: COEFF_NF.format(20),
- entete5: COEFF_NF.format(1),
- pied1: nf.format(calculationService.calculeMoyenne(moyenneAnnees, true)),
- pied2: nf.format(calculationService.calculeMin(moyenneAnnees)),
- pied3: nf.format(calculationService.calculeMax(moyenneAnnees)),
-
- )
-
- tab.data << celluleMoyenne
}
+ return tab
}
-
}
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.scolarite.Enseignement
/**
* @author bper
import org.lilie.services.eliot.notes.Evaluation
import org.lilie.services.eliot.notes.CalcMoyennesInfo
import org.lilie.services.eliot.notes.AppreciationClasseEnseignementPeriode
+import org.lilie.services.eliot.notes.Note
+import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.scolarite.SousService
/**
* Agrège les informations du tableau de notes
CalcMoyennesInfo calcMoyennesInfo
List<AppreciationClasseEnseignementPeriode> allAppreciationClasseEnseignementPeriode
+
+ List<Note> getNotesEvaluation(Evaluation evaluation) {
+ List<Note> allNotes = lignes*.notes.flatten().findAll { it }
+ return (List<Note>) allNotes.findAll {it.evaluation?.id == evaluation.id}
+ }
+
+ NoteFormateur getNoteFormateur() {
+ return enseignement.service.structureEnseignement.
+ etablissement.etablissementNotes.getNoteFormateur()
+ }
+
+ String getAppreciationClasse() {
+ return allAppreciationClasseEnseignementPeriode ?
+ allAppreciationClasseEnseignementPeriode.first().appreciation : ""
+ }
+
+ List<SousService> getSousServices() {
+ return enseignement.service.getSousServices(typePeriode)
+ }
}
eleveApps << app
mapAppreciations.put(eleve, eleveApps)
}
-
}
-
/**
* @return les notes d'un élève
*/
List<Note> getNotesForEleve(Personne eleve) {
- return mapNotes.get(eleve)
+ return mapNotes.get(eleve) ?: []
}
/**
* @return les résultats d'un élève
*/
List<ResultatEleveEnseignementPeriode> getResultatsForEleve(Personne eleve) {
- return mapResultats.get(eleve)
+ return mapResultats.get(eleve) ?: []
}
/**
* @return les appreciations d'un élève
*/
List<AppreciationEleveEnseignementPeriode> getAppreciationsForEleve(Personne eleve) {
- return mapAppreciations.get(eleve)
+ return mapAppreciations.get(eleve) ?: []
}
}
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.notes.resultat.eleve.ResultatEleveEnseignementPeriodeService
-import org.lilie.services.eliot.notes.resultat.NotesDirtyMoyenneService
-import org.lilie.services.eliot.notes.resultat.UptodateService
+
import org.lilie.services.eliot.notes.ResultatEleveEnseignementPeriode
import org.lilie.services.eliot.notes.Evaluation
import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
+
import org.lilie.services.eliot.notes.Note
import org.lilie.services.eliot.notes.exception.PeriodeVerrouilleException
import org.lilie.services.eliot.notes.NotesDroitService
import org.lilie.services.eliot.scolarite.SousService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.notes.CalcMoyennesInfo
-import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
+
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
-import java.util.Map.Entry
+
import org.lilie.services.eliot.notes.resultat.classe.AppreciationClasseEnseignementPeriodeService
import org.lilie.services.eliot.notes.resultat.eleve.AppreciationEleveEnseignementPeriodeService
import org.lilie.services.eliot.notes.AppreciationClasseEnseignementPeriode
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.structureenseignement.StructureEnseignementElevesListes
import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
-import org.lilie.services.eliot.notes.notes.NotesEvaluationService
-import org.lilie.services.eliot.notes.notes.NotesNoteService
-import org.lilie.services.eliot.notes.notes.NoteParams
+
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.notes.NotesFonction
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.notes.resultat.CalculationService
+
import org.lilie.services.eliot.notes.resultat.Moyenne
+import org.lilie.services.eliot.tableau.Tableau
+
+import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.tableau.Cellule
+import org.lilie.services.eliot.utils.EliotFormatter
+import org.lilie.services.eliot.scolarite.PeriodeService
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+
+import org.lilie.services.eliot.notes.notes.NoteParams
+import org.lilie.services.eliot.notes.notes.NotesEvaluationService
+import org.lilie.services.eliot.notes.notes.NotesNoteService
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+import org.lilie.services.eliot.notes.resultat.CalculationService
+import org.lilie.services.eliot.notes.resultat.NotesDirtyMoyenneService
+import org.lilie.services.eliot.notes.resultat.UptodateService
+import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
+import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
+
+import java.util.Map.Entry
+import org.lilie.services.eliot.notes.resultat.NoteInfo
/**
* Récuperation des tableaux de notes
EleveAnnuaireService eleveAnnuaireService
EnseignementService enseignementService
CalculationService calculationService
+ PeriodeService periodeService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
static transactional = true
- /**
- * Construis le tableau de notes
- * @author bper
- */
- TableauDeNotes construisTableauDeNotes(SecuriteSession securiteSession,
- Enseignement enseignement,
- TypePeriode typePeriode)
- throws AutorisationException, IllegalArgumentException {
- return construisTableauDeNotes(securiteSession, enseignement, typePeriode, true)
- }
+ static final NoteFormateur NF_PAR_DEFAUT = new NoteFormateur()
+ static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
+
/**
* Construis le tableau de notes
*/
TableauDeNotes construisTableauDeNotes(SecuriteSession securiteSession,
Enseignement enseignement,
- TypePeriode typePeriode,
- Boolean avecEvaluations)
+ TypePeriode typePeriode)
throws AutorisationException, IllegalArgumentException {
checkArgumentNotNull('enseignement', enseignement)
List<Evaluation> evaluations = []
- CalcMoyennesInfo calcInfo = new CalcMoyennesInfo()
-
- calcInfo = notesDirtyMoyenneService.internalVerifieMoyennesAjour(
+ CalcMoyennesInfo calcInfo = notesDirtyMoyenneService.internalVerifieMoyennesAjour(
enseignement.service.structureEnseignement
)
enseignement,
periodesDuTDN
)
+
+ evaluations.sort {it.dateEvaluation}
}
List<TableauDeNotesLigne> lignes = creeTableauDeNotesLignes(
evaluations: evaluations
)
- if (avecEvaluations == false) {
- tdn.evaluations = []
- }
-
return tdn
}
}
List<Periode> periodesPrecedentes =
- typePeriode.isNotation() ? (List) periodesDuTDN*.getPeriodesPrecedentes().flatten() : []
+ typePeriode.isNotation() ? (List) periodesDuTDN*.getPeriodesPrecedentes().flatten() : []
// Récupère les resultats des élèves pour l'enseignement
List<ResultatEleveEnseignementPeriode> resultats =
return enseignement
}
+
+
+ Tableau transformeToSimpleTableau(SecuriteSession securiteSession,
+ TableauDeNotes tdn,
+ Boolean avecNotes = true,
+ Boolean avecAppreciations = true) {
+
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
+ Tableau tableau = new Tableau()
+
+ ajouteColonneEleve(tableau, tdn, 0)
+
+ if (!tdn?.typePeriode?.isAnnee()){
+ if (avecNotes) {
+ ajouteColonnesEvaluations(tableau, tdn, 1)
+ ajouteColonnesMoyennesSousService(tableau, tdn, 1000)
+ }
+ }
+
+ if (pref.moyennesPrecedentes == true) {
+ ajouteColonnesMoyennesPrecedentes(securiteSession, tableau, tdn, 2000)
+ }
+
+ Map<Integer, BigDecimal> moyenneNumeriqueByLigne = ajouteColonneMoyenne(tableau, tdn, 3000)
+
+ if (pref.rangs == true) {
+ ajouteColonneRang(tableau, tdn, moyenneNumeriqueByLigne, 4000)
+ }
+
+ if (avecAppreciations){
+ ajouteColonneAppreciation(tableau, tdn, 5000)
+ }
+
+ return tableau
+ }
+
+
+ private void ajouteColonneEleve(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer colIndex) {
+
+ if (tdn?.typePeriode?.isAnnee()){
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.nomEleve', isCodeI18n: true))
+ } else {
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.titre', isCodeI18n: true))
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: 'eliot.notes.libelle.sousMatiere', isCodeI18n: true))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: 'eliot.notes.libelle.dateEvaluation', isCodeI18n: true))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: 'eliot.notes.libelle.devoirSur', isCodeI18n: true))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: 'eliot.notes.libelle.eleveCoeff', isCodeI18n: true))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: 'eliot.notes.libelle.type', isCodeI18n: true))
+ }
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur:tdnLigne.eleve.nomAffichage()))
+ }
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.moyennes', isCodeI18n: true))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: 'eliot.notes.libelle.noteMinMoyenneClasse', isCodeI18n: true))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: 'eliot.notes.libelle.noteMaxMoyenneClasse', isCodeI18n: true))
+ }
+
+
+ private void ajouteColonnesEvaluations(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer startColIndex) {
+
+ tdn.evaluations.eachWithIndex {Evaluation evaluation, Integer index ->
+ ajouteColonneEvaluation(tableau, tdn, evaluation, startColIndex + index)
+ }
+ }
+
+
+ private void ajouteColonneEvaluation(Tableau tableau,
+ TableauDeNotes tdn,
+ Evaluation evaluation,
+ Integer colIndex) {
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: evaluation.titre))
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: evaluation.modaliteMatiere?.libelle))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: EliotFormatter.format(evaluation.dateEvaluation)))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: COEFF_NF.format(evaluation.noteMaxPossible)))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: COEFF_NF.format(evaluation.coefficient)))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: evaluation.typeActivite.code))
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+ Note note = tdnLigne.notes.find {it.evaluation.id == evaluation.id}
+ Cellule celluleNote = new Cellule(valeur: NF_PAR_DEFAUT.format(note?.valeur))
+ tableau.setCellule(rowIndex, colIndex, celluleNote)
+ }
+
+ NoteFormateur nf = tdn.getNoteFormateur()
+
+ List<BigDecimal> notes = tdn.getNotesEvaluation(evaluation)*.valeurNumerique
+
+ String moyenneEvalClasse = nf.format(calculationService.calculeMoyenne(notes, true))
+
+ String noteEvalMax = NF_PAR_DEFAUT.format(calculationService.calculeMax(notes))
+ String noteEvalMin = NF_PAR_DEFAUT.format(calculationService.calculeMin(notes))
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: moyenneEvalClasse))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: noteEvalMin))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: noteEvalMax))
+ }
+
+
+ private void ajouteColonnesMoyennesSousService(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer startColIndex) {
+ List<SousService> sousServices = tdn.getSousServices()
+
+ sousServices.eachWithIndex {SousService sousService, Integer index ->
+ ajouteColonneMoyenneSousService(tableau, tdn, sousService, startColIndex + index)
+ }
+ }
+
+ private void ajouteColonneMoyenneSousService(Tableau tableau,
+ TableauDeNotes tdn,
+ SousService sousService,
+ Integer colIndex) {
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.moyenneCourt', isCodeI18n: true))
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: sousService.modaliteMatiere.code))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: COEFF_NF.format(20)))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: COEFF_NF.format(sousService.coeff)))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: ''))
+
+ List<BigDecimal> allMoyennesSousService = []
+
+ NoteFormateur nf = tdn.getNoteFormateur()
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+ List<Note> notes = tdnLigne.notes.findAll {
+ it.evaluation.modaliteMatiere.id == sousService.modaliteMatiere.id
+ }
+
+ Moyenne moyenneEleveSousService = calculationService.calculeMoyenneNotesPonderee(notes)
+
+ if (moyenneEleveSousService?.valeurNumerique != null) {
+ allMoyennesSousService << moyenneEleveSousService?.valeurNumerique
+ }
+
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur: nf.format(moyenneEleveSousService?.getValeurAffichage())))
+ }
+
+ String moyenneSousServiceClasse = nf.format(calculationService.calculeMoyenne(allMoyennesSousService)?.valeurNumerique)
+ String moyenneSousServiceMin = nf.format(calculationService.calculeMin(allMoyennesSousService))
+ String moyenneSousServiceMax = nf.format(calculationService.calculeMax(allMoyennesSousService))
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: moyenneSousServiceClasse))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: moyenneSousServiceMin))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: moyenneSousServiceMax))
+ }
+
+ private void ajouteColonneRang(Tableau tableau,
+ TableauDeNotes tdn,
+ Map<Integer, BigDecimal> moyenneNumeriqueByLigne,
+ Integer colIndex) {
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.rang', isCodeI18n: true))
+ if (!tdn?.typePeriode?.isAnnee()){
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: ''))
+ }
+
+ NoteFormateur nf = tdn.getNoteFormateur()
+
+ Map<BigDecimal, Integer> rangs =
+ calculationService.calculeRangs(moyenneNumeriqueByLigne.values().toList(), nf.getPrecision())
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+
+ String rang = ''
+
+ if (moyenneNumeriqueByLigne.containsKey(rowIndex)) {
+ BigDecimal moyenne = moyenneNumeriqueByLigne.get(rowIndex)
+ rang = rangs.get(moyenne)
+ }
+
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur: rang))
+ }
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: ''))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: ''))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: ''))
+ }
+
+ /**
+ * Ajoute les colonnes des moyennes des périodes précédentes
+ */
+ private void ajouteColonnesMoyennesPrecedentes(SecuriteSession securiteSession,
+ Tableau tableau,
+ TableauDeNotes tdn,
+ Integer colIndex) {
+ List<TypePeriode> typePeriodes =
+ notesTypePeriodeService.getTypePeriodes(securiteSession, tdn.enseignement.service)
+
+ List<TypePeriode> typePeriodePrecedents =
+ notesTypePeriodeService.getTypePeriodePrecedents(typePeriodes, tdn.typePeriode)
+
+ typePeriodePrecedents?.eachWithIndex {TypePeriode typePeriodePrecedent, Integer index ->
+ ajouteColonneMoyenneXmestre(
+ tableau,
+ tdn,
+ colIndex,
+ typePeriodePrecedent
+ )
+ colIndex++
+ }
+ }
+
+
+ /**
+ * Ajoute la colonne de moyenne d'un Xmestre indique par le type de période
+ */
+ private void ajouteColonneMoyenneXmestre(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer colIndex,
+ TypePeriode typePeriode){
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: periodeService.
+ getPeriodeCodeCourt(typePeriode?.libelle), isCodeI18n: true))
+
+ if (!tdn?.typePeriode?.isAnnee()){
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: ''))
+ }
+
+ NoteFormateur nf = tdn.getNoteFormateur()
+ List<BigDecimal> moyenneNumeriques = []
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+
+ TypePeriode typePeriodeEquivalent =
+ notesTypePeriodeService.getTypePeriodeEquivalent(typePeriode)
+
+ ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode =
+ tdnLigne.resultatsXmestresPrecedents.find{
+ it.periode.typePeriode.id == typePeriode.id ||
+ it.periode.typePeriode.id == typePeriodeEquivalent?.id
+ }
+
+ def moyenne = resultatEleveEnseignementPeriode?.getValeurAffichage()
+
+ if (moyenne instanceof BigDecimal) {
+ moyenneNumeriques << moyenne
+ }
+
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur: nf.format(moyenne)))
+ }
+
+ String moyenneClasse = nf.format(calculationService.calculeMoyenne(moyenneNumeriques))
+ String moyenneMin = nf.format(calculationService.calculeMin(moyenneNumeriques))
+ String moyenneMax = nf.format(calculationService.calculeMax(moyenneNumeriques))
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: moyenneClasse))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: moyenneMin))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: moyenneMax))
+ }
+
+
+ private Map<Integer, BigDecimal> ajouteColonneMoyenne(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer colIndex) {
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.moyenneCourt', isCodeI18n: true))
+ if (!tdn?.typePeriode?.isAnnee()){
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: ''))
+ }
+
+ NoteFormateur nf = tdn.getNoteFormateur()
+ List<BigDecimal> moyenneNumeriques = []
+ Map<Integer, BigDecimal> moyenneNumeriqueByLigne = [:]
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+ def moyenne = null
+
+ if (tdn.typePeriode.isAnnee()) {
+ // On utilise la moyenne stokée en base pour la période année
+ moyenne = tdnLigne.resultat?.getValeurAffichage()
+ } else {
+ // On calcule la moyenne à la volée
+ List<SousService> sousServices = tdn.getSousServices()
+ List<Note> notes = tdnLigne.notes
+
+ if (sousServices) {
+ List<NoteInfo> moyenneSousServices =
+ notes.groupBy {it.evaluation.modaliteMatiere.id}.collect {
+ Long modaliteMatiereId , List<Note> noteSousServices ->
+
+ SousService sousService = sousServices.find {
+ it.modaliteMatiere.id == modaliteMatiereId
+ }
+
+ new NoteInfo(
+ calculationService.calculeMoyenneNotesPonderee(noteSousServices),
+ sousService.coeff
+ )
+ }
+
+ moyenne = calculationService.calculeMoyennePonderee(moyenneSousServices)?.getValeur()
+ }
+ else {
+ moyenne = calculationService.calculeMoyenneNotesPonderee(notes)?.getValeur()
+ }
+ }
+
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur: nf.format(moyenne)))
+
+ if (moyenne instanceof BigDecimal) {
+ moyenneNumeriqueByLigne.put(rowIndex, moyenne)
+ moyenneNumeriques << moyenne
+ }
+ }
+
+ String moyenneClasse = nf.format(calculationService.calculeMoyenne(moyenneNumeriques))
+ String moyenneMin = nf.format(calculationService.calculeMin(moyenneNumeriques))
+ String moyenneMax = nf.format(calculationService.calculeMax(moyenneNumeriques))
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: moyenneClasse))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: moyenneMin))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: moyenneMax))
+
+ return moyenneNumeriqueByLigne
+ }
+
+
+ private void ajouteColonneAppreciation(Tableau tableau,
+ TableauDeNotes tdn,
+ Integer colIndex) {
+
+ tableau.setCelluleEntete(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.appreciations', isCodeI18n: true))
+ if (!tdn?.typePeriode?.isAnnee()){
+ tableau.setCelluleEntete(2, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(3, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(4, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(5, colIndex, new Cellule(valeur: ''))
+ tableau.setCelluleEntete(6, colIndex, new Cellule(valeur: ''))
+ }
+
+ tdn.lignes.eachWithIndex {TableauDeNotesLigne tdnLigne, Integer rowIndex ->
+ tableau.setCellule(rowIndex, colIndex, new Cellule(valeur: tdnLigne.appreciation))
+ }
+
+ tableau.setCellulePied(1, colIndex, new Cellule(valeur: 'eliot.notes.libelle.appreciationClasse', isCodeI18n: true))
+ tableau.setCellulePied(2, colIndex, new Cellule(valeur: tdn.getAppreciationClasse()))
+ tableau.setCellulePied(3, colIndex, new Cellule(valeur: ''))
+ }
+
}
Personne utilisateur = (Personne) securiteSession.getPersonne()
- return PreferenceUtilisateurNotes.createCriteria().get{
+ PreferenceUtilisateurNotes pref = PreferenceUtilisateurNotes.createCriteria().get{
eq('utilisateur', utilisateur)
}
+ if (!pref) {
+ pref = new PreferenceUtilisateurNotes(utilisateur: utilisateur)
+ pref.save(failOnError: true, flush: true)
+ }
+
+ return pref
}
void metAJourPreferenceUtilisateur(SecuriteSession securiteSession,
* @param ignoreAnnotations s'il faut ignorer les annotations
* (pour exemple pour les moyennes des classes)
* @param precision nombre de chiffres après la virgule (précision=2 => 0,01)
+ * @param interdisDepassement20 si on interdit la moyenne a depasser 20.
+ * Par defaut on l'interdit.
* @return moyenne arithmétique
* @author msan
* @author bper
*/
Moyenne calculeMoyenne(List listeValeurs,
Boolean ignoreAnnotations = false,
- int precision = PRECISION_PAR_DEFAUT) {
-
+ int precision = PRECISION_PAR_DEFAUT,
+ Boolean interdisDepassement20 = true
+ ) {
Moyenne moyenne = null
if (listeValeurs) {
BigDecimal total = 0
// notes numeriques saisies
moyenne = new Moyenne(total.divide(count, precision, RoundingMode.HALF_UP))
// il ne faut pas depasser Moyenne Maximal
- if (moyenne.valeurNumerique > MOYENNE_MAX) {
+ if (interdisDepassement20 && moyenne.valeurNumerique > MOYENNE_MAX) {
moyenne.valeurNumerique = MOYENNE_MAX
}
} else if (dernierNoteTextuelle != null && !ignoreAnnotations) {
*/
Map<BigDecimal, Integer> calculeRangs(List<BigDecimal> valeurs, BigDecimal precision = null) {
- List<BigDecimal> valeursOrdonnees = valeurs.sort().reverse()
+ List<BigDecimal> valeursOrdonnees = valeurs.grep{it != null}.sort().reverse()
Map<BigDecimal, Integer> mapValeurRang = [:]
// (rien ajuoté dans le dénominateur)
BigDecimal noteMaximal
- NoteInfo(Moyenne moyenne, BigDecimal coeff, Boolean optionel, BigDecimal noteMaximal = 20) {
+ NoteInfo(Moyenne moyenne, BigDecimal coeff, Boolean optionel = false, BigDecimal noteMaximal = 20) {
this.moyenne = moyenne
this.coeff = coeff
this.optionel = optionel
)
)
+ return internalFindAllTypePeriodeForService(service, seulementEvalauable, nature)
+ }
+
+ /**
+ * Retourne les types de période rattachés au service
+ * (Service -> RelPeriodeService -> Periode -> TypePeriode)
+ * @param service
+ * @param seulementEvaluable cherche seulement les rels évaluables
+ * @param nature
+ * @return List < TypePeriode >
+ * @throws IllegalArgumentException
+ * @author bper
+ */
+ List<TypePeriode> internalFindAllTypePeriodeForService(Service service,
+ Boolean seulementEvalauable,
+ NaturePeriode nature = null)
+ throws IllegalArgumentException {
+
+ if (!service) {
+ throw new IllegalArgumentException("Le paramètre {service} ne doit pas etre null")
+ }
+
List<TypePeriode> typePeriodes = RelPeriodeService.createCriteria().listDistinct {
eq('service', service)
if (seulementEvalauable) {
return xmestres
}
+ /**
+ * //TOCHECK on ne verifie pas la securite. est-ce genant dans ce cas d'utilisation ?
+ * @param service
+ * @return
+ */
+ List<TypePeriode> getTypePeriodes(SecuriteSession securiteSession, Service service) {
+ // Liste des périodes évaluables du service
+ List<TypePeriode> typePeriodes = findAllTypePeriodeForService(
+ securiteSession,
+ service,
+ true
+ )
+
+
+ // Enlève les types de période equivanlents
+ typePeriodes = excludeTypePeriodesEquivalents(
+ typePeriodes,
+ TypeIntervalleEnum.TRIMESTRE)
+
+ return typePeriodes
+ }
+
+
+ List<TypePeriode> getTypePeriodePrecedents(List<TypePeriode> typePeriodes,
+ TypePeriode typePeriode) {
+
+ typePeriodes = trieTypePeriodes(typePeriodes)
+
+ Integer i = typePeriodes.indexOf(typePeriode)
+
+ return (i == 0) ? [] : typePeriodes[0..i-1]
+ }
+
}
/**
* Creation des périodes
- * @param typePeriode
- * @param structureEnseignement
- * @param dateDebut
- * @param dateFin
- * @return
*/
Periode getOuCreePeriode(TypePeriode typePeriode,
StructureEnseignement structureEnseignement,
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.scolarite.Matiere
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.test.PopulationTestEtablissement
-import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.notes.notes.NoteParams
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigneParams
import org.lilie.services.eliot.scolarite.RelPeriodeService
import org.lilie.services.eliot.scolarite.OrigineEnum
-import org.lilie.services.eliot.scolarite.ModaliteCours
-import org.lilie.services.eliot.scolarite.AnneeScolaire
+
import org.lilie.services.eliot.test.PopulationTestMatiere
import org.lilie.services.eliot.notes.notes.tableaudenotes.EnregistreTableauDeNotesParams
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.notes.resultat.UptodateService
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
-import org.lilie.services.eliot.annuaire.ProprietesScolarite
-import org.lilie.services.eliot.annuaire.Fonction
-import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
import org.lilie.services.eliot.notes.resultat.MoyenneCalculLauncherService
-import org.lilie.services.eliot.scolarite.enseignement.EnseignementService
import org.lilie.services.eliot.test.PopulationTestClasse
-import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
import org.lilie.services.eliot.scolarite.StructureEnseignementSts
import org.lilie.services.eliot.textes.TypeActivite
+import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
+import org.lilie.services.eliot.scolarite.PeriodeService
+import org.lilie.services.eliot.tableau.Tableau
+
+import org.lilie.services.eliot.utils.NoteFormateur
class TableauDeNotesServiceTests extends GrailsUnitTestCase {
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
- UptodateService uptodateService
MoyenneCalculLauncherService moyenneCalculLauncherService
AnneeScolaireService anneeScolaireService
- ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
- EnseignementService enseignementService
+ EleveAnnuaireService eleveAnnuaireService
+ PeriodeService periodeService
InitPeriodeTestService initPeriodeTestService
TableauDeNotesService tableauDeNotesService
- StructureEnseignementNotesService structureEnseignementNotesService
-
- BigDecimal valeurNoteT1 = 15
- BigDecimal valeurNoteT2 = 15
- BigDecimal valeurNoteT3 = 12
- BigDecimal valeurNoteBrevet = 11
-
- //Preparer les dates pour les tests
- Date dateDebut1ApresDebut2 = new Date(1990, 5, 14)
- Date dateDebut2 = new Date(111, 5, 6)
- Date dateFin1 = new Date(111, 9, 25)
- Date dateFin2 = new Date(111, 10, 1)
- Date dateDebut3 = new Date(111, 6, 6)
- Date dateFin3 = new Date(111, 11, 25)
- Date dateDebut = new Date(111, 5, 17)
- Date dateFin = new Date(111, 9, 20)
- Date dateCreation1 = new Date(109, 12, 28)
- Date dateCreation = new Date(111, 1, 1)
- Date dateEvaluation = new Date(110, 2, 25)
-
- Date demain = null
-
- AnneeScolaire anneeScolaire = null
-
- //Preparer les periodes
- Periode periodeT1_1 = null
- Periode periodeT2_1 = null
- Periode periodeT3_1 = null
- Periode periodeAnnee_1 = null
- Periode periode_Brevet = null
- Periode periodeT1_2 = null
-
- //Etablissement
- Etablissement etablissement1 = null
- //Service
- Service service1classe1 = null
-
- Matiere matiere1 = null
- Matiere matiere2 = null
- Matiere matiere3 = null
-
- StructureEnseignement classe1enTrimestres = null
- StructureEnseignement classe2enTrimestres = null
- StructureEnseignement regroupement = null
-
- Enseignement enseignement = null
- Enseignement enseignement1 = null
- Enseignement enseignement2 = null
- Enseignement enseignement3 = null
- //eleve
- Personne eleve1classe1 = null
- Personne eleve4classe2 = null
- //Evaluation
- Evaluation eval_T1 = null
- Evaluation eval_T2 = null
- Evaluation eval_T3 = null
- Evaluation eval_Brevet = null
+ Etablissement etablissement = null
- //Noes
- Note note_T1 = null
- Note note_T2 = null
- Note note_T3 = null
- Note note_Brevet = null
+ StructureEnseignement classe1
+ StructureEnseignement classe2
+ StructureEnseignement regroupement
- //NotesParams
- NoteParams noteParams1Eleve1 = null
- NoteParams noteParams1Eleve2 = null
- NoteParams noteParams2Eleve1 = null
- NoteParams noteParams2Eleve2 = null
+ Personne eleve1 = null
+ Personne eleve2 = null
- //modaliteCours
- ModaliteCours modaliteCours = null
-
- SecuriteSession securiteSessionDirection = null
+ Personne enseignant = null
+ SecuriteSession securiteSessionEnseignant = null
+ Enseignement enseignement = null
- List<StructureEnseignement> classes = []
+ Personne directeur = null
+ SecuriteSession securiteSessionDirecteur = null
- Service service = null
+ TypePeriode t1 = null
+ TypePeriode t2 = null
+ TypePeriode t3 = null
+ TypePeriode annee = null
- PersonneProprietesScolarite personneProprietesScolarite = null
+ Evaluation eval1T1 = null
+ Evaluation eval2T1 = null
- private final String libelleInitial = 'libelleInitial'
+ Evaluation eval1T2 = null
+ Evaluation eval2T2 = null
- private final String appreciationEleve1 = 'assez bien'
- private final String appreciationEleve2 = 'Trés bien'
+ Evaluation eval1T3 = null
+ Evaluation eval2T3 = null
protected void setUp() {
super.setUp()
- //Initialiser les données
initPeriodeTestService.initialisePeriodesDeTest()
- // Récupération de la structure CLASSE_1 Etab 1
- etablissement1 = localInitDonneesCommunesTestService.getEtablissement(
+ t1 = initPeriodeTestService.t1
+ t2 = initPeriodeTestService.t2
+ t3 = initPeriodeTestService.t3
+ annee = initPeriodeTestService.annee
+
+ etablissement = localInitDonneesCommunesTestService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
- eleve1classe1 = creePersonne("111100098720000010", "Michal", "Luxo")
+ classe1 = localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_1)
+ classe2 = localInitDonneesCommunesTestService.getClasse(PopulationTestClasse.CLASSE_5)
- ProprietesScolarite propretesScolarite = creeProprietesScolarite()
+ periodeService.creePeriodesNotationPourStructureEnseignement(classe1)
+ periodeService.creePeriodesNotationPourStructureEnseignement(classe2)
- personneProprietesScolarite = creePersonneProprietesScolarite(
- eleve1classe1,
- propretesScolarite
- )
+ eleve1 = creePersonne("111100098720000010", "A", "B")
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, classe1)
- eleve4classe2 = creePersonne("11110147800011", "Amine", "Jao")
+ eleve2 = creePersonne("111101478000110000", "B", "A")
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, classe2)
- creePersonneProprietesScolarite(
- eleve4classe2,
- creeProprietesScolarite()
- )
- //anneescolaire
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
+ regroupement = creeRegroupement([classe1, classe2])
- //creer une classe classe1Trimestres
- classe1enTrimestres = localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1
- )
- structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
- classe1enTrimestres.save()
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve1, regroupement)
+ eleveAnnuaireService.ajouteEleveDansStructureEnseignement(eleve2, regroupement)
- //creer une classe classe2Trimestres
- classe2enTrimestres = localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_5
- )
- structureEnseignementNotesService.setTypeIntervalle(classe1enTrimestres, TypeIntervalleEnum.TRIMESTRE)
- classe1enTrimestres.save()
+ Service service = creeService(regroupement)
- //ajouter (inscription) l' eleve1 au classe1Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve1classe1,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
- //ajouter (inscription) l' eleve2 au classe2Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve4classe2,
- etablissement1,
- classe2enTrimestres,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
+ enseignant = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ENSEIGNANT_1)
+ securiteSessionEnseignant = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
+ directeur = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.DIRECTION_1)
+ securiteSessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1)
- modaliteCours = localInitDonneesCommunesTestService.getModaliteTestCG()
+ enseignement = creeEnseignement(enseignant.autorite, service)
- classes.add(classe1enTrimestres)
- classes.add(classe2enTrimestres)
+ eval1T1 = creeEvaluation(enseignement, t1)
+ eval2T1 = creeEvaluation(enseignement, t1)
- matiere1 = localInitDonneesCommunesTestService.
- getMatiere(PopulationTestMatiere.ANGLAIS)
- matiere2 = localInitDonneesCommunesTestService.
- getMatiere(PopulationTestMatiere.FRANCAIS)
- matiere3 = localInitDonneesCommunesTestService.
- getMatiere(PopulationTestMatiere.MATH)
+ eval1T2 = creeEvaluation(enseignement, t2)
+ eval2T2 = creeEvaluation(enseignement, t2)
- Calendar cal = GregorianCalendar.getInstance()
- cal.add(Calendar.DAY_OF_MONTH, 1)
- demain = cal.getTime() // demain
+ eval1T3 = creeEvaluation(enseignement, t3)
+ eval2T3 = creeEvaluation(enseignement, t3)
+
+ deverrouillePeriode(classe1, t1)
+ deverrouillePeriode(classe1, t2)
+ deverrouillePeriode(classe1, t3)
+ deverrouillePeriode(classe1, annee)
+ deverrouillePeriode(classe2, t1)
+ deverrouillePeriode(classe2, t2)
+ deverrouillePeriode(classe2, t3)
+ deverrouillePeriode(classe2, annee)
}
protected void tearDown() {
super.tearDown()
}
- /** Tester la saisie bloqué des notes lorsque la fin de saisie de periode est depassé
- * @author mjao
- */
- void testSaisieNotesBloque() {
- Date dateFinSaisie = new Date(109, 10, 20)
- EnregistreTableauDeNotesParams tableauDeNotesParams =
- initialiserTableauDeNotesParams(dateFinSaisie)
+ def testSaisieNotesPeriodeVerrouille() {
- Personne enseignant = localInitDonneesCommunesTestService.
- getPersonne(PopulationTestActeur.ENSEIGNANT_1)
- tableauDeNotesParams.operateurSaisie = enseignant
+ verrouillePeriode(classe2, t1)
- SecuriteSession securiteSessionens =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
+ EnregistreTableauDeNotesParams params = initEnregistreTableauDeNotesParams(
+ t1,
+ [
+ (eleve1): [(eval1T1): '15.5', (eval2T1): 'ABS'],
+ (eleve2): [(eval1T1): '10.12', (eval2T1): '1.01']
+ ],
+ [:]
+ )
- Boolean exceptionLeve = false
+ // Saisie par enseignant
+ Boolean exceptionLevee = false
try {
- tableauDeNotesService.enregistreTableauDeNotes(securiteSessionens,
- etablissement1,
- tableauDeNotesParams)
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
}
catch (PeriodeVerrouilleException e) {
- exceptionLeve = true
+ exceptionLevee = true
+ }
+
+ assertTrue(
+ "Saisie de notes par un enseignant doit etre bloquée pour l'élève 2 car la période T1 de sa classe est verrouillée",
+ exceptionLevee
+ )
+
+
+ // Correction par directeur
+ params.operateurSaisie = directeur
+ params.enseignantCorrige = enseignant
+
+ exceptionLevee = false
+ try {
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionDirecteur,
+ etablissement,
+ params)
}
- assertTrue("Saisie bloqué car la fin de saisie de periode est depassé", exceptionLeve)
+ catch (PeriodeVerrouilleException e) {
+ exceptionLevee = true
+ }
+
+ assertFalse(
+ "Correction de notes par un directeur ne doit jamais etre bloquée",
+ exceptionLevee
+ )
}
- /**
- * Tester la saisie bloquees de notes lorsque la fin de saisie de periode
- * n'est pas depassée
- * @author mjao
- */
- void testSaisieNotesAutorise() {
- // Remplir le tableauDeNotesParams
- Date dateFinSaisie = demain
- EnregistreTableauDeNotesParams tableauDeNotesParams =
- initialiserTableauDeNotesParams(dateFinSaisie)
+ def testSaisieAppreciationsPeriodeVerrouille() {
- Personne enseignant = localInitDonneesCommunesTestService.
- getPersonne(PopulationTestActeur.ENSEIGNANT_1)
- tableauDeNotesParams.operateurSaisie = enseignant
+ verrouillePeriode(classe2, t1)
- SecuriteSession securiteSessionens =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
+ EnregistreTableauDeNotesParams params = initEnregistreTableauDeNotesParams(
+ t1,
+ [:],
+ [
+ (eleve1): "Bon élève",
+ (eleve2): "Mauvais élève"
+ ]
+ )
- Boolean exceptionLeve = false
+ // Saisie par enseignant
+ Boolean exceptionLevee = false
try {
- tableauDeNotesService.enregistreTableauDeNotes(securiteSessionens,
- etablissement1,
- tableauDeNotesParams)
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
}
catch (PeriodeVerrouilleException e) {
- exceptionLeve = true
+ exceptionLevee = true
}
- assertFalse("Saisie bloqué car la fin de saisie de periode est depassé", exceptionLeve)
+
+ assertTrue(
+ "Saisie d'appréciations par un enseignant doit etre bloquée pour l'élève 2 car la période T1 de sa classe est verrouillée",
+ exceptionLevee
+ )
+
+
+ // Correction par directeur
+ params.operateurSaisie = directeur
+ params.enseignantCorrige = enseignant
+
+ exceptionLevee = false
+ try {
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionDirecteur,
+ etablissement,
+ params)
+ }
+ catch (PeriodeVerrouilleException e) {
+ exceptionLevee = true
+ }
+
+ assertFalse(
+ "Correction d'appréciations par un directeur ne doit jamais etre bloquée",
+ exceptionLevee
+ )
}
- /** Tester l'affichage des notes , des moyennes et des appreciations de
- * tableau de note
- * @author mjao
- */
- void testConstruireTableauDeNotesPeriodeAnnee() {
- // Dans ce test , on teste l'affichage des notes et des appreciation
- //on teste le recalcul des moyennes pour les periodes Notaion, Examen et Année
+ def testSaisieNotesEtAppreciationsAutorises() {
- initialiserDonneesTableauDeNotes()
+ verrouillePeriode(classe2, t1)
- SecuriteSession securiteSessionens =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1
+ EnregistreTableauDeNotesParams params = initEnregistreTableauDeNotesParams(
+ t1,
+ [(eleve1): [(eval1T1): '15.5', (eval2T1): 'ABS']],
+ [(eleve1): "Bon élève"]
)
- Autorite enseignant =
- localInitDonneesCommunesTestService.getAutorite(
- PopulationTestActeur.ENSEIGNANT_1
+ Boolean exceptionLevee = false
+ try {
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
+ }
+ catch (PeriodeVerrouilleException e) {
+ exceptionLevee = true
+ }
+
+ assertFalse(
+ "Saisie de notes et d'appréciations par un enseignant doit etre autorisée " +
+ "pour l'élève 1 car la période T1 de sa classe n'est pas verrouillée",
+ exceptionLevee
)
+ }
- List<Autorite> eleves = [eleve1classe1.autorite, eleve4classe2.autorite]
- uptodateService.marqueDirtyEleves(
- securiteSessionens,
- eleves,
- periodeT1_1,
- enseignement,
- null
+ def testConstruisTableauDeNotesPeriodeNotation() {
+
+ EnregistreTableauDeNotesParams params = initEnregistreTableauDeNotesParams(
+ t1,
+ [(eleve1): [(eval1T1): '7.5', (eval2T1): '9']],
+ [(eleve1): "Pas top"]
)
- uptodateService.marqueDirtyEleves(
- securiteSessionens,
- eleves,
- periodeT2_1,
- enseignement,
- null
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
+
+ params = initEnregistreTableauDeNotesParams(
+ t2,
+ [(eleve1): [(eval1T2): '12.5', (eval2T2): '10']],
+ [(eleve1): "Pas mal"]
)
- uptodateService.marqueDirtyEleves(
- securiteSessionens,
- eleves,
- periodeT3_1,
- enseignement,
- null
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
+
+ params = initEnregistreTableauDeNotesParams(
+ t3,
+ [
+ (eleve1): [(eval1T3): '19.5', (eval2T3): 'DISP'],
+ (eleve2): [(eval1T3): '10.12', (eval2T3): 'ABS']
+ ],
+ [
+ (eleve1): "Excellent!",
+ (eleve2): "Moyen"
+ ]
)
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
+
+ verrouillePeriode(classe2, t3)
+ eleveAnnuaireService.desactiveEleveDansStructureEnseignement(eleve2, regroupement)
- uptodateService.marqueDirtyEleves(
- securiteSessionens,
- eleves,
- periode_Brevet,
+ moyenneCalculLauncherService.calculeToutesMoyennes()
+
+ TableauDeNotes tdn = tableauDeNotesService.construisTableauDeNotes(
+ securiteSessionEnseignant,
enseignement,
- null
+ t3
)
- moyenneCalculLauncherService.calculeToutesMoyennes()
+ assertTrue(
+ "Le tableau de notes ne contient pas les 2 évaluations",
+ tdn.evaluations*.id.contains(eval1T3.id) && tdn.evaluations*.id.contains(eval2T3.id)
+ )
- TableauDeNotes params = tableauDeNotesService.construisTableauDeNotes(
- securiteSessionens,
- enseignementService.getEnseignement(
- service,
- enseignant
- ),
- initPeriodeTestService.annee
+ assertEquals(
+ "Le nombre de lignes de le tableau ne correspont pas au nombre d'élève dans le groupe",
+ 2,
+ tdn.lignes.size()
)
- TableauDeNotesLigne tableauDeNotesLigne =
- (TableauDeNotesLigne) params.lignes.find {
- it.eleve.autorite.id == eleve1classe1.autorite.id
- }
+ TableauDeNotesLigne ligneEleve1 = tdn.lignes.find {it.eleve.id == eleve1.id}
+ TableauDeNotesLigne ligneEleve2 = tdn.lignes.find {it.eleve.id == eleve2.id}
assertNotNull(
- "Le tableau de note de l'eleve1classe1 n'existe pas",
- tableauDeNotesLigne
+ "Tableau ne contient pas la ligne correspondant à l'élève 1",
+ ligneEleve1
)
- //Tester la bonne recuperation de typePeriode
- TypePeriode typePeriode = params.typePeriode
- assertEquals(
- "Le type de periode renvoyé par le tableau de notes n'est pas correcte",
- typePeriode,
- initPeriodeTestService.annee
+ assertNotNull(
+ "Tableau ne contient pas la ligne correspondant à l'élève 2",
+ ligneEleve2
)
assertEquals(
- "L'eleve n'a pas les resultas pour toutes les périodes",
- 3, // (T1, T2, T3)
- tableauDeNotesLigne.resultatsXmestresPrecedents.size()
+ "La classe de l'élève 1 n'est pas correcte",
+ classe1.id,
+ ligneEleve1.classe.id
)
- //Verifer la recuperation de la bonne classe
assertEquals(
- "Le classe qui correspond à l'eleve1classe1 n'est pas correcte",
- tableauDeNotesLigne.classe.id,
- classe1enTrimestres.id
+ "La classe de l'élève 1 n'est pas correcte",
+ classe2.id,
+ ligneEleve2.classe.id
+ )
+
+ assertFalse(
+ "Ligne du tableau qui correspont à l'élève 1 est vérrouillée",
+ ligneEleve1.verrouille
+ )
+
+ assertTrue(
+ "Ligne du tableau qui correspont à l'élève 1 n'est pas vérrouillée",
+ ligneEleve2.verrouille
+ )
+
+ assertNull(
+ "La date de verrouillage n'est pas null pour l'élève 1 alors que la période n'est pas verrouillée",
+ ligneEleve1.dateVerrouillage
)
- //verifer le calcul de moyenne
- BigDecimal moyenneAnnee = (valeurNoteT1 + valeurNoteT2 + valeurNoteT3) / 3
assertEquals(
- "La moyenne d'annee n'est pas correct",
- moyenneAnnee,
- tableauDeNotesLigne.resultat.moyenne
- )
-
- //Tester le cas d'une periode de type notation
- TableauDeNotes params_Notation =
- tableauDeNotesService.construisTableauDeNotes(
- securiteSessionens,
- enseignementService.getEnseignement(
- service,
- enseignant
- ),
- initPeriodeTestService.t1
- )
-
- //Tester la recuperation de TableauDeNoteLigne de l'eleve pour la periode T1
- TableauDeNotesLigne tableauDeNotesLigneNotation =
- (TableauDeNotesLigne) params_Notation.lignes.find {
- it.eleve.id == eleve1classe1.id
- }
+ "La date de verrouillage pour l'élève 2 n'est pas correcte",
+ findPeriode(classe2, t3).dateFinSaisie,
+ ligneEleve2.dateVerrouillage
+ )
- assertNotNull(
- "Le tableau de note de l'eleve1classe1 n'existe pas",
- tableauDeNotesLigneNotation
+ assertTrue(
+ "L'élève 1 n'est pas actif dans le tableau alors qu'il l'est dans le regroupement",
+ ligneEleve1.actif
+ )
+
+ assertFalse(
+ "L'élève 2 est actif dans le tableau alors qu'il ne l'est pas dans le regroupement",
+ ligneEleve2.actif
)
- //Tester la bonne recuperation de typePeriode
- typePeriode = params_Notation.typePeriode
assertEquals(
- "Le type de periode renvoyé par le tableau de notes n'est pas correct",
- typePeriode,
- initPeriodeTestService.t1
+ "La période de l'élève 1 ne correspon pas à la pétiode T3 de sa classe",
+ findPeriode(classe1, t3),
+ ligneEleve1.periode
)
- //Tester la recuperation de resultat
- assertNotNull(
- "le resultat de l'eleve1classe1 n'existe pas",
- tableauDeNotesLigneNotation.resultat
+ assertEquals(
+ "La période de l'élève 2 ne correspon pas à la pétiode T3 de sa classe",
+ findPeriode(classe2, t3),
+ ligneEleve2.periode
)
- //Tester la recuperation des notes pour la periode T_1
- Note noteNotation = (Note) tableauDeNotesLigneNotation.notes.find {
- it.id == note_T1.id
- }
+ assertTrue(
+ "La ligne correspondante à l'élève 1 ne contient pas les 2 notes enregistrées",
+ ligneEleve1.notes.size() == 2
+ )
- assertNotNull(
- "La note de l'eleve pour la periode T1 n'existe pas",
- noteNotation
+ assertEquals(
+ "La valeur de la note pour l'eval1T3 n'est pas correcte pour l'élève 1",
+ 19.5,
+ ligneEleve1.notes.find {it.evaluation.id == eval1T3.id}.getValeur()
)
- //Tester le cas pour une periode D'EXaman
- TableauDeNotes params_Examen =
- tableauDeNotesService.construisTableauDeNotes(
- securiteSessionens,
- enseignementService.getEnseignement(
- service,
- enseignant
- ),
- initPeriodeTestService.brevetBlanc
+ assertEquals(
+ "La valeur de la note pour l'eval2T3 n'est pas correcte pour l'élève 1",
+ 'DISP',
+ ligneEleve1.notes.find {it.evaluation.id == eval2T3.id}.getValeur()
)
- TableauDeNotesLigne tableauDeNotesLigneExamen =
- (TableauDeNotesLigne) params_Examen.lignes.find {
- it.eleve.id == eleve1classe1.id
- }
+ assertTrue(
+ "La ligne correspondante à l'élève 1 ne contient pas le bon résultat",
+ ligneEleve1.resultat != null &&
+ ligneEleve1.resultat.periode.id == findPeriode(classe1, t3).id &&
+ ligneEleve1.resultat.eleve.id == eleve1.autorite.id
+ )
- assertNotNull(
- "Le tableau de note de l'eleve1classe1 pour la periode Examen n'existe pas",
- tableauDeNotesLigneExamen
+ assertTrue(
+ "La ligne correspondante à l'élève 1 ne contient pas les résultats des périodes précedentes T1 et T2",
+ ligneEleve1.resultatsXmestresPrecedents.size() == 2
)
- //Tester la bonne recuperation de typePeriode
- typePeriode = params_Examen.typePeriode
assertEquals(
- "Le type de periode renvoyé par le tableau de notes n'est pas correcte",
- typePeriode,
- initPeriodeTestService.brevetBlanc
+ "L'appréciation de l'élève 1 n'est pas correcte",
+ "Excellent!",
+ ligneEleve1.appreciation
)
- //Tester la recuperation de resultat
- assertNotNull(
- "le resultat de l'eleve1classe1 n'existe pas",
- tableauDeNotesLigneExamen.resultat
+
+ // Periode année
+ params = initEnregistreTableauDeNotesParams(
+ annee,
+ [:],
+ [(eleve1): "Très bonne année", (eleve2): "Moyen"]
)
- //Tester la recuperation des notes pour la periode T_1
- Note noteBrevet = (Note) tableauDeNotesLigneExamen.notes.find {
- it.id == note_Brevet.id
- }
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
- assertNotNull(
- "La note de l'eleve pour la periode T1 n'existe pas",
- noteBrevet
+ tdn = tableauDeNotesService.construisTableauDeNotes(
+ securiteSessionEnseignant,
+ enseignement,
+ annee
+ )
+
+ ligneEleve1 = tdn.lignes.find {it.eleve.id == eleve1.id}
+
+ assertTrue(
+ "La ligne correspondante à l'élève 1 ne contient pas les résultats des périodes précedentes T1, T2 et T2",
+ ligneEleve1.resultatsXmestresPrecedents.size() == 3
)
+ assertEquals(
+ "L'appréciation de l'élève 1 n'est pas correcte",
+ "Très bonne année",
+ ligneEleve1.appreciation
+ )
}
- void testEnregistrementBloquePourEleveInactif() {
- //Tester le cas d'enregistrement des notes pour un eleve inactif : eleve.autorite = false
- eleve1classe1.autorite.estActive = false
- eleve1classe1.autorite.dateDesactivation = new Date()
- eleve1classe1.autorite.etat = CompteUtilisateurEtat.INACTIF
+ def testTransformeToSimpleTableauSansSousMatieres() {
- // Remplir le tableauDeNotesParams
- Date dateFinSaisie = demain
- EnregistreTableauDeNotesParams tableauDeNotesParams =
- initialiserTableauDeNotesParams(dateFinSaisie)
+ eval2T2.coefficient = 2
+ eval2T2.save(failOnError: true)
- Personne enseignant = localInitDonneesCommunesTestService.
- getPersonne(PopulationTestActeur.ENSEIGNANT_1)
- tableauDeNotesParams.operateurSaisie = enseignant
+ EnregistreTableauDeNotesParams params = initEnregistreTableauDeNotesParams(
+ t1,
+ [
+ (eleve1): [(eval1T1): '15.5'],
+ (eleve2): [(eval1T1): '10.5']
+ ],
+ [:]
+ )
- SecuriteSession securiteSessionens =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
+ params = initEnregistreTableauDeNotesParams(
+ t2,
+ [
+ (eleve1): [(eval1T2): '7.5', (eval2T2): 'ABS'],
+ (eleve2): [(eval1T2): '10.5', (eval2T2): '11.5']
+ ],
+ [
+ (eleve1): "Pas top",
+ (eleve2): "Pas mieux"
+ ]
+ )
- Boolean exceptionLeve = false
- try {
- tableauDeNotesService.enregistreTableauDeNotes(securiteSessionens,
- etablissement1,
- tableauDeNotesParams)
- }
- catch (IllegalArgumentException) {
- exceptionLeve = true
- }
- assertFalse("Enregistrement de notes doit être possible même pour un élève inactif : eleve change etablissement",
- exceptionLeve)
+ params.appreciation = "Très mauvais trimestre pout tous"
- //Tester le cas d'enregistrement des notes pour un eleve inactif : l'eleve change de classe
- personneProprietesScolarite.estActive = false
+ tableauDeNotesService.enregistreTableauDeNotes(
+ securiteSessionEnseignant,
+ etablissement,
+ params)
- exceptionLeve = false
- try {
- tableauDeNotesService.enregistreTableauDeNotes(securiteSessionens,
- etablissement1,
- tableauDeNotesParams)
- }
- catch (IllegalArgumentException) {
- exceptionLeve = true
- }
- assertFalse("Enregistrement de notes doit être possible même pour un élève inactif: eleve change de classe",
- exceptionLeve)
+ moyenneCalculLauncherService.calculeToutesMoyennes()
+
+ TableauDeNotes tdn = tableauDeNotesService.construisTableauDeNotes(
+ securiteSessionEnseignant,
+ enseignement,
+ t2
+ )
+
+ Tableau tableau = tableauDeNotesService.transformeToSimpleTableau(
+ securiteSessionEnseignant,
+ tdn
+ )
+
+ NoteFormateur moyenneFormateur = tdn.getNoteFormateur()
+ NoteFormateur noteFormateur = new NoteFormateur(0.01, ',')
+
+
+ //****** Vérifie la 1ère ligne du tableau *******
+
+ assertEquals(
+ "Contenu de la cellule [0, 0] est incorrecte (nom de l'élève 1)",
+ eleve1.nomAffichage(),
+ tableau.getCellule(0, 0).valeur
+ )
+
+ assertEquals(
+ "Contenu de la cellule [0, 1] est incorrecte (note évaluation 1 élève 1)",
+ noteFormateur.format('7.5'),
+ tableau.getCellule(0, 1).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule [0, 2] est incorrecte (note évaluation 2 élève 1)",
+ 'ABS',
+ tableau.getCellule(0, 2).valeur,
+ )
+ assertEquals(
+ "Contenu de la cellule [0, 2000] est incorrecte (moyenne T1 élève 1)",
+ moyenneFormateur.format('15.5'),
+ tableau.getCellule(0, 2000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule [0, 3000] est incorrecte (moyenne générale élève 1)",
+ moyenneFormateur.format('7.5'),
+ tableau.getCellule(0, 3000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule [0, 4000] est incorrecte (rang élève 1)",
+ '2',
+ tableau.getCellule(0, 4000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule [0, 5000] est incorrecte (appréciation élève 1)",
+ "Pas top",
+ tableau.getCellule(0, 5000).valeur,
+ )
+
+
+ // ****** Vérifie le peid du tableau ********
+
+ // Colonne évaluation 1
+ BigDecimal moyClasseEval1 = (7.5 + 10.5)/2
+
+ assertEquals(
+ "Contenu de la cellule du pied [1, 1] est incorrecte (moyenne classe évaluation 1)",
+ moyenneFormateur.format(moyClasseEval1),
+ tableau.getCellulePied(1, 1).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [2, 1] est incorrecte (note min évaluation 1)",
+ noteFormateur.format('7.5'),
+ tableau.getCellulePied(2, 1).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [3, 1] est incorrecte (note max évaluation 1)",
+ noteFormateur.format('10.5'),
+ tableau.getCellulePied(3, 1).valeur,
+ )
+
+ // Colonne évaluation 2
+ assertEquals(
+ "Contenu de la cellule du pied [1, 2] est incorrecte (moyenne classe évaluation 2)",
+ moyenneFormateur.format('11.5'),
+ tableau.getCellulePied(1, 2).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [2, 2] est incorrecte (note min évaluation 2)",
+ noteFormateur.format('11.5'),
+ tableau.getCellulePied(2, 2).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [3, 2] est incorrecte (note max évaluation 2)",
+ noteFormateur.format('11.5'),
+ tableau.getCellulePied(3, 2).valeur,
+ )
+
+ // Colonne moyenne T1
+ BigDecimal moyClasseT1 = (15.5 + 10.5)/2
+
+ assertEquals(
+ "Contenu de la cellule du pied [1, 2000] est incorrecte (moyenne groupe T1)",
+ moyenneFormateur.format(moyClasseT1),
+ tableau.getCellulePied(1, 2000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [2, 2000] est incorrecte (moyenne min T1)",
+ moyenneFormateur.format('10.5'),
+ tableau.getCellulePied(2, 2000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [3, 2000] est incorrecte (moyenne max T1)",
+ moyenneFormateur.format('15.5'),
+ tableau.getCellulePied(3, 2000).valeur,
+ )
+
+ // Colonne moyenne générale
+ BigDecimal moyEleve1 = 7.5
+ BigDecimal moyEleve2 = (10.5 + 11.5 * 2)/(1 + 2) // Moyenne pondérée des notes
+ BigDecimal moyClasse = (moyEleve1 + moyEleve2)/2 // Moyenne simple de moyennes élèves
+
+ assertEquals(
+ "Contenu de la cellule du pied [1, 3000] est incorrecte (moyenne générale groupe)",
+ moyenneFormateur.format(moyClasse),
+ tableau.getCellulePied(1, 3000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [2, 3000] est incorrecte (moyenne générale min)",
+ moyenneFormateur.format(moyEleve1),
+ tableau.getCellulePied(2, 3000).valeur,
+ )
+
+ assertEquals(
+ "Contenu de la cellule du pied [3, 3000] est incorrecte (moyenne générale max)",
+ moyenneFormateur.format(moyEleve2),
+ tableau.getCellulePied(3, 3000).valeur,
+ )
+
+ // Appréciation générale
+ assertEquals(
+ "Contenu de la cellule du pied [2, 5000] est incorrecte (appréciation générale)",
+ params.appreciation,
+ tableau.getCellulePied(2, 5000).valeur,
+ )
}
- /**
- * Creation ou recupeartion des périodes
- * @param typePeriode
- * @param structureEnseignement
- * @param dateDebut
- * @param dateFin
- * @param dateFin
- ** @return periode
- * @autor mjao
- */
- private Periode getOuCreePeriode(TypePeriode typePeriode,
- StructureEnseignement structureEnseignement,
- Date dateDebut,
- Date dateFin,
- Date dateFinSaisie) {
-
- Periode periode = Periode.findByTypePeriodeAndClasse(typePeriode, structureEnseignement)
- if (!periode) {
- periode = new Periode(
- typePeriode: typePeriode,
- classe: structureEnseignement,
- dateDebut: dateDebut,
- dateFin: dateFin,
- dateFinSaisie: dateFinSaisie,
- datePublicationBulletins: dateCreation
+
+ private EnregistreTableauDeNotesParams initEnregistreTableauDeNotesParams(TypePeriode typePeriode,
+ Map eleveEvalNote,
+ Map eleveAppreciation) {
+
+ List<Personne> eleves = (List) (eleveEvalNote.keySet().toList() + eleveAppreciation.keySet().toList())
+
+ List<TableauDeNotesLigneParams> lignes = eleves.collect {Personne eleve ->
+ new TableauDeNotesLigneParams(
+ eleve: eleve,
+ appreciation: eleveAppreciation.get(eleve),
+ notes: eleveEvalNote.get(eleve)?.collect {Evaluation eval, String note ->
+ new NoteParams(
+ eleve: eleve,
+ evaluation: eval,
+ valeur: note
+ )
+ }
)
- structureEnseignement.addToPeriodes(periode)
- } else {
- periode.dateDebut = dateDebut
- periode.dateFin = dateFin
- periode.dateFinSaisie = dateFinSaisie
}
- periode.save(flush: true)
- return periode
+
+ return new EnregistreTableauDeNotesParams(
+ service: enseignement.service,
+ typePeriode: typePeriode,
+ lignes: lignes,
+ operateurSaisie: enseignant
+ )
+ }
+
+ private void verrouillePeriode(StructureEnseignement classe,
+ TypePeriode typePeriode) {
+
+ Calendar cal = GregorianCalendar.getInstance()
+ cal.add(Calendar.DAY_OF_YEAR, -1)
+ Date hier = cal.getTime()
+
+ setDateFinPeriode(classe, typePeriode, hier)
}
- /**
- * Crée ou get une evaluation attaché a une periode
- * @author mjao
- */
- private Evaluation creeEvaluation(List<Periode> periodes,
- Enseignement enseignement,
- Date dateCreation) {
+
+ private void deverrouillePeriode(StructureEnseignement classe,
+ TypePeriode typePeriode) {
+
+ Calendar cal = GregorianCalendar.getInstance()
+ cal.add(Calendar.DAY_OF_YEAR, 1)
+ Date demain = cal.getTime()
+
+ setDateFinPeriode(classe, typePeriode, demain)
+ }
+
+ private void setDateFinPeriode(StructureEnseignement classe,
+ TypePeriode typePeriode,
+ Date daiteFinPeriode) {
+
+ Periode periode = findPeriode(classe, typePeriode)
+
+ periode.dateFinSaisie = daiteFinPeriode
+
+ periode.save(failOnError: true, flush: true)
+ }
+
+ private Periode findPeriode(StructureEnseignement classe, TypePeriode typePeriode) {
+ return Periode.findByClasseAndTypePeriode(classe, typePeriode)
+ }
+
+
+ private Evaluation creeEvaluation(Enseignement enseignement, TypePeriode typePeriode) {
+
+ StructureEnseignement structureEnseignement = enseignement.service.structureEnseignement
+
+ List<Periode> periodes = structureEnseignement.isClasse() ?
+ structureEnseignement.periodes.toList() :
+ structureEnseignement.classes.toList()*.periodes.flatten().toList()
Evaluation evaluation = new Evaluation(
enseignement: enseignement,
- dateCreation: dateCreation,
- dateEvaluation: dateEvaluation,
- periodes: periodes,
+ dateEvaluation: new Date(),
+ periodes: (Set) periodes.findAll {it.typePeriode.id == typePeriode.id},
publiable: true,
- titre: libelleInitial,
+ titre: "Devoir",
coefficient: 1,
noteMaxPossible: 20,
typeActivite: TypeActivite.findByEtablissement(
}
- /**
- * Crée un service minimal
- * @param matiere matière
- * @param structureEnseignement
- * @param origine de service
- * @author msan
- * @author mjao
- */
- private Service creeService(Matiere matiere,
- StructureEnseignement structureEnseignement,
- OrigineEnum origine) {
+ private Service creeService(StructureEnseignement structureEnseignement) {
Service service = new Service(
- modaliteCours: modaliteCours,
+ modaliteCours: localInitDonneesCommunesTestService.getModaliteTestCG(),
structureEnseignement: structureEnseignement,
- matiere: matiere,
- origine: origine,
+ matiere: localInitDonneesCommunesTestService.getMatiere(PopulationTestMatiere.ANGLAIS),
+ origine: OrigineEnum.MANUEL,
servicePrincipal: true
)
- service.save(flush: true)
- if (service.hasErrors()) {
- println(service.errors)
- }
- attacheService(structureEnseignement, service)
+ service.save(flush: true, failOnError: true)
+ attacheServiceAuxPeriodes(structureEnseignement, service)
return service
}
- /**
- * Attache service à toutes les périodes de la structure
- * @param structureEnseignemen
- * @param service
- * @autor mjao
- */
- private void attacheService(StructureEnseignement structureEnseignement,
- Service service) {
- structureEnseignement.periodes.each { Periode periode ->
+
+ private void attacheServiceAuxPeriodes(StructureEnseignement structureEnseignement,
+ Service service) {
+
+ List<Periode> periodes = structureEnseignement.isClasse() ?
+ structureEnseignement.periodes.toList() :
+ structureEnseignement.classes.toList()*.periodes.flatten()
+
+ periodes.each { Periode periode ->
RelPeriodeService rel = getRelPeriodeService(periode, service)
service.addToRelPeriodeServices(rel)
- service.save(flush: true)
+ service.save(flush: true, failOnError: true)
}
}
- /**
- * Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
- * @return RelPeriodeService
- */
+
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periode, service)
if (!rel) {
rel = new RelPeriodeService(periode: periode, service: service)
rel.evaluable = true
rel.coeff = 1
- rel.save(flush: true)
+ rel.save(flush: true, failOnError: true)
}
return rel
}
- /**
- * Crée une Enseignement
- * @author mjao
- */
+
private Enseignement creeEnseignement(Autorite enseignant, Service service) {
Enseignement enseignement = new Enseignement(
return enseignement
}
- /**
- * Crée un regroupement
- * @author mjao
- */
- private StructureEnseignement creeRegroupement(List<StructureEnseignement> classes,
- List<Periode> periodes) {
- regroupement = new StructureEnseignement(
+
+ private StructureEnseignement creeRegroupement(List<StructureEnseignement> classes) {
+
+ StructureEnseignement regroupement = new StructureEnseignement(
idExterne: "1275000000",
type: StructureEnseignement.TYPE_GROUPE,
classes: classes,
- periodes: periodes,
code: "2ndTest",
- anneeScolaire: anneeScolaire,
- etablissement: etablissement1,
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ etablissement: etablissement,
structureEnseignementNotes: new StructureEnseignementNotes(),
structureEnseignementSts: new StructureEnseignementSts()
)
- regroupement.save(flush: true)
+
+ regroupement.save(flush: true, failOnError: true)
+
return regroupement
}
- /**
- * 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, Evaluation evaluation, BigDecimal valeur) {
- Note note = new Note(
- eleve: eleve,
- evaluation: evaluation,
- valeurNumerique: valeur
- )
- note.save(flush: true)
- if (note.hasErrors()) {
- println(note.errors)
- }
- return note
- }
- /**
- * Crée une personne (eleve)
- * idExterne l'idExterne de la personne
- * @return personne l'eleve
- * @author mjao
- */
private Personne creePersonne(String idExterne, String nom, String prenom) {
Autorite autorite = new Autorite(
type: Autorite.TYPE_ACTEUR,
idExterne: idExterne
)
- autorite.save()
-
- if (autorite.hasErrors()) {
- println(autorite.errors)
- }
+ autorite.save(failOnError: true)
Personne personne = new Personne(
nom: nom,
prenom: prenom,
autorite: autorite,
- etablissementRattachement: etablissement1
+ etablissementRattachement: etablissement
)
- personne.save()
- if (personne.hasErrors()) {
- println(personne.errors)
- }
- return personne
+ personne.save(failOnError: true, flush: true)
- }
-
- /**
- * Crée une ProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private ProprietesScolarite creeProprietesScolarite() {
-
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- etablissement: etablissement1
- )
- proprietesScolarite.save()
- if (proprietesScolarite.hasErrors()) {
- println(proprietesScolarite.errors)
- }
- return proprietesScolarite
-
- }
-
- /**
- * Crée une PersonneProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private PersonneProprietesScolarite creePersonneProprietesScolarite(
- Personne personne,
- ProprietesScolarite proprietesScolarite
- ) {
-
- PersonneProprietesScolarite personneProprietesScolarite =
- new PersonneProprietesScolarite(
-
- personne: personne,
- proprietesScolarite: creeProprietesScolarite(),
- estActive: true
-
- )
- personneProprietesScolarite.save()
- return personneProprietesScolarite
- }
-
- /**
- * Initialiser le dto TableauDeNotesParams
- * @param dateFinSaisiet
- * @author mjao
- */
- EnregistreTableauDeNotesParams initialiserTableauDeNotesParams(Date dateFinSaisie) {
- periodeT1_1 = getOuCreePeriode(initPeriodeTestService.t1,
- classe1enTrimestres,
- dateDebut1ApresDebut2,
- dateFin1,
- dateFinSaisie)
- periodeT1_2 = getOuCreePeriode(initPeriodeTestService.t1,
- classe2enTrimestres,
- dateDebut2,
- dateFin2,
- dateFinSaisie)
- //creer un regroupement attaché au periodes periodeT1_1 ,periodeT1_2
- List<Periode> periodes = [periodeT1_1, periodeT1_2]
- regroupement = creeRegroupement(classes, periodes)
-
- //ajouter (inscription) l' eleve1 au classe1Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve1classe1,
- etablissement1,
- regroupement,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
- //ajouter (inscription) l' eleve2 au classe2Trimestres
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve4classe2,
- etablissement1,
- regroupement,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
-
- //creer un service attaché au regroupemenet
- service1classe1 = creeService(matiere1, regroupement, OrigineEnum.MANUEL)
-
- //creer un enseignement
- enseignement = creeEnseignement(localInitDonneesCommunesTestService.
- getAutorite(PopulationTestActeur.ENSEIGNANT_1), service1classe1)
-
-
- service1classe1.addToEnseignements(enseignement)
-
- //creer une evaluation attaché à l'enseignement
- Evaluation eval = creeEvaluation(periodes, enseignement, dateCreation)
-
- //creer les notes params des eleves
- noteParams1Eleve1 = new NoteParams(
- eleve: eleve1classe1,
- evaluation: eval,
- valeur: 'ABS'
- )
- noteParams1Eleve2 = new NoteParams(
- eleve: eleve4classe2,
- evaluation: eval,
- valeur: 18
- )
-
- //Creer le TableauDeNotesParams
- List<NoteParams> notesEleve1 = [noteParams1Eleve1]
- List<NoteParams> notesEleve2 = [noteParams1Eleve2]
-
- TableauDeNotesLigneParams tableauDeNotesLigneParamsEleve1 =
- new TableauDeNotesLigneParams(
- eleve: eleve1classe1,
- appreciation: appreciationEleve1,
- notes: notesEleve1
- )
- TableauDeNotesLigneParams tableauDeNotesLigneParamsEleve2 =
- new TableauDeNotesLigneParams(
- eleve: eleve4classe2,
- appreciation: appreciationEleve2,
- notes: notesEleve2
- )
-
- //construire les lognes de tableau de notes selectionnés par l'enseignant
- List<TableauDeNotesLigneParams> lignes = [
- tableauDeNotesLigneParamsEleve1,
- tableauDeNotesLigneParamsEleve2
- ]
-
- //construire le TableauDeNotesParams
- EnregistreTableauDeNotesParams tableauDeNotesParams =
- new EnregistreTableauDeNotesParams(
- service: service1classe1,
- typePeriode: initPeriodeTestService.t1,
- lignes: lignes
- )
- return tableauDeNotesParams
- }
-
- /**
- * Initialiser le tableau de notes(periodes, classes, eleves ,notes , resultatsEeleveEnseignementPeriode)
- * @author mjao
- */
- void initialiserDonneesTableauDeNotes() {
-
- //creer les periodes
- Date dateFinSaisie = new Date(108, 10, 20)
-
- periodeT1_1 = getOuCreePeriode(initPeriodeTestService.t1,
- classe1enTrimestres,
- dateDebut1ApresDebut2,
- dateFin1,
- dateFinSaisie)
-
- periodeT2_1 = getOuCreePeriode(initPeriodeTestService.t2,
- classe1enTrimestres,
- dateDebut2,
- dateFin1,
- dateFinSaisie)
-
- periodeT3_1 = getOuCreePeriode(initPeriodeTestService.t3,
- classe1enTrimestres,
- dateDebut3,
- dateFin3,
- dateFinSaisie)
-
- periodeAnnee_1 = getOuCreePeriode(initPeriodeTestService.annee,
- classe1enTrimestres,
- null,
- null,
- dateFinSaisie)
-
- periode_Brevet = getOuCreePeriode(initPeriodeTestService.brevetBlanc,
- classe1enTrimestres,
- null,
- null,
- dateFinSaisie)
-
- //creer un service
- service = creeService(matiere1, classe1enTrimestres, OrigineEnum.MANUEL)
-
- //creer un enseignement
- enseignement = creeEnseignement(localInitDonneesCommunesTestService.
- getAutorite(PopulationTestActeur.ENSEIGNANT_1), service)
-
- //creer un enseignement
- service.addToEnseignements(enseignement)
-
-
- eval_T1 = creeEvaluation([periodeT1_1], enseignement, dateCreation)
- eval_T2 = creeEvaluation([periodeT2_1], enseignement, dateCreation)
- eval_T3 = creeEvaluation([periodeT3_1], enseignement, dateCreation)
- eval_Brevet = creeEvaluation([periode_Brevet], enseignement, dateCreation)
-
- //creer des notes
- note_T1 = creeNote(eleve1classe1.autorite, eval_T1, valeurNoteT1)
- note_T2 = creeNote(eleve1classe1.autorite, eval_T2, valeurNoteT2)
- note_T3 = creeNote(eleve1classe1.autorite, eval_T3, valeurNoteT3)
- note_Brevet = creeNote(eleve1classe1.autorite, eval_Brevet, valeurNoteBrevet)
+ return personne
}
}
--- /dev/null
+package org.lilie.services.eliot.notes
+
+import grails.plugin.spock.UnitSpec
+import org.lilie.services.eliot.notes.impression.tdn.OptionsImpressionParams
+import org.lilie.services.eliot.notes.impression.tdn.ImpressionTdnService
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.scolarite.Enseignement
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.scolarite.TypePeriode
+import org.lilie.services.eliot.tableau.Tableau
+import org.lilie.services.eliot.tableau.Ligne
+import org.lilie.services.eliot.tableau.Cellule
+
+/**
+ * @author bper
+ */
+class ImpressionTdnServiceSpec extends UnitSpec {
+
+ TableauDeNotesService tableauDeNotesService
+
+ LocalPersonneService localPersonneService
+ ImpressionTdnService impressionTdnService
+
+ SecuriteSession securiteSession
+ TableauDeNotes tdn
+ Enseignement enseignement
+ Service service
+ Matiere matiere
+ Autorite enseignant
+ Personne enseignantPersonne
+ StructureEnseignement structureEnseignement
+ Etablissement etablissement
+ TypePeriode typePeriode
+
+ Tableau tableau
+ Ligne ligne
+ Cellule celluleEleve
+ Cellule cellule
+ Cellule celluleAppreciation
+
+ def setup() {
+ localPersonneService = Mock(LocalPersonneService)
+ tableauDeNotesService = Mock(TableauDeNotesService)
+
+ impressionTdnService = new ImpressionTdnService(
+ localPersonneService: localPersonneService,
+ tableauDeNotesService: tableauDeNotesService
+ )
+
+ securiteSession = Mock(SecuriteSession)
+ tdn = Mock(TableauDeNotes)
+ enseignement = Mock(Enseignement)
+ service = Mock(Service)
+ matiere = Mock(Matiere)
+ enseignant = Mock(Autorite)
+ enseignantPersonne = Mock(Personne)
+ structureEnseignement = Mock(StructureEnseignement)
+ etablissement = Mock(Etablissement)
+ typePeriode = Mock(TypePeriode)
+
+ tableau = Mock(Tableau)
+ ligne = Mock(Ligne)
+ celluleEleve = Mock(Cellule)
+ cellule = Mock(Cellule)
+ celluleAppreciation = Mock(Cellule)
+ }
+
+ def "Impression - option 'Note et Moyennes'"() {
+ when:
+ tab = impressionTdnService.transformeToTableauDeNotesImpression(
+ securiteSession,
+ tdn,
+ optionsImpressionParams,
+ message
+ )
+
+ then:
+ tab != null
+ tab.classe == codeStructureEnseignement
+ tab.etablissement == etablissementNomAffichage
+ tab.enseignant == enseignantNomAffichageInitiales
+ tab.matiere == matiereLibelleCourt
+ tab.appreciationGenerale == appreciationGenerale
+ tab.data.size() == 1
+
+ tab.data[0].enteteLigne == celluleEleveValeur
+
+ tab.data[0].entete1 == 'entete 1'
+ tab.data[0].entete2 == 'entete 2'
+ tab.data[0].entete3 == 'entete 3'
+ tab.data[0].entete4 == 'entete 4'
+ tab.data[0].entete5 == 'entete 5'
+ tab.data[0].entete6 == 'entete 6'
+ tab.data[0].valeur == celluleValeur
+ tab.data[0].finLigne == ''
+ tab.data[0].index == 2
+ tab.data[0].pied1 == 'pied 1'
+ tab.data[0].pied2 == 'pied 2'
+ tab.data[0].pied3 == 'pied 3'
+
+ 3 * tdn.enseignement >> enseignement
+ 1 * tdn.getAppreciationClasse() >> appreciationGenerale
+ 1 * tdn.typePeriode >> typePeriode
+
+ 2 * enseignement.service >> service
+ 1 * enseignement.enseignant >> enseignant
+
+ 1 * service.structureEnseignement >> structureEnseignement
+ 1 * service.matiere >> matiere
+
+ 1 * structureEnseignement.code >> codeStructureEnseignement
+ 1 * structureEnseignement.etablissement >> etablissement
+
+ 1 * matiere.libelleCourt >> matiereLibelleCourt
+ 1 * etablissement.nomAffichage >> etablissementNomAffichage
+ 1 * localPersonneService.findPersonneByAutorite(enseignant) >> enseignantPersonne
+ 1 * enseignantPersonne.nomAffichageInitiales() >> enseignantNomAffichageInitiales
+ 1 * typePeriode.isAnnee() >> false
+
+ 1 * tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession,
+ tdn,
+ optionsImpressionParams.notesEtMoyennes,
+ optionsImpressionParams.appreciations
+ ) >> tableau
+
+ 1 * tableau.traduisI18n(message)
+
+ 1 * tableau.eachLigneWithIndex({ closure ->
+ closure(ligne, 1)
+ return true
+ })
+
+ 1 * ligne.eachCelluleWithIndex({ closure ->
+ closure(celluleEleve, 1)
+ closure(cellule, 2)
+ return true
+ })
+
+ 1 * ligne.getAllColIndex() >> allColIndex
+ 1 * ligne.getCellule(1) >> celluleEleve
+ 1 * ligne.getCellule(2) >> cellule
+
+ 1 * tableau.getCelluleEntete(1, 2) >> new Cellule(valeur: 'entete 1')
+ 1 * tableau.getCelluleEntete(2, 2) >> new Cellule(valeur: 'entete 2')
+ 1 * tableau.getCelluleEntete(3, 2) >> new Cellule(valeur: 'entete 3')
+ 1 * tableau.getCelluleEntete(4, 2) >> new Cellule(valeur: 'entete 4')
+ 1 * tableau.getCelluleEntete(5, 2) >> new Cellule(valeur: 'entete 5')
+ 1 * tableau.getCelluleEntete(6, 2) >> new Cellule(valeur: 'entete 6')
+
+ 1 * tableau.getCellulePied(1, 2) >> new Cellule(valeur: 'pied 1')
+ 1 * tableau.getCellulePied(2, 2) >> new Cellule(valeur: 'pied 2')
+ 1 * tableau.getCellulePied(3, 2) >> new Cellule(valeur: 'pied 3')
+
+ 1 * celluleEleve.valeur >> celluleEleveValeur
+ 1 * cellule.valeur >> celluleValeur
+
+ where:
+ tab = null
+
+ optionsImpressionParams = new OptionsImpressionParams(
+ notesEtMoyennes: true,
+ appreciations: false
+ )
+
+ codeStructureEnseignement = 'TES1'
+ etablissementNomAffichage = "Lycée de la Plaine de l'Ain"
+ enseignantNomAffichageInitiales = 'M. Pierre Dupont'
+ matiereLibelleCourt = 'Math'
+ appreciationGenerale = 'Très bonne classe'
+
+ celluleEleveValeur = 'Marie Dupré'
+ celluleValeur = '12.00'
+
+ allColIndex = [1, 2]
+
+ message = {}
+ }
+
+ def "Impression - option 'Appreciations'"() {
+ when:
+ tab = impressionTdnService.transformeToTableauDeNotesImpression(
+ securiteSession,
+ tdn,
+ optionsImpressionParams,
+ message
+ )
+
+ then:
+ tab != null
+ tab.classe == codeStructureEnseignement
+ tab.etablissement == etablissementNomAffichage
+ tab.enseignant == enseignantNomAffichageInitiales
+ tab.matiere == matiereLibelleCourt
+ tab.appreciationGenerale == appreciationGenerale
+ tab.data.size() == 1
+
+ tab.data[0].enteteLigne == celluleEleveValeur
+
+ tab.data[0].entete1 == 'entete 1'
+ tab.data[0].entete2 == 'entete 2'
+ tab.data[0].entete3 == 'entete 3'
+ tab.data[0].entete4 == 'entete 4'
+ tab.data[0].entete5 == 'entete 5'
+ tab.data[0].entete6 == 'entete 6'
+ tab.data[0].valeur == celluleValeur
+ tab.data[0].finLigne == celluleAppreciationValeur
+ tab.data[0].index == 2
+ tab.data[0].pied1 == 'pied 1'
+ tab.data[0].pied2 == 'pied 2'
+ tab.data[0].pied3 == 'pied 3'
+
+ 3 * tdn.enseignement >> enseignement
+ 1 * tdn.getAppreciationClasse() >> appreciationGenerale
+ 1 * tdn.typePeriode >> typePeriode
+
+ 2 * enseignement.service >> service
+ 1 * enseignement.enseignant >> enseignant
+
+ 1 * service.structureEnseignement >> structureEnseignement
+ 1 * service.matiere >> matiere
+
+ 1 * structureEnseignement.code >> codeStructureEnseignement
+ 1 * structureEnseignement.etablissement >> etablissement
+
+ 1 * matiere.libelleCourt >> matiereLibelleCourt
+ 1 * etablissement.nomAffichage >> etablissementNomAffichage
+ 1 * localPersonneService.findPersonneByAutorite(enseignant) >> enseignantPersonne
+ 1 * enseignantPersonne.nomAffichageInitiales() >> enseignantNomAffichageInitiales
+ 1 * typePeriode.isAnnee() >> false
+
+ 1 * tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession,
+ tdn,
+ optionsImpressionParams.notesEtMoyennes,
+ optionsImpressionParams.appreciations
+ ) >> tableau
+
+ 1 * tableau.traduisI18n(message)
+
+ 1 * tableau.eachLigneWithIndex({ closure ->
+ closure(ligne, 1)
+ return true
+ })
+
+ 1 * ligne.eachCelluleWithIndex({ closure ->
+ closure(celluleEleve, 1)
+ closure(cellule, 2)
+ closure(celluleAppreciation, 3)
+ return true
+ })
+
+ 1 * ligne.getAllColIndex() >> allColIndex
+ 1 * ligne.getCellule(1) >> celluleEleve
+ 1 * ligne.getCellule(2) >> cellule
+ 1 * ligne.getCellule(3) >> celluleAppreciation
+
+ 1 * tableau.getCelluleEntete(1, 2) >> new Cellule(valeur: 'entete 1')
+ 1 * tableau.getCelluleEntete(2, 2) >> new Cellule(valeur: 'entete 2')
+ 1 * tableau.getCelluleEntete(3, 2) >> new Cellule(valeur: 'entete 3')
+ 1 * tableau.getCelluleEntete(4, 2) >> new Cellule(valeur: 'entete 4')
+ 1 * tableau.getCelluleEntete(5, 2) >> new Cellule(valeur: 'entete 5')
+ 1 * tableau.getCelluleEntete(6, 2) >> new Cellule(valeur: 'entete 6')
+
+ 1 * tableau.getCellulePied(1, 2) >> new Cellule(valeur: 'pied 1')
+ 1 * tableau.getCellulePied(2, 2) >> new Cellule(valeur: 'pied 2')
+ 1 * tableau.getCellulePied(3, 2) >> new Cellule(valeur: 'pied 3')
+
+ 1 * celluleEleve.valeur >> celluleEleveValeur
+ 1 * cellule.valeur >> celluleValeur
+ 1 * celluleAppreciation.valeur >> celluleAppreciationValeur
+
+ where:
+ tab = null
+
+ optionsImpressionParams = new OptionsImpressionParams(
+ notesEtMoyennes: false,
+ appreciations: true
+ )
+
+ codeStructureEnseignement = 'TES1'
+ etablissementNomAffichage = "Lycée de la Plaine de l'Ain"
+ enseignantNomAffichageInitiales = 'M. Pierre Dupont'
+ matiereLibelleCourt = 'Math'
+ appreciationGenerale = 'Très bonne classe'
+
+ celluleEleveValeur = 'Marie Dupré'
+ celluleValeur = '12.00'
+ celluleAppreciationValeur = 'Bon travail'
+
+ allColIndex = [1, 2, 3]
+
+ message = {}
+ }
+
+ def "Impression - option 'Note et Moyennes' - periode année"() {
+ when:
+ tab = impressionTdnService.transformeToTableauDeNotesImpression(
+ securiteSession,
+ tdn,
+ optionsImpressionParams,
+ message
+ )
+
+ then:
+ tab != null
+ tab.classe == codeStructureEnseignement
+ tab.etablissement == etablissementNomAffichage
+ tab.enseignant == enseignantNomAffichageInitiales
+ tab.matiere == matiereLibelleCourt
+ tab.appreciationGenerale == appreciationGenerale
+ tab.data.size() == 1
+
+ tab.data[0].enteteLigne == celluleEleveValeur
+
+ tab.data[0].entete1 == 'entete 1'
+ tab.data[0].entete2 == ''
+ tab.data[0].entete3 == ''
+ tab.data[0].entete4 == ''
+ tab.data[0].entete5 == ''
+ tab.data[0].entete6 == ''
+ tab.data[0].valeur == celluleValeur
+ tab.data[0].finLigne == ''
+ tab.data[0].index == 2
+ tab.data[0].pied1 == 'pied 1'
+ tab.data[0].pied2 == 'pied 2'
+ tab.data[0].pied3 == 'pied 3'
+
+ 3 * tdn.enseignement >> enseignement
+ 1 * tdn.getAppreciationClasse() >> appreciationGenerale
+ 1 * tdn.typePeriode >> typePeriode
+
+ 2 * enseignement.service >> service
+ 1 * enseignement.enseignant >> enseignant
+
+ 1 * service.structureEnseignement >> structureEnseignement
+ 1 * service.matiere >> matiere
+
+ 1 * structureEnseignement.code >> codeStructureEnseignement
+ 1 * structureEnseignement.etablissement >> etablissement
+
+ 1 * matiere.libelleCourt >> matiereLibelleCourt
+ 1 * etablissement.nomAffichage >> etablissementNomAffichage
+ 1 * localPersonneService.findPersonneByAutorite(enseignant) >> enseignantPersonne
+ 1 * enseignantPersonne.nomAffichageInitiales() >> enseignantNomAffichageInitiales
+ 1 * typePeriode.isAnnee() >> true
+
+ 1 * tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession,
+ tdn,
+ optionsImpressionParams.notesEtMoyennes,
+ optionsImpressionParams.appreciations
+ ) >> tableau
+
+ 1 * tableau.traduisI18n(message)
+
+ 1 * tableau.eachLigneWithIndex({ closure ->
+ closure(ligne, 1)
+ return true
+ })
+
+ 1 * ligne.eachCelluleWithIndex({ closure ->
+ closure(celluleEleve, 1)
+ closure(cellule, 2)
+ return true
+ })
+
+ 1 * ligne.getAllColIndex() >> allColIndex
+ 1 * ligne.getCellule(1) >> celluleEleve
+ 1 * ligne.getCellule(2) >> cellule
+
+ 1 * tableau.getCelluleEntete(1, 2) >> new Cellule(valeur: 'entete 1')
+
+ 1 * tableau.getCellulePied(1, 2) >> new Cellule(valeur: 'pied 1')
+ 1 * tableau.getCellulePied(2, 2) >> new Cellule(valeur: 'pied 2')
+ 1 * tableau.getCellulePied(3, 2) >> new Cellule(valeur: 'pied 3')
+
+ 1 * celluleEleve.valeur >> celluleEleveValeur
+ 1 * cellule.valeur >> celluleValeur
+
+ where:
+ tab = null
+
+ optionsImpressionParams = new OptionsImpressionParams(
+ notesEtMoyennes: true,
+ appreciations: false
+ )
+
+ codeStructureEnseignement = 'TES1'
+ etablissementNomAffichage = "Lycée de la Plaine de l'Ain"
+ enseignantNomAffichageInitiales = 'M. Pierre Dupont'
+ matiereLibelleCourt = 'Math'
+ appreciationGenerale = 'Très bonne classe'
+
+ celluleEleveValeur = 'Marie Dupré'
+ celluleValeur = '12.00'
+
+ allColIndex = [1, 2]
+
+ message = {}
+ }
+
+ def "Impression - option 'Appreciations' - periode année"() {
+ when:
+ tab = impressionTdnService.transformeToTableauDeNotesImpression(
+ securiteSession,
+ tdn,
+ optionsImpressionParams,
+ message
+ )
+
+ then:
+ tab != null
+ tab.classe == codeStructureEnseignement
+ tab.etablissement == etablissementNomAffichage
+ tab.enseignant == enseignantNomAffichageInitiales
+ tab.matiere == matiereLibelleCourt
+ tab.appreciationGenerale == appreciationGenerale
+ tab.data.size() == 1
+
+ tab.data[0].enteteLigne == celluleEleveValeur
+
+ tab.data[0].entete1 == 'entete 1'
+ tab.data[0].entete2 == ''
+ tab.data[0].entete3 == ''
+ tab.data[0].entete4 == ''
+ tab.data[0].entete5 == ''
+ tab.data[0].entete6 == ''
+ tab.data[0].valeur == celluleValeur
+ tab.data[0].finLigne == celluleAppreciationValeur
+ tab.data[0].index == 2
+ tab.data[0].pied1 == 'pied 1'
+ tab.data[0].pied2 == 'pied 2'
+ tab.data[0].pied3 == 'pied 3'
+
+ 3 * tdn.enseignement >> enseignement
+ 1 * tdn.getAppreciationClasse() >> appreciationGenerale
+ 1 * tdn.typePeriode >> typePeriode
+
+ 2 * enseignement.service >> service
+ 1 * enseignement.enseignant >> enseignant
+
+ 1 * service.structureEnseignement >> structureEnseignement
+ 1 * service.matiere >> matiere
+
+ 1 * structureEnseignement.code >> codeStructureEnseignement
+ 1 * structureEnseignement.etablissement >> etablissement
+
+ 1 * matiere.libelleCourt >> matiereLibelleCourt
+ 1 * etablissement.nomAffichage >> etablissementNomAffichage
+ 1 * localPersonneService.findPersonneByAutorite(enseignant) >> enseignantPersonne
+ 1 * enseignantPersonne.nomAffichageInitiales() >> enseignantNomAffichageInitiales
+ 1 * typePeriode.isAnnee() >> true
+
+ 1 * tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession,
+ tdn,
+ optionsImpressionParams.notesEtMoyennes,
+ optionsImpressionParams.appreciations
+ ) >> tableau
+
+ 1 * tableau.traduisI18n(message)
+
+ 1 * tableau.eachLigneWithIndex({ closure ->
+ closure(ligne, 1)
+ return true
+ })
+
+ 1 * ligne.eachCelluleWithIndex({ closure ->
+ closure(celluleEleve, 1)
+ closure(cellule, 2)
+ closure(celluleAppreciation, 3)
+ return true
+ })
+
+ 1 * ligne.getAllColIndex() >> allColIndex
+ 1 * ligne.getCellule(1) >> celluleEleve
+ 1 * ligne.getCellule(2) >> cellule
+ 1 * ligne.getCellule(3) >> celluleAppreciation
+
+ 1 * tableau.getCelluleEntete(1, 2) >> new Cellule(valeur: 'entete 1')
+
+ 1 * tableau.getCellulePied(1, 2) >> new Cellule(valeur: 'pied 1')
+ 1 * tableau.getCellulePied(2, 2) >> new Cellule(valeur: 'pied 2')
+ 1 * tableau.getCellulePied(3, 2) >> new Cellule(valeur: 'pied 3')
+
+ 1 * celluleEleve.valeur >> celluleEleveValeur
+ 1 * cellule.valeur >> celluleValeur
+ 1 * celluleAppreciation.valeur >> celluleAppreciationValeur
+
+ where:
+ tab = null
+
+ optionsImpressionParams = new OptionsImpressionParams(
+ notesEtMoyennes: false,
+ appreciations: true
+ )
+
+ codeStructureEnseignement = 'TES1'
+ etablissementNomAffichage = "Lycée de la Plaine de l'Ain"
+ enseignantNomAffichageInitiales = 'M. Pierre Dupont'
+ matiereLibelleCourt = 'Math'
+ appreciationGenerale = 'Très bonne classe'
+
+ celluleEleveValeur = 'Marie Dupré'
+ celluleValeur = '12.00'
+ celluleAppreciationValeur = 'Bon travail'
+
+ allColIndex = [1, 2, 3]
+
+ message = {}
+ }
+
+}
\ No newline at end of file
--- /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.annuaire.SecuriteSession
+
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+import org.lilie.services.eliot.tableau.Tableau
+import org.lilie.services.eliot.tableau.Ligne
+import org.lilie.services.eliot.tableau.Cellule
+import org.lilie.services.eliot.scolarite.TypePeriode
+import org.lilie.services.eliot.scolarite.Periode
+import org.lilie.services.eliot.scolarite.IntervalleEnum
+import org.lilie.services.eliot.scolarite.PeriodeService
+
+import grails.plugin.spock.UnitSpec
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+
+import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
+
+import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.scolarite.Enseignement
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.notes.EtablissementNotes
+import org.lilie.services.eliot.notes.resultat.CalculationService
+import org.lilie.services.eliot.notes.resultat.Moyenne
+import org.lilie.services.eliot.notes.Evaluation
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.textes.TypeActivite
+
+/**
+ * @author agia
+ */
+class TableauDeNotesServiceSpec extends UnitSpec {
+
+ TableauDeNotesService tableauDeNotesService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
+ NotesTypePeriodeService notesTypePeriodeService
+ CalculationService calculationService
+ PeriodeService periodeService
+ SecuriteSession securiteSession
+
+ String nomEval1
+ TableauDeNotes tdn
+ boolean isColonneEleve
+ boolean isColonnesNotes
+ boolean isColonneMoyPrec1
+ boolean isColonneMoyPrec2
+ boolean isColonneMoyPrec3
+ boolean isColonneMoyenne
+ boolean isColonneRang
+ boolean isColonneAppreciations
+
+ def setup(){
+ securiteSession = Mock(SecuriteSession)
+ preferenceUtilisateurNotesService = Mock()
+ calculationService = Mock()
+ notesTypePeriodeService = Mock()
+ periodeService = Mock()
+ tableauDeNotesService = new TableauDeNotesService(
+ preferenceUtilisateurNotesService: preferenceUtilisateurNotesService,
+ calculationService: calculationService,
+ notesTypePeriodeService: notesTypePeriodeService,
+ periodeService: periodeService
+ )
+ }
+
+ def "transformeToSimpleTableau - période année / sans rangs / sans moyennes précédentes / sans appréciations"() {
+
+ setup:
+ TypePeriode typePeriode = new TypePeriode(
+ intervalle: IntervalleEnum.ANNEE
+ )
+ initDonnees(typePeriode)
+ PreferenceUtilisateurNotes pref = new PreferenceUtilisateurNotes(
+ moyennesPrecedentes: false,
+ rangs: false
+ )
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession) >> pref
+
+ when:
+ Tableau tableau =
+ tableauDeNotesService.transformeToSimpleTableau(securiteSession, tdn, false, false)
+
+ verifieColonnes(tableau)
+
+ then:
+ isColonneEleve
+ // pas de notes en période ANNEE
+ !isColonnesNotes
+ !isColonneMoyPrec1
+ !isColonneMoyPrec2
+ !isColonneMoyPrec3
+ isColonneMoyenne
+ !isColonneRang
+ !isColonneAppreciations
+
+ }
+
+ def "transformeToSimpleTableau - période année / avec rangs / avec moyennes précédentes / avec appréciations"() {
+
+ setup:
+ TypePeriode typePeriode = new TypePeriode(
+ intervalle: IntervalleEnum.ANNEE
+ )
+ initDonnees(typePeriode)
+ PreferenceUtilisateurNotes pref = new PreferenceUtilisateurNotes(
+ moyennesPrecedentes: true,
+ rangs: true
+ )
+ List<TypePeriode> typePeriodesList = []
+ List<TypePeriode> typePeriodesPrecedentesList = [
+ new TypePeriode(intervalle: IntervalleEnum.T1, libelle: libelleTypePeriode1),
+ new TypePeriode(intervalle: IntervalleEnum.T2, libelle: libelleTypePeriode2),
+ new TypePeriode(intervalle: IntervalleEnum.T3, libelle: libelleTypePeriode3)
+ ]
+
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession) >> pref
+ notesTypePeriodeService.getTypePeriodes(securiteSession, _) >> typePeriodesList
+ notesTypePeriodeService.getTypePeriodePrecedents(typePeriodesList, _) >> typePeriodesPrecedentesList
+ periodeService.getPeriodeCodeCourt(libelleTypePeriode1) >> libelleColonneMoyPrec1
+ periodeService.getPeriodeCodeCourt(libelleTypePeriode2) >> libelleColonneMoyPrec2
+ periodeService.getPeriodeCodeCourt(libelleTypePeriode3) >> libelleColonneMoyPrec3
+
+ when:
+ Tableau tableau =
+ tableauDeNotesService.transformeToSimpleTableau(securiteSession, tdn, true, true)
+
+ verifieColonnes(tableau)
+
+ then:
+ isColonneEleve
+ // pas de notes en période ANNEE
+ !isColonnesNotes
+ isColonneMoyPrec1
+ isColonneMoyPrec2
+ isColonneMoyPrec3
+ isColonneMoyenne
+ isColonneRang
+ isColonneAppreciations
+
+ where:
+ libelleTypePeriode1 = 'T1'
+ libelleTypePeriode2 = 'T2'
+ libelleTypePeriode3 = 'T3'
+ libelleColonneMoyPrec1 = '1er T.'
+ libelleColonneMoyPrec2 = '2e T.'
+ libelleColonneMoyPrec3 = '3e T.'
+
+ }
+
+ def "transformeToSimpleTableau - période 3e trimestre / avec rangs / avec moyennes précédentes / avec notes / avec appréciations"() {
+
+ setup:
+ TypePeriode typePeriode = new TypePeriode(
+ intervalle: IntervalleEnum.T3
+ )
+ initDonnees(typePeriode)
+ PreferenceUtilisateurNotes pref = new PreferenceUtilisateurNotes(
+ moyennesPrecedentes: true,
+ rangs: true
+ )
+ List<TypePeriode> typePeriodesList = []
+ List<TypePeriode> typePeriodesPrecedentesList = [
+ new TypePeriode(intervalle: IntervalleEnum.T1, libelle: libelleTypePeriode1),
+ new TypePeriode(intervalle: IntervalleEnum.T2, libelle: libelleTypePeriode2)
+ ]
+
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession) >> pref
+ notesTypePeriodeService.getTypePeriodes(securiteSession, _) >> typePeriodesList
+ notesTypePeriodeService.getTypePeriodePrecedents(typePeriodesList, _) >> typePeriodesPrecedentesList
+ periodeService.getPeriodeCodeCourt(libelleTypePeriode1) >> libelleColonneMoyPrec1
+ periodeService.getPeriodeCodeCourt(libelleTypePeriode2) >> libelleColonneMoyPrec2
+ tdn.enseignement.service.getSousServices(_) >> []
+
+ when:
+ Tableau tableau =
+ tableauDeNotesService.transformeToSimpleTableau(securiteSession, tdn, true, true)
+
+ verifieColonnes(tableau)
+
+ then:
+ isColonneEleve
+ isColonnesNotes
+ isColonneMoyPrec1
+ isColonneMoyPrec2
+ !isColonneMoyPrec3
+ isColonneMoyenne
+ isColonneRang
+ isColonneAppreciations
+
+ where:
+ libelleTypePeriode1 = 'T1'
+ libelleTypePeriode2 = 'T2'
+ libelleColonneMoyPrec1 = '1er T.'
+ libelleColonneMoyPrec2 = '2e T.'
+
+ }
+
+ private void initDonnees(TypePeriode typePeriode) {
+ EtablissementNotes etabNotes = new EtablissementNotes()
+ Etablissement etab = new Etablissement(
+ etablissementNotes : etabNotes
+ )
+ StructureEnseignement struc = new StructureEnseignement(
+ etablissement: etab
+ )
+ Service service= new Service (
+ structureEnseignement: struc,
+ sousServices: []
+ )
+ Enseignement enseignement= new Enseignement(
+ service: service
+ )
+ nomEval1 = 'eval1'
+ TypeActivite typeActivite = new TypeActivite(code: '')
+ List<Evaluation> evaluations = [
+ new Evaluation(id: 1, titre: nomEval1, typeActivite: typeActivite)
+ ]
+ List<TableauDeNotesLigne> lignes = []
+ tdn = new TableauDeNotes(
+ typePeriode: typePeriode,
+ enseignement: enseignement,
+ evaluations: evaluations,
+ lignes: lignes
+ )
+ Moyenne moyenne = new Moyenne(10.toBigDecimal())
+
+ isColonneEleve = false
+ isColonnesNotes = false
+ isColonneMoyPrec1 = false
+ isColonneMoyPrec2 = false
+ isColonneMoyPrec3 = false
+ isColonneMoyenne = false
+ isColonneRang = false
+ isColonneAppreciations = false
+
+ calculationService.calculeMoyenne(_) >> moyenne
+ }
+
+ private void verifieColonnes(Tableau tableau){
+ String libelleColonneMoyPrec1 = '1er T.'
+ String libelleColonneMoyPrec2 = '2e T.'
+ String libelleColonneMoyPrec3 = '3e T.'
+
+ tableau.entetes.values().each{ Ligne ligneEntete ->
+ String valeurPremiereCellule = ligneEntete.getCellule(0).valeur
+ if (valeurPremiereCellule?.equalsIgnoreCase('eliot.notes.libelle.nomEleve')){
+ isColonneEleve = true
+ } else if (valeurPremiereCellule?.equalsIgnoreCase('eliot.notes.libelle.titre')) {
+ isColonneEleve = true
+ }
+ ligneEntete.cellules.values().each{ Cellule cellule ->
+ if (nomEval1.equalsIgnoreCase(cellule.valeur)){
+ isColonnesNotes = true
+ }
+ else if (libelleColonneMoyPrec1.equalsIgnoreCase(cellule.valeur)){
+ isColonneMoyPrec1 = true
+ }
+ else if (libelleColonneMoyPrec2.equalsIgnoreCase(cellule.valeur)){
+ isColonneMoyPrec2 = true
+ }
+ else if (libelleColonneMoyPrec3.equalsIgnoreCase(cellule.valeur)){
+ isColonneMoyPrec3 = true
+ }
+ else if ('eliot.notes.libelle.moyenneCourt'.equalsIgnoreCase(cellule.valeur)){
+ isColonneMoyenne = true
+ }
+ else if ('eliot.notes.libelle.rang'.equalsIgnoreCase(cellule.valeur)){
+ isColonneRang = true
+ }
+ else if ('eliot.notes.libelle.appreciations'.equalsIgnoreCase(cellule.valeur)){
+ isColonneAppreciations = true
+ }
+ }
+ }
+ }
+
+}
--- /dev/null
+package org.lilie.services.eliot.notes.export
+
+import grails.plugin.spock.UnitSpec
+import org.lilie.services.eliot.notes.export.tableaudenotes.TableauDeNotesExportService
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
+import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.tableau.Tableau
+import org.lilie.services.eliot.tableau.Ligne
+import org.lilie.services.eliot.tableau.Cellule
+
+/**
+ * @author onic
+ */
+class TableauDeNotesExportServiceSpec extends UnitSpec {
+
+ TableauDeNotesExportService tableauDeNotesExportService
+
+ TableauDeNotesService tableauDeNotesService
+ SecuriteSession securiteSession
+ Tableau tableauGenerique
+
+ Ligne ligneEntete
+ Ligne ligne
+ Ligne lignePied
+
+ Cellule celluleEntete
+ Cellule cellule
+ Cellule cellulePied
+
+ def setup() {
+ tableauGenerique = Mock(Tableau)
+
+ ligneEntete = Mock(Ligne)
+ ligne = Mock(Ligne)
+ lignePied = Mock(Ligne)
+
+ celluleEntete = Mock(Cellule)
+ cellule = Mock(Cellule)
+ cellulePied = Mock(Cellule)
+
+ tableauDeNotesService = Mock(TableauDeNotesService)
+
+ tableauDeNotesExportService = new TableauDeNotesExportService(
+ tableauDeNotesService: tableauDeNotesService
+ )
+
+ securiteSession = Mock(SecuriteSession)
+ }
+
+ def 'transformeTdnEnDonneesCSV'() {
+
+ when:
+ donneesPourExportCSV = tableauDeNotesExportService.transformeTdnEnDonneesCSV(
+ securiteSession, tableauDeNotes, traducteurMessages)
+
+ then:
+ donneesPourExportCSV != null
+
+ donneesPourExportCSV.colonnes.size() == 1
+ donneesPourExportCSV.colonnes[0] == valeurEntete
+
+ donneesPourExportCSV.lignes.size() == 2
+ donneesPourExportCSV.lignes[0].size() == 1
+ donneesPourExportCSV.lignes[0][0] == valeur
+ donneesPourExportCSV.lignes[1].size() == 1
+ donneesPourExportCSV.lignes[1][0] == valeurPied
+
+ 1 * tableauDeNotesService.transformeToSimpleTableau(
+ securiteSession, tableauDeNotes) >> tableauGenerique
+
+ 1 * tableauGenerique.traduisI18n(traducteurMessages)
+
+ 1 * tableauGenerique.eachLigneEnteteWithIndex({ closure ->
+ def index = 1
+ closure(ligneEntete, index)
+ return true
+ })
+
+ 1 * ligneEntete.eachCelluleWithIndex({ closure ->
+ def index = 1
+ closure(celluleEntete, index)
+ return true
+ })
+
+ 1 * celluleEntete.valeur >> valeurEntete
+
+ 1 * tableauGenerique.eachLigneWithIndex({ closure ->
+ def index = 1
+ closure(ligne, index)
+ return true
+ })
+
+ 1 * ligne.eachCelluleWithIndex({ closure ->
+ def index = 1
+ closure(cellule, index)
+ return true
+ })
+
+ 1 * cellule.valeur >> valeur
+
+ 1 * tableauGenerique.eachLignePiedWithIndex({ closure ->
+ def index = 1
+ closure(lignePied, index)
+ return true
+ })
+
+ 1 * lignePied.eachCelluleWithIndex({ closure ->
+ def index = 1
+ closure(cellulePied, index)
+ return true
+ })
+
+ 1 * cellulePied.valeur >> valeurPied
+
+ where:
+ donneesPourExportCSV = null
+ tableauDeNotes = new TableauDeNotes()
+
+ traducteurMessages = {}
+
+ valeurEntete = 'Valeur entête'
+ valeur = 'Valeur'
+ valeurPied = 'Valeur pied'
+
+ }
+
+}
/**
* Calcule la moyenne sur un field de store
+ *
+ * !!! L'utilisation des float dans la somme crée des erreurs type
+ * 12.60 + 12.70 = 23.299999999999997
+ * une fois appliqué la précision 0.1 cela donne une moyenne de 12.6 à la
+ * place de 12.7
+ *
* @param {Ext.data.Store} store Store du tableau de notes
* @param {String} nomField Nom de field
* @return moyenne Moyenne calculée sur le field du store
if (record.get(nomField) !== '' && record.get(nomField) !== null) {
var valeur = parseFloat(record.get(nomField));
if (!isNaN(valeur)) {
- total += valeur;
+ total += Math.round(1000 * valeur);
nb++;
}
}
if (nb == 0) {
return null
} else {
- return total / nb;
+ return (total / nb) / 1000;
}
},
<?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="802" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">
<property name="ireport.zoom" value="1.5"/>
- <property name="ireport.x" value="395"/>
+ <property name="ireport.x" value="124"/>
<property name="ireport.y" value="0"/>
<style name="titre_document" hAlign="Center" fontName="Arial" fontSize="18"/>
<style name="label" hAlign="Left" fontName="Arial" fontSize="10"/>
<staticText>
<reportElement style="titre_document" x="599" y="0" width="202" height="30"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="12" isPdfEmbedded="true"/>
</textElement>
<text><![CDATA[Synthèse]]></text>
</staticText>
<textField>
<reportElement x="9" y="10" width="80" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA["Page "+$V{PAGE_NUMBER}+" sur"]]></textFieldExpression>
</textField>
<textField evaluationTime="Report">
<reportElement x="89" y="10" width="40" height="20"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
</textField>
<textField pattern="">
<reportElement x="551" y="11" width="250" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[(
new SimpleDateFormat(
<staticText>
<reportElement style="titre_document" x="600" y="0" width="202" height="30"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="12" isPdfEmbedded="true"/>
</textElement>
<text><![CDATA[Tableau de notes]]></text>
</staticText>
<textField>
<reportElement x="0" y="10" width="80" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA["Page "+$V{PAGE_NUMBER}+" sur"]]></textFieldExpression>
</textField>
<textField evaluationTime="Report">
<reportElement x="84" y="10" width="40" height="20"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
</textField>
<textField pattern="">
<reportElement x="552" y="8" width="250" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[(
new SimpleDateFormat(
<?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="A4" pageWidth="842" pageHeight="595" orientation="Landscape" columnWidth="802" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">
<property name="ireport.zoom" value="1.5"/>
- <property name="ireport.x" value="0"/>
+ <property name="ireport.x" value="124"/>
<property name="ireport.y" value="0"/>
<style name="titre_document" hAlign="Center" fontName="Arial" fontSize="18"/>
<style name="label" hAlign="Left" fontName="Arial" fontSize="10"/>
<staticText>
<reportElement style="titre_document" x="600" y="0" width="202" height="30"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="12" isPdfEmbedded="true"/>
</textElement>
<text><![CDATA[Tableau de notes]]></text>
</staticText>
<textField>
<reportElement x="0" y="10" width="80" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA["Page "+$V{PAGE_NUMBER}+" sur"]]></textFieldExpression>
</textField>
<textField evaluationTime="Report">
<reportElement x="84" y="10" width="40" height="20"/>
<textElement>
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
</textField>
<textField pattern="">
<reportElement x="552" y="8" width="250" height="20"/>
<textElement textAlignment="Right">
- <font fontName="Arial" isPdfEmbedded="true"/>
+ <font fontName="Arial" size="6" isPdfEmbedded="true"/>
</textElement>
<textFieldExpression class="java.lang.String"><![CDATA[(
new SimpleDateFormat(
<?xml version="1.0" encoding="UTF-8"?>
-<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="802" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">
+<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="842" leftMargin="0" rightMargin="0" topMargin="0" bottomMargin="0">
<property name="ireport.zoom" value="2.0"/>
<property name="ireport.x" value="0"/>
<property name="ireport.y" value="0"/>
<crosstabCell width="31" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="31" height="43" rowTotalGroup="eleve">
<cellContents>
<textField isStretchWithOverflow="true">
<reportElement style="cellule_note" stretchType="RelativeToTallestObject" x="0" y="0" width="113" height="14"/>
- <textElement/>
+ <textElement textAlignment="Justified"/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{appreciation}]]></textFieldExpression>
</textField>
</cellContents>
<crosstabCell width="37" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="37" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="37" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="37" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="37" height="43" rowTotalGroup="eleve">
<?xml version="1.0" encoding="UTF-8"?>
-<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="802" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">
+<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="842" leftMargin="0" rightMargin="0" topMargin="0" bottomMargin="0">
<property name="ireport.zoom" value="3.0"/>
<property name="ireport.x" value="0"/>
<property name="ireport.y" value="0"/>
<crosstabCell width="31" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="31" height="44" rowTotalGroup="eleve">
<cellContents>
<textField isStretchWithOverflow="true" isBlankWhenNull="true">
<reportElement style="cellule_note" x="0" y="0" width="111" height="14"/>
- <textElement/>
+ <textElement textAlignment="Justified"/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{appreciation}]]></textFieldExpression>
</textField>
</cellContents>
</staticText>
<textField isBlankWhenNull="true">
<reportElement style="appr" mode="Opaque" x="0" y="10" width="111" height="32"/>
- <textElement/>
+ <textElement textAlignment="Justified"/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{appr}]]></textFieldExpression>
</textField>
</cellContents>
<crosstabCell width="31" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="31" height="44" rowTotalGroup="eleve">
<?xml version="1.0" encoding="UTF-8"?>
-<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="802" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20">
+<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="proto" language="groovy" pageWidth="842" pageHeight="595" orientation="Landscape" whenNoDataType="BlankPage" columnWidth="842" leftMargin="0" rightMargin="0" topMargin="0" bottomMargin="0">
<property name="ireport.zoom" value="1.5"/>
<property name="ireport.x" value="0"/>
<property name="ireport.y" value="0"/>
<crosstabCell width="31" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="31" height="44" rowTotalGroup="eleve">
<cellContents>
<textField isStretchWithOverflow="true" isBlankWhenNull="true">
<reportElement style="cellule_note" x="0" y="0" width="111" height="14"/>
- <textElement/>
+ <textElement textAlignment="Justified"/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{appreciation}]]></textFieldExpression>
</textField>
</cellContents>
</staticText>
<textField>
<reportElement style="appr" x="0" y="10" width="111" height="32"/>
- <textElement/>
+ <textElement textAlignment="Justified"/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{appr}]]></textFieldExpression>
</textField>
</cellContents>
<crosstabCell width="31" height="14">
<cellContents style="cellule_note">
<textField isBlankWhenNull="true">
- <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14"/>
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} != 3000]]></printWhenExpression>
+ </reportElement>
<textElement/>
<textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
</textField>
+ <textField isBlankWhenNull="true">
+ <reportElement style="cellule_note" stretchType="RelativeToBandHeight" x="0" y="0" width="31" height="14">
+ <printWhenExpression><![CDATA[$V{index} == 3000]]></printWhenExpression>
+ </reportElement>
+ <textElement>
+ <font isBold="true"/>
+ </textElement>
+ <textFieldExpression class="java.lang.String"><![CDATA[$V{noteMeasure}]]></textFieldExpression>
+ </textField>
</cellContents>
</crosstabCell>
<crosstabCell width="31" height="44" rowTotalGroup="eleve">