import org.lilie.services.eliot.notes.impression.synthese.ImpressionSyntheseService
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
+import org.lilie.services.eliot.notes.PreferenceUtilisateurNotes
+import org.lilie.services.eliot.notes.preferences.PreferenceUtilisateurNotesService
+import org.lilie.services.eliot.PeriodeLibelleMode
/**
* Cette classe représente le controleur de
BulletinService bulletinService
PeriodeService periodeService
ImpressionSyntheseService impressionSyntheseService
+ PreferenceUtilisateurNotesService preferenceUtilisateurNotesService
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
)
)
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
Map result = wrapResultat {
Synthese synthese = null
Boolean appreciationModifiable = false
Boolean moyennesAjour = true
Date dateDernierCalculMoyennes = null
Periode periode = null
+ List<Periode> periodesPrecedentes = []
// Récupère la liste des classes
List<StructureEnseignement> classes = notesStructureEnseignementService.
findAllClasseForUtilisateur(
- securiteSession,
- etablissementCourant(),
- Action.CONSULTATION)
+ securiteSession,
+ etablissementCourant(),
+ Action.CONSULTATION)
classes.sort {a, b -> cc.compare(a.code, b.code)}
if (classe) {
// La liste des période dans combo triée
- List<Periode> periodes = triePeriodes(classe.periodes.toList())
+ List<Periode> periodes = classe.periodes.toList().sort()
+
periodeInfos = periodes.collect {
new PeriodeInfo(
idPeriode: it.id,
// Période sélectionnée ou la période en cours
periode = (periodeId != null) ? Periode.get(periodeId) :
periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre() }
+
if (periode) {
// Période selectionnée
periodeId = periode.id
dateDernierCalculMoyennes = synthese.dateDernierCalculMoyennes
// Les services et les sous-services qui correspondent aux colonnes de la synthèse
- serviceInfos = getServiceInfos(synthese.syntheseClasse.services, periode, classe)
+ serviceInfos = getServiceInfos(synthese.syntheseClasse.services, periode)
+
+ if (periode.isPeriodeNotation()) {
+ periodesPrecedentes = periode.getPeriodesPrecedentes()
+ }
}
}
result.syntheseEleves = synthese?.syntheseEleves as JSON
result.syntheseClasses = synthese?.syntheseClasse as JSON
result.verrouille = periode ? periode.verrouille : true
+
+ result.periodesPrecedentes = periodesPrecedentes.collect {
+ [
+ id: it.id,
+ libelle: getTypePeriodeLibelle(it.typePeriode, PeriodeLibelleMode.COURT)
+ ]
+ } as JSON
+
+ result.affichage = [
+ moyennesPrecedentes: pref?.moyennesPrecedentes ?: false,
+ rangs: pref?.rangs ?: false
+ ]
}
result = ajouteAnnotations(result)
Periode periode = Periode.get(jsonParams.periodeId)
DonneesPourExportCSV donnees =
- prepareDonneesPourExportCSV(securiteSession, classe, periode)
+ prepareDonneesPourExportCSV(securiteSession, classe, periode)
sendCsvFile(response, donnees, "Synthese_${classe.code}_${periode.libelle}")
}
/**
* Prepare donnees pour l'export CSV
- * @param securiteSession
- * @param classe
- * @param periode
- * @return
*/
private DonneesPourExportCSV prepareDonneesPourExportCSV(
- SecuriteSession securiteSession, StructureEnseignement classe, Periode periode) {
+ SecuriteSession securiteSession, StructureEnseignement classe, Periode periode) {
DonneesPourExportCSV donnees = new DonneesPourExportCSV()
+ PreferenceUtilisateurNotes pref =
+ preferenceUtilisateurNotesService.getPreferenceUtilisateur(securiteSession)
+
+ List<Periode> periodesPrecedentes = periode?.getPeriodesPrecedentes()
+
// Récupère la synthese
Synthese synthese = syntheseService.construisSynthese(securiteSession, classe, periode)
List ligneEnteteEns = [message(code: 'eliot.notes.libelle.enseignants', default: 'Enseignants')]
List ligneEnteteCoeff = [message(code: 'eliot.notes.libelle.coeff', default: 'Coeff.')]
- List colonneMaps = getServiceInfos(synthese.syntheseClasse.services, periode, classe)
+ List colonneMaps = getServiceInfos(synthese.syntheseClasse.services, periode)
List<Map> syntheseEleveMaps =
- synthese.syntheseEleves.collect {SaisieSyntheseConfig.convertForSyntheseEleve(it)}
+ synthese.syntheseEleves.collect {SaisieSyntheseConfig.convertForSyntheseEleve(it)}
List<Map> syntheseClasseMaps =
- SaisieSyntheseConfig.convertForSyntheseClasse(synthese.syntheseClasse)
+ SaisieSyntheseConfig.convertForSyntheseClasse(synthese.syntheseClasse)
List<Map> ligneMaps = []
ligneMaps.addAll(syntheseEleveMaps)
}
}
- // Ajoute la colonne "Moy." et "Appréciations générales"
+ if (pref?.moyennesPrecedentes == true && periode?.isPeriodeNotation()){
+ periodesPrecedentes?.each{ Periode periodePrecedente ->
+ donnees.colonnes << message(
+ code: periodeService.getNomPeriodePrecedente(periodePrecedente.typePeriode?.libelle)
+ )
+ }
+ }
+
+ // Ajoute la colonne "Moy."
donnees.colonnes << message(
code: 'eliot.notes.libelle.moyenneCourt',
default: 'Moy.'
)
+
+ if (pref?.rangs == true){
+ // Ajoute la colonne de rang si l'option a été cochée
+ donnees.colonnes << message(
+ code: 'eliot.notes.libelle.rang',
+ default: 'Rang'
+ )
+ }
+
+ // Ajoute la colonne "Appréciations générales"
donnees.colonnes << message(
code: 'eliot.notes.libelle.appreciationsGenerales',
default: 'Appréciations générales'
)
ligneMaps.eachWithIndex {Map map, Integer i ->
+ // moy. prec.
+ if (pref?.moyennesPrecedentes == true && periode?.isPeriodeNotation()){
+ for (int j = 0; j < periodesPrecedentes?.size(); ++j){
+ def moyennePrecedente = map.get("moyennePeriodePrecedente${periodesPrecedentes[j].id}")
+ lignes.get(i) << nf.format(moyennePrecedente)
+ }
+ }
+ // moyenne
lignes.get(i) << nf.format(map.moyenne)
+ // rang
+ if (pref?.rangs == true){
+ lignes.get(i) << map.rang
+ }
+ // appréciation
lignes.get(i) << map.appreciationGenerale
}
/**
* Construis une liste des Maps correspondant aux Services et SousServices
- * @param services
- * @param periode
- * @return
* @author bper
*/
private List getServiceInfos(List<Service> services,
- Periode periode,
- StructureEnseignement classe) {
- List serviceInfos = []
+ Periode periode) {
+ List colonnes = []
String moy = message(code: 'eliot.notes.libelle.moyenneCourt', default: 'Moy.')
services?.each {Service service ->
sousServices.each {SousService sousService ->
if (sousService.typePeriode == periode.typePeriode && sousService.evaluable) {
def idCompose = SaisieSyntheseConfig.getIdCompose(service.id, sousService.id)
- serviceInfos << [
+ colonnes << [
id: service.id,
idCompose: idCompose,
lblMatiere: service.matiere.codeGestion,
}
}
def idCompose = SaisieSyntheseConfig.getIdCompose(service.id)
- serviceInfos << [
+ colonnes << [
id: service.id,
idCompose: idCompose,
lblMatiere: service.matiere.codeGestion,
]
}
- // Si c'est la période "Année" on affiche les moyennes générales de chaque Xmestre
- if (periode.isPeriodeAnnee()) {
- String lblMatiere = message(
- code: 'eliot.notes.libelle.moyennesGenerales',
- default: 'Moy. générales'
- )
- List<Periode> periodeXmestres = classe.periodes.findAll {it.isPeriodeXmestre()} as List
- periodeXmestres = triePeriodes(periodeXmestres)
- periodeXmestres.each {
- def idCompose = SaisieSyntheseConfig.getIdCompose("periode_${it.id}")
- serviceInfos << [
- id: -1,
- idCompose: idCompose,
- lblMatiere: lblMatiere,
- enseignants: [],
- coeff: 1,
- sousServiceCode: getTypePeriodeLibelleCourt(it.typePeriode),
- isOption: false,
- isSousService: false
- ]
- }
- }
-
- return serviceInfos
+ return colonnes
}
/**
/**
* Calcul des données pour l'impression de la sytnhèse
- * @param securiteSession
- * @param params
- * @return
*/
private SyntheseImpression donneesTableauSynthese(SecuriteSession securiteSession, Map params) {
notesDroitService.verifieAutorisationByEtablissement(
Synthese synthese = syntheseService.construisSynthese(securiteSession, classe, periode)
// Crée la syntheseImpression
- return construisTableauImpression(synthese)
+ return construisTableauImpression(synthese, securiteSession)
}
/**
* Convertion de l'objet synthese vers un objet capable d'être imprimé
- * @param synthese
- * @return
*/
- private SyntheseImpression construisTableauImpression(Synthese synthese) {
+ private SyntheseImpression construisTableauImpression(Synthese synthese,
+ SecuriteSession securiteSession) {
SyntheseImpression tab =
- impressionSyntheseService.construisTableauImpression(synthese)
+ impressionSyntheseService.construisTableauImpression(synthese, securiteSession)
// i18n-isation des données du tableau
tab.periode = getTypePeriodeLibelle(synthese?.periode?.typePeriode)
if (it instanceof CelluleTypePeriode) {
CelluleTypePeriode moyenne = (CelluleTypePeriode) it
- moyenne.entete1 = getTypePeriodeLibelleCourt(moyenne.typePeriode)
+ moyenne.entete1 = getTypePeriodeLibelle(moyenne.typePeriode, PeriodeLibelleMode.ABREGE)
}
if (it instanceof CelluleI18n) {
/**
* Gestion du breadCrumbs
- * @return
*/
protected List getBreadCrumbsInfo() {
List breadCrumbsInfo = super.getBreadCrumbsInfo()
+
breadCrumbsInfo << new BreadCrumbsItemInfo(
codeLabel: 'notes.menu.saisie.titrePrincipal'
)
+
breadCrumbsInfo << new BreadCrumbsItemInfo(
codeLabel: 'notes.menu.saisie.synthese.titrePrincipal'
)
return breadCrumbsInfo
-
}
-
}
\ No newline at end of file