import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
import org.lilie.services.eliot.brevet.BrevetSerie
-import org.lilie.services.eliot.scolarite.Service
class StructureEnseignementNotes {
BrevetSerie brevetSerie
Date datePublicationBrevet
- Service serviceSport // Le service de la classe sélectionné pour calculer la moyenne de l'epreuve EPS de brevet
static constraints = {
typeIntervalle (nullable: true, inList: [TypeIntervalleEnum.SEMESTRE, TypeIntervalleEnum.TRIMESTRE])
brevetSerie(nullable: true)
datePublicationBrevet(nullable: true)
- serviceSport(nullable: true, validator: serviceSportValidator)
}
static mapping = {
structureEnseignement column: 'structure_enseignement_id'
}
- static serviceSportValidator = {Service val, StructureEnseignementNotes struct ->
- return (val == null) ? true :
- struct.structureEnseignement.isClasse() &&
- val.structureEnseignement.id == struct.structureEnseignement.id
- }
-
@Override
String toString() {
return "$structureEnseignement $typeIntervalle $brevetSerie"
'numeroBureau',
'telephonePro',
'telephonePerso',
- 'telephonePortable'
+ 'telephonePortable',
+ 'prenomInitiale'
]
final static def TYPES = [
Set<RelPeriodeService> relPeriodeServices
Set<SousService> sousServices
+ // La service est sélectionné pour le calcul des moyennes de sport pour le Brevet
+ // Il ne peut y avoir qu'un service pour chaque classe
+ Boolean choisiPourSport = false
+
/*
* Les services ayant les memes valeurs pour structureEnseignement, matiere et origine
* sont considerés comme identique dans le module Notes. Un des ces service est donc
nbHeures(nullable: true)
coEns(nullable: true)
servicePrincipal(nullable: false)
+ choisiPourSport(nullable: false, validator: choisiPourSportValidator)
+ }
+
+ static choisiPourSportValidator = {Boolean val, Service obj ->
+ return !val || (obj.servicePrincipal && obj.structureEnseignement.isClasse())
}
static transients = [
/**
* 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
* 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
</changeSet>
+
+ <changeSet id="4" author="bper">
+
+ <comment>
+ Ajout de la colonne 'choisi_pour_sport' dans la table 'ent.service'
+ </comment>
+
+ <dropForeignKeyConstraint baseTableSchemaName="entnotes"
+ baseTableName="structure_enseignement_notes"
+ constraintName="fk_structure_enseignement_notes_service_sport" />
+
+ <dropColumn schemaName="entnotes"
+ tableName="structure_enseignement_notes"
+ columnName="service_sport_id" />
+
+ <addColumn schemaName="ent" tableName="service">
+ <column name="choisi_pour_sport" type="boolean" defaultValue="false">
+ <constraints nullable="false"/>
+ </column>
+ </addColumn>
+
+ <sql>
+ CREATE UNIQUE INDEX ux_service_choisi_pour_sport_true
+ ON ent.service (structure_enseignement_id)
+ WHERE choisi_pour_sport = TRUE;
+ </sql>
+
+ </changeSet>
+
</databaseChangeLog>
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.TypePeriode
-import org.lilie.services.eliot.notes.domaine.TypePeriodeInfo
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesLigne
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotes
-import grails.converters.JSON
+
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.notes.scolarite.NotesServiceService
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauDeNotesService
-import org.lilie.services.eliot.notes.scolarite.NotesTypePeriodeService
-import org.lilie.services.eliot.notes.notes.NotesEvaluationService
+
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.notes.saisie.TableauDeNotesGraphComposant
+
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.notes.resultat.MoyenneService
+
import org.lilie.services.eliot.export.tableaux.LigneImpression
-import org.lilie.services.eliot.notes.resultat.NoteInfo
+
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.notes.resultat.CalculationService
-import org.lilie.services.eliot.notes.scolarite.NotesSousServiceService
+
import org.lilie.services.eliot.export.tableaux.TableauDeNotesImpression
import org.lilie.services.eliot.resultat.Moyenne
-import org.lilie.services.eliot.notes.brevet.BrevetRelEpreuveMatiereService
+
import org.lilie.services.eliot.EliotConstantes
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauNotesSportService
-import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauNotesSport
+
+import grails.converters.JSON
+import org.lilie.services.eliot.notes.brevet.BrevetRelEpreuveMatiereService
+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.*
/**
* Controller commun de Saisie et Consultation de Tableau de Notes
EnseignementService enseignementService
BrevetRelEpreuveMatiereService brevetRelEpreuveMatiereService
TableauNotesSportService tableauNotesSportService
+ NotesStructureEnseignementService notesStructureEnseignementService
static final NoteFormateur NF_PAR_DEFAUT = new NoteFormateur()
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
Periode periode = periodes.find {it.dateFinSaisie == null}
periodesDefinis = (periode == null)
- isMatiereEPS = brevetRelEpreuveMatiereService.isMatiereEPS(service.matiere)
+ isMatiereEPS = service.choisiPourSport
}
resultat.enseignementId = enseignement?.id
import org.lilie.services.eliot.notes.brevet.BrevetOptionsEleveService
import org.lilie.services.eliot.notes.brevet.BrevetOptionsEleve
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.notes.scolarite.NotesServiceService
+import org.lilie.services.eliot.securite.impl.Autorite
class ParametragesBrevetController extends AbstractNotesController {
NotesStructureEnseignementService notesStructureEnseignementService
NotesDroitService notesDroitService
+ NotesServiceService notesServiceService
+
def index = {
Etablissement etab = etablissementCourant()
}
- private void ajouteAllSeries(Map modele) {
+ private void ajouteAllSeries(Map modele, Boolean asJson = true) {
List<BrevetSerie> series = brevetSerieService.findAllSerie(securiteSession)
series.sort{it.libelleCourt}
- modele.series = series.collect {
- [id: it.id, libelle: it.libelleCourt]
- } as JSON
+ modele.series = series.collect {[id: it.id, libelle: it.libelleCourt]}
+ if (asJson) {modele.series = modele.series as JSON}
modele.serieParDefaut = (series?.size()>0 ? series.first().id : null)
}
* Ajoute matieres de l'etablissement courant dans le modele
* @param modele
*/
- private void ajouteAllMatieres(Map modele) {
+ private void ajouteAllMatieres(Map modele, Boolean asJson = true) {
List<Matiere> matieres = Matiere.findAllByEtablissementAndAnneeScolaire(
etablissementCourant(),
anneeScolaireService.anneeScolaireEnCours()
)
matieres.sort{it.codeGestion}
- modele.matieres = matieres.collect {
- [id: it.id, libelle: it.codeGestion]
- } as JSON
+ modele.matieres = matieres.collect {[id: it.id, libelle: it.codeGestion]}
+ if (asJson) {modele.matieres = modele.matieres as JSON}
}
- private void ajouteAllClasses(Map modele) {
+ private void ajouteAllClasses(Map modele, Boolean asJson = true) {
List<StructureEnseignement> classes =
notesStructureEnseignementService.findAllClasseForEtablissementAvecPeriodes(
securiteSession,
etablissementCourant()
)
classes.sort {a, b -> cc.compare(a.code, b.code)}
- modele.classes = classes.collect {
- Periode annee = it.getPeriodeAnnee()
+
+ List<Service> serviceSports = notesServiceService.findAllServiceMatiereSportByClasses(
+ securiteSession,
+ classes
+ )
+
+ modele.classes = classes.collect {StructureEnseignement classe ->
+
+ List servicesEps = serviceSports.findAll {it.structureEnseignement.id == classe.id}.collect {
+ [
+ id: it.id,
+ libelle: getLibelleServiceSport(it)
+ ]
+ }
+
+ Periode annee = classe.getPeriodeAnnee()
[
- id: it.id,
- libelle: it.code,
+ id: classe.id,
+ libelle: classe.code,
dateDebut: annee?.dateDebut,
- dateFin: annee?.dateFin
+ dateFin: annee?.dateFin,
+ servicesEps: servicesEps
]
- } as JSON
+ }
+
+ if (asJson) {modele.classes = modele.classes as JSON}
}
- private void ajouteClassesInscritesAuBrevet(Map modele) {
+ private String getLibelleServiceSport(Service service) {
+ "${service.matiere.codeGestion} - ${service.enseignements*.enseignant*.nomAffichage().join(', ')}"
+ }
+
+
+ private void ajouteClassesInscritesAuBrevet(Map modele, Boolean asJson = true) {
Map<StructureEnseignement, List<BrevetSerie>> mapClasseSeries =
brevetClasseService.findAllClassesInscritesAuBrevetAvecSeries(
etablissementCourant()
)
+ List<Service> serviceSports = notesServiceService.findAllServiceChoisiPourSportByClasses(
+ securiteSession,
+ mapClasseSeries.keySet().toList()
+ )
+
modele.classesBrevet = mapClasseSeries.collect {
StructureEnseignement classe, List<BrevetSerie> series ->
[
id: classe.id,
code: classe.code,
serie: series.first().id,
+ serviceEpsId: serviceSports.find {it.structureEnseignement.id == classe.id}?.id,
datePublication: classe.datePublicationBrevet
]
- }.sort {a, b -> cc.compare(a.code, b.code)} as JSON
+ }.sort {a, b -> cc.compare(a.code, b.code)}
+ if (asJson) {modele.classesBrevet = modele.classesBrevet as JSON}
+ }
+
+
+ def rechargeClasses = {
+ Map result = tryCatch {
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant(),
+ ActionEnum.CONSULTATION,
+ NotesFonction.DIRECTION_ASSIMILE)
+
+ Map resultat = [:]
+
+ ajouteAllClasses(resultat, false)
+ ajouteClassesInscritesAuBrevet(resultat, false)
+
+ return resultat
+ }
+
+ render result as JSON
}
id: epreuve.id,
numero: epreuve.code,
libelle: epreuve.libelle,
- matieres: matieres*.id.join(',')
+ matieres: matieres*.id.join(','),
+ isEpreuveEps: epreuve.isSport()
]
}
StructureEnseignement classe = StructureEnseignement.get(params.id)
Date datePublication = DateUtil.parseDateJavascript(params.datePublication)
BrevetSerie serie = BrevetSerie.get(params.serie)
+ Service serviceSport = params.serviceEpsId ? Service.get(params.serviceEpsId) : null
Map resultat = checkDatePublication(classe, datePublication)
if (resultat) {
securiteSession,
classe,
serie,
- datePublication
+ datePublication,
+ serviceSport
)
}
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.brevet.BrevetFiche
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.notes.scolarite.NotesServiceService
class BrevetClasseService {
AnneeScolaireService anneeScolaireService
StructureEnseignementNotesService structureEnseignementNotesService
+ NotesServiceService notesServiceService
SessionFactory sessionFactory
return map
}
+ List<StructureEnseignement> findAllClasseInscriteAuSerie(Etablissement etablissement,
+ BrevetSerie serie) {
+
+ return (List<StructureEnseignement>) PersonneProprietesScolarite.createCriteria().list {
+ createAlias('proprietesScolarite', 'ps')
+ createAlias('ps.structureEnseignement', 'classe')
+
+ createAlias('personne', 'personne')
+ createAlias('personne.brevetFiches', 'brevetFiches')
+ createAlias('brevetFiches.notes', 'notes')
+ createAlias('notes.epreuve', 'epreuve')
+
+ eq('epreuve.serie', serie)
+
+ projections {
+ groupProperty('ps.structureEnseignement')
+ }
+
+ eq('brevetFiches.anneeScolaire', anneeScolaireService.anneeScolaireEnCours())
+ eq('classe.etablissement', etablissement)
+ eq('classe.type', StructureEnseignement.TYPE_CLASSE)
+
+ eq('estActive', true)
+ }
+ }
+
/**
* Retourne toutes les classes d'un établissement dont au moins un élève est inscrit
* pour le Brevet.
void inscrisClasseAuBrevet(SecuriteSession securiteSession,
StructureEnseignement classe,
BrevetSerie serie,
- Date datePublication) {
+ Date datePublication,
+ Service serviceSport = null) {
notesDroitService.verifieAutorisationByEtablissement(
securiteSession,
sessionFactory.currentSession.flush()
}
+ notesServiceService.choisiServicePourSport(securiteSession, classe, serviceSport)
+
structureEnseignementNotesService.setDatePublicationBrevet(classe, datePublication)
classe.save(failOnError: true, flush: true)
}
BrevetNote note = BrevetNote.get(it.noteId)\r
if (note && note.appreciation != it.appreciation) {\r
note.appreciation = it.appreciation\r
- note.save(failOnError: true)\r
+ note.save(failOnError: true, flush: true)\r
}\r
}\r
- sessionFactory.currentSession.flush()\r
}\r
\r
/**\r
break\r
\r
case BrevetModeCalculNote.MOYENNE_SPORT :\r
- epreuveInfo.moyenne = calculeMoyenneSport(periode.classe, eleve)\r
- Matiere matiereSport = getMatiereSport(periode.classe)\r
- epreuveInfo.matieres = matiereSport ? [matiereSport] : []\r
+ Service serviceSport = findServiceSport(periode.classe)\r
+ epreuveInfo.moyenne = calculeMoyenneSport(serviceSport, eleve)\r
+ epreuveInfo.matieres = serviceSport ? [serviceSport.matiere] : []\r
break\r
\r
default: \r
}\r
}\r
\r
- private BigDecimal calculeMoyenneSport(StructureEnseignement classe, Personne eleve) {\r
- Service serviceSport = classe.structureEnseignementNotes.serviceSport\r
+ private findServiceSport(StructureEnseignement classe) {\r
+ return Service.findByStructureEnseignementAndChoisiPourSport(classe, true)\r
+ }\r
+\r
+ private BigDecimal calculeMoyenneSport(Service serviceSport, Personne eleve) {\r
\r
if (!serviceSport) {\r
return null\r
return calculationService.calculeMoyenne(notes*.valeurSur20, true)?.valeurNumerique\r
}\r
\r
- private Matiere getMatiereSport(StructureEnseignement classe) {\r
- return classe.structureEnseignementNotes.serviceSport?.matiere\r
- }\r
-\r
/**\r
* Moyenne ponderee des resultats\r
* @author msan\r
import org.hibernate.SessionFactory
import org.lilie.services.eliot.brevet.BrevetNote
import org.hibernate.FetchMode
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Service
class BrevetRelEpreuveMatiereService {
NotesDroitService notesDroitService
+ BrevetClasseService brevetClasseService
SessionFactory sessionFactory
!matieres.any{it.id == rel.matiere.id}
}
+ if (epreuve.isSport()) {
+ annulleChoixServiceSport(etablissement, epreuve, relsToSupprimer)
+ }
+
supprimeRelEpreuveMatieres(relsToSupprimer)
matieres.each {Matiere matiere ->
}
+ private void annulleChoixServiceSport(Etablissement etablissement,
+ BrevetEpreuve epreuve,
+ List<BrevetRelEpreuveMatiere> relsToSupprimer) {
+
+ if (relsToSupprimer.isEmpty()) {
+ return
+ }
+
+ List<StructureEnseignement> classes =
+ brevetClasseService.findAllClasseInscriteAuSerie(etablissement, epreuve.serie)
+
+ if (classes.isEmpty()) {
+ return
+ }
+
+ List<Matiere> matieres = relsToSupprimer*.matiere
+
+ List<Service> services = Service.createCriteria().list {
+ 'in'('structureEnseignement', classes)
+ 'in'('matiere', matieres)
+ eq('servicePrincipal', true)
+ eq('choisiPourSport', true)
+ }
+
+ services*.choisiPourSport = false
+ services*.save(failOnError: true)
+
+ sessionFactory.currentSession.flush()
+ }
+
+
/**
* Supprime les relations Epreuve <-> Matiere en mettant à ajour la matière
* dans les notes de brevet.
}
}
-
- /**
- * Retourne true si la matière est liée à une
- * des épreuves EPS (EDUCATION PHYSIQUE ET SPORTIVE)
- * @author bper
- */
- Boolean isMatiereEPS(Matiere matiere) {
- return BrevetRelEpreuveMatiere.createCriteria().count {
- eq('matiere', matiere)
- epreuve {
- eq('libelle', 'EDUCATION PHYSIQUE ET SPORTIVE')
- }
- maxResults(1)
- } as Boolean
- }
-
}
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.notes.NotesFonction
import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.brevet.BrevetRelEpreuveMatiere
+import org.lilie.services.eliot.brevet.BrevetModeCalculNote
class NotesServiceService extends ServiceService {
}
return existeDeja
}
+
+ /**
+ * Retourne tous les services évaluables dont les matières sont affectées à des épreuves
+ * de brevet de type SPORT pour les classes données.
+ * @author bper
+ */
+ List<Service> findAllServiceMatiereSportByClasses(SecuriteSession securiteSession,
+ List<StructureEnseignement> classes) {
+
+ if (classes.isEmpty()) {
+ return []
+ }
+
+ Map mapEtabClasse = classes.groupBy {it.etablissement}
+
+ if (mapEtabClasse.size() > 1) {
+ throw new IllegalArgumentException(
+ "Les classes ${classes} n'appartiennent pas au meme établissement ")
+ }
+
+ Etablissement etablissement = (Etablissement) mapEtabClasse.keySet().toList().first()
+
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissement,
+ ActionEnum.CONSULTATION,
+ (List) (NotesFonction.DIRECTION_ASSIMILE)
+ )
+
+ List<Matiere> matiereSports = (List<Matiere>) BrevetRelEpreuveMatiere.createCriteria().listDistinct {
+ matiere {
+ eq('etablissement', etablissement)
+ }
+ epreuve {
+ eq('modeCalculNote', BrevetModeCalculNote.MOYENNE_SPORT)
+ }
+
+ projections {
+ property('matiere')
+ }
+ }
+
+ if (matiereSports.isEmpty()) {
+ return []
+ }
+
+ return Service.createCriteria().listDistinct {
+ 'in'('structureEnseignement', classes)
+ 'in'('matiere', matiereSports)
+
+ eq('servicePrincipal', true)
+
+ createAlias("relPeriodeServices", "relPS")
+ eq('relPS.evaluable', true)
+ }
+ }
+
+ /**
+ * Retourne tous les services évaluables sélectionnés en tant que sevices de SPORT.
+ * @author bper
+ */
+ List<Service> findAllServiceChoisiPourSportByClasses(SecuriteSession securiteSession,
+ List<StructureEnseignement> classes) {
+
+ if (classes.isEmpty()) {
+ return []
+ }
+
+ Map mapEtabClasse = classes.groupBy {it.etablissement}
+
+ if (mapEtabClasse.size() > 1) {
+ throw new IllegalArgumentException(
+ "Les classes ${classes} n'appartiennent pas au meme établissement ")
+ }
+
+ Etablissement etablissement = (Etablissement) mapEtabClasse.keySet().toList().first()
+
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissement,
+ ActionEnum.CONSULTATION,
+ (List) (NotesFonction.DIRECTION_ASSIMILE)
+ )
+
+ return Service.createCriteria().listDistinct {
+ 'in'('structureEnseignement', classes)
+ eq('choisiPourSport', true)
+
+ eq('servicePrincipal', true)
+
+ createAlias("relPeriodeServices", "relPS")
+ eq('relPS.evaluable', true)
+ }
+ }
+
+ /**
+ * Marque le serice donné en tant que service de sport pour la classe donnée.
+ * Si le service est null => de-sélectionne les service sélectionné.
+ * @author bper
+ */
+ void choisiServicePourSport(SecuriteSession securiteSession,
+ StructureEnseignement classe,
+ Service service) {
+
+
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ classe.etablissement,
+ ActionEnum.MODIFICATION,
+ (List) (NotesFonction.DIRECTION_ASSIMILE)
+ )
+
+ if (service && classe.id != service.structureEnseignement.id) {
+ throw new IllegalArgumentException(
+ "Le serice $service n'est le service da la classe $classe")
+ }
+
+ Service serviceDejaChoisi = Service.findByStructureEnseignementAndChoisiPourSport(
+ classe,
+ true
+ )
+
+ if (serviceDejaChoisi?.id == service?.id) {
+ return
+ }
+
+ if (serviceDejaChoisi) {
+ serviceDejaChoisi.choisiPourSport = false
+ serviceDejaChoisi.save(failOnError: true, flush: true)
+ }
+
+ if (service) {
+ service.choisiPourSport = true
+ service.save(failOnError: true, flush: true)
+ }
+ }
}
\ No newline at end of file
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.annuaire.FonctionEnum
import org.lilie.services.eliot.notes.NotesFonction
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.notes.StructureEnseignementNotes
/**
* Extension de LocalStructureEnseignementService pour eliot-notes
fetchMode('periodes',FetchMode.JOIN)
}
}
-
}
<g:setJsValueLink name="urlOptions" controller="parametragesBrevet" action="options"/>
<g:setJsValueLink name="urlEnregistreOptions" controller="parametragesBrevet" action="enregistreOptions"/>
<g:setJsValueLink name="urlInitialiseClasses" controller="parametragesBrevet" action="initialiseClasses"/>
+ <g:setJsValueLink name="urlRechargeClasses" controller="parametragesBrevet" action="rechargeClasses"/>
// Libellés
<g:setJsVar value="ConfigServeur.libelle"/>
\r
BigDecimal moyenneSport = BigDecimal.valueOf((Long)(5 + 10 + 20)).divide((Long) 3, 10, RoundingMode.HALF_UP)\r
\r
- classe.structureEnseignementNotes.serviceSport = service1\r
- classe.structureEnseignementNotes.save(failOnError: true)\r
+ notesServiceService.choisiServicePourSport(securiteSessionDirection, classe, service1)\r
\r
creeAppreciation(eleve1, enseignement1, 'bubu')\r
creeAppreciation(eleve1, enseignement2, 'zuzu')\r
classeModel: this.classeModel
});
+ this.classeController.observeEpreuveController(this.epreuveController);
+
this.classeView = new this.ns.ClasseView({
classeModel: this.classeModel,
classeBrevetStore: this.classeController.classeBrevetStore,
{name: 'id'},
{name: 'libelle'},
{name: 'dateDebut', type: 'date', dateFormat: 'c'},
- {name: 'dateFin', type: 'date', dateFormat: 'c'},
+ {name: 'dateFin', type: 'date', dateFormat: 'c'},
+ {name: 'servicesEps'}
]
})
});
{name: 'id'},
{name: 'ordre', convert: this.creeOrdre},
{name: 'serie'},
+ {name: 'serviceEpsId'},
{name: 'datePublication', type: 'date', dateFormat: 'c'},
{name: 'creation'}
]);
params: {
id: classe.get('id'),
serie: classe.get('serie'),
+ serviceEpsId: classe.get('serviceEpsId'),
datePublication: classe.get('datePublication')
},
this);
},
+ observeEpreuveController: function(controller) {
+
+ controller.addListener(
+ this.Constantes.eventId.epreuveEpsChange,
+ function() {
+ this.rechargeClasses();
+ },
+ this);
+ },
+
creeClasse: function() {
var classe = new this.RecordType({
id: null,
});
}
+ },
+
+ rechargeClasses: function () {
+ eliot.commun.AjaxHelper.request({
+
+ url: this.ConfigServeur.url.urlRechargeClasses,
+
+ params: {
+ },
+
+ success: function(reponse) {
+ this.classeBrevetStore.loadData({classes: reponse.classesBrevet});
+ this.classeStore.loadData({classes: reponse.classes});
+ },
+
+ failure: function(reponse) {
+ },
+ scope: this
+ });
}
});
\ No newline at end of file
{
header: this.ConfigServeur.libelle.serie,
dataIndex: 'serie',
- width: 635,
+ width: 235,
editor: this.creeSerieEditor(),
renderer: function(value, metaData, record) {
var libelle = '';
return libelle;
}
},
+ {
+ header: 'Matière EPS',
+ dataIndex: 'serviceEpsId',
+ width: 400,
+ editor: this.creeServiceEpsEditor(),
+ renderer: function(value, metaData, record) {
+ var libelle = '';
+ if (value !== undefined) {
+
+ var classeId = record.get('id');
+ var classe = classeStore.getById(classeId);
+
+ //if (classe) {}
+ var servicesEps = classe.get('servicesEps');
+
+ for (var i = 0; i < servicesEps.length; i++) {
+ if (servicesEps[i].id == value) {
+ libelle = servicesEps[i].libelle;
+ }
+ }
+ }
+
+ return libelle;
+ }
+ },
{
header: this.ConfigServeur.libelle.datePublication,
dataIndex: 'datePublication',
listeners: {
select: function(combo, classe) {
this.initDatePublicationEditor(classe, true);
+ this.initServiceEpsEditor(classe);
},
scope: this
}
return this.serieEditor;
},
+ creeServiceEpsEditor: function() {
+ var store = new Ext.data.Store({
+ autoLoad: false,
+ reader: new Ext.data.JsonReader({
+ idProperty: 'id',
+ fields:[{name: 'id'}, {name: 'libelle'}]
+ })
+ });
+
+ this.serviceEpsEditor = new Ext.form.ComboBox({
+ store: store,
+ valueField:'id',
+ displayField: 'libelle',
+ triggerAction: 'all',
+ allowBlank: true,
+ mode: 'local',
+ editable: false,
+ disabled: false
+ });
+ return this.serviceEpsEditor;
+ },
+
+ initServiceEpsEditor: function(classeStoreRecord) {
+ if (classeStoreRecord) {
+ this.serviceEpsEditor.clearValue();
+ var store = this.serviceEpsEditor.store;
+ store.loadData(classeStoreRecord.get('servicesEps'));
+
+ var selected = this.serviceEpsEditor.getValue();
+ if (!selected && store.getTotalCount() > 0) {
+ this.serviceEpsEditor.setValue(store.getAt(0).get('id'));
+ }
+ }
+ },
+
creeDatePublicationEditor: function() {
this.datePublicationEditor = new Ext.form.DateField({
xtype: 'datefield',
this.serieEditor.enable();
}
- this.initDatePublicationEditor(
- this.config.classeStore.getById(classe.get('id')), false);
+ var classeStoreRecord = this.config.classeStore.getById(classe.get('id'))
+
+ this.initServiceEpsEditor(classeStoreRecord);
+ this.initDatePublicationEditor(classeStoreRecord, false);
}
return true;
urlSupprimeClasse: undefined,
urlOptions: undefined,
urlEnregistreOptions: undefined,
- urlInitialiseClasses: undefined
+ urlInitialiseClasses: undefined,
+ urlRechargeClasses: undefined
},
libelle: {
actionSupprime: 'actionSupprime',
ouvreOptionsEleves: 'ouvreOptionsEleves',
initialise: 'initialise',
- selectionChange: 'selectionChange'
+ selectionChange: 'selectionChange',
+ epreuveEpsChange: 'epreuveEpsChange'
},
composantId: {
},
addAllEvents: function() {
- //this.addEvents();
+ this.addEvents(this.Constantes.eventId.epreuveEpsChange);
},
creeConfig: function() {
{name: 'id'},
{name: 'numero'},
{name: 'libelle'},
- {name: 'matieres'}
+ {name: 'matieres'},
+ {name: 'isEpreuveEps'}
]
})
});
this.epreuveStore.commitChanges();
mask.hide();
eliot.notes.Messages.showConfirmation(this.ConfigServeur.messages.succesModifie);
+
+ if (epreuve.get('isEpreuveEps')) {
+ this.fireEvent(this.Constantes.eventId.epreuveEpsChange);
+ }
},
failure: function(reponse) {