--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+
+
+package org.lilie.services.eliot.notes
+
+import grails.test.GrailsUnitTestCase
+import org.lilie.services.eliot.notes.test.InitDonneesNotesTestService
+import org.lilie.services.eliot.test.InitPeriodeTestService
+import org.lilie.services.eliot.notes.scolarite.NotesPeriodeService
+import org.lilie.services.eliot.scolarite.Periode
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.Service
+import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Enseignement
+import org.lilie.services.eliot.scolarite.ModaliteMatiere
+import org.lilie.services.eliot.scolarite.NaturePeriodeEnum
+import org.lilie.services.eliot.test.PopulationTestClasse
+import org.lilie.services.eliot.scolarite.TypePeriode
+import org.lilie.services.eliot.scolarite.OrigineEnum
+import org.lilie.services.eliot.scolarite.RelPeriodeService
+import org.lilie.services.eliot.scolarite.ModaliteCours
+import org.lilie.services.eliot.notes.scolarite.NotesModaliteMatiereParams
+import org.lilie.services.eliot.test.PopulationTestActeur
+import org.lilie.services.eliot.notes.scolarite.ModifResult
+import org.lilie.services.eliot.scolarite.TypeIntervalleEnum
+import org.lilie.services.eliot.test.PopulationTestEtablissement
+import org.lilie.services.eliot.test.PopulationTestMatiere
+
+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
+
+/**
+ * RelModaliteMatiereServicePeriodeService
+ * @author mjao
+ */
+class NotesSousServiceServiceTests extends GrailsUnitTestCase {
+ NotesPeriodeService notesPeriodeService
+ InitPeriodeTestService initPeriodeTestService
+ LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ InitDonneesNotesTestService initDonneesNotesTestService
+ NotesSousServiceService notesSousServiceService
+ //Preparer les dates
+ def sessionFactory
+ Date dateDebut1ApresDebut2 = new Date(2011, 5, 14)
+ Date dateDebut2 = new Date(2011, 5, 6)
+ Date dateFin1 = new Date(2011, 9, 30)
+ Date dateFin2 = new Date(2011, 9, 30)
+ Date datePublication = new Date(2011, 4, 10)
+ ModaliteCours modaliteCours1 = null
+
+ //periodes
+ Periode periodeT1_1 = null
+ Periode periodeT2_1 = null
+ Periode periodeT3_1 = null
+ Periode periodeAnnee_1 = null
+ Periode periode_test = null
+ Periode periodeBrevet = null
+ //Etablissement
+ Etablissement etablissement1 = null
+ //Service
+ Service service1classe1 = null
+ //matiere
+ Matiere matiere1 = null
+ StructureEnseignement classe1enTrimestres = null
+ Enseignement enseignement = null
+ ModaliteMatiere modaliteMatiere1 = null
+ ModaliteMatiere modaliteMatiere2 = null
+ NaturePeriodeEnum natureNotation = NaturePeriodeEnum.NOTATION
+ NaturePeriodeEnum natureExamen = NaturePeriodeEnum.EXAMEN
+ ResultatClassePeriode resultatClassePeriode = null
+ ResultatElevePeriode resultatElevePeriode = null
+ SousService sousService_1 = null
+
+ Autorite eleve = null
+ private final String libelleInitial = 'libelleInitial'
+
+ protected void setUp() {
+ super.setUp()
+ //Initialiser les données
+ initPeriodeTestService.initialisePeriodesDeTest()
+ // Récupération de la structure CLASSE_1 Etab 1
+ etablissement1 = localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
+ )
+ classe1enTrimestres =
+ localInitDonneesCommunesTestService.getClasse(
+ PopulationTestClasse.HORS_ANNUAIRE_CLASSE_1
+ )
+ classe1enTrimestres.typeIntervalle = TypeIntervalleEnum.TRIMESTRE
+ classe1enTrimestres.save()
+
+ periodeT3_1 = getOuCreePeriode(initPeriodeTestService.t3, classe1enTrimestres)
+ periodeT1_1 = getOuCreePeriode(initPeriodeTestService.t1, classe1enTrimestres)
+ periodeT2_1 = getOuCreePeriode(initPeriodeTestService.t2, classe1enTrimestres)
+ periodeAnnee_1 = getOuCreePeriode(initPeriodeTestService.annee, classe1enTrimestres)
+ periodeBrevet = getOuCreePeriode(initPeriodeTestService.brevetBlanc,
+ classe1enTrimestres, dateDebut1ApresDebut2, dateFin1)
+
+ modaliteCours1 = localInitDonneesCommunesTestService.getModaliteTestCG()
+ matiere1 = localInitDonneesCommunesTestService.
+ getMatiere(PopulationTestMatiere.ANGLAIS)
+ modaliteMatiere1 = creeModaliteMatiere(service1classe1,
+ "code1",
+ "libelle1",
+ etablissement1)
+ modaliteMatiere2 = creeModaliteMatiere(service1classe1,
+ "code2",
+ "libelle2",
+ etablissement1)
+
+ service1classe1 = creeService(matiere1, classe1enTrimestres, OrigineEnum.MANUEL)
+
+ //creer une enseignement attaché au service1classe1
+ enseignement = creeEnseignement(localInitDonneesCommunesTestService.
+ getAutorite(PopulationTestActeur.ENSEIGNANT_1), service1classe1)
+
+
+ service1classe1.addToEnseignements(enseignement)
+
+ eleve = localInitDonneesCommunesTestService.getAutorite(
+ PopulationTestActeur.ELEVE_1_CLASSE_1)
+
+ }
+
+ protected void tearDown() {
+ super.tearDown()
+ }
+
+ void testCreeSousService() {
+ //Creer une NotesModaliteMatiereParams
+ NotesModaliteMatiereParams notesModaliteMatiereParams = new NotesModaliteMatiereParams(
+ serviceParent: service1classe1,
+ modaliteMatiere: modaliteMatiere1,
+ classe: classe1enTrimestres,
+ nature: natureNotation,
+ evaluable: true,
+ typePeriode: initPeriodeTestService.t1,
+ )
+ Map<TypePeriode, BigDecimal> coeffs = [:]
+ coeffs.put(initPeriodeTestService.t1, 5)
+ notesModaliteMatiereParams.coeffs = coeffs
+ //SecuriteSession directeur
+ SecuriteSession securiteSessionDirection =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1
+ )
+ //appeler la methode de creation de RelMpdaliteMatiereServicePeriode
+ ModifResult modifResul = notesSousServiceService.creeSousService(
+ securiteSessionDirection,
+ notesModaliteMatiereParams)
+ //Tester la creation de RelModaliteMatiereServicePeriode
+ SousService sousService1 = getSousService(
+ service1classe1,
+ periodeT1_1.typePeriode,
+ modaliteMatiere1)
+
+ SousService sousService2 = getSousService(
+ service1classe1,
+ periodeT2_1.typePeriode,
+ modaliteMatiere1)
+
+ SousService sousService3 = getSousService(
+ service1classe1,
+ periodeT3_1.typePeriode,
+ modaliteMatiere1
+ )
+ SousService sousService4 = getSousService(
+ service1classe1,
+ periodeAnnee_1.typePeriode,
+ modaliteMatiere1)
+ SousService sousService5 = getSousService(
+ service1classe1,
+ periodeAnnee_1.typePeriode,
+ modaliteMatiere1)
+ assertNotNull("la creation de sousService attaché au periodeT1_1 a été échoué",
+ sousService1)
+ assertNotNull("la creation de sousService attaché au periodeT2_1 a été échoué",
+ sousService2)
+ assertNotNull("la creation de sousService attaché au periodeT3_1 a été échoué",
+ sousService3)
+ assertNotNull("la creation de sousService a été échoué",
+ sousService4)
+ assertNotNull("la creation de sousService a été échoué",
+ sousService5)
+
+ //Tester l'evaluabilité
+ assertEquals("le champ evaluable n'a pas été enregistré correctement",
+ sousService1.evaluable, true)
+ assertEquals("le champ evaluable attaché au service1classé1-periodeT2_ 1 n'est pas correcte",
+ sousService2.evaluable, true)
+ assertEquals("le champ evaluable attaché au service1classé1-periodeT3_1 n'est pas correcte",
+ sousService3.evaluable, true)
+ assertEquals("le champ evaluable service1classé1-periodeAnnee_1 n'est pas correcte",
+ sousService4.evaluable, true)
+ //Tester le coeffcient
+ def coeff = sousService1.coeff
+ assertEquals("le coefficient attaché au service1classé1-periodeT1_1 n'a pas été enregistré correctement",
+ sousService1.coeff, 5)
+ assertEquals("le coefficient attaché au service1classé1-periodeT2_1 n'est pas correcte",
+ sousService2.coeff, 1)
+ assertEquals("le coefficient attaché au service1classé1-periodeT3_1 n'est pas correcte",
+ sousService3.coeff, 1)
+ assertEquals("le coefficient attaché au service1classé1-periodeAnnee_1 n'est pas correcte",
+ sousService4.coeff, 1)
+ //calculer l'ordre
+ NotesModaliteMatiereParams notesModaliteMatiereParams2 = new NotesModaliteMatiereParams(
+ serviceParent: service1classe1,
+ modaliteMatiere: modaliteMatiere2,
+ classe: classe1enTrimestres,
+ nature: natureExamen,
+ evaluable: true,
+ typePeriode: initPeriodeTestService.brevetBlanc,
+ )
+ modifResul = notesSousServiceService.creeSousService(
+ securiteSessionDirection,
+ notesModaliteMatiereParams2)
+ SousService sousService = getSousService(
+ service1classe1,
+ periodeBrevet.typePeriode,
+ modaliteMatiere2)
+ assertEquals("l'ordre ne coincide pas avec celui attendu", sousService.ordre, 2)
+ }
+
+ void testModifieSousService() {
+ //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
+ SecuriteSession securiteSessionDirection =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1
+ )
+ ModifResult modifResult = notesSousServiceService.modifieSousService(
+ securiteSessionDirection,
+ notesModaliteMatiereParams
+ )
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periode periodeT1_1
+ SousService sousService1 = getSousService(
+ service1classe1,
+ periodeT1_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periode periodeT2_1
+ SousService sousService2 = getSousService(
+ service1classe1,
+ periodeT2_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periodeT3_1
+ SousService sousService3 = getSousService(
+ service1classe1,
+ periodeT3_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periodeAnnee_1
+ SousService sousService4 = getSousService(
+ service1classe1,
+ periodeAnnee_1.typePeriode,
+ modaliteMatiere2)
+
+ //Tester la modification de modaliteMatiere
+ assertNotNull("la modification de sous-matiere dans le sousservice attaché au periodeT1_1 a été échoué",
+ sousService1)
+ assertNotNull("la modification de sous-matiere dans le sousservice attaché au periodeT2_1 a été échoué",
+ sousService2)
+ assertNotNull("la modification de sous-matiere dans le sousservice attaché au periodeT3_1 a été échoué",
+ sousService3)
+ assertNotNull("la modification de sous-matiere dans le sousservice attaché au periodeAnnee_1a été échoué",
+ sousService4)
+ //Tester la modofcation d'evaluabilité
+ assertEquals("la modificatiion d'evaluabilité dans le sousservice service1classe1-modaliteMatiere2 attaché au periodeT1_1 a été échoué",
+ sousService1.evaluable, true)
+ assertEquals("le champ evaluable attaché au service1classe1-periodeT2_ 1 n'est pas correcte",
+ sousService2.evaluable, true)
+ assertEquals("le champ evaluable attaché au service1classe1-periodeT3_1 n'est pas correcte",
+ sousService3.evaluable, true)
+ assertEquals("le champ evaluable service1classe1-periodeAnnee_1 n'est pas correcte",
+ sousService4.evaluable, true)
+ // Tester la modification de coefficients
+ assertEquals("le coefficient attaché au service1classe1-periodeT1_1 n'a pas été enregistré correctement",
+ sousService1.coeff, 5)
+ assertEquals("le coefficient attaché au service1classe1-periodeT2_1 n'est pas correcte",
+ sousService2.coeff, 1)
+ assertEquals("le coefficient attaché au service1classe1-periodeT3_1 n'est pas correcte",
+ sousService3.coeff, 1)
+ assertEquals("le coefficient attaché au service1classe1-periodeAnnee_1 n'est pas correcte",
+ sousService4.coeff, 1)
+ }
+
+ void testCreeSousServicePasAuthorise() {
+ //Creation d'un sous-service dans chaque periode de service1classe1 pour les modifer aprés
+ //Creer une NotesModaliteMatiereParams
+ NotesModaliteMatiereParams notesModaliteMatiereParams = new NotesModaliteMatiereParams(
+ serviceParent: service1classe1,
+ modaliteMatiere: modaliteMatiere1,
+ 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.creeSousService(
+ securiteSessionDirecteur,
+ notesModaliteMatiereParams
+ )
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertFalse("Directeur ne peut pas creer un sous-service", exceptionLeve)
+ SecuriteSession securiteSessionEnseignement =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1)
+
+ exceptionLeve = false
+ // test accés Enseigneur
+ try {
+ notesSousServiceService.creeSousService(
+ securiteSessionEnseignement,
+ notesModaliteMatiereParams)
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertTrue("Enseignant peut creer un sous-service ", exceptionLeve)
+ //teste accès parent
+ SecuriteSession securiteSessionParent =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.PARENT_1)
+ exceptionLeve = false
+ try {
+ notesSousServiceService.creeSousService(
+ securiteSessionParent,
+ notesModaliteMatiereParams)
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertTrue("Parent peut creer un sous-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 creer un sous-service ", exceptionLeve)
+ }
+
+ /**
+ * Tester la suppression des sous-services
+ * @author mjao
+ */
+ void testSupprimeSousServicesCompletement() {
+
+ SousService sousService = null
+ List<Periode> periodes = notesPeriodeService.
+ findAllPeriodeForStructureEnseignement(service1classe1.structureEnseignement)
+ periodes.each { Periode periode ->
+ sousService = creeSousService(
+ service1classe1,
+ periode.typePeriode,
+ modaliteMatiere1
+ )
+
+ //creer un ResultatEleveServicePeriode
+ creeResultatEleveSousServicePeriode(periode,
+ service1classe1,
+ eleve,
+ sousService)
+
+ creeResultatEleveEnseignementPeriode(
+ eleve,
+ periode,
+ enseignement)
+ creeResultatClasseEnseignementPeriode(
+ enseignement,
+ periode,
+ classe1enTrimestres)
+ creeResultatClasseSousServicePeriode(
+ periode,
+ service1classe1,
+ classe1enTrimestres,
+ sousService)
+ resultatClassePeriode = creeOrGetResultatlClassePeriode(periode, classe1enTrimestres)
+ //creer un ResultatElevePeriode (uptodate-->true)
+ resultatElevePeriode = creeOrGetResultatlElevePeriode(periode, eleve)
+
+
+ }
+ //creer une evaluation et une note pour verifer leur suppression
+ // Evaluation eval = creeEvaluation(periodeBrevet, enseignement,sousService)
+
+ // Note note = creeNote(eleve, eval)
+ SecuriteSession securiteSessionDirection =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1
+ )
+ notesSousServiceService.supprimeSousServicesCompletement(securiteSessionDirection,
+ service1classe1,
+ modaliteMatiere1,
+ periodeT1_1.typePeriode,
+ NaturePeriodeEnum.NOTATION)
+
+//recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periode periodeT1_1
+ SousService sousService1 = getSousService(
+ service1classe1,
+ periodeT1_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periode periodeT2_1
+ SousService sousService2 = getSousService(
+ service1classe1,
+ periodeT2_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periodeT3_1
+ SousService sousService3 = getSousService(
+ service1classe1,
+ periodeT3_1.typePeriode,
+ modaliteMatiere2)
+ //recuperer le sousservice :service1classe1-modaliteMatiere2 attaché au periodeAnnee_1
+ SousService sousService4 = getSousService(
+ service1classe1,
+ periodeAnnee_1.typePeriode,
+ modaliteMatiere2)
+ //Testet la suppression des sous-services
+ assertNull("le sousService1 n'a pas été supprimé", sousService1)
+ assertNull("le sousService2 n'a pas été supprimé", sousService2)
+ assertNull("le sousService3 n'a pas été supprimé", sousService3)
+ assertNull("le sousService4 n'a pas été supprimé", sousService4)
+
+ //TOTEST tester la suppression d'evaluations et des notes aprés la resolution de probeleme de tests d'integration avec les requetes HQL
+ //Tester la suppression d'evaluation
+ //assertNull(" l'evaluation n'a pas été supprimé",Evaluation.get(eval.id))
+ //assertNull(" la note n'a pas été supprimé",Note.get(note.id))
+
+ //Tester la suppression de ResultatEleveSousServicePeriode
+ ResultatEleveSousServicePeriode resultatEleveSousServicePeriode =
+ getResultatEleveSousServicePeriode(periodeT1_1,
+ service1classe1,
+ eleve,
+ sousService_1)
+ assertNull("ResultatEleveSousServicePeriode n'a pas été supprime",
+ resultatEleveSousServicePeriode)
+
+ //Tester la suppression de ResultatClasseServicePeriode
+ ResultatClasseSousServicePeriode resultatClasseSousServicePeriode = getResultatClasseSousServicePeriode(
+ periodeT1_1,
+ service1classe1,
+ classe1enTrimestres,
+ sousService_1)
+ assertNull("ResultatClasseSousServicePeriode n'a pas été supprime",
+ resultatClasseSousServicePeriode)
+ //Tester la mise a jour de ResultatClassePeriode
+ resultatClassePeriode = ResultatClassePeriode.findByClasseAndPeriode(classe1enTrimestres, periodeT1_1)
+ // assertEquals("le ResultatClassePeriode n'a pas été mis à jour",
+// resultatClassePeriode.uptodate,false)
+ //Tester la mise à jour de resultatElevePeriode
+ resultatElevePeriode = creeOrGetResultatlElevePeriode(periodeT1_1, eleve)
+// assertEquals("le ResultatClassePeriode n'a pas été mis à jour",
+// resultatClassePeriode.uptodate,false)
+ }
+ /**
+ * Tester la methode NotesServiceService.serviceEvaluableDansAutrePeriodes()
+ * @author mjao
+ */
+ void testSousServiceEvaluableDansAutrePeriodes() {
+
+ SecuriteSession securiteSessionDirecteur =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1)
+ //creer un sousService evaluable dans une periode de notation
+ SousService sousService1 = creeSousService(
+ service1classe1,
+ periodeT1_1.typePeriode,
+ modaliteMatiere1
+ )
+ //creer un sousService evaluable dans une periode d'examen
+ SousService sousService2 = creeSousService(
+ service1classe1,
+ periodeBrevet.typePeriode,
+ modaliteMatiere1
+ )
+ TypePeriode typePeriode = null
+ //Tester si le sousService1 est evaluable dans d'autres periodes que celles de notation {PerodeBrevet}
+ Boolean sousServiceEvaluable = notesSousServiceService.sousServiceEvaluableDansAutrePeriodes(
+ securiteSessionDirecteur,
+ service1classe1,
+ modaliteMatiere1,
+ natureNotation,
+ typePeriode)
+
+ assertTrue("Le sousService1 est evaluable dans d'autres periodes {PeriodeBrevet}",
+ sousServiceEvaluable)
+ sousServiceEvaluable = notesSousServiceService.sousServiceEvaluableDansAutrePeriodes(
+ securiteSessionDirecteur,
+ service1classe1,
+ modaliteMatiere1,
+ natureExamen,
+ periodeBrevet.typePeriode)
+ //Tester si le sousService2 est evaluable dans d'autres periodes que celles de Examen{Perode Noationt}
+ assertTrue("Le sousService2 est evaluable dans d'autres periodes {PeriodeBrevet}",
+ sousServiceEvaluable)
+
+ //Tester le cas ou service1classe1 n'est pas evaluable dans periodeBreve
+ sousService2.evaluable = false
+ sousService2.save()
+ sousServiceEvaluable = notesSousServiceService.sousServiceEvaluableDansAutrePeriodes(
+ securiteSessionDirecteur,
+ service1classe1,
+ modaliteMatiere1,
+ natureNotation,
+ periodeBrevet.typePeriode)
+ assertFalse("Le sousService1 n'est pas evaluable dans d'autres periodes",
+ sousServiceEvaluable)
+
+ }
+ /**
+ * Tester la methode NotesServiceService.hasDonneesLiees()
+ * @author mjao
+ */
+ void testSousServiceHasDonneesLiees() {
+
+ //creer un sous-service
+ SousService sousService = creeSousService(
+ service1classe1,
+ periodeT1_1.typePeriode,
+ modaliteMatiere1
+ )
+ Boolean sousServiceHasDonnees = notesSousServiceService.sousServiceHasDonneesLiees(
+ service1classe1,
+ modaliteMatiere1)
+
+ assertFalse("Le sousService est lié à des données", sousServiceHasDonnees)
+
+ //Creer une evaluation lié ay sous service
+ Evaluation eval = creeEvaluation(periodeT1_1,
+ enseignement,
+ sousService.modaliteMatiere)
+
+ sousServiceHasDonnees = notesSousServiceService.sousServiceHasDonneesLiees(
+ service1classe1,
+ modaliteMatiere1)
+ 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)
+ }
+ /**
+ * Tester l'autorisation de modification des sous-services
+ * @author mjao
+ */
+ void testSupprimeSousServicePasAuthorise() {
+ //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)
+ }
+ // test accés Directeur
+ SecuriteSession securiteSessionDirecteur =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.DIRECTION_1)
+ Boolean exceptionLeve = false
+ try {
+ notesSousServiceService.supprimeSousServicesCompletement(securiteSessionDirecteur,
+ service1classe1,
+ modaliteMatiere1,
+ periodeT1_1.typePeriode,
+ NaturePeriodeEnum.NOTATION
+ )
+
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertFalse("Directeur ne peut pas supprimer un sous-service", exceptionLeve)
+ SecuriteSession securiteSessionEnseignement =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.ENSEIGNANT_1)
+
+ exceptionLeve = false
+ // test accés Enseigneur
+ try {
+ notesSousServiceService.supprimeSousServicesCompletement(securiteSessionEnseignement,
+ service1classe1,
+ modaliteMatiere1,
+ periodeT1_1.typePeriode,
+ NaturePeriodeEnum.NOTATION
+ )
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertTrue("Enseignant peut supprimer un service ", exceptionLeve)
+ //teste accès parent
+ SecuriteSession securiteSessionParent =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.PARENT_1)
+ exceptionLeve = false
+ try {
+ notesSousServiceService.supprimeSousServicesCompletement(securiteSessionParent,
+ service1classe1,
+ modaliteMatiere1,
+ periodeT1_1.typePeriode,
+ NaturePeriodeEnum.NOTATION
+ )
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertTrue("Parent peut supprimer un service ", exceptionLeve)
+ //teste accès eleve
+ SecuriteSession securiteSessionEleve =
+ localInitDonneesCommunesTestService.getSecuriteSession(
+ PopulationTestActeur.ELEVE_2_CLASSE_1)
+ exceptionLeve = false
+ try {
+ notesSousServiceService.supprimeSousServicesCompletement(securiteSessionEleve,
+ service1classe1,
+ modaliteMatiere1,
+ periodeT1_1.typePeriode,
+ NaturePeriodeEnum.NOTATION
+ )
+ }
+ catch (AutorisationException e) {
+ exceptionLeve = true
+ }
+ assertTrue("Eleve peut supprimer un service ", exceptionLeve)
+ }
+
+ /**
+ * Creation des périodes
+ * @param typePeriode
+ * @param structureEnseignement
+ * @param dateDebut
+ * @param dateFin
+ * @return
+ */
+ private Periode getOuCreePeriode(TypePeriode typePeriode,
+ StructureEnseignement structureEnseignement,
+ Date dateDebut = null,
+ Date dateFin = null) {
+
+ Periode periode = Periode.findByTypePeriodeAndClasse(typePeriode,
+ structureEnseignement)
+ if (!periode) {
+ periode = new Periode(
+ typePeriode: typePeriode,
+ classe: structureEnseignement,
+ dateDebut: dateDebut,
+ dateFin: dateFin
+ )
+ structureEnseignement.addToPeriodes(periode)
+ } else {
+ periode.dateDebut = dateDebut
+ periode.dateFin = dateFin
+ }
+ periode.save(flush: true)
+
+ return periode
+ }
+
+ /**
+ * Crée un service minimal
+ * @param matiere matière
+ * @author msan
+ * @author mjao
+ */
+ private Service creeService(Matiere matiere,
+ StructureEnseignement structureEnseignement,
+ OrigineEnum origine) {
+
+ Service service = new Service(
+ modaliteCours: modaliteCours1,
+ structureEnseignement: structureEnseignement,
+ matiere: matiere,
+ origine: origine
+ )
+ service.save(flush: true)
+ if (service.hasErrors()) {
+ println(service.errors)
+ }
+
+ attacheService(structureEnseignement, service)
+ return service
+ }
+
+ /**
+ * 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 ->
+ RelPeriodeService rel = getRelPeriodeService(periode, service)
+ service.addToRelPeriodeServices(rel)
+ service.save(flush: true)
+ }
+ }
+
+ /**
+ * 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)
+ if (!rel) {
+ rel = new RelPeriodeService(periode: periode, service: service)
+ rel.evaluable = true
+ rel.coeff = 1
+ rel.save(flush: true)
+ }
+ 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,
+ String libelle,
+ Etablissement etablissement) {
+ ModaliteMatiere modaliteMatiere = new ModaliteMatiere(
+ code: code,
+ libelle: libelle,
+ etablissement: etablissement
+
+ )
+ modaliteMatiere.save(flush: true)
+ if (modaliteMatiere.hasErrors()) {
+ println(modaliteMatiere.errors)
+ }
+ return modaliteMatiere
+
+ }
+ /**
+ * get un sous-service
+ * @param service
+ * @param typeperiode
+ * @param modalite
+ * @return sous-service
+ */
+ private SousService getSousService(
+ Service service,
+ TypePeriode typePeriode,
+ ModaliteMatiere modaliteMatiere) {
+ def criteria = SousService.createCriteria()
+ SousService sousService = criteria.get {
+ and {
+ eq('service', service)
+ eq('typePeriode', typePeriode)
+ eq('modaliteMatiere', modaliteMatiere)
+ }
+ }
+ return sousService
+ }
+/**
+ * creer un sous-Service
+ * @param service
+ * @param typeperiode
+ * @param modalite
+ * @return sous-service
+ */
+ private SousService creeSousService(
+ Service service,
+ TypePeriode typePeriode,
+ ModaliteMatiere modaliteMatiere) {
+ SousService rel = new SousService(
+ modaliteMatiere: modaliteMatiere,
+ service: service,
+ typePeriode: typePeriode,
+ evaluable: true, // par défaut
+ coeff: 1 // par défaut
+ )
+ service.addToSousServices(rel)
+ rel.save(flush: true)
+ return rel
+ }
+ /**
+ * Crée ou get une evaluation attaché a une periode
+ * @param periode
+ * @param enseignement
+ * @author mjao
+ */
+ private Evaluation creeEvaluation(Periode periode,
+ Enseignement enseignement,
+ ModaliteMatiere modaliteMatiere) {
+ Evaluation evaluation = new Evaluation(
+ enseignement: enseignement,
+ dateCreation: datePublication,
+ periodes: [periode],
+ publiable: true,
+ dateEvaluation: datePublication,
+ titre: libelleInitial,
+ coefficient: 1,
+ noteMaxPossible: 20,
+ modaliteMatiere: modaliteMatiere
+ )
+ //evaluation.periodes << periode
+
+
+ evaluation.save(flush: true)
+ if (evaluation.hasErrors()) {
+ println(evaluation.errors)
+ }
+
+ return evaluation
+ }
+ /**
+ * Crée une Enseignement
+ * @param enseignant
+ * @param service
+ * @author mjao
+ */
+ private Enseignement creeEnseignement(Autorite enseignant, Service service) {
+ Enseignement enseignement = new Enseignement(
+ enseignant: enseignant,
+ service: service,
+ nbHeures: 5
+
+ )
+ enseignement.save(flush: true)
+
+ 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(
+ Autorite eleve,
+ Periode periode,
+ Enseignement enseignement) {
+ ResultatEleveEnseignementPeriode resultat = new ResultatEleveEnseignementPeriode(
+ periode: periode,
+ eleve: eleve,
+ enseignement: enseignement
+
+ )
+ resultat.save(flush: true)
+
+ return resultat
+ }
+ /**
+ * crée un ResultatEleveSousServicePeriode
+ * @param periode
+ * @param service
+ * @param eleve
+ * @author mjao
+ */
+ private ResultatEleveSousServicePeriode creeResultatEleveSousServicePeriode(
+ Periode periode,
+ Service service,
+ Autorite eleve,
+ SousService sousService) {
+
+ ResultatEleveServicePeriode resultatS = new ResultatEleveServicePeriode(
+ periode: periode,
+ service: service,
+ eleve: eleve
+ )
+ ResultatEleveSousServicePeriode resultatSS = new ResultatEleveSousServicePeriode(
+ resultatEleveServicePeriode: resultatS,
+ sousService: sousService
+ )
+
+ resultatS.save(flush: true)
+ println(resultatS.errors)
+ resultatSS.save(flush: true)
+ println(resultatS.errors)
+
+ return resultatSS
+ }
+ /**
+ * return un ResultatEleveSousServicePeriode
+ * @param periode
+ * @param service
+ * @param eleve
+ * @author mjao
+ */
+ private ResultatEleveSousServicePeriode getResultatEleveSousServicePeriode(
+ Periode periode,
+ Service service,
+ Autorite eleve,
+ SousService sousService) {
+
+ return ResultatEleveSousServicePeriode.createCriteria().get {
+ resultatEleveServicePeriode {
+ eq('eleve', eleve)
+ eq('periode', periode)
+ eq('service', service)
+ }
+ eq('sousService', sousService)
+ }
+ }
+ /**
+ * creer un ResultatClasseEnseignementPeriode
+ * @param periode
+ * @param eleve
+ * @param enseignement
+ * @author mjao
+ */
+ private ResultatClasseEnseignementPeriode creeResultatClasseEnseignementPeriode(
+ Enseignement enseignement,
+ Periode periode,
+ StructureEnseignement classe) {
+ ResultatClasseEnseignementPeriode resultat = new ResultatClasseEnseignementPeriode(
+ periode: periode,
+ enseignement: enseignement,
+ classe: classe
+ )
+ resultat.save(flush: true)
+
+ return resultat
+ }
+ /**
+ * get un ResultatClassseEnseignementPeriode
+ * @param periode
+ * @param eleve
+ * @param enseignement
+ * @author mjao
+ */
+ private ResultatClasseEnseignementPeriode getResultatClasseEnseignementPeriode(
+ Enseignement enseignement,
+ Periode periode,
+ StructureEnseignement classe) {
+ def criteria = ResultatClasseEnseignementPeriode.createCriteria()
+ ResultatClasseEnseignementPeriode resultatClasseEnseignementPeriode = criteria.get {
+ eq('enseignement', enseignement)
+ eq('periode', periode)
+ eq('classe', classe)
+ }
+ return resultatClasseEnseignementPeriode
+ }
+
+/**
+ * crée un ResultatClasseServicePeriode
+ * @param periode
+ * @param service
+ * @param classe
+ * @author mjao
+ */
+ private ResultatClasseSousServicePeriode creeResultatClasseSousServicePeriode(
+ Periode periode,
+ Service service,
+ StructureEnseignement classe,
+ SousService sousService) {
+
+ ResultatClasseServicePeriode resultatS = new ResultatClasseServicePeriode(
+ periode: periode,
+ service: service,
+ classe: classe,
+ uptodate: true
+ )
+ ResultatClasseSousServicePeriode resultatSS = new ResultatClasseSousServicePeriode(
+ resultatClasseServicePeriode: resultatS,
+ sousService: sousService
+ )
+
+ resultatS.save(flush: true)
+ resultatSS.save(flush: true)
+
+ return resultatSS
+ }
+
+ /**
+ * get un ResultatClasseServicePeriode
+ * @param periode
+ * @param service
+ * @param classe
+ * @author mjao
+ */
+ private ResultatClasseSousServicePeriode getResultatClasseSousServicePeriode(
+ Periode periode,
+ Service service,
+ StructureEnseignement classe,
+ SousService sousService) {
+ return ResultatClasseSousServicePeriode.createCriteria().get {
+ resultatClasseServicePeriode {
+ eq('classe', classe)
+ eq('periode', periode)
+ eq('service', service)
+ }
+ eq('sousService', sousService)
+ }
+ }
+ /**
+ * get ou creer un ResultatServicePeriode
+ * @param periode
+ * @param service
+ * @author mjao
+ */
+ private ResultatClassePeriode creeOrGetResultatlClassePeriode(Periode periode,
+ StructureEnseignement classe) {
+ ResultatClassePeriode rel = ResultatClassePeriode.findByPeriodeAndClasse(periode, classe)
+ if (!rel) {
+ rel = new ResultatClassePeriode(periode: periode, classe: classe, uptodate: true)
+ rel.save(flush: true)
+ }
+ return rel
+ }
+ /**
+ * get ou creer un ResultatElevePeriode
+ * @param eleve
+ * @param periode
+ * @author mjao
+ */
+ private ResultatElevePeriode creeOrGetResultatlElevePeriode(Periode periode,
+ Autorite eleve) {
+ ResultatElevePeriode rel = ResultatElevePeriode.findByPeriodeAndEleve(periode, eleve)
+ if (!rel) {
+ rel = new ResultatElevePeriode(periode: periode, eleve: eleve, uptodate: true)
+ rel.save(flush: true)
+ }
+ return rel
+ }
+
+
+}