class EliotConstantes {
static final JSON_SUCCESS = 'success' // champ JSON success
static final JSON_MESSAGE = 'message' // champ JSON message
+ static final JSON_ERROR = 'errors'
static final OK = 'OK'
static final KO = 'KO'
Map classesProfPrincipaux =
enseignantAnnuaireService.findAllProfesseurPrincipalForAllClasse(
- securiteSession,
(List<StructureEnseignement>) (elevesClasse.values()).toList()
)
import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
import org.lilie.services.eliot.securite.perimetre.PerimetreClasseEnseignantPrincipal
import org.lilie.services.eliot.securite.AutorisationException
+import org.lilie.services.eliot.scolarite.Enseignement
+import org.lilie.services.eliot.scolarite.Service
/**
* Gestion des droits d'accès aux entités de l'application eliot-notes
"générales (Synthèse ou Conseil de classe) de la classe $classe "
)
}
+ }
+
+
+ void verifieDroitEnregistrerSelectionNotesSport(SecuriteSession securiteSession,
+ List<Note> notes) {
+
+ List<Enseignement> enseignements =
+ (List<Enseignement>) notes.groupBy {it.evaluation.enseignement}.keySet().toList()
+
+ List<Service> services = enseignements.groupBy {it.service}.keySet().toList()
+ if (services.size() > 1) {
+ throw new IllegalArgumentException(
+ "Les notes $notes correspondent à plusieurs services")
+ }
+
+ Service service = services.first()
+
+ if (!enseignements.any {hasDroitAccesEnseignement(securiteSession, it)}) {
+ throw new AutorisationException(
+ "La personne ${securiteSession.personne} n'a pas accès au tableau de notes sport du service $service")
+ }
}
+
+
+ void verifieDroitConsulterTableauNotesSport(SecuriteSession securiteSession,
+ Service service) {
+
+ List<Enseignement> enseignements = service.enseignements.toList()
+
+ if (!enseignements.any {hasDroitAccesEnseignement(securiteSession, it)}) {
+ throw new AutorisationException(
+ "La personne ${securiteSession.personne} n'a pas accès au tableau de notes sport du service $service")
+ }
+ }
+
+
}
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.notes.NotesDroitService
-import org.lilie.services.eliot.securite.perimetre.PerimetreClasseEnseignantPrincipal
-import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
/**
* Appreciation d'un élève et service
// Vérifie si l'élève est parmi les élèves de la classe
Boolean isEleveOfClasse = localStructureEnseignementService.
isEleveDansStructureEnseignement(
- securiteSession,
+ null,
eleve,
classe)
"Enregistrement de notes impossibles pour un élève inactif : " + eleve.nomAffichage())
}
- Boolean isDirection = notesDroitService.hasPerimetre(securiteSession, PerimetreEtablissement)
- Boolean isProfPrincipal = classe ?
- notesDroitService.isObjetDansPerimetre(
- securiteSession, PerimetreClasseEnseignantPrincipal, classe) : false
-
- Boolean isDatePublicationBulletinDepassee = periode.getBulletinsPublies()
-
- if ((!isDirection && !isProfPrincipal && periode.verrouille) ||
- (isProfPrincipal && isDatePublicationBulletinDepassee)) {
- throw new PeriodeVerrouilleException(periode)
- }
-
AppreciationElevePeriode app = internalFindOrCree(eleve.autorite, periode)
app.appreciation = appreciation
save(app)
createAlias('personne', 'p')
createAlias('p.autorite', 'aut')
- if(actif){
- eq('estActive', actif)
- eq('aut.estActive', actif)
- } else {
- 'or'{
+ if (actif != null) {
+ if (actif) {
eq('estActive', actif)
eq('aut.estActive', actif)
+ } else {
+ 'or'{
+ eq('estActive', actif)
+ eq('aut.estActive', actif)
+ }
}
}
* @return une map de couple classes/professeurs principaux
* @author bahj
*/
- Map findAllProfesseurPrincipalForAllClasse(SecuriteSession securiteSession,
- List<StructureEnseignement> classes) {
+ Map findAllProfesseurPrincipalForAllClasse(List<StructureEnseignement> classes) {
Map classesProfPrincipaux = [:]
List resultats = []
result = [
(EliotConstantes.JSON_SUCCESS): false,
// (EliotConstantes.JSON_MESSAGE): massage(code:'eliot.notes.message.exception'),
- (NotesConstantes.JSON_ERROR): command.errors,
+ (EliotConstantes.JSON_ERROR): command.errors,
]
}
return result
Service service = Service.get(params.serviceId)
- TableauNotesSport tab = tableauNotesSportService.construisTableau(securiteSession, service)
+ notesDroitService.verifieDroitConsulterTableauNotesSport(securiteSession, service)
+
+ TableauNotesSport tab = tableauNotesSportService.construisTableau(service)
return [notesBrevetEps: [devoirs: tab.evaluations, lignes: tab.lignes]]
}
selection.put(Long.valueOf(k), Boolean.valueOf(v))
}
- tableauNotesSportService.enregistreSelection(securiteSession, selection)
+ notesDroitService.verifieDroitEnregistrerSelectionNotesSport(selection)
+
+ tableauNotesSportService.enregistreSelection(selection)
}
render resultat as JSON
*/
class ApplicationController extends AbstractApplicationController{
- Object findPage(String codePage){
+ protected Object findPage(String codePage){
Page.valueOf(codePage)
}
+++ /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
-
-/**
- * Constantes pour Notes
- * @author msan
- * @author bper
- *
- * @deprecated (bper)
- */
-class NotesConstantes {
- static final JSON_ERROR ='errors'
-}
notesDroitService.verifieDroitAccesObjetDomaine(securiteSession, evaluation.enseignement)
- List<Note> notes = notesNoteService.saveOrUpdateAll(
- securiteSession,
- evaluation,
- noteParams)
+ List<Note> notes = notesNoteService.saveOrUpdateAll(evaluation,noteParams)
withFormat {
json {
NotesFonctionnalite.NOTES_SAISIE_NOTES_ENSEIGNANTS
])
- Boolean success = false
- Map result = [:]
- try {
- Autorite enseignant = SessionUtils.utilisateur(session)
+ Autorite enseignant = securiteSession.defaultAutorite
List<Service> services = notesServiceService.
findAllServiceForEnseignant(enseignant, etablissementCourant())
- success = true
- result.serviceInfos = services
- } catch (AutorisationException e) {
- result['errorMsg'] = e.message
- }
-
- result[EliotConstantes.JSON_SUCCESS] = success
- if (result['errorMsg']) {
- log.error(result['errorMsg'])
- }
-
- return result
+ return [serviceInfos: services]
}
render result as JSON
}
params.creation = true
- return modifieSousService(command)
+ return creeOuModifieSousService(command)
}
render result as JSON
Map result = tryCatch{
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
- modifieSousService(command)
+ creeOuModifieSousService(command)
}
render result as JSON
}
- private Map modifieSousService(ServiceCommand command) {
+ private Map creeOuModifieSousService(ServiceCommand command) {
Map valeurs = [:]
if (command.hasErrors()) {
valeurs[(EliotConstantes.JSON_SUCCESS)] = false
if (creation) {
resultatModification = notesSousServiceService.creeSousService(dto)
} else {
- resultatModification = notesSousServiceService.modifieSousService(
- securiteSession,
- dto
- )
+ resultatModification = notesSousServiceService.modifieSousService(dto)
}
if (resultatModification.mmExisteDeja) {
String uai = (jsonParams.uai.toString() == 'null') ? null : jsonParams.uai.toString()
Boolean isUaiValide = Etablissement.valideUai(uai)
- Map result = [:]
+ Map map = [:]
if (uai != null && !isUaiValide) {
- result.success = false
- result.message = message(code: 'eliot.notes.export.admissionPostBac.libelle.message.RNE.erreur')
+ map.success = false
+ map.message = message(code: 'eliot.notes.export.admissionPostBac.libelle.message.RNE.erreur')
}
else {
admissionPostBacExportService.exporteAsynchrone(
classes,
typeExport)
- result.message = message(code: 'eliot.notes.export.admissionPostBac.libelle.message.preparation.succes')
+ map.message = message(code: 'eliot.notes.export.admissionPostBac.libelle.message.preparation.succes')
}
- return result
+ return map
}
render(result as JSON)
response.contentType = "application/octet-stream"
response.characterEncoding = "ISO-8859-1"
- response.outputStream << admissionPostBacExportService.getFichierInputStream(
- getSecuriteSession(),
- demandeTraitement)
+ response.outputStream << admissionPostBacExportService.getFichierInputStream(demandeTraitement)
}
classes
)
- Map result = [:]
- result.message = message(code: 'eliot.notes.export.notanet.message.preparation.succes')
-
- return result
+ return [message: message(code: 'eliot.notes.export.notanet.message.preparation.succes')]
}
render(result as JSON)
List<DefaultDemandeTraitement> demandes =
demandeTraitementService.getHistoriqueDemandesTraitements(demandeParams)
- Map result = (Map) [:]
+ Map map = (Map) [:]
List exports = []
demandes.each { DefaultDemandeTraitement demande ->
]
}
- result.success = true
- result.message = ''
-
- result.nbLignes =
+ map.nbLignes =
demandeTraitementService.getNombreDemandeTraitementHistorique(demandeParams)
- result.exports = exports
+ map.exports = exports
- return result
+ return map
}
render(result as JSON)
import org.lilie.services.eliot.impression.constantes.TypeMedia
import org.lilie.services.eliot.impression.TemplateDocument
import org.lilie.services.eliot.demon.DemandeTraitementService
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.impression.stockage.PublipostageStockageFichierService
import org.lilie.services.eliot.notes.demon.NotesDemandeTraitementService
import org.lilie.services.eliot.demon.DemandeTraitement
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.securite.perimetre.PerimetreClasseEnseignantPrincipal
import org.lilie.services.eliot.securite.perimetre.PerimetreEtablissement
+import org.lilie.services.eliot.notes.exception.PeriodeVerrouilleException
/**
* Appréciations saisie par le conseil de classe pour les élèves d'une classe
}
}
+ verifieDroitSaisiePeriodeVerrouille(param)
+
conseilDeClasseService.enregistreAppreciations(param)
}
return breadCrumbsInfo
}
+
+
+ private void verifieDroitSaisiePeriodeVerrouille(ConseilDeClasseParam param) {
+
+ Periode periode = param.periode
+
+ Boolean isDirection = notesDroitService.hasPerimetre(securiteSession, PerimetreEtablissement)
+ Boolean isProfPrincipal = notesDroitService.isObjetDansPerimetre(
+ securiteSession, PerimetreClasseEnseignantPrincipal, periode.classe)
+
+ Boolean isDatePublicationBulletinDepassee = periode.getBulletinsPublies()
+
+ if ((!isDirection && !isProfPrincipal && periode.verrouille) ||
+ (isProfPrincipal && isDatePublicationBulletinDepassee)) {
+ throw new PeriodeVerrouilleException(periode)
+ }
+ }
}
/**
* Constructeur
- * @param controller
- * @param tableauDeNotesService
- * @param eleve
- * @param service
- * @param enseignant
- * @return
*/
TableauRecapEleveComposant(AbstractNotesController controller,
TableauDeNotesService tableauDeNotesService,
this.controller = controller
this.recaps = tableauDeNotesService.construisTableauDeNotesRecapEleves(
- controller.securiteSession,
eleve,
tableauDeNotesService.enseignementService.getEnseignement(
service,
texte: texte
)
+ modeleAppreciationProfesseur.save(failOnError: true, flush: true)
+
return modeleAppreciationProfesseur
}
import org.lilie.services.eliot.notes.export.admissionpostbac.rapport.ApbRapport\r
import org.lilie.services.eliot.scolarite.Personne\r
import org.lilie.services.eliot.notes.export.admissionpostbac.dto.ApbClasse\r
-import org.lilie.services.eliot.annuaire.SecuriteSession\r
import org.lilie.services.eliot.scolarite.personne.enseignant.EnseignantAnnuaireService\r
import org.lilie.services.eliot.notes.export.admissionpostbac.rapport.ApbErreurClasseSansProfPrincipal\r
import org.lilie.services.eliot.notes.export.admissionpostbac.rapport.ApbErreurClasseSansPeriodes\r
NotesDirtyMoyenneService notesDirtyMoyenneService\r
AdmissionPostBacUtilsService admissionPostBacUtilsService\r
\r
- void extraisClasses(SecuriteSession securiteSession,\r
- List<StructureEnseignement> classes,\r
- ApbTypeExportEnum typeExport,\r
- ApbEtablissement apbEtablissement,\r
- Map<String, ApbEnseignant> apbEnseignantsMap,\r
- ApbRapport rapport) {\r
+ void extraisClasses(List<StructureEnseignement> classes,\r
+ ApbTypeExportEnum typeExport,\r
+ ApbEtablissement apbEtablissement,\r
+ Map<String, ApbEnseignant> apbEnseignantsMap,\r
+ ApbRapport rapport) {\r
\r
Map professeurPrincipauxParClasse =\r
- enseignantAnnuaireService.findAllProfesseurPrincipalForAllClasse(\r
- securiteSession,\r
- classes)\r
+ enseignantAnnuaireService.findAllProfesseurPrincipalForAllClasse(classes)\r
\r
exclusClassesSansProfPrincipaux(professeurPrincipauxParClasse, classes, rapport)\r
exclusClassesSansPeriodes(classes, rapport)\r
String uai = (params.uai == null || params.uai == JSONObject.NULL) ? null : params.uai
Boolean fichierDisponible = exporte(
- getSecuriteSessionSysteme(etablissement),
nomFichier,
etablissement,
classes,
}
- InputStream getFichierInputStream(SecuriteSession securiteSession,
- DemandeTraitement demandeTraitement) {
+ InputStream getFichierInputStream(DemandeTraitement demandeTraitement) {
String nomFichier = genereNomFichier(demandeTraitement)
return new FileInputStream(nomFichier)
}
- private Boolean exporte(SecuriteSession securiteSession,
- String fileName,
+ private Boolean exporte(String fileName,
Etablissement etablissement,
List<StructureEnseignement> classes,
ApbTypeExportEnum typeExport,
String uai = null) {
ApbFichier apbFichier = admissionPostBacExtractionService.extraire(
- securiteSession,
etablissement,
classes,
typeExport,
/**
* Génère le fichier de rapport.
- * @param fileName
- * @param rapport
* @author bper
*/
private Boolean creeRapport(String fileName, ApbRapport rapport) {
package org.lilie.services.eliot.notes.export.admissionpostbac
import org.codehaus.groovy.grails.commons.GrailsApplication
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.notes.export.AbstractExportService
import org.lilie.services.eliot.scolarite.etablissement.PreferenceEtablissementService
import org.lilie.services.eliot.notes.export.admissionpostbac.dto.*
static transactional = true
- ApbFichier extraire(SecuriteSession securiteSession,
- Etablissement etablissement,
+ ApbFichier extraire(Etablissement etablissement,
List<StructureEnseignement> classes,
ApbTypeExportEnum typeExport,
ApbRapport rapport) {
)
admissionPostBacClasseExtractionService.extraisClasses(
- securiteSession,
classes,
typeExport,
apbEtablissement,
rapport)
admissionPostBacSynthesesExtractionService.extraisSyntheses(
- securiteSession,
classes,
apbEtablissement,
typeExport,
import org.lilie.services.eliot.notes.export.admissionpostbac.dto.ApbAnneeScolaire
import org.lilie.services.eliot.notes.export.admissionpostbac.dto.ApbBulletin
import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.notes.resultat.synthese.SyntheseService
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.annuaire.Mef
private static final NoteFormateur NF = new NoteFormateur(0.01, '.')
- void extraisSyntheses(SecuriteSession securiteSession,
- List<StructureEnseignement> classes,
+ void extraisSyntheses(List<StructureEnseignement> classes,
ApbEtablissement apbEtablissement,
ApbTypeExportEnum typeExport,
Map<String, ApbEnseignant> apbEnseignantsMap,
ApbServiceNotation serviceNotationMOYGEN =
findOrCreateApbServiceNotationMOYGEN(
- securiteSession,
apbEtablissement,
synthese.syntheseClasse.resultatClassePeriode,
apbServiceNotationsMap,
}
- private ApbServiceNotation findOrCreateApbServiceNotationMOYGEN(SecuriteSession securiteSession,
- ApbEtablissement apbEtablissement,
+ private ApbServiceNotation findOrCreateApbServiceNotationMOYGEN(ApbEtablissement apbEtablissement,
ResultatClassePeriode resultatClassePeriode,
Map<String, ApbServiceNotation> apbServiceNotationsMap,
Map<String, ApbEnseignant> apbEnseignantsMap,
if (apbServiceNotation == null) {
Map professeurPrincipauxParClasse =
- enseignantAnnuaireService.findAllProfesseurPrincipalForAllClasse(
- securiteSession, [classe])
+ enseignantAnnuaireService.findAllProfesseurPrincipalForAllClasse([classe])
Personne enseignant = admissionPostBacUtilsService.getProfesseurPrincipal(
(List<Personne>) professeurPrincipauxParClasse.get(classe))
import org.lilie.services.eliot.menu.SousMenu
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
import org.lilie.services.eliot.notes.page.Page
-import org.lilie.services.eliot.notes.NotesFonctionnalite
/**
*
* Enregistre ou mets a jour les notes. Cette methode est a utiliser seulement
* par les WebServices.
*/
- List<Note> saveOrUpdateAll(SecuriteSession securiteSession,
- Evaluation evaluation,
+ List<Note> saveOrUpdateAll(Evaluation evaluation,
List<NoteParams> noteParams) {
if (!evaluation.creeParWebservice) {
)
}
- // verifie les droits de modification des notes
- Enseignement enseignement = evaluation.enseignement
-
if (!evaluation.creeParWebservice) {
throw new IllegalArgumentException(
"Evaluation ${evaluation.id} n'a pas ete cree par un WebSrevice")
}
- noteParams = getNoteParamsValides(securiteSession, evaluation, noteParams)
+ noteParams = getNoteParamsValides(evaluation, noteParams)
if (!noteParams) {
return []
/**
* Filtre les mauvais parametres
*/
- private List<NoteParams> getNoteParamsValides(SecuriteSession securiteSession,
- Evaluation evaluation,
+ private List<NoteParams> getNoteParamsValides(Evaluation evaluation,
List<NoteParams> noteParams) {
noteParams = noteParams.findAll {it.valeur != null}
evaluation.enseignement.service.structureEnseignement
noteParams = noteParams.findAll {
localStructureEnseignementService.isEleveDansStructureEnseignement(
- securiteSession,
+ null,
it.eleve,
structureEnseignement
)
* Construis la liste des récapitulatifs du tableau de notes pour un élève
* @author bper
*/
- List<TableauDeNotesRecapEleve> construisTableauDeNotesRecapEleves(SecuriteSession securiteSession,
- Personne eleve,
+ List<TableauDeNotesRecapEleve> construisTableauDeNotesRecapEleves(Personne eleve,
Enseignement enseignement) {
if (!eleve || !enseignement) { return [] }
typePeriodes.each { TypePeriode typePeriode ->
TableauDeNotesRecapEleve recap = construisTableauDeNotesRecapEleve(
- securiteSession,
eleve,
enseignement,
typePeriode,
* Construis un recapitulatif pour un eleve et un typePeriode
* @param recaps le recap est place dans recaps si l'eleve est present
* dans le tableau de notes pour pour le typePeriode donne
- * @return
*/
- private TableauDeNotesRecapEleve construisTableauDeNotesRecapEleve(SecuriteSession securiteSession,
- Personne eleve,
+ private TableauDeNotesRecapEleve construisTableauDeNotesRecapEleve(Personne eleve,
Enseignement enseignement,
TypePeriode typePeriode,
List<TableauDeNotesRecapEleve> recaps) {
package org.lilie.services.eliot.notes.notes.tableaudenotes
import org.lilie.services.eliot.notes.Evaluation
-import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.textes.TypeActiviteParDefaut
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.notes.Note
import org.lilie.services.eliot.scolarite.personne.eleve.EleveAnnuaireService
import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.scolarite.NaturePeriode
-import javax.naming.AuthenticationException
class TableauNotesSportService {
* Retourne le tableau de notes pour les devoirs de type SPORT.
* @author bper
*/
- TableauNotesSport construisTableau(SecuriteSession securiteSession,
- Service service) {
-
- verifieAutorisationConsulterTableauNotesSport(securiteSession, service)
+ TableauNotesSport construisTableau(Service service) {
List<Personne> eleves = eleveAnnuaireService.findAllEleveByStructureEnseignement(
service.structureEnseignement,
true
)
- eleves.sort {it.nomAffichage()}
+
+ eleves.sort {it.nomAffichage()}
List<Evaluation> evaluations = findAllEvalSportPourService(service)
evaluations.sort()
* EPS de Brevet.
* @author bper
*/
- void enregistreSelection(SecuriteSession securiteSession,
- Map<Long,Boolean> selection) {
+ void enregistreSelection(Map<Long,Boolean> selection) {
if (selection.isEmpty()) {
return
List<Note> notes = findAllNoteByIds(noteIds)
- verifieAutorisationModifierNotes(securiteSession, notes)
-
verifieNoteSports(notes)
notes.each {
}
- private verifieAutorisationConsulterTableauNotesSport(SecuriteSession securiteSession,
- Service service) {
-
- List<Enseignement> enseignements = service.enseignements.toList()
-
- if (!enseignements.any {notesDroitService.hasDroitAccesEnseignement(securiteSession, it)}) {
- throw new AuthenticationException(
- "La personne ${securiteSession.personne} n'a pas accès au tableau de notes " +
- "sport du service $service")
- }
- }
-
-
- private verifieAutorisationModifierNotes(SecuriteSession securiteSession,
- List<Note> notes) {
-
- List<Enseignement> enseignements =
- (List<Enseignement>) notes.groupBy {it.evaluation.enseignement}.keySet().toList()
-
- List<Service> services = enseignements.groupBy {it.service}.keySet().toList()
-
- if (services.size() > 1) {
- throw new IllegalArgumentException(
- "Les notes $notes correspondent à plusieurs services")
- }
-
- Service service = services.first()
-
- if (!enseignements.any {notesDroitService.hasDroitAccesEnseignement(securiteSession, it)}) {
- throw new AuthenticationException(
- "La personne ${securiteSession.personne} n'a pas accès au tableau de notes sport du service $service")
- }
- }
-
-
void verifieMax3NotesChoisies(List<Note> notes) {
Service service = findServiceFromNotes(notes)
// 1) traitement des sous-matieres
if (report.reportSousServices) {
reporteSousServicesAuService(
- securiteSession,
reportServiceCorrespondanceNewSession.serviceSource,
reportTraitement.serviceCible,
report.naturePeriode,
if (serviceSource) {
// traite les sous-services
reporteOrdreCoefficientsAuxSousServices(
- securiteSession,
serviceSource,
serviceCible,
classeCible,
* Reporte les ordres de sous-services et les coefficients de service source
* vers le service cible, s'il a des sous-services
*/
- private void reporteOrdreCoefficientsAuxSousServices(SecuriteSession securiteSession,
- Service serviceSource,
+ private void reporteOrdreCoefficientsAuxSousServices(Service serviceSource,
Service serviceCible,
StructureEnseignement classeCible,
NaturePeriode naturePeriode,
/**
* Report les sous-services d'un service vers l'autre pour une nature/type de periode
*/
- private void reporteSousServicesAuService(SecuriteSession securiteSession,
- Service serviceSource,
+ private void reporteSousServicesAuService(Service serviceSource,
Service serviceCible,
NaturePeriode naturePeriode,
TypePeriode typePeriode) {
if (sousServiceExistant) {
if (sousServiceExistant.evaluable) {
notesSousServiceService.modifieSousService(
- securiteSession,
new NotesModaliteMatiereParams(
coeffs: coeffMap,
serviceParent: service,
package org.lilie.services.eliot.notes.resultat
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.notes.InfoCalculMoyennesClasse
import org.springframework.dao.DataIntegrityViolationException
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.hibernate.SessionFactory
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.hibernate.exception.ConstraintViolationException
import org.lilie.services.eliot.notes.DirtyMoyenne
import org.hibernate.FetchMode
classeDejaTraiteeIds << classe.id
try {
infoCalculMoyennesClasseService.enleveVerrou(classe)
-
- SecuriteSession securiteSession = DefaultSecuriteSessionFactory.
- getEliotNotesSecuriteSessionForCodePorteurENT(
- classe.etablissement.codePorteurENT)
- lanceMajMoyennes(securiteSession,classe)
+ lanceMajMoyennes(classe)
sessionFactory.currentSession.flush()
sessionFactory.currentSession.clear()
/**
* Lance le mise à jour des moyennes pour une classe s'il n'y pas d'autres
* processus qui calculent les moyennes pour cette classe au même temps.
- * @param securiteSession
- * @param classe
* @author msan
* @author bper
*/
@SuppressWarnings('CatchException')
- private void lanceMajMoyennes(SecuriteSession securiteSession,
- StructureEnseignement classe) {
+ private void lanceMajMoyennes(StructureEnseignement classe) {
if (classe == null) {
throw new IllegalArgumentException(
}
// Calcule les moyennes
- moyenneService.majMoyennes(securiteSession, classe, infoCalcul.dateDebutCalcul)
+ moyenneService.majMoyennes(classe, infoCalcul.dateDebutCalcul)
}
import org.lilie.services.eliot.notes.Note
import org.lilie.services.eliot.notes.ResultatEleveServicePeriode
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.notes.ResultatEleveSousServicePeriode
import org.lilie.services.eliot.scolarite.SousService
* Attention! Avant d'appeler cette méthode il est nécessaire que
* infoCalculMoyennesClasse correspondante à la classe soit verrouillé
* (calculEnCours = true, dateVerrou = new Date()) dans une autre transaction.
- * @param classe
- * @param securiteSession
* @author msan
* @author bper
*/
- void majMoyennes(SecuriteSession securiteSession,
- StructureEnseignement classe,
+ void majMoyennes(StructureEnseignement classe,
Date dateDebutCalculPrecedent) {
infoCalculMoyennesClasseService.marqueDebutCalcul(classe)
}
// Calcule les moyennes
- internalMajMoyennes(securiteSession, classe, dateDebutCalculPrecedent)
+ internalMajMoyennes(classe, dateDebutCalculPrecedent)
if (log.isInfoEnabled()) {
log.info(
* Met à jour les moyennes.
* Seulement cette méthode doit être utilisé pour tous les mises à jours des moyennes.
*
- * @param securiteSession
* @param classe classe dont les moyennes doivent etre mis a jour
* @param dateDebutCalculPrecedent date de debut de precedent calcul des moyennes
* @author msan
* @author bper
*/
- private void internalMajMoyennes(SecuriteSession securiteSession,
- StructureEnseignement classe,
+ private void internalMajMoyennes(StructureEnseignement classe,
Date dateDebutCalculPrecedent) {
// Récupère les élèves de la classe
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.Personne
import org.springframework.context.ApplicationContext
import org.springframework.context.ApplicationContextAware
package org.lilie.services.eliot.notes.resultat.synthese
import org.lilie.services.eliot.scolarite.Periode
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Service
import org.lilie.services.eliot.notes.scolarite.NotesServiceService
import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.RelPeriodeServiceService
import org.lilie.services.eliot.scolarite.Service
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.scolarite.SousService
class NotesRelPeriodeServiceService extends RelPeriodeServiceService {
"Les classes ${classes} n'appartiennent pas au meme établissement ")
}
- Etablissement etablissement = (Etablissement) mapEtabClasse.keySet().toList().first()
-
return Service.createCriteria().listDistinct {
'in'('structureEnseignement', classes)
eq('choisiPourSport', true)
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.notes.resultat.UptodateService
import org.lilie.services.eliot.notes.notes.NotesEvaluationService
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.exception.SauvegardeEchoueException
import org.lilie.services.eliot.scolarite.NaturePeriode
import org.lilie.services.eliot.scolarite.StructureEnseignement
/**
* Modifie un sous-service
*/
- ResultatModification modifieSousService(SecuriteSession secutiteSession,
- NotesModaliteMatiereParams params)
+ ResultatModification modifieSousService(NotesModaliteMatiereParams params)
throws SauvegardeEchoueException {
return creeOrModifieSousService(params, false)
// vérifie que MM n'est pas encore lié - sinon - leve un message
if (mmChangee) {
- if (internalVerifieRelationExiste(
- service,
- mmFinal,
- nature,
- typePeriodeEdite
- )) {
+ if (internalVerifieRelationExiste(service, mmFinal, nature, typePeriodeEdite)) {
resultatModification.mmExisteDeja = true
return resultatModification
}
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.notes.export.admissionpostbac.dto.ApbTypeExportEnum
-import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
import org.lilie.services.eliot.notes.test.JeuDonneesTest
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.notes.export.admissionpostbac.rapport.ApbRapport
import java.text.DecimalFormatSymbols
import java.text.DecimalFormat
Etablissement etablissement = jd.etablissement
- SecuriteSession securiteSession = DefaultSecuriteSessionFactory.
- getEliotNotesSecuriteSessionForCodePorteurENT(
- etablissement.codePorteurENT)
+ etablissement.uai = "1234567A" // UAI valide
admissionPostBacExportService.exporte(
- securiteSession,
XML_FILE_NAME,
etablissement,
classes,
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
import org.lilie.services.eliot.test.InitPeriodeTestService
import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.test.PopulationTestActeur
-import org.lilie.services.eliot.test.PopulationTestEtablissement
+
import org.lilie.services.eliot.scolarite.AnneeScolaire
-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.securite.impl.Autorite
-import org.lilie.services.eliot.notes.exception.PeriodeVerrouilleException
import org.lilie.services.eliot.notes.resultat.eleve.AppreciationElevePeriodeService
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
InitDonneesNotesTestService initDonneesNotesTestService
InitPeriodeTestService initPeriodeTestService
- NotesPeriodeService notesPeriodeService
AnneeScolaireService anneeScolaireService
AppreciationElevePeriodeService appreciationElevePeriodeService
ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
- Calendar dateFinSaisieNonDepassee = Calendar.getInstance()
- Calendar dateFinSaisieDepassee = Calendar.getInstance()
- Calendar datePublicationBulletinNonDepassee = Calendar.getInstance()
- Calendar datePublicationBulletinDepassee = Calendar.getInstance()
-
- Etablissement etablissement1 = null
-
- Periode periodeT1_1 = null
- Periode periodeT1_2 = null
+ Periode periodeT1Classe1 = null
+ Periode periodeT1Classe2 = null
Personne eleve = null
- Personne eleve2 = null
-
- StructureEnseignement classe1enTrimestres = null
- StructureEnseignement classe1_2 = null
- PersonneProprietesScolarite personneProprietesScolarite = null
-
- AnneeScolaire anneeScolaire = null
-
- String appreciation = null
+ String appreciation1 = "Eleve serieux"
+ String appreciation2 = "Très moyen"
protected void setUp() {
initPeriodeTestService.initialisePeriodesDeTest()
initDonneesNotesTestService.initDonneesTest()
- //get Etablissement
- etablissement1 =
- localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
-
//anneescolaire
- anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()
//StrcureEnseignement
- classe1enTrimestres = localInitDonneesCommunesTestService.getClasse(
+ StructureEnseignement classe1 = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1
)
- classe1_2 = localInitDonneesCommunesTestService.getClasse(
+
+ StructureEnseignement classe2 = localInitDonneesCommunesTestService.getClasse(
PopulationTestClasse.CLASSE_1_2
)
// creer une personne eleve et l'ajouter dans la classe classe1enTrimestres
eleve = creePersonne("11110147800011")
- eleve2 = creePersonne("11110147800012")
-
- personneProprietesScolarite = creePersonneProprietesScolarite(
- eleve,
- creeProprietesScolarite()
- )
- personneProprietesScolarite = creePersonneProprietesScolarite(
- eleve2,
- creeProprietesScolarite()
- )
proprieteScolariteTestUtilService.inscrireEleveClasse(
eleve,
- etablissement1,
- classe1enTrimestres,
- anneeScolaire,
- null,
- null,
- null,
- true
- )
- proprieteScolariteTestUtilService.inscrireEleveClasse(
- eleve2,
- etablissement1,
- classe1_2,
+ classe1.etablissement,
+ classe1,
anneeScolaire,
null,
null,
)
//get periode de notation
- periodeT1_1 = initDonneesNotesTestService.getOuCreePeriode(
+ periodeT1Classe1 = initDonneesNotesTestService.getOuCreePeriode(
initPeriodeTestService.t1,
- classe1enTrimestres
+ classe1
)
- periodeT1_2 = initDonneesNotesTestService.getOuCreePeriode(
+
+ periodeT1Classe2 = initDonneesNotesTestService.getOuCreePeriode(
initPeriodeTestService.t1,
- classe1_2
+ classe2
)
+ }
- //appreciation
- appreciation = "Eleve serieux"
+ protected void tearDown() {
+ super.tearDown()
+ }
- // Dates de fermeture
- dateFinSaisieNonDepassee.add(Calendar.DAY_OF_MONTH, 1)
- dateFinSaisieDepassee.add(Calendar.DAY_OF_MONTH, -1)
- datePublicationBulletinNonDepassee.add(Calendar.DAY_OF_MONTH, 1)
- datePublicationBulletinDepassee.add(Calendar.DAY_OF_MONTH, -1)
+ void testMajAppreciation() {
+
+ // Premier enreigistrement
+ appreciationElevePeriodeService.majAppreciation(
+ eleve,
+ periodeT1Classe1,
+ appreciation1
+ )
+
+ AppreciationElevePeriode appreciationElevePeriode =
+ AppreciationElevePeriode.findByEleveAndPeriode(eleve.autorite, periodeT1Classe1)
+
+ assertEquals(
+ "L'appréciation n'a pas été enregistré",
+ appreciation1,
+ appreciationElevePeriode?.appreciation
+ )
+
+
+ // Mise à jour
+ appreciationElevePeriodeService.majAppreciation(
+ eleve,
+ periodeT1Classe1,
+ appreciation2
+ )
+
+ appreciationElevePeriode =
+ AppreciationElevePeriode.findByEleveAndPeriode(eleve.autorite, periodeT1Classe1)
+
+ assertEquals(
+ "L'appréciation n'a pas été mise à jour",
+ appreciation2,
+ appreciationElevePeriode?.appreciation
+ )
}
- protected void tearDown() {
- super.tearDown()
+
+ void testMajAppreciationElevePasDansClasse() {
+
+ Boolean exceptionLevee = false
+
+ try {
+ appreciationElevePeriodeService.majAppreciation(
+ eleve,
+ periodeT1Classe2,
+ appreciation1
+ )
+ } catch (IllegalArgumentException ex) {
+ exceptionLevee = true
+ }
+
+ assertTrue(
+ "L'excetion n'a pas été levée alors que l'éleve n'est pas dans la classe",
+ exceptionLevee)
}
nom: "Michal",
prenom: "Luxo",
autorite: autorite,
- etablissementRattachement: etablissement1,
)
personne.save(failOnError: true)
return personne
}
-
- /**
- * Crée une ProprietesScolarite
- * @return proprietesScolarite d'un eleve
- * @author mjao
- */
- private ProprietesScolarite creeProprietesScolarite() {
-
- ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- fonction: Fonction.findByCode(FonctionEnum.ELEVE.getCode()),
- etablissement: etablissement1
- )
- proprietesScolarite.save()
- if (proprietesScolarite.hasErrors()) {
- println(proprietesScolarite.errors)
- }
- return proprietesScolarite
-
- }
-
- /**
- * 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
- }
-
}
infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(classe1enTrimestres, null)
//Appeler la methode à tester
Bulletin bulletin = bulletinService.construisBulletin(securiteSessionEnseignant,
infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
- moyenneService.majMoyennes(securiteSessionEnseignant, classe1enTrimestres, null)
+ moyenneService.majMoyennes(classe1enTrimestres, null)
Bulletin bulletinT1 = bulletinService.construisBulletin(
securiteSessionEnseignant,
}
- /**
- * Tests : Accées Eleve1 à un bulletin de notes d'un autre Eleve2
- * @author mjao
- */
- void testAccesEleve1BulletinEleve2() {
-
- // Le securité session d'un eleve
- SecuriteSession securiteSessionEleve =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ELEVE_2_CLASSE_1)
-
- //periodeT2_1 publie
- periodeT2_1.datePublicationBulletins = new Date(111, 1, 1)
-
- Boolean exceptionLeve = false
- try {
- bulletinService.construisBulletin(securiteSessionEleve,
- eleve1,
- periodeT2_1)
- }
- catch (AutorisationException e) {
-
- exceptionLeve = true
- }
- assertTrue("l'eleve 2 peut acceder au bulletin de notes de l'eleve1", exceptionLeve)
-
- }
-
- /**
- * Tests : Accées Eleve1 à un bulletin de notes d'un autre Eleve2
- * @author mjao
- */
- void testAccesParent1ReleveEleve2() {
-
- // Le securité session d'un eleve
- SecuriteSession securiteSessionParent =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.PARENT_1)
-
- //periodeT2_1 publie
- periodeT2_1.datePublicationBulletins = new Date(111, 1, 1)
-
- Boolean exceptionLeve = false
- try {
-
- bulletinService.construisBulletin(securiteSessionParent,
- eleve2,
- periodeT2_1)
-
- } catch (AutorisationException e) {
-
- exceptionLeve = true
- }
- assertTrue("Le parent1 peut acceder au bulletin de notes de l'eleve2", exceptionLeve)
-
- }
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
- * @return evaluation
* @author mjao
*/
private Evaluation creeEvaluation(List<Periode> periodes,
}
/**
* Crée une note
- * @param eleve
- * @param evaluation qui correspond à l'eleve
- * @param valeur : la valeur numerique de note
* @author mjao
*/
private Note creeNote(Autorite eleve,
//============ calcul les moyennes
infoCalculMoyennesClasseService.creeVerrou(classe)
- moyenneService.majMoyennes(securiteSession, classe, hier)
+ moyenneService.majMoyennes(classe, hier)
//============ verifie les moyennes
ResultatEleveEnseignementPeriode resultat_ens_t1 =
//============ calcul les moyennes
infoCalculMoyennesClasseService.creeVerrou(classe)
- moyenneService.majMoyennes(securiteSession, classe, hier)
+ moyenneService.majMoyennes(classe, hier)
//============ verifie les moyennes
ResultatElevePeriode resultat_t1 =
//============ calcul les moyennes
infoCalculMoyennesClasseService.creeVerrou(classe)
- moyenneService.majMoyennes(securiteSession, classe, hier)
+ moyenneService.majMoyennes(classe, hier)
//============ verifie les moyennes
infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
- moyenneService.majMoyennes(securiteSessionDicerteur, classe1enTrimestres, null)
+ moyenneService.majMoyennes(classe1enTrimestres, null)
// recuperer les ResultatEleve-classePeriode
ResultatElevePeriode resultElevePeriodeT1 = ResultatElevePeriode.
infoCalculMoyennesClasseService.creeVerrou(classe1enTrimestres)
infoCalculMoyennesClasseService.creeVerrou(classe2enTrimestres)
- moyenneService.majMoyennes(securiteSessionDirection, classe1enTrimestres, null)
- moyenneService.majMoyennes(securiteSessionDirection, classe2enTrimestres, null)
+ moyenneService.majMoyennes(classe1enTrimestres, null)
+ moyenneService.majMoyennes(classe2enTrimestres, null)
//Recuperer les resultatsEleves-ClassesSousServiceperiode avant le bascule
ResultatEleveSousServicePeriode rESSP1 = getResultatEleveSousServicePeriode(
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
package org.lilie.services.eliot.notes
import grails.test.GrailsUnitTestCase
import org.lilie.services.eliot.scolarite.SousService
import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.notes.scolarite.NotesSousServiceService
Map<TypePeriode, BigDecimal> coeffs = [:]
coeffs.put(initPeriodeTestService.t1, 5)
notesModaliteMatiereParams.coeffs = coeffs
- SecuriteSession securiteSessionDirection =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
- )
+
notesSousServiceService.modifieSousService(
- securiteSessionDirection,
notesModaliteMatiereParams
)
+
//recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periode periodeT1_1
SousService sousService1 = getSousService(
service1classe1,
// assertEquals("le ResultatClassePeriode n'a pas été mis à jour",
// resultatClassePeriode.uptodate,false)
}
+
/**
* Tester la methode NotesServiceService.serviceEvaluableDansAutrePeriodes()
* @author mjao
periodeBrevet.typePeriode)
assertFalse("Le sousService1 n'est pas evaluable dans d'autres periodes",
sousServiceEvaluable)
-
}
+
/**
* Tester la methode NotesServiceService.hasDonneesLiees()
* @author mjao
assertTrue("Le sousService est lié à des données", sousServiceHasDonnees)
}
- /**
- * Tester l'autorisation de modification des sous-services
- * @author mjao
- */
- void testModifieSousServicePasAuthorise() {
- //Creation d'un sous-service dans chaque periode de service1classe1 pour les modifer aprés
- List<Periode> periodes = notesPeriodeService.
- findAllPeriodeForStructureEnseignement(service1classe1.structureEnseignement)
- periodes.each { Periode periode ->
- creeSousService(
- service1classe1,
- periode.typePeriode,
- modaliteMatiere1)
- }
- NotesModaliteMatiereParams notesModaliteMatiereParams = new NotesModaliteMatiereParams(
- serviceParent: service1classe1,
- modaliteMatiere: modaliteMatiere1,
- nouveauModaliteMatiere: modaliteMatiere2,
- classe: classe1enTrimestres,
- nature: natureNotation,
- evaluable: true,
- typePeriode: initPeriodeTestService.t1,
- )
- Map<TypePeriode, BigDecimal> coeffs = [:]
- coeffs.put(initPeriodeTestService.t1, 5)
- notesModaliteMatiereParams.coeffs = coeffs
- // test accés Directeur
- SecuriteSession securiteSessionDirecteur =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1)
- Boolean exceptionLeve = false
- try {
- notesSousServiceService.modifieSousService(
- securiteSessionDirecteur,
- notesModaliteMatiereParams
- )
- }
- catch (AutorisationException e) {
- exceptionLeve = true
- }
- assertFalse("Directeur ne peut pas modfier un sous-service", exceptionLeve)
- SecuriteSession securiteSessionEnseignement =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
-
- exceptionLeve = false
- // test accés Enseigneur
- try {
- notesSousServiceService.modifieSousService(
- securiteSessionEnseignement,
- notesModaliteMatiereParams)
- }
- catch (AutorisationException e) {
- exceptionLeve = true
- }
- assertTrue("Enseignant peut modifier un service ", exceptionLeve)
- //teste accès parent
- SecuriteSession securiteSessionParent =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.PARENT_1)
- exceptionLeve = false
- try {
- notesSousServiceService.modifieSousService(
- securiteSessionParent,
- notesModaliteMatiereParams)
- }
- catch (AutorisationException e) {
- exceptionLeve = true
- }
- assertTrue("Parent peut modifier un service ", exceptionLeve)
- //teste accès eleve
- SecuriteSession securiteSessionEleve =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ELEVE_2_CLASSE_1)
- exceptionLeve = false
- try {
- notesSousServiceService.modifieSousService(
- securiteSessionEleve,
- notesModaliteMatiereParams)
- }
- catch (AutorisationException e) {
- exceptionLeve = true
- }
- assertTrue("Eleve peut modifier un service ", exceptionLeve)
- }
/**
* Creation des périodes
/**
* Crée un service minimal
- * @param matiere matière
* @author msan
* @author mjao
*/
/**
* Attache service à toutes les périodes de la structure
- * @param structureEnseignement
- * @param service
*/
private void attacheService(StructureEnseignement structureEnseignement, Service service) {
structureEnseignement.periodes.each { Periode periode ->
/**
* Get ou crée la relation evaluable = true, coeff = 1
- * @param periode
- * @param service
- * @return
*/
private RelPeriodeService getRelPeriodeService(Periode periode, Service service) {
RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periode, service)
}
return rel
}
+
/**
* Creation d'une modalité Matiere attaché à un service
* @param service attaché à la modalité matiere
- * @return modalité matiere
*/
private ModaliteMatiere creeModaliteMatiere(Service service,
String code,
return modaliteMatiere
}
+
/**
* get un sous-service
- * @param service
- * @param typeperiode
- * @param modalite
- * @return sous-service
*/
private SousService getSousService(
Service service,
}
return sousService
}
-/**
- * creer un sous-Service
- * @param service
- * @param typeperiode
- * @param modalite
- * @return sous-service
- */
+
+ /**
+ * creer un sous-Service
+ */
private SousService creeSousService(Service service,
TypePeriode typePeriode,
ModaliteMatiere modaliteMatiere) {
sousService.save(flush: true)
return sousService
}
+
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
* @author mjao
*/
private Evaluation creeEvaluation(Periode periode,
return evaluation
}
+
/**
* Crée une Enseignement
- * @param enseignant
- * @param service
* @author mjao
*/
private Enseignement creeEnseignement(Autorite enseignant, Service service) {
return enseignement
}
- /**
- * Crée une note
- * @param eleve
- * @param evaluation
- * @author mjao
- */
- private Note creeNote(Autorite eleve, Evaluation evaluation) {
- Note note = new Note(
- eleve: eleve,
- evaluation: evaluation
- )
- note.save(flush: true)
- if (note.hasErrors()) {
- println(note.errors)
- }
- return note
- }
- /**
- * get un ResultatEleveEnseignementPeriode
- * @param periode
- * @param eleve
- * @param enseignement
- * @author mjao
- */
- private ResultatEleveEnseignementPeriode getResultatEleveEnseignementPeriode(
- Autorite eleve,
- Periode periode,
- Enseignement enseignement) {
- def criteria = ResultatEleveEnseignementPeriode.createCriteria()
- ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode = criteria.get {
- eq('eleve', eleve)
- eq('periode', periode)
- eq('enseignement', enseignement)
- }
- return resultatEleveEnseignementPeriode
- }
+
/**
* creer un ResultatEleveEnseignementPeriode
- * @param periode
- * @param eleve
- * @param enseignement
* @author mjao
*/
private ResultatEleveEnseignementPeriode creeResultatEleveEnseignementPeriode(
return resultat
}
+
/**
* crée un ResultatEleveSousServicePeriode
- * @param periode
- * @param service
- * @param eleve
* @author mjao
*/
private ResultatEleveSousServicePeriode creeResultatEleveSousServicePeriode(
return resultatSS
}
+
/**
* return un ResultatEleveSousServicePeriode
- * @param periode
- * @param service
- * @param eleve
* @author mjao
*/
private ResultatEleveSousServicePeriode getResultatEleveSousServicePeriode(
eq('sousService', sousService)
}
}
+
/**
* creer un ResultatEnseignementPeriode
- * @param enseignement
- * @param periode
* @author mjao
*/
private ResultatEnseignementPeriode creeResultatClasseEnseignementPeriode(Enseignement enseignement,
return resultat
}
+
/**
* get un ResultatClassseEnseignementPeriode
- * @param enseignement
- * @param periode
* @author mjao
*/
private ResultatEnseignementPeriode getResultatClasseEnseignementPeriode(Enseignement enseignement,
return resultatClasseEnseignementPeriode
}
-/**
- * crée un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
- * @author mjao
- */
+ /**
+ * crée un ResultatClasseServicePeriode
+ * @author mjao
+ */
private ResultatClasseSousServicePeriode creeResultatClasseSousServicePeriode(
Periode periode,
Service service,
/**
* get un ResultatClasseServicePeriode
- * @param periode
- * @param service
- * @param classe
* @author mjao
*/
private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(
eq('sousService', sousService)
}
}
+
/**
* get ou creer un ResultatServicePeriode
- * @param periode
- * @param service
* @author mjao
*/
private ResultatClassePeriode creeOrGetResultatlClassePeriode(Periode periode,
}
return rel
}
+
/**
* get ou creer un ResultatElevePeriode
- * @param eleve
- * @param periode
* @author mjao
*/
private ResultatElevePeriode creeOrGetResultatlElevePeriode(Periode periode,
import org.lilie.services.eliot.notes.notes.ReleveServiceNote
import org.lilie.services.eliot.notes.notes.ReleveSousServiceNote
import org.lilie.services.eliot.notes.exception.PeriodeNonPublieException
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.textes.TypeActivite
/**
// test: L'eleve n'a pas un accées au relevé dont la periode est non-publieé
Boolean exceptionLeve = false
try {
- releveService.construisReleve(securiteSessionEleve,
+ releveService.construisReleve(
+ securiteSessionEleve,
eleve1,
periodeT2_1)
} catch(PeriodeNonPublieException e) {
// test: Le parent 1 n'a pas un accées au relevé de l'eleve1 dont la periode
// est non- publieé
- // La securité session d'un parent pour un eleve1_classe1
- SecuriteSession securiteSessionParent =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.PARENT_1)
-
exceptionLeve = false
try {
- releveService.construisReleve(securiteSessionEleve,
+ releveService.construisReleve(
+ securiteSessionEleve,
eleve1,
periodeT2_1)
} catch(PeriodeNonPublieException e) {
exceptionLeve = true
}
- assertTrue("Le parent1 peut acceder au relevé de notes non-publie de l'eleve1",
- exceptionLeve)
-
- }
-
- /**
- * Test que les eleves et parents n'ont pas acces aux services non-evaluables
- */
- void testAcceesEleveParentAuxServicesEvaluables(){
-
- // Le securité session d'un eleve
- SecuriteSession securiteSessionEleve =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ELEVE_1_CLASSE_1)
-
- //changer l'evaluabilité de service normale à false
- RelPeriodeService rel = RelPeriodeService.findByPeriodeAndService(periodeT2_1, serviceNormal)
- rel.evaluable = false
- rel.save(flush:true)
-
- //periodeT2_1 publie
- periodeT2_1.datePublicationReleves = new Date(111,1,1)
-
- // test: L'eleve n'a pas l'accées au services non evaluables
- Releve releve = releveService.construisReleve(securiteSessionEleve,
- eleve1,
- periodeT2_1)
-
- ReleveServiceNote releveSN = releve.serviceNotes.find {it.service.id == serviceNormal.id}
- assertNull("Le serviceNormal est present dans le releve des notes de l'eleve1",
- releveSN)
-
- ReleveServiceNote releveSP = releve.serviceNotes.find{it.service.id == serviceParent.id}
- assertNotNull("Le serviceParent n'est pas present dans le releve des notes de l'eleve1",
- releveSP)
-
- // Le securité session d'un parent
- SecuriteSession securiteSessionParent =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.PARENT_1)
-
- // test: Le parent n'a pas l'accées au services non evaluables
- releve = releveService.construisReleve(securiteSessionEleve,
- eleve1,
- periodeT2_1)
-
- releveSN = releve.serviceNotes.find {it.service.id == serviceNormal.id}
- assertNull("Le serviceNormal est present dans le releve des notes de l'eleve1",
- releveSN)
-
- releveSP = releve.serviceNotes.find{it.service.id == serviceParent.id}
- assertNotNull("Le serviceParent n'est pas present dans le releve des notes de l'eleve1",
- releveSP)
- }
-
- /**
- * Test qu'un eleve ne peut pas acceder les releves d'aun autre eleve
- */
- void testAccesEleve1ReleveEleve2() {
-
- // Le securité session d'un eleve
- SecuriteSession securiteSessionEleve =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.ELEVE_2_CLASSE_1)
-
- //periodeT2_1 publie
- periodeT2_1.datePublicationReleves = new Date(111,1,1)
- Boolean exceptionLeve = false
- try {
- releveService.construisReleve(securiteSessionEleve,
- eleve1,
- periodeT2_1)
- } catch(AutorisationException e) {
- exceptionLeve = true
- }
- assertTrue("l'eleve 2 peut acceder au releve de notes de l'eleve1", exceptionLeve)
+ assertTrue(
+ "Le parent1 peut acceder au relevé de notes non-publie de l'eleve1",
+ exceptionLeve)
}
- /**
- * Test qu'un parent ne peut pas acceder les releves d'un eleve qui
- * n'est pas sont enfant.
- */
- void testAccesParent1ReleveEleve2() {
-
- // Le securité session d'un eleve
- SecuriteSession securiteSessionParent =
- localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.PARENT_1)
-
- //periodeT2_1 publie
- periodeT2_1.datePublicationReleves = new Date(111,1,1)
-
- Boolean exceptionLeve = false
- try {
- releveService.construisReleve(securiteSessionParent,
- eleve2,
- periodeT2_1)
- } catch(AutorisationException e) {
- exceptionLeve = true
- }
- assertTrue("Le parent1 peut acceder au releve de notes de l'eleve2", exceptionLeve)
-
- }
/**
* Crée ou get une evaluation attaché a une periode
- * @param periode
- * @param enseignement
- * @param dateCreation
- * @return evaluation
* @author mjao
*/
private Evaluation creeEvaluation(List<Periode> periodes ,
/**
* Crée une note
- * @param eleve
- * @param evaluation qui correspond à l'eleve
- * @param valeur : la valeur numerique de note
* @author mjao
*/
private Note creeNote(Autorite eleve,
note.save(failOnError: true, flush:true)
return note
}
+
/**
* Crée un sous-service
- *@return regroupment une structure d'enseignement
* @author mjao
*/
private SousService creeSousService(Service service,
/**
* Creation d'une modalité Matiere attaché à un sous-service
- * @param sousservice sous-service attaché à la modalité matiere
- *@param code le code de la modaliteMatire
- *@param libelle le libelle de la modalitematiere
- *@param etablissement l'etablissement
- * @return modalité matiere
* @author mjao
*/
private ModaliteMatiere creeModaliteMatiere(String code,
Service service = creeService(regroupement)
enseignant = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.ENSEIGNANT_1)
- securiteSessionEnseignant = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
directeur = localInitDonneesCommunesTestService.getPersonne(PopulationTestActeur.DIRECTION_1)
securiteSessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.DIRECTION_1)
deverrouillePeriode(classe2, t2)
deverrouillePeriode(classe2, t3)
deverrouillePeriode(classe2, annee)
+
+ securiteSessionEnseignant = localInitDonneesCommunesTestService.getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
}
protected void tearDown() {
import org.lilie.services.eliot.textes.TypeActivite
import org.lilie.services.eliot.textes.TypeActiviteParDefaut
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauNotesSport
import org.lilie.services.eliot.notes.notes.tableaudenotes.TableauNotesSportLigne
Personne eleve1
Personne eleve2
- SecuriteSession securiteSessionSystem
-
protected void setUp() {
super.setUp()
jd = initDonneesNotesTestService.creeJeuDonneesTest()
- securiteSessionSystem = DefaultSecuriteSessionFactory.
- getEliotNotesSecuriteSessionForCodePorteurENT(
- jd.etablissement.codePorteurENT)
-
ens1 = jd.ens1Service1Classe1
ens2 = jd.ens2Service1Classe1
eleve1 = jd.eleve1Classe1
void testConstruisTableau() {
TableauNotesSport tab =
- tableauNotesSportService.construisTableau(securiteSessionSystem, jd.service1Classe1)
+ tableauNotesSportService.construisTableau(jd.service1Classe1)
assertEquals(
"Le nombre de lignes dans le tableau ne correspond pas au nombre d'élève dans la classe",
(noteHandEleve2.id): true
]
- tableauNotesSportService.enregistreSelection(securiteSessionSystem, selection)
+ tableauNotesSportService.enregistreSelection(selection)
TableauNotesSport tab =
- tableauNotesSportService.construisTableau(securiteSessionSystem, jd.service1Classe1)
+ tableauNotesSportService.construisTableau(jd.service1Classe1)
tab.lignes.each {TableauNotesSportLigne ligne ->
ligne.notes.each {Note note ->
// Sélectionne une note dont l'éval n'est pas de type SPORT
selection = [(noteNonSportEleve1.id): true]
checkIllegalArgumentException {
- tableauNotesSportService.enregistreSelection(securiteSessionSystem, selection)
+ tableauNotesSportService.enregistreSelection(selection)
}
// Sélectionne une note dont l'éval n'est pas dans une période de notation
selection = [(noteSkiExamEleve1.id): true]
checkIllegalArgumentException {
- tableauNotesSportService.enregistreSelection(securiteSessionSystem, selection)
+ tableauNotesSportService.enregistreSelection(selection)
}
// Passe un id de note qui n'existe pas
selection = [(0 as Long): true]
checkIllegalArgumentException {
- tableauNotesSportService.enregistreSelection(securiteSessionSystem, selection)
+ tableauNotesSportService.enregistreSelection(selection)
}
// Sélectionne une 4ème note pour l'élève 1
selection = [(noteHandEleve1.id): true]
checkIllegalStateException {
- tableauNotesSportService.enregistreSelection(securiteSessionSystem, selection)
+ tableauNotesSportService.enregistreSelection(selection)
}
}
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.scolarite.TypePeriode
import org.lilie.services.eliot.test.PopulationTestClasse
-import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
import org.lilie.services.eliot.textes.TypeActivite
import org.lilie.services.eliot.notes.StructureEnseignementNotesService
import org.lilie.services.eliot.notes.Evaluation
* +--------+--------+------------+
*/
- //securité session
- SecuriteSession securiteSessionEnseignant =
- getSecuriteSession(PopulationTestActeur.ENSEIGNANT_1)
-
InfoCalculMoyennesClasse infoCalculMoyennesClasse =
new InfoCalculMoyennesClasse(
classe: classe,
// Appeler la methode majMoyenne pour tester quelle sont les moyennes qui sont recalculés
moyenneService.majMoyennes(
- securiteSessionEnseignant,
classe,
infoCalculMoyennesClasse.dateDebutCalcul)
//Dans ce test , on va tester le recalcul de moyennes et la mise à jour de uptodate
//dans le cas ou le service est attaché à une seule enseignement
- TypeIntervalleEnum type = periodeT1.typeIntervalle
-
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
//calcul des moyennes de l'eleve 1
BigDecimal moyenneT1_E1 = (((valeurNote1_1_1 * 20) / noteMax) + ((valeurNote1_2_1 * 20) / noteMax)).divide(2, precision, RoundingMode.HALF_UP)
infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
ResultatEleveEnseignementPeriode resultatEleveEnseignementPeriode1 =
getResultatEleveEnseignementPeriode(eleve1, periodeT1, enseignement1)
noteT3_1_2 = creeNote(eleve1, evalT3_1_2, valeurNote3_1_2)
noteT3_2_2 = creeNote(eleve1, evalT3_2_2, valeurNote3_2_2)
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
-
//calculer les moyennes de chaque enseignement pour chaque periode
BigDecimal moyenneEnseignant_1_T1 = (((valeurNote1_1_1 * 20) / noteMax) + ((valeurNote1_2_1 * 20) / noteMax)).divide(2, precision, RoundingMode.HALF_UP)
BigDecimal moyenneEnseignant_2_T1 = (((valeurNote1_1_2 * 20) / noteMax) + ((valeurNote1_2_2 * 20) / noteMax)).divide(2, precision, RoundingMode.HALF_UP)
infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a testet
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
//Tester les ResultatEleveEnseignementPeriode qui correspondent à l'enseignement 1
//Tester le recalcul des moyennes
rel2.coeff = 3
rel3.coeff = 1
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
-
//creer une evaluation attachés au service optionnel
evalOPtionnel1 = creeEvaluation([periodeT1], enseignement3, dateCreation1, dateEvaluation1)
evalOPtionnel2 = creeEvaluation([periodeT2], enseignement3, dateCreation1, dateEvaluation1)
infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
//Dans ce test on teste le calcul des moyenne lorsqu'on a un service optionnel
//on envisage le cas ou la moyenne depasse 20
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
-
//changer les coefficient de service normal pour chaque periode
RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1, service)
RelPeriodeService rel2 = RelPeriodeService.findByPeriodeAndService(periodeT2, service)
infoCalculMoyennesClasseService.creeVerrou(classe)
BigDecimal moyenneAnnuel = (moyenneT1 + moyenneT2 + moyenneT3).divide(3, precision, RoundingMode.HALF_UP)//moy =21.67
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
//Dans ce test on teste le calcul des moyenne lorsqu'on a un service optionnel
//on envisage le cas ou la moyenne de service optionnel est inferieur à 10
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
//changer les coefficient de service normal pour chaque periode
RelPeriodeService rel1 = RelPeriodeService.findByPeriodeAndService(periodeT1, service)
infoCalculMoyennesClasseService.creeVerrou(classe)
//Appeller la methode a tester
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
//Tester le recalcul des moyennes dans ResultatElevePeriode1
ResultatElevePeriode resultatElevePeriode1 = ResultatElevePeriode.findByEleveAndPeriode(eleve1.autorite, periodeT1)
//3- un service Parent qui est composé de deux sousServices(sousService 1 et sousService 2)
//securité session
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
//creer les sousServices
//cree des sous-services associés au service
marqueDirtyMoyenneEleves()
- moyenneService.majMoyennes(securiteSessionEnseignant, classe, null)
+ moyenneService.majMoyennes(classe, null)
//***Les resultatsEleveServiceParentPeriode pour l'eleve 1
void testCalculMoyenneServiceDateChangement1() {
//securité session
- SecuriteSession securiteSessionEnseignant = getSecuriteSession(
- PopulationTestActeur.ENSEIGNANT_1)
InfoCalculMoyennesClasse infoCalculMoyennesClasse =
new InfoCalculMoyennesClasse(
// Appeller la methode majMoyenne pour tester quelle sont les moyennes qui sont recalculés
moyenneService.majMoyennes(
- securiteSessionEnseignant,
classe,
infoCalculMoyennesClasse.dateDebutCalcul)
//****************** Methodes utilitaires ************************************
//****************************************************************************
- /**
- * Cree une SecuriteSession d'acteur donne
- * @param populationTestActeur
- * @return
- */
- SecuriteSession getSecuriteSession(PopulationTestActeur populationTestActeur) {
- return (SecuriteSession) localInitDonneesCommunesTestService.
- getSecuriteSession(populationTestActeur)
- }
-
/**
* Crée une evaluation attachée a une periode
* @author mjao
)
then:
- 1 * notesSousServiceService.creeSousService(_, _)
- 0 * notesSousServiceService.modifieSousService(_, _)
+ 1 * notesSousServiceService.creeSousService(_)
+ 0 * notesSousServiceService.modifieSousService(_)
}
def "creeSousServices - existant"() {
then:
0 * notesSousServiceService.creeSousService(_)
- nbModification * notesSousServiceService.modifieSousService(_, _)
+ nbModification * notesSousServiceService.modifieSousService(_)
where:
sousServiceEvaluable | nbModification