import.porteur = ${importHelper.porteur} and
import.academie = ${importHelper.academie}
""")
- // desactive tous les profils de scolarites des responsables eleves
- desactiveProfilsScolariteForResponsablesEleveDesactives(sql)
-
}
/**
where
eleve_id = ${eleve.idInterne}
""")
- // Desactiver les profils scolarites des parents
- desactiveProfilsScolariteForResponsablesEleveDesactives(sql)
}
/**
where
id = ${resp.responsable_eleve_idInterne}
""")
-
- // Active les profils attaches du responsable lie pour l'eleve concerne.
- // Cela revient a mettre a jour les responsable_propriete_scolarite
- updateResponsableProfilsScolariteAttaches(sql, resp, eleve)
- }
-
-/**
- * Met à jour les profils de scolarite du responsable élève
- * @param sql la canal sql
- * @param respo responsable élève
- * @param eleve
- */
- def updateResponsableProfilsScolariteAttaches(Sql sql, Acteur respo, Acteur eleve) {
-
- respo.profilsScolarite.each { ProprietesScolarite props ->
- try {
- Long idPersProps = personnePropsScolariteActiveExisteDansAnnuaire(sql, respo, props)
- if (idPersProps) { // reactive le profil de scolarité si il existe
- activePersonneProprietesScolariteForId(sql, idPersProps)
- } else { // ajoute le profil de scolarite si il n'existe pas
- insertPersonneProprietesScolarite(sql, respo, props)
- }
- } catch (Exception e) {
- eleve.alertes << e.message
- }
- }
}
/**
eleve_id = ${eleve.idInterne} and
import_id <> ${importId}
""")
-
- // Desactive les profils de scolarites des responsables perimes
- desactiveProfilsScolariteForResponsablesEleveDesactives(sql)
- }
-
-/**
- * Desactive les profils de scolarite des responsable eleves desactives
- * @param sql le canal SQL
- */
- def desactiveProfilsScolariteForResponsablesEleveDesactives(Sql sql) {
-
- sql.execute("""
- update
- ent.personne_propriete_scolarite pp
- set
- est_active = false,
- aaf_import_id = ${importId}
- from
- ent.responsable_eleve r
- where
- r.est_active = FALSE and
- r.import_id = ${importId} and
- pp.personne_id = r.personne_id
- """)
}
-
/**
* Insert un ResponsableEleve
* @param sql le canal SQL
""")
resp.responsable_eleve_idInterne = respEleveId
- // insere ou met à jours les responsable profils de scolarite
- updateResponsableProfilsScolariteAttaches(sql, resp, eleve)
return respEleveId
}
def props = request.attributes
- def profilsScolariteParents = []
String regime = props['ENTEleveRegime']
String idSconet = props['ENTEleveStructRattachId']
fonction: Fonction.ELEVE,
structureEnseignement: structCourante
)
- // pour les parents
- profilsScolariteParents << new ProprietesScolarite(
- fonction: Fonction.PERS_REL_ELEVE,
- structureEnseignement: structCourante
- )
}
// recupere les groupes
fonction: Fonction.ELEVE,
structureEnseignement: structCourante
)
- // pour les parents
- profilsScolariteParents << new ProprietesScolarite(
- fonction: Fonction.PERS_REL_ELEVE,
- structureEnseignement: structCourante
- )
}
// recupere les responsables en suivant les directives du MEN par défaut
setResponsablesElevesForAutoritesParentales(
autoritesParentales,
parents,
- resultat,
- profilsScolariteParents
+ resultat
)
// si aucun responsable d'élèves et deduction doit être faite uniquement
// à partir de l'attribut "ENTElevesParents"
if (!resultat.responsableEleves && responsablesElevesDeduitsDesParents) {
- setResponsablesElevesForParentsUniquement(parents, resultat, profilsScolariteParents)
+ setResponsablesElevesForParentsUniquement(parents, resultat)
}
return resultat
private def setResponsablesElevesForAutoritesParentales(def autoritesParentales,
def parents,
- Eleve eleve,
- List<ProprietesScolarite> profilsParents) {
+ Eleve eleve) {
autoritesParentales.eachWithIndex { obj, i ->
ResponsableEleve resp = new ResponsableEleve()
resp.autorite_idExterne = obj
if (parents.contains(obj)) {
resp.parent = true
}
- // roles du parent
- resp.profilsScolarite = profilsParents
eleve.responsableEleves << resp
}
}
private def setResponsablesElevesForParentsUniquement(def parents,
- Eleve eleve,
- List<ProprietesScolarite> profilsParents) {
+ Eleve eleve) {
parents.eachWithIndex { obj, i ->
if (i < 2) {
ResponsableEleve resp = new ResponsableEleve()
resp.autorite_idExterne = obj
resp.responsableLegal = i + 1
resp.parent = true
- // role du parent
- resp.profilsScolarite = profilsParents
eleve.responsableEleves << resp
}
}
// inner join esecurite.autorite as a on p.autoe l'alerte sur le deuxieme responsable legal
assertTrue elv1.alertes[0].contains(PARENT_ID_EXTERNE_2)
- // vérifie les profils de scolarité des parents
- rows = sql.rows("""
- select p.id
- from ent.personne as p
- inner join securite.autorite as a on p.autorite_id = a.id
- where
- a.id_externe = ${PARENT_ID_EXTERNE_1}
- """)
- Long p_resp_1 = rows[0].id
-
- def ppsResp1Rows = sql.rows("""
- select
- ps.id,
- f.code,
- ps.structure_enseignement_id as str,
- ps.etablissement_id as etab,
- ps.porteur_ent_id as porteur
- from ent.personne_propriete_scolarite as pps
- inner join ent.propriete_scolarite as ps on pps.propriete_scolarite_id = ps.id
- inner join ent.fonction as f on ps.fonction_id = f.id
- where pps.personne_id = ${p_resp_1}
- """)
-
- assertEquals 4, ppsResp1Rows.findAll {it.str != null}.size()
- assertEquals 1, ppsResp1Rows.findAll {it.str == null && it.etab == null && it.porteur != null}.size()
-
eleveLoader.doTermineLoading(sql)
sql.rollback()
}
assertEquals 7, eleveLoader.nombreProfilsScolariteEleveInseresOuMisAJour(sql)
- assertEquals 13, eleveLoader.nombreProfilsScolariteParentsInseresOuMisAJour(sql)
+ assertEquals 0, eleveLoader.nombreProfilsScolariteParentsInseresOuMisAJour(sql)
assertEquals 0, eleveLoader.nombreProfilsScolariteElevesDesactives(sql)
assertEquals 0, eleveLoader.nombreProfilsScolariteParentsDesactives(sql)
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.FileAppender
import org.apache.log4j.DailyRollingFileAppender
import org.lilie.services.eliot.textes.DataStoreId
* @author jtra , othe
*/
-/**
- * Configuration de l'annuaire (pour les tests d'intégration du plugin)
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
// Proprietes du service d'impression
eliot {
import org.lilie.services.eliot.scolarite.IntervalleEnum
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.securite.EliotDroitsService
-
import org.lilie.services.eliot.annuaire.EliotFonctionnalites
/**
import org.lilie.services.eliot.annuaire.Acteur
import org.lilie.services.eliot.annuaire.AnnuaireService
import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.GroupeInfo
+import org.lilie.socle.api.webdroits.dto.ResultatRechercheGUDto
/**
* Controller permettant de rechercher dans l'annuaire.
AnnuaireService annuaireService
DistantAutoriteService distantAutoriteService
+ LocalGroupeService localGroupeService
+ GroupeService groupeService
private static final String TOUS_ETABLISSEMENTS = 'TOUS'
private Map getModelPourRecherche(String typeRechercheAutorisee) {
listeTypeGroupeG: listeTypeGroupeOrdonneeGroupes,
typeGroupeScolarite: typeGroupeScolarite,
typeGroupeTous: typeGroupeTous,
- listeDroitsActeurs: params?.listeDroitsAMasquer
+ listeDroitsActeurs: params?.listeDroitsAMasquer,
+ itemId: params.itemId
]
}
}
def rechercher = {
+ Long itemId = params.itemId ? Long.parseLong(params.itemId) : null
String motClef = params.motCle
String profil = params.profil
String fonction = params.fonction
tous,
SessionUtils.securiteSession(session)
)
+
+ resultat = removeAllGroupeDistantForGroupeLocalAvecAutorisationParDefaut(
+ Item.get(itemId),
+ resultat
+ )
}
filtrerRecherche(resultat)
if (params.listeDroitsActeurs &&
params.listeDroitsActeurs != '' &&
- params.listeDroitsActeurs != 'null' ) {
+ params.listeDroitsActeurs != 'null') {
laListe = params.listeDroitsActeurs.toString()
}
try {
if (distantAutoriteService.isAutoriteEncodee(idActeur)) {
Autorite autorite =
- distantAutoriteService.getAutoriteForAutoriteEncodee(
- idActeur,
- true
- )
+ distantAutoriteService.getAutoriteForAutoriteEncodee(
+ idActeur,
+ true
+ )
idActeur = autorite.idExterne
}
Long lidacteur = Long.parseLong(idActeur)
}
+ /*
+
+ Supprime de la liste des résultats de la recherche les groupes
+ distants qui correspondent aux groupes locaux auquel l'item est déjà partagé
+ */
+ private Map removeAllGroupeDistantForGroupeLocalAvecAutorisationParDefaut(Item item, Map resultat) {
+
+ List<ProprietesScolarite> groupesLocaux =
+ localGroupeService.findAllGroupeLocalAvecAutorisationParDefaut(item)
+
+ List<GroupeInfo> groupesDistans =
+ groupeService.findAllGroupeDistantByGoupesLocaux(
+ SessionUtils.securiteSession(session),
+ groupesLocaux
+ )
+
+ List<Long> allGroupeIdExterneASuppr = groupesDistans*.groupeId
+
+ List<ResultatRechercheGUDto> groupeASupprimer = resultat.resultats.findAll {
+ allGroupeIdExterneASuppr.contains(it.identifiant)
+ }
+
+ resultat.resultats.removeAll(groupeASupprimer)
+ resultat.nbResultats = resultat.resultats.size()
+
+ return resultat
+ }
+
def afficherProfils = {
Map listeProfils = annuaireService.getProfils(
SessionUtils.securiteSession(session),
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.securite.permission.DroitsEtPermissionsService
-import org.lilie.services.eliot.droits.Droit
+import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
+import org.lilie.services.eliot.securite.permission.Droit
/**
* Fournit les actions communes aux applications pour la gestion de la page
DistantAutoriteService distantAutoriteService
LocalPersonneService localPersonneService
- DroitsEtPermissionsService droitsEtPermissionsService
+ PartageManuelService partageManuelService
/**
* Génère le code HTML des lignes des "entrées droits" pour chaque autorité
// On reçoit une liste d'ids de groupes ou d'users
List<Droit> listeDroits = []
- List<Autorite> autorites = droitsEtPermissionsService.getListeAutorites(
+ List<Autorite> autorites = partageManuelService.getListeAutorites(
params.ids,
params.type
)
listeDroits << new Droit(
nomAutorite: autorite.nomAffichage(),
- idAutorite: idAutorite,
+ autoriteIdExterne: idAutorite,
type: params.type,
consultation: Boolean.TRUE,
modification: Boolean.FALSE
--- /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
+
+class OperationMaintenance {
+
+ static final ETAT_TERMINE = 'TERMINE'
+
+ Long id
+ String code
+ String etat
+
+ static mapping = {
+ id column: 'id', generator: 'sequence', params: [sequence: 'public.operation_maintenance_id_seq']
+ table('public.operation_maintenance')
+ version false
+ }
+
+}
+++ /dev/null
-package org.lilie.services.eliot.annuaire
-
-import org.lilie.services.eliot.scolarite.Personne
-
-/**
- * Classe de domaine faisant le lien entre personne et groupe de personne
- * @author othe
- */
-class AppartenancePersonneGroupe {
- Personne personne
- GroupePersonnes groupePersonnes
-
- static constraints = {
- personne(nullable: false)
- groupePersonnes(nullable: false)
- }
-
- static mapping = {
- table('ent.appartenance_personne_groupe')
- id column: 'id', generator: 'sequence', params: [sequence: 'ent.appartenance_personne_groupe_id_seq']
- version false
- }
-
-
- public String toString() {
- return "AppartenancePersonneGroupe{" +
- "personne=" + personne +
- ", groupePersonnes=" + groupePersonnes +
- '}';
- }
-}
+++ /dev/null
-package org.lilie.services.eliot.annuaire
-
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.securite.impl.Item
-
-/**
- * Classe de domaine pour les groupes de personne
- * @author othe
- */
-class GroupePersonnes {
- String nom
- boolean virtuel
- Autorite autorite
- Item item
- ProprietesScolarite proprietesScolarite
-
- static constraints = {
- }
-
- static mapping = {
- table('ent.groupe_personnes')
- id column: 'id', generator: 'sequence', params: [sequence: 'ent.groupe_personnes_id_seq']
- version false
- autorite column: 'autorite_id'
- item column: 'item_id'
- proprietesScolarite joinTable: [name: 'ent.propriete_scolarite', key: 'propriete_scolarite_id']
- }
-
-
- public String toString() {
- return "GroupePersonnes{" +
- "nom='" + nom + '\'' +
- ", virtuel=" + virtuel +
- ", autorite=" + autorite +
- ", item=" + item +
- ", proprietesScolarite=" + proprietesScolarite +
- '}';
- }
-}
class Autorite implements org.lilie.services.eliot.securite.Autorite {
- public static final String ID_EXTERNE_DEFAULT_AUTORITE = "AUTORITE_PAR_DEFAUT"
-
- Long id
- String type
- String idExterne
- String idSts
- String localisation
-
- private Boolean estActive = true
- CompteUtilisateurEtat etat = CompteUtilisateurEtat.ACTIF
-
- Long importId
- Date dateDesactivation
- String nomEntiteCible
- Long idEnregistrementCible
-
- static constraints = {
- type(inList: [Autorite.TYPE_ACTEUR, Autorite.TYPE_GROUPE, Autorite.TYPE_ELIOT])
- idSts nullable: true
- dateDesactivation nullable: true
- importId nullable: true
- nomEntiteCible nullable: true
- idEnregistrementCible nullable: true
- etat nullable: true
- localisation(nullable: true)
+ public static final String ID_EXTERNE_DEFAULT_AUTORITE = "AUTORITE_PAR_DEFAUT"
+
+ Long id
+ String type
+ String idExterne
+ String idSts
+ String localisation
+
+ private Boolean estActive = true
+ CompteUtilisateurEtat etat = CompteUtilisateurEtat.ACTIF
+
+ Long importId
+ Date dateDesactivation
+ String nomEntiteCible
+ Long idEnregistrementCible
+
+ static constraints = {
+ type(inList: [Autorite.TYPE_ACTEUR, Autorite.TYPE_GROUPE, Autorite.TYPE_ELIOT])
+ idExterne nullable: true
+ idSts nullable: true
+ dateDesactivation nullable: true
+ importId nullable: true
+ nomEntiteCible nullable: true
+ idEnregistrementCible nullable: true
+ etat nullable: true
+ localisation(nullable: true)
+ }
+
+ static mapping = {
+ table('securite.autorite')
+ cache true
+ id column: 'id', generator: 'sequence', params: [sequence: 'securite.autorite_id_seq']
+ idEnregistrementCible column: 'enregistrement_cible_id'
+ }
+
+ AutoriteNomAffichageService autoriteNomAffichageService
+ static transients = [
+ 'autoriteNomAffichageService',
+ 'typeEliot'
+ ]
+
+ private String nomAffichage
+
+ /**
+ *
+ * @return le nom d'affichage de l'autorité
+ * @param avecMEF si le nom de groupe devrait contenir l'information sur le MEF ou pas
+ */
+ String nomAffichage(Boolean avecMEF = false) {
+ if (nomAffichage == null) {
+ nomAffichage = autoriteNomAffichageService.getNomAffichage(this, avecMEF)
}
-
- static mapping = {
- table('securite.autorite')
- cache true
- id column: 'id', generator: 'sequence', params: [sequence: 'securite.autorite_id_seq']
- idEnregistrementCible column: 'enregistrement_cible_id'
- }
-
- AutoriteNomAffichageService autoriteNomAffichageService
- static transients = [
- 'autoriteNomAffichageService',
- 'typeEliot'
- ]
-
- private String nomAffichage
-
- /**
- *
- * @return le nom d'affichage de l'autorité
- * @param avecMEF si le nom de groupe devrait contenir l'information sur le MEF ou pas
- */
- String nomAffichage(Boolean avecMEF = false) {
- if (nomAffichage == null) {
- nomAffichage = autoriteNomAffichageService.getNomAffichage(this, avecMEF)
- }
- return nomAffichage
+ return nomAffichage
+ }
+
+ /**
+ * Méthode retournant les permissions de l'autorité sur l'item passé en paramètre
+ */
+ public int findPermissionsOnItem(org.lilie.services.eliot.securite.Item item) {
+ return Autorisation.findByAutoriteAndItem(this, item)?.valeurPermissions ?: 0;
+ }
+
+ /**
+ * Retourne une chaine de caractère qui encode cette autorité
+ * Le format d'encodage est : #type,#idExterne
+ */
+ public String encodeAsString() {
+ return "T$type-ID$idExterne"
+ }
+
+ /**
+ * @return true si cette autorité est de type Système, false sinon
+ */
+ public boolean isTypeEliot() {
+ return type == TYPE_ELIOT
+ }
+
+ /**
+ * @return true si cette autorite a un accès restreint aux applications eliot
+ */
+ boolean aUnAccesRetreint() {
+ return etat == CompteUtilisateurEtat.ACCES_RESTREINT
+ }
+
+ boolean getEstActive() {
+ return this.estActive
+ }
+
+ void setEstActive(Boolean value) {
+ this.estActive = value
+ }
+
+ boolean equals(o) {
+ if (this.is(o)) {
+ return true;
}
- /**
- * Méthode retournant les permissions de l'autorité sur l'item passé en paramètre
- */
- public int findPermissionsOnItem(org.lilie.services.eliot.securite.Item item) {
- return Autorisation.findByAutoriteAndItem(this, item)?.valeurPermissions ?: 0;
+ if (!(o instanceof Autorite)) {
+ return false;
}
- /**
- * Retourne une chaine de caractère qui encode cette autorité
- * Le format d'encodage est : #type,#idExterne
- */
- public String encodeAsString() {
- return "T$type-ID$idExterne"
- }
+ Autorite autorite = (Autorite) o;
- /**
- * @return true si cette autorité est de type Système, false sinon
- */
- public boolean isTypeEliot() {
- return type == TYPE_ELIOT
+ if (idExterne == null && autorite.idExterne == null && id != autorite.id) {
+ return false;
}
- /**
- * @return true si cette autorite a un accès restreint aux applications eliot
- */
- boolean aUnAccesRetreint() {
- return etat == CompteUtilisateurEtat.ACCES_RESTREINT
+ if (idExterne != autorite.idExterne) {
+ return false;
}
-
- boolean getEstActive() {
- return this.estActive
- }
-
- void setEstActive(Boolean value) {
- this.estActive = value
+ if (type != autorite.type) {
+ return false;
}
- boolean equals(o) {
- if (this.is(o)) {
- return true;
- }
+ return true;
+ }
- if (!(o instanceof Autorite)) {
- return false;
- }
+ int hashCode() {
+ int result;
- Autorite autorite = (Autorite) o;
-
- if (idExterne != autorite.idExterne) {
- return false;
- }
- if (type != autorite.type) {
- return false;
- }
-
- return true;
+ result = type.hashCode();
+ if (idExterne) {
+ result = 31 * result + idExterne.hashCode();
+ } else {
+ result = 31 * result + id.hashCode();
}
+ return result;
+ }
- int hashCode() {
- int result;
-
- result = type.hashCode();
- result = 31 * result + idExterne.hashCode();
- return result;
- }
+ public String toString() {
+ return "Autorite{id=$id, type=$type, idExterne=$idExterne, localisation=$localisation, estActive=$estActive, dateDesactivation=$dateDesactivation, etat=$etat}"
+ }
- public String toString() {
- return "Autorite{id=$id, type=$type, idExterne=$idExterne, estActive=$estActive, dateDesactivation=$dateDesactivation, etat=$etat}"
- }
-
- public void modifieEtat(CompteUtilisateurEtat etat) {
- this.etat = etat
- this.estActive = etat == CompteUtilisateurEtat.ACTIF
- }
+ public void modifieEtat(CompteUtilisateurEtat etat) {
+ this.etat = etat
+ this.estActive = etat == CompteUtilisateurEtat.ACTIF
+ }
}
+++ /dev/null
-package org.lilie.services.eliot.securite.impl
-
-class Permission implements org.lilie.services.eliot.securite.Permission {
- String nom
- int valeur
-
- static constraints = {
- }
-
- String toString() {
- "${nom} (code ${valeur})"
- }
-
- static mapping = {
- table ('securite.permission')
- id column:'id', generator: 'sequence', params: [sequence: 'securite.permission_id_seq']
- }
-}
eliot.fonction.libelle.APP=Apprentissage
eliot.groupescolarite.libelle.enseignants=Enseignants
-eliot.groupescolarite.libelle.enseignantsPrincipaux=Enseignants Principaux
-eliot.groupescolarite.libelle.direction=Personnel de l'établissement(DIRECTION)
-eliot.groupescolarite.libelle.education=Personnel de l'établissement(EDUCATION)
-eliot.groupescolarite.libelle.documentation=Personnel de l'établissement(DOCUMENTATION)
-eliot.groupescolarite.libelle.adminLocal=Administrateur local de l'établissement
// Création de l'autorité
Autorite autoriteCree = new Autorite(
type: type,
- idExterne: idExterne
+ idExterne: idExterne,
+ localisation: type == Autorite.TYPE_GROUPE ?
+ Autorite.LOCALISATION_DISTANTE : null
)
+
autoriteCree.save(flush: true, failOnError: true)
return autoriteCree
}
return Autorite.findByTypeAndIdExterne(type, idExterne, [cache: true])
}
- return (Autorite)GormUtils.withSavepoint(action, onDataIntegrityViolation)
+ return (Autorite) GormUtils.withSavepoint(action, onDataIntegrityViolation)
}
return null // jtra : Il serait préférable de lever une exception
// Création de l'autorité
autorite = new Autorite(
type: type,
- idExterne: idExterne)
+ idExterne: idExterne,
+ localisation: type == Autorite.TYPE_GROUPE ?
+ Autorite.LOCALISATION_DISTANTE : null
+ )
+
autorite.save(flush: true, failOnError: true)
}
catch (DataIntegrityViolationException e) {
}
/**
- * Méthode retournant toutes les autorités pour un acteur donné
+ * Méthode retournant toutes les autorités distantes pour un acteur donné
* @param acteur l'acteur
* @return la liste d'autorités
*/
groupeIds = acteur.groupesIds
}
- if(groupeIds == null) {
+ if (groupeIds == null) {
groupeIds = []
}
--- /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
+
+import org.lilie.services.eliot.annuaire.GroupeInfo
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.annuaire.StructureInformations
+import org.lilie.services.eliot.annuaire.AnnuaireService
+import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
+
+/**
+ * @author bahj, bper
+ */
+class GroupeService {
+
+ static transactional = true
+ AnnuaireService annuaireService
+ DistantStructureEnseignementService distantStructureEnseignementService
+
+ /**
+ * Retourne les groupes distants qui correspondent aux groupes locaux en paramètre
+ * @param securiteSession
+ * @param groupesLocaux
+ * @return
+ */
+ public List<GroupeInfo> findAllGroupeDistantByGoupesLocaux(SecuriteSession securiteSession, List<ProprietesScolarite> groupesLocaux) {
+
+ List<GroupeInfo> groupesDistants = []
+
+ groupesLocaux.each {ProprietesScolarite groupeLocal ->
+ switch (groupeLocal.fonction.code) {
+ case FonctionEnum.ELEVE.code:
+ groupesDistants.addAll(
+ findAllEleveGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.PERS_REL_ELEVE.code:
+ groupesDistants.addAll(
+ findAllParentGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.ENSEIGNANT.code:
+ if (groupeLocal.responsableStructureEnseignement) {
+ groupesDistants.addAll(
+ findAllEnseignantPrincipalGroupeDistant(securiteSession, groupeLocal)
+ )
+ } else {
+ groupesDistants.addAll(
+ findAllEnseignantGroupeDistant(securiteSession, groupeLocal)
+ )
+ }
+ break
+
+ case FonctionEnum.DIRECTION.code:
+ groupesDistants.addAll(
+ findAllDirectionGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.EDUCATION.code:
+ groupesDistants.addAll(
+ findAllEducationGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.DOCUMENTALISTE.code:
+ groupesDistants.addAll(
+ findAllDocumentalisteGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.ADMIN_LOCAL.code:
+ groupesDistants.addAll(
+ findAllAdminLocalGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+
+ case FonctionEnum.CHEF_TRAVAUX.code:
+ groupesDistants.addAll(
+ findAllChefDeTravauxGroupeDistant(securiteSession, groupeLocal)
+ )
+ break
+ }
+ }
+
+ return groupesDistants
+ }
+
+ List<GroupeInfo> findAllEleveGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ return annuaireService.getGroupeInfoElevePourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+ }
+
+ List<GroupeInfo> findAllParentGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ return annuaireService.getGroupeInfoParentsPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+ }
+
+ List<GroupeInfo> findAllEnseignantPrincipalGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ return annuaireService.getGroupeInfoProfPrincipauxPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+ }
+
+ List<GroupeInfo> findAllEnseignantGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ return annuaireService.getGroupeInfoEnseignantPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+ }
+
+ List<GroupeInfo> findAllDocumentalisteGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ return [
+ annuaireService.getGroupeInfoDocumentationForEtablissement(
+ groupeLocal.etablissement.idExterne
+ )
+ ]
+ }
+
+ List<GroupeInfo> findAllEducationGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ return [
+ annuaireService.getGroupeInfoEducationForEtablissement(
+ groupeLocal.etablissement.idExterne
+ )
+ ]
+ }
+
+ List<GroupeInfo> findAllDirectionGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+
+ return [
+ annuaireService.getGroupeInfoDirectionForEtablissement(
+ groupeLocal.etablissement.idExterne
+ )
+ ]
+ }
+
+ List<GroupeInfo> findAllChefDeTravauxGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+ return [
+ annuaireService.getGroupeInfoChefDeTravauxForEtablissement(
+ groupeLocal.etablissement.idExterne
+ )
+ ]
+ }
+
+ List<GroupeInfo> findAllAdminLocalGroupeDistant(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal
+ ) {
+ return [
+ annuaireService.getGroupeInfoAdminsLocauxForEtablissement(
+ groupeLocal.etablissement.idExterne
+ )
+ ]
+ }
+
+}
import org.springframework.dao.DataIntegrityViolationException
import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
/**
* Service de gestion des autorités utilisant l'annuaire local
return Autorite.findByIdSts(idSts)
}
- /**
- * Méthode retournant l'autorité acteur pour un id donné
- * @param idExterne l'id externe de l'autorite
- * @param forceCreation flag indiquant si il faut forcer la création si
- * l'autorité n'existe pas
- * @return l'autorité
- */
- Autorite getAutoriteActeurForIdExterne(String idExterne,
- boolean forceCreation = false) {
- return getAutoriteForTypeAndIdExterne(
- Autorite.TYPE_ACTEUR,
- idExterne,
- forceCreation)
- }
-
/**
* Verifie si l;autorite est active
* @param idExterne
}
/**
- * Retourne l'autorité de type 'type' et d'IdExterne 'idExterne'
- * Si le flag forceCreation est positionné à true, l'autorité est
- * automatiquement créée si elle n'existe pas en base
- * @param type le type de l'autorité
- * @param idExterne l'idExterne de l'autorité
- * @param forceCreation
+ * Méthode retournant l'autorité acteur pour un id donné
+ * @param idExterne l'id externe de l'autorite
+ * @param forceCreation flag indiquant si il faut forcer la création si
+ * l'autorité n'existe pas
* @return l'autorité
*/
- Autorite getAutoriteForTypeAndIdExterne(String type,
- String idExterne,
- boolean forceCreation = false) {
+ Autorite getAutoriteActeurForIdExterne(String idExterne,
+ boolean forceCreation = false) {
Autorite autorite = Autorite.findByTypeAndIdExterne(
- type,
+ Autorite.TYPE_ACTEUR,
idExterne,
[cache: true]
)
Closure action = {
// Création de l'autorité
Autorite autoriteCree = new Autorite(
- type: type,
+ type: Autorite.TYPE_ACTEUR,
idExterne: idExterne
)
+
autoriteCree.save(flush: true, failOnError: true)
return autoriteCree
}
Closure onDataIntegrityViolation = { DataIntegrityViolationException e ->
- return Autorite.findByTypeAndIdExterne(type, idExterne, [cache: true])
+ return Autorite.findByTypeAndIdExterne(Autorite.TYPE_ACTEUR, idExterne, [cache: true])
}
- return (Autorite)GormUtils.withSavepoint(action, onDataIntegrityViolation)
+ return (Autorite) GormUtils.withSavepoint(action, onDataIntegrityViolation)
}
}
* @param autoriteIds
* @return La liste des autorites correspondant à la liste des ids
*/
- List<Autorite> findAllAutorites(List<Long> autoriteIds){
+ List<Autorite> findAllAutorites(List<Long> autoriteIds) {
return Autorite.getAll(autoriteIds)
}
+
+ /* Vérifie que la ps est liée à une autorité de type Groupe. Si ce n'est pas le
+ cas et que forceCreation = true, on créé l'autorité et on la rattache à la ps
+ */
+
+ Autorite getAutoriteGroupeLocal(ProprietesScolarite proprieteScolarite,
+ boolean forceCreation = false) {
+
+ Autorite psAutorite = proprieteScolarite.autorite
+
+ if (psAutorite) {
+ if (psAutorite.type == Autorite.TYPE_GROUPE && psAutorite.localisation == Autorite.LOCALISATION_LOCALE) {
+ return psAutorite
+ } else {
+ throw new IllegalStateException("La ps d'id ${proprieteScolarite.id} est déjà liéé à une autorité, mais qui n'est pas de type GROUPE")
+ }
+ } else {
+ // création de l'autorité
+ Autorite autorite = new Autorite(
+ type: Autorite.TYPE_GROUPE,
+ localisation: Autorite.LOCALISATION_LOCALE,
+ nomEntiteCible: 'ent.propriete_scolarite',
+ idEnregistrementCible: proprieteScolarite.id
+ )
+ autorite.save(failOnError: true)
+ // rattachement de l'autorité à la ps
+ proprieteScolarite.autorite = autorite
+ proprieteScolarite.save(failOnError: true)
+
+ return autorite
+ }
+
+ }
}
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-
-
package org.lilie.services.eliot.applications
+import org.lilie.services.eliot.securite.impl.AnnuaireMode
+
/**
* @author jbui
*/
public enum ModuleEliot {
- ELIOT_ABSENCES('eliot-absences', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_AGENDA('eliot-agenda', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_DEMON_DOCS('eliot-demon-docs', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_DEMON_SCOLARITE('eliot-demon-scolarite', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_NOTES('eliot-notes', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_SCOLARITE('eliot-scolarite', BaseDonneesEliot.ELIOT_SCOLARITE),
- ELIOT_TEXTES('eliot-textes', BaseDonneesEliot.ELIOT_SCOLARITE),
+ ELIOT_ABSENCES('eliot-absences', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.LOCAL, AnnuaireMode.LOCAL),
+ ELIOT_AGENDA('eliot-agenda', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.MIXTE, AnnuaireMode.LOCAL),
+ ELIOT_DEMON_DOCS('eliot-demon-docs', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.DISTANT, AnnuaireMode.DISTANT),
+ ELIOT_DEMON_SCOLARITE('eliot-demon-scolarite', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.DISTANT, AnnuaireMode.LOCAL),
+ ELIOT_NOTES('eliot-notes', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.LOCAL, AnnuaireMode.LOCAL),
+ ELIOT_SCOLARITE('eliot-scolarite', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.DISTANT, AnnuaireMode.LOCAL),
+ ELIOT_TEXTES('eliot-textes', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.MIXTE, AnnuaireMode.LOCAL),
- ELIOT_DOCS('eliot-docs', BaseDonneesEliot.ELIOT_DOCS),
- ELIOT_MESSAGERIE('eliot-messagerie', BaseDonneesEliot.ELIOT_DOCS),
+ ELIOT_DOCS('eliot-docs', BaseDonneesEliot.ELIOT_DOCS, AnnuaireMode.DISTANT, AnnuaireMode.DISTANT),
+ ELIOT_MESSAGERIE('eliot-messagerie', BaseDonneesEliot.ELIOT_DOCS, AnnuaireMode.DISTANT, AnnuaireMode.DISTANT),
BREVET('brevet'),
SMS('sms'),
- SCRIPT('Script')
+ SCRIPT('Script'),
+
+ ELIOT_PLUGIN('grails-eliot-app-plugin', BaseDonneesEliot.ELIOT_SCOLARITE, AnnuaireMode.MIXTE, AnnuaireMode.LOCAL)
String getId() {this}
private String nom
private BaseDonneesEliot baseCorrespondante // base de donnees qui est
- // utilisee par ce module
+ // utilisee par ce module
+ AnnuaireMode sessionACLMode
+ AnnuaireMode sessionAnnuaireMode
private ModuleEliot() {}
return this.baseCorrespondante
}
- private ModuleEliot(String nom, BaseDonneesEliot baseDonneesEliot = null) {
+ private ModuleEliot(String nom,
+ BaseDonneesEliot baseDonneesEliot = null,
+ AnnuaireMode sessionACLMode = null,
+ AnnuaireMode sessionAnnuaireMode = null) {
this.nom = nom
- if (baseDonneesEliot) {
- this.baseCorrespondante = baseDonneesEliot
- }
+ this.baseCorrespondante = baseDonneesEliot
+ this.sessionACLMode = sessionACLMode
+ this.sessionAnnuaireMode = sessionAnnuaireMode
}
static public ModuleEliot parseByNom(String nom) {
module.nom == nom
}
}
-
-
}
import org.lilie.services.eliot.DistantAutoriteService
import org.lilie.services.eliot.applications.textes.recherche.TextesIndexationService
import org.lilie.services.eliot.annuaire.AnnuaireService
-import org.lilie.services.eliot.annuaire.GroupeInfo
import org.lilie.services.eliot.scolarite.StructureEnseignement
-import org.lilie.services.eliot.securite.PermissionsManager
-import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
-import org.lilie.services.eliot.annuaire.StructureInformations
-import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
import org.lilie.services.eliot.ItemService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.scolarite.Personne
-
import org.lilie.services.eliot.textes.CahierDeTextes
import org.lilie.services.eliot.textes.Dossier
import org.lilie.services.eliot.textes.Activite
import org.lilie.services.eliot.textes.CahierDeTextesType
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.TypeActiviteService
+import org.lilie.services.eliot.securite.permission.partageauto.CahierDeTextesPartageAutoService
/**
* Classe de service exposant les opérations relatives aux cahier de textes
DistantAutoriteService distantAutoriteService
TextesIndexationService textesIndexationService
AnnuaireService annuaireService
- DistantStructureEnseignementService distantStructureEnseignementService
RelDossierAutorisationCahierService relDossierAutorisationCahierService
AnneeScolaireService anneeScolaireService
CiteScolaireService citeScolaireService
SessionFactory sessionFactory
EtablissementService etablissementService
TypeActiviteService typeActiviteService
+ CahierDeTextesPartageAutoService cahierDeTextesPartageAutoService
/**
* Création d'un cahier de textes privé.
try {
textesIndexationService.indexerCahierDeTextes(securiteSession, cdt, false)
}
- catch(Exception e) {
+ catch (Exception e) {
log.warn("Erreur durant l'indexation d'un cahier de textes", e)
}
}
Item item = new Item(type: ItemService.ITEM_TYPE_CDT)
item.save()
- // crée l'autorisation et specifie que l'autorité et le propriétaire de l'item
+ // crée l'autorisation et specifie que l'autorité est le propriétaire de l'item
autorisationService.creeAutorisation(enseignant, item, true, 0)
)
}
- ajouterPermissionsCommunauteCahierDeTextes(securiteSession, cdt)
+ cahierDeTextesPartageAutoService.partageCahierService(cdt)
// fsil : indexation du cahier de textes
try {
textesIndexationService.indexerCahierDeTextes(securiteSession, cdt, false)
0
)
- if (cdt.droitsIncomplets || service.structureEnseignement.idExterne == "-1") {
- ajouterPermissionsCommunauteCahierDeTextes(securiteSession, cdt)
- }
-
// fsil : on reindexe contenus et droits en cas de modifs
try {
textesIndexationService.indexerCahierDeTextes(securiteSession, cdt, true)
}
}
- /**
- * Méthode permettant d'ajouter les droits de la communauté éducative à un
- * cahier de textes de services
- * @param cahier le cahier de textes de service
- */
- private void ajouterPermissionsCommunauteCahierDeTextes(SecuriteSession securiteSession,
- CahierDeTextes cahier) {
- // si pas de service, pas de permissions à ajouter
- if (!cahier.service) {
- return
- }
-
- // récupération des groupes devant bénéficier des autorisations de consultation
- List<GroupeInfo> groupesEnDroitConsultation = []
-
- // Groupe devant bénéficier des autorisations de modification des droits et permissions
- List<GroupeInfo> groupesEnDroitModificationDEP = []
-
- StructureEnseignement structEns = cahier.service.structureEnseignement
- if (cahier.service.structureEnseignement.idExterne != "-1") {
- StructureInformations structInfo =
- distantStructureEnseignementService.newStructureInformations(structEns)
- // Groupe des élèves
- groupesEnDroitConsultation.addAll(
- annuaireService.getGroupeInfoElevePourStructureEnseignement(
- securiteSession,
- structInfo
- )
- )
- // Groupe des parents
- groupesEnDroitConsultation.addAll(
- annuaireService.getGroupeInfoParentsPourStructureEnseignement(
- securiteSession,
- structInfo
- )
- )
- // Groupe des enseignants
- groupesEnDroitConsultation.addAll(
- annuaireService.getGroupeInfoEnseignantPourStructureEnseignement(
- securiteSession,
- structInfo
- )
- )
- cahier.droitsIncomplets = (groupesEnDroitConsultation.size() == 0)
- } else {
- cahier.droitsIncomplets = true
- }
-
- // Liste des établissements de la même cité scolaire
- List<Etablissement> etablissementsCiteScolaire =
- citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
- structEns.etablissement
- )
-
- // Ajoute les droits à l'ensemble des établissements de la cité scolaire
- etablissementsCiteScolaire.each {Etablissement etab ->
- String idExterneEtablissement = etab.idExterne
- // Direction :
- // - droit de consultation de contenu
- // - droit de modification des droits et permissions
- GroupeInfo direction = annuaireService.getGroupeInfoDirectionForEtablissement(
- idExterneEtablissement
- )
- groupesEnDroitConsultation.add(direction)
- groupesEnDroitModificationDEP.add(direction)
- // Chef de travaux :
- // - droit de consultation de contenu
- // - droit de modification des droits et permissions
- GroupeInfo chefDeTravaux = annuaireService.getGroupeInfoChefDeTravauxForEtablissement(
- idExterneEtablissement
- )
- groupesEnDroitConsultation.add(chefDeTravaux)
- groupesEnDroitModificationDEP.add(chefDeTravaux)
- // Admins locaux :
- // - droit de consultation de contenu
- // - droit de modification des droits et permissions
- GroupeInfo adminsLocaux = annuaireService.getGroupeInfoAdminsLocauxForEtablissement(
- idExterneEtablissement
- )
- groupesEnDroitConsultation.add(adminsLocaux)
- groupesEnDroitModificationDEP.add(adminsLocaux)
- // Personnel d'éducation :
- // - droit de consultation de contenu
- groupesEnDroitConsultation << annuaireService.getGroupeInfoEducationForEtablissement(
- idExterneEtablissement
- )
- }
-
- SecuriteSession eliotTextesSecuriteSess =
- DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
- securiteSession.codePorteurENT
- )
-
- ajouteDefaultDroitConsultation(eliotTextesSecuriteSess,
- groupesEnDroitConsultation,
- cahier
- )
-
- ajouteDefaultDroitModificationDEP(eliotTextesSecuriteSess,
- groupesEnDroitModificationDEP,
- cahier
- )
- }
-
- /**
- * Attribut des droits de consultation de type par défaut
- * @param eliotTextesSecuriteSess sécurité système
- * @param groupeEnDroitConsultations liste des groupes
- * @param cahier
- * @return
- */
- private ajouteDefaultDroitConsultation(SecuriteSession eliotTextesSecuriteSess,
- List<GroupeInfo> groupeEnDroitConsultations,
- CahierDeTextes cahier) {
-
- groupeEnDroitConsultations.removeAll([null])
- List<Autorite> autoriteEnDroitConsultations =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitConsultations*.groupeId*.toString(),
- true
- )
-
- autoriteEnDroitConsultations.each {Autorite autorite ->
- PermissionsManager permManager = new DefaultPermissionsManager(cahier.item,
- autorite,
- eliotTextesSecuriteSess
- )
- permManager.addPermissionConsultationParDefaut()
- }
- }
-
- /**
- * Attribut des droits de modification des droits et permissions de type par défaut
- * @param eliotTextesSecuriteSess sécurité système
- * @param groupeEnDroitModificationDEP liste des groupes
- * @param cahier
- * @return
- */
- private ajouteDefaultDroitModificationDEP(SecuriteSession eliotTextesSecuriteSess,
- List<GroupeInfo> groupeEnDroitModificationDEP,
- CahierDeTextes cahier) {
-
- groupeEnDroitModificationDEP.removeAll([null])
- List<Autorite> autoriteEnDroitModificationDEP =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitModificationDEP*.groupeId*.toString(),
- true
- )
-
- autoriteEnDroitModificationDEP.each {Autorite autorite ->
- PermissionsManager permManager = new DefaultPermissionsManager(cahier.item,
- autorite,
- eliotTextesSecuriteSess
- )
- permManager.addPermissionModificationPermissionsParDefaut()
- }
- }
-
/**
* Méthode retournant le nom à affecter à un nouveau cahier de textes de
* service
import org.lilie.services.eliot.portail.TypeUtilisateur
import org.lilie.services.eliot.LocalAutoriteService
import org.lilie.services.eliot.securite.impl.Autorite
-import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.securite.impl.AnnuaireMode
+import org.lilie.services.eliot.securite.AnnuaireModeService
/**
* Simulateur de CAS utilisé par le mode développement
DistantDonneesPersoService distantDonneesPersoService
LilieHttpService lilieHttpService
LocalAutoriteService localAutoriteService
+ AnnuaireModeService annuaireModeService
def initialiseHttpRequestAvecLogin(def httpRequest,
String codePorteurENT,
* @return true si on est en mode annuaire local
*/
private Boolean isAnnuaireLocal(){
- AnnuaireMode annuaireMode = AnnuaireMode.valueOf(
- AnnuaireMode.class,
- ConfigurationHolder.config.eliot.annuaire.sessionAnnuaire.mode
- )
- return (annuaireMode == AnnuaireMode.LOCAL)
+ return annuaireModeService.getSessionAnnuaireMode() == AnnuaireMode.LOCAL
}
/**
import org.lilie.socle.core.utils.constantes.Constantes
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
-import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.portail.TypeUtilisateur
import org.lilie.socle.api.portail.business.PersonnePortailBusiness
import org.lilie.socle.api.annuaire.dto.PersonneDto
+import org.lilie.services.eliot.securite.AnnuaireModeService
/**
* Service de gestion des données d'authentification stockées dans les requêtes et sessions
// cas particulier des correspondants de déploiement
@SuppressWarnings('GrailsStatelessService')
PersonnePortailBusiness personnePortailBusiness
+ AnnuaireModeService annuaireModeService
/**
* Teste si un acteur est authentifié
DefaultSecuriteSessionFactory securiteSessionFactory =
new DefaultSecuriteSessionFactory(
- sessionACLmode: AnnuaireMode.valueOf(
- AnnuaireMode.class,
- ConfigurationHolder.config.eliot.annuaire.sessionACL.mode
- ),
- sessionAnnuaireMode: AnnuaireMode.valueOf(
- AnnuaireMode.class,
- ConfigurationHolder.config.eliot.annuaire.sessionAnnuaire.mode
- )
+ sessionACLmode: annuaireModeService.getSessionACLMode(),
+ sessionAnnuaireMode: annuaireModeService.getSessionAnnuaireMode()
)
SecuriteSession securiteSession =
--- /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.scolarite.annuaire
+
+import org.lilie.services.eliot.annuaire.Fonction
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.scolarite.Matiere
+import org.lilie.services.eliot.annuaire.PorteurEnt
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
+import org.lilie.services.eliot.scolarite.AnneeScolaire
+import org.lilie.services.eliot.LocalAutoriteService
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.hibernate.FetchMode
+import org.lilie.services.eliot.securite.impl.Item
+
+class LocalGroupeService {
+
+ AnneeScolaireService anneeScolaireService
+ CiteScolaireService citeScolaireService
+ ProprietesScolariteService proprietesScolariteService
+ LocalAutoriteService localAutoriteService
+ LocalStructureEnseignementService localStructureEnseignementService
+
+ /**
+ * Retourne tous les groupes auxquels la personne appartient de façon explicite
+ * et implicite (cas de parent d'élèves).
+ * @author bper
+ */
+ List<ProprietesScolarite> findAllGroupePourPersonne(Personne personne,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+
+ // Attention : dans un criteria, on ne peut pas utiliser fetch et projections
+ // car projections annule le fetch :(
+
+ List<PersonneProprietesScolarite> pps =
+ (List<PersonneProprietesScolarite>) PersonneProprietesScolarite.createCriteria().listDistinct {
+
+ fetchMode('proprietesScolarite', FetchMode.JOIN)
+ fetchMode('proprietesScolarite.autorite', FetchMode.JOIN)
+
+ eq('personne', personne)
+ eq('estActive', true)
+
+ proprietesScolarite {
+ eq('anneeScolaire', anneeScolaire)
+ }
+ }
+
+ List<ProprietesScolarite> groupesLocaux = pps.collect {it.proprietesScolarite}
+
+ // Si la personne a une fonction 'PERS_REL_ELEVE' on récupère ses groupes de
+ // parents en passant par leurs enfants.
+ if (groupesLocaux.any {it.fonction.code == FonctionEnum.PERS_REL_ELEVE.code}) {
+ List<StructureEnseignement> structures =
+ localStructureEnseignementService.findAllStructureEnseignementPourResponsableEleve(personne)
+
+ if (structures) {
+ List<ProprietesScolarite> groupesParents =
+ ProprietesScolarite.createCriteria().list {
+ 'in'('structureEnseignement', structures)
+ fonction {
+ eq('code', FonctionEnum.PERS_REL_ELEVE.code)
+ }
+
+ fetchMode('autorite', FetchMode.JOIN)
+ }
+
+ groupesLocaux.addAll(groupesParents)
+ }
+ }
+
+ return groupesLocaux
+ }
+
+
+ ProprietesScolarite findOrCreeGroupeDeDirection(Etablissement etablissement) {
+ return findOrCreeGroupeEtablissement(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.DIRECTION.code)
+ )
+ }
+
+ List<ProprietesScolarite> findOrCreeGroupeDeDirectionCiteScolaire(Etablissement etablissement) {
+ return findOrCreeAllGroupeEtablissementCiteScolaire(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.DIRECTION.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDeChefDeTravaux(Etablissement etablissement) {
+ return findOrCreeGroupeEtablissement(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.CHEF_TRAVAUX.code)
+ )
+ }
+
+ List<ProprietesScolarite> findOrCreeGroupeDeChefDeTravauxCiteScolaire(Etablissement etablissement) {
+ return findOrCreeAllGroupeEtablissementCiteScolaire(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.CHEF_TRAVAUX.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDAdminLocal(Etablissement etablissement) {
+ return findOrCreeGroupeEtablissement(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.ADMIN_LOCAL.code)
+ )
+ }
+
+ List<ProprietesScolarite> findOrCreeGroupeDAdminLocalCiteScolaire(Etablissement etablissement) {
+ return findOrCreeAllGroupeEtablissementCiteScolaire(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.ADMIN_LOCAL.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDEducation(Etablissement etablissement) {
+ return findOrCreeGroupeEtablissement(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.EDUCATION.code)
+ )
+ }
+
+ List<ProprietesScolarite> findOrCreeGroupeDEducationCiteScolaire(Etablissement etablissement) {
+ return findOrCreeAllGroupeEtablissementCiteScolaire(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.EDUCATION.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDeDocumentaliste(Etablissement etablissement) {
+ return findOrCreeGroupeEtablissement(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.DOCUMENTALISTE.code)
+ )
+ }
+
+ List<ProprietesScolarite> findOrCreeGroupeDeDocumentalisteCiteScolaire(Etablissement etablissement) {
+ return findOrCreeAllGroupeEtablissementCiteScolaire(
+ etablissement,
+ Fonction.findByCode(FonctionEnum.DOCUMENTALISTE.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDEleves(StructureEnseignement structureEnseignement) {
+ return findOrCreeGroupeStructureEnseignement(
+ structureEnseignement,
+ Fonction.findByCode(FonctionEnum.ELEVE.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDeParents(StructureEnseignement structureEnseignement) {
+ return findOrCreeGroupeStructureEnseignement(
+ structureEnseignement,
+ Fonction.findByCode(FonctionEnum.PERS_REL_ELEVE.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDEnseignants(StructureEnseignement structureEnseignement) {
+ return findOrCreeGroupeStructureEnseignement(
+ structureEnseignement,
+ Fonction.findByCode(FonctionEnum.ENSEIGNANT.code)
+ )
+ }
+
+ ProprietesScolarite findOrCreeGroupeDEnseignantsPrincipaux(StructureEnseignement structureEnseignement) {
+ return findOrCreeGroupeStructureEnseignement(
+ structureEnseignement,
+ Fonction.findByCode(FonctionEnum.ENSEIGNANT.code),
+ true
+ )
+ }
+
+
+ List<ProprietesScolarite> findOrCreeAllGroupeEnseignantForStructureGroupe(StructureEnseignement structureEnseignement) {
+ return findOrCreeAllGroupeEnseignantForStructureGroupe(structureEnseignement, null)
+ }
+
+ List<ProprietesScolarite> findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(StructureEnseignement structureEnseignement) {
+ return findOrCreeAllGroupeEnseignantForStructureGroupe(structureEnseignement, true)
+ }
+
+ private List<ProprietesScolarite> findOrCreeAllGroupeEnseignantForStructureGroupe(StructureEnseignement structureEnseignement,
+ Boolean isResponsable) {
+ if (structureEnseignement.type != StructureEnseignement.TYPE_GROUPE) {
+ throw new IllegalArgumentException("La structure d'enseignement doit être de type groupe !")
+ }
+ List<StructureEnseignement> classes = structureEnseignement.classes?.toList()
+
+ if (!classes || classes.isEmpty()) {
+ throw new IllegalStateException("""Les structures d'enseignement de type Groupe doivent toujours être
+ liées à une liste de classes. Or, le groupe d'id ${structureEnseignement.id} ne l'est pas.""")
+ }
+
+ List<ProprietesScolarite> psList = []
+
+ // Ajoute les groupes d'enseignants de toutes les classes qui composent le GROUPE
+ classes.each { StructureEnseignement classe ->
+ psList << findOrCreeGroupeStructureEnseignement(
+ classe,
+ Fonction.findByCode(FonctionEnum.ENSEIGNANT.code),
+ isResponsable
+ )
+ }
+
+ if (!isResponsable) {
+ // Ajoute le groupe d'enseignants du GROUPE lui meme
+ psList << findOrCreeGroupeStructureEnseignement(
+ structureEnseignement,
+ Fonction.findByCode(FonctionEnum.ENSEIGNANT.code),
+ isResponsable
+ )
+ }
+
+ return psList
+ }
+
+ private ProprietesScolarite findOrCreeGroupeStructureEnseignement(StructureEnseignement structureEnseignement,
+ Fonction fonction,
+ Boolean isResponsable = null
+ ) {
+
+ if (!structureEnseignement || !fonction) {
+ log.error("""L'appel à la méthode findGroupeStructureEnseignement doit passer
+ en paramètres une structure d'enseignement et une fonction""")
+ return null
+ }
+
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ structureEnseignement: structureEnseignement,
+ fonction: fonction,
+ responsableStructureEnseignement: isResponsable
+ )
+
+ ProprietesScolarite ps = proprietesScolariteService.findOrCreePS(paramPs)
+
+ localAutoriteService.getAutoriteGroupeLocal(ps, true)
+
+ return ps
+
+ }
+
+ private ProprietesScolarite findOrCreeGroupeEtablissement(Etablissement etablissement,
+ Fonction fonction,
+ Matiere matiere = null
+ ) {
+
+ if (!etablissement || !fonction) {
+ log.error("""L'appel à la méthode findOrCreeGroupeEtablissement doit passer
+ en paramètres un établissement et une fonction""")
+ return null
+ }
+
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ etablissement: etablissement,
+ fonction: fonction,
+ matiere: matiere
+ )
+
+ ProprietesScolarite ps = proprietesScolariteService.findOrCreePS(paramPs)
+
+ localAutoriteService.getAutoriteGroupeLocal(ps, true)
+
+ return ps
+
+ }
+
+ private List<ProprietesScolarite> findOrCreeAllGroupeEtablissementCiteScolaire(Etablissement etablissement,
+ Fonction fonction,
+ Matiere matiere = null
+ ) {
+
+ if (!etablissement || !fonction) {
+ log.error("""L'appel à la méthode findOrCreeAllGroupeEtablissementCiteScolaire doit passer
+ en paramètres un établissement et une fonction""")
+ return null
+ }
+
+ // etab + fonction + matiere -> une seule PS
+
+ List<Etablissement> etablissements =
+ citeScolaireService.findAllEtablissementBySameCiteScolaireFor(etablissement)
+
+ AnneeScolaire anneeEnCours = anneeScolaireService.anneeScolaireEnCours()
+
+ List<ProprietesScolarite> psList =
+ (List<ProprietesScolarite>) ProprietesScolarite.createCriteria().list {
+ eq('anneeScolaire', anneeEnCours)
+ eq('fonction', fonction)
+ if (matiere) {
+ eq('matiere', matiere)
+ } else {
+ isNull('matiere')
+ }
+ 'in'('etablissement', etablissements)
+ }
+
+ // vérifier que les groupes trouvés soient liés à une autorité de type groupe
+ psList.each {
+ localAutoriteService.getAutoriteGroupeLocal(it, true)
+ }
+
+ // S'il n'y a pas autant de groupes que d'établissements, cela signifie que
+ // certains établissements n'ont pas de groupe correspondant à la fonction
+ // et la matière passées en paramètres.
+ // Il faut alors créer ces groupes
+
+ List<Etablissement> etablissementsAvecGroupe =
+ psList.collect {it.etablissement}
+ List<Etablissement> etablissementsSansGroupe =
+ etablissements - etablissementsAvecGroupe
+
+ if (etablissementsSansGroupe.size() > 0) {
+
+ List<ProprietesScolarite> nouvellesPs = []
+
+ etablissementsSansGroupe.each { Etablissement etablissementSansGroupe ->
+ ProprietesScolariteParam psParam = new ProprietesScolariteParam(
+ anneeScolaire: anneeEnCours,
+ etablissement: etablissementSansGroupe,
+ fonction: fonction,
+ matiere: matiere
+ )
+ ProprietesScolarite ps = proprietesScolariteService.creePS(psParam)
+
+ localAutoriteService.getAutoriteGroupeLocal(ps, true)
+
+ nouvellesPs.add(ps)
+ }
+
+ psList.addAll(nouvellesPs)
+
+ }
+
+ return psList
+
+ }
+
+ private ProprietesScolarite findOrCreeGroupePorteurEnt(PorteurEnt porteurEnt,
+ Fonction fonction
+ ) {
+
+ if (!porteurEnt || !fonction) {
+ log.error("""L'appel à la méthode findOrCreeGroupePorteurEnt doit passer
+ en paramètres un porteurEnt et une fonction""")
+ return null
+ }
+
+ ProprietesScolariteParam paramPs = new ProprietesScolariteParam(
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ porteurEnt: porteurEnt,
+ fonction: fonction
+ )
+
+ ProprietesScolarite ps = proprietesScolariteService.findOrCreePS(paramPs)
+
+ localAutoriteService.getAutoriteGroupeLocal(ps, true)
+
+ return ps
+
+ }
+
+ /*
+ Retourne les groupes locaux auxquels l'item est partagé
+ */
+ List<ProprietesScolarite> findAllGroupeLocalAvecAutorisationParDefaut(Item item) {
+
+ String hql = """
+ select groupe
+ from ProprietesScolarite as groupe
+ left join fetch groupe.structureEnseignement
+ left join fetch groupe.etablissement
+ left join fetch groupe.fonction,
+ Autorisation as autorisation
+ where groupe.autorite = autorisation.autorite
+ and autorisation.item = :item
+ and autorisation.valeurPermissionsExpliciteDefaut != 0
+ """
+
+ return ProprietesScolarite.executeQuery(hql, [item: item])
+ }
+
+}
eq('structureEnseignement', param.structureEnseignement)
} else if (param.etablissement != null) {
eq('etablissement', param.etablissement)
+ } else if (param.porteurEnt != null) {
+ eq('porteurEnt', param.porteurEnt)
}
if (param.matiere != null) {
if (param.responsableStructureEnseignement != null) {
eq('responsableStructureEnseignement', param.responsableStructureEnseignement)
+ } else {
+ isNull('responsableStructureEnseignement')
}
}
}
* Crée un nouveau PS à partir des paramètres donnés.
* @author bper
*/
- private ProprietesScolarite creePS(ProprietesScolariteParam param) {
+ public ProprietesScolarite creePS(ProprietesScolariteParam param) {
ProprietesScolarite ps = new ProprietesScolarite(
etablissement: param.etablissement,
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.annuaire.AnnuaireService
import org.lilie.services.eliot.annuaire.GroupeInfo
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.securite.AnnuaireModeService
/**
* Service de récupération du nom d'affichage d'une autorité
LocalPersonneService localPersonneService
AnnuaireService annuaireService
+ AnnuaireModeService annuaireModeService
/**
* Retourne le nom d'affichage d'une autorité
*/
public String getNomAffichageAutoriteGroupe(Autorite autorite,
Boolean withMEF = false) {
- if (autorite.type != Autorite.TYPE_GROUPE) {
+ if (
+ autorite.type != Autorite.TYPE_GROUPE ||
+ autorite.localisation == null
+ ) {
throw new IllegalArgumentException(
"L'autorite $autorite n'est pas de type Groupe"
)
}
- if (isACLModeLocal()) {
+ if (autorite.localisation == Autorite.LOCALISATION_LOCALE) {
+ return getNomAffichageAutoriteGroupeLocal(autorite)
+ }
+ else {
+ return getNomAffichageAutoriteGroupeDistant(autorite, withMEF)
+ }
+ }
+
+ /**
+ * Retourne le nom d'affichage d'une autorité de type Groupe local
+ * @param autorite
+ * @return
+ * @author bahj
+ */
+ private String getNomAffichageAutoriteGroupeLocal(Autorite autorite) {
+
+ String nom = null
+ ProprietesScolarite ps = ProprietesScolarite.findByAutorite(autorite)
+
+ if (!ps) {
throw new IllegalStateException(
- "Méthode non implémentée pour l'annuaire local"
+ """L'autorité n'est pas de type groupe local,
+ elle n'est attachée à aucune proprièté de scolarité"""
)
}
- else {
- String result
- GroupeInfo groupe = annuaireService.getGroupeInfo(autorite.idExterne)
- if (groupe) {
- result = groupe.titre
- if (withMEF && groupe.mef) {
- result += (' - ' + groupe.mef)
+ if (!ps.fonction) {
+ throw new IllegalStateException(
+ """L'autorité n'est pas attachée à un groupe de scolarité,
+ aucune fonction"""
+ )
+ }
+ switch (ps.fonction.code) {
+ case FonctionEnum.ELEVE.getCode():
+ nom = "Elèves ($ps.structureEnseignement.code)"
+ break
+ case FonctionEnum.PERS_REL_ELEVE.getCode():
+ nom = "Parents ($ps.structureEnseignement.code)"
+ break
+ case FonctionEnum.ENSEIGNANT.getCode():
+ if (ps.responsableStructureEnseignement) {
+ nom = "Enseignants Principaux ($ps.structureEnseignement.code)"
+ }
+ else {
+ nom = "Enseignants ($ps.structureEnseignement.code)"
}
- } else {
- result = autorite.idExterne
+ break
+ case FonctionEnum.DIRECTION.getCode():
+ nom = "Personnel de l'établissement (DIRECTION)"
+ break
+ case FonctionEnum.EDUCATION.getCode():
+ nom = "Personnel de l'établissement (EDUCATION)"
+ break
+ case FonctionEnum.DOCUMENTALISTE.getCode():
+ nom = "Personnel de l'établissement (DOCUMENTATION)"
+ break
+ case FonctionEnum.ADMIN_LOCAL.getCode():
+ nom = "Administrateur local de l'établissement"
+ break
+ case FonctionEnum.CHEF_TRAVAUX.getCode():
+ nom = "Chef de travaux de l'établissement"
+ break
+ }
+ return nom
+ }
+
+ /**
+ * Retourne le nom d'affichage d'une autorité de type Groupe distant
+ * @param autorite
+ * @return
+ * @author bahj
+ */
+ private String getNomAffichageAutoriteGroupeDistant(Autorite autorite, Boolean withMEF) {
+ String result
+ GroupeInfo groupe = annuaireService.getGroupeInfo(autorite.idExterne)
+ if (groupe) {
+ result = groupe.titre
+ if (withMEF && groupe.mef) {
+ result += (' - ' + groupe.mef)
}
- return result
+ } else {
+ result = autorite.idExterne
}
+ return result
}
/**
}
private boolean isAnnuaireModeLocal() {
- def mode = ConfigurationHolder.config.eliot.annuaire.sessionAnnuaire.mode
-
- return mode == AnnuaireMode.LOCAL.toString()
+ return annuaireModeService.getSessionAnnuaireMode() == AnnuaireMode.LOCAL
}
private boolean isACLModeLocal() {
- def mode = ConfigurationHolder.config.eliot.annuaire.sessionACL.mode
-
- return mode == AnnuaireMode.LOCAL.toString()
+ return annuaireModeService.getSessionACLMode() == AnnuaireMode.LOCAL
}
}
import org.lilie.services.eliot.scolarite.Enseignement
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.scolarite.Etablissement
+
import org.lilie.services.eliot.scolarite.OrigineEnum
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
}
/**
- * Crée un PPS correspondant à l'enseignement donné s'il n'en existe pas.
+ * Ajoute l'enseignant dans les groupes d'enseignants correspondant à l'enseignement.
* @author bper
*/
void ajouteEnseignantDansAllGroupeParEnseignement(Enseignement enseignement) {
- ajouteEnseignantDansGroupeEnseignantStructure(enseignement)
+ ajouteEnseignantDansAllGroupeEnseignantStructure(enseignement)
ajouteEnseignantDansGroupeEnseignantMaitiereEtab(enseignement)
}
- private void ajouteEnseignantDansGroupeEnseignantStructure(Enseignement enseignement) {
- PersonneProprietesScolariteParam param = initPpsParamEnseignantDansStructure(enseignement)
- personneProprietesScolariteService.findOrCreePPS(param)
+ /**
+ * Ajoute l'enseignant dans le groupe de la structure d'enseignement elle meme et
+ * dans le cas de structure d'enseignement de type 'GROUPE' l'ajoute dans toutes
+ * le classes qui composent ce groupe.
+ */
+ private void ajouteEnseignantDansAllGroupeEnseignantStructure(Enseignement enseignement) {
+ List<PersonneProprietesScolariteParam> params = initAllPpsParamEnseignantDansStructure(enseignement)
+ params.each {personneProprietesScolariteService.findOrCreePPS(it)}
}
private void ajouteEnseignantDansGroupeEnseignantMaitiereEtab(Enseignement enseignement) {
desactiveEnseignantDansGroupeEnseignantMaitiereEtab(enseignement)
}
+ /**
+ * Désactive l'enseignant dans le structure d'enseignement elle meme est dans le cas de
+ * classe le désactive aussi dans les groupes de la classe à condition
+ * qu'il n'existe pas d'autres enseignements du meme prof dans la meme structure
+ * ou dans un groupe lié au structure.
+ */
private void desactiveEnseignantDansGroupeEnseignantStructure(Enseignement enseignement) {
- if (!autreEnseignementAvecMemeEnseignantStructureExiste(enseignement)) {
- PersonneProprietesScolariteParam param = initPpsParamEnseignantDansStructure(enseignement)
- personneProprietesScolariteService.desactiveAllPPS(param)
+ List<PersonneProprietesScolariteParam> params = initAllPpsParamEnseignantDansStructure(enseignement)
+ params.each {
+ if (!autreEnseignementAvecMemeEnseignantEtStructuresExiste(
+ enseignement,
+ it.proprietesScolariteParam.structureEnseignement)
+ ) {
+ personneProprietesScolariteService.desactiveAllPPS(it)
+ }
}
}
- private Boolean autreEnseignementAvecMemeEnseignantStructureExiste(Enseignement enseignement) {
+ private Boolean autreEnseignementAvecMemeEnseignantEtStructuresExiste(Enseignement enseignement,
+ StructureEnseignement structure) {
+
+ List<StructureEnseignement> structures = structure.isClasse() ?
+ (List<StructureEnseignement>) (structure.groupes.toList() + structure) : [structure]
+
Enseignement.createCriteria().count {
eq('enseignant', enseignement.enseignant)
service {
- eq('structureEnseignement', enseignement.service.structureEnseignement)
+ 'in'('structureEnseignement', structures)
}
ne('id', enseignement.id)
maxResults(1)
}
/**
- * Instancie le DTO PersonneProprietesScolariteParam à partir de l'enseignement donné.
+ * Instancie la liste DTO PersonneProprietesScolariteParam à partir de l'enseignement donné.
* @author bper
*/
- private PersonneProprietesScolariteParam initPpsParamEnseignantDansStructure(Enseignement enseignement) {
+ private List<PersonneProprietesScolariteParam> initAllPpsParamEnseignantDansStructure(Enseignement enseignement) {
Personne enseignant =
localPersonneService.findPersonneByAutorite(enseignement.enseignant)
StructureEnseignement structure = enseignement.service.structureEnseignement
- return new PersonneProprietesScolariteParam(
- personne: enseignant,
- origine: enseignement.origine,
- proprietesScolariteParam: new ProprietesScolariteParam(
- fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
- structureEnseignement: structure,
- anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
- )
- )
+ List<StructureEnseignement> structures = structure.isGroupe() ?
+ (List<StructureEnseignement>) (structure.classes.toList() + structure) : [structure]
+
+ return structures.collect {
+ new PersonneProprietesScolariteParam(
+ personne: enseignant,
+ origine: enseignement.origine,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ structureEnseignement: it,
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ )
+ )
+ }
}
/**
} as Boolean
}
+
+ /**
+ * Retourne toutes les structures d'enseignement auxquelles les élèves
+ * dont la personne est responsable sont attachés.
+ */
+ List<StructureEnseignement> findAllStructureEnseignementPourResponsableEleve(Personne personne) {
+ String hql = """
+ select distinct ps.structureEnseignement
+ from
+ ResponsableEleve re,
+ PersonneProprietesScolarite pps
+ join pps.proprietesScolarite ps
+ join ps.fonction f
+ where
+ pps.personne = re.eleve and
+ pps.estActive = true and
+ f.code = 'ELEVE' and
+ ps.structureEnseignement is not null and
+ re.estActive = true and
+ re.personne = :personne
+ """
+
+ return StructureEnseignement.executeQuery(hql, [personne: personne])
+ }
+
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
+ * This file is part of L'Interface Libre et Interactive de l'Enseignement (Lilie).
+ *
+ * Lilie is free software. You can redistribute it and/or modify since
+ * you respect the terms of either (at least one of the both license) :
+ * - under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * - the CeCILL-C as published by CeCILL-C; either version 1 of the
+ * License, or any later version
+ *
+ * There are special exceptions to the terms and conditions of the
+ * licenses as they are applied to this software. View the full text of
+ * the exception in file LICENSE.txt in the directory of this software
+ * distribution.
+ *
+ * Lilie is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Licenses for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the CeCILL-C along with Lilie. If not, see :
+ * <http://www.gnu.org/licenses/> and
+ * <http://www.cecill.info/licences.fr.html>.
+ */
+
+package org.lilie.services.eliot.securite
+
+import org.lilie.services.eliot.securite.impl.AnnuaireMode
+import org.codehaus.groovy.grails.commons.DefaultGrailsApplication
+import org.lilie.services.eliot.applications.ModuleEliot
+
+class AnnuaireModeService {
+
+ static transactional = false
+
+ @SuppressWarnings('GrailsStatelessService')
+ DefaultGrailsApplication grailsApplication
+
+ AnnuaireMode getSessionACLMode() {
+ return getModuleEliot().getSessionACLMode()
+ }
+
+ AnnuaireMode getSessionAnnuaireMode() {
+ return getModuleEliot().getSessionAnnuaireMode()
+ }
+
+ private ModuleEliot getModuleEliot() {
+ String appName = grailsApplication.getMetadata().get('app.name')
+ ModuleEliot app = ModuleEliot.parseByNom(appName)
+
+ if (!app) {
+ throw new IllegalStateException("Le module $appName est inconnu")
+ }
+
+ return app
+ }
+}
--- /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.securite.permission
+
+import org.lilie.services.eliot.annuaire.StructureInformations
+import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
+import org.lilie.services.eliot.annuaire.AnnuaireService
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
+import org.lilie.services.eliot.scolarite.Etablissement
+
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.annuaire.GroupeInfo
+import org.lilie.services.eliot.DistantAutoriteService
+import org.lilie.services.eliot.securite.impl.Autorisation
+import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.OperationMaintenance
+
+abstract class AbstractMigraionPartgasService {
+
+ static transactional = false
+
+ DistantStructureEnseignementService distantStructureEnseignementService
+ AnnuaireService annuaireService
+ DistantAutoriteService distantAutoriteService
+
+
+ protected Boolean dejaExecute(String codeOperation) {
+ OperationMaintenance.createCriteria().count {
+ eq('code', codeOperation)
+ eq('etat', OperationMaintenance.ETAT_TERMINE)
+ } as Boolean
+ }
+
+
+ protected void marqueFinOperation(String codeOperation) {
+ OperationMaintenance operation =
+ (OperationMaintenance) OperationMaintenance.createCriteria().get {
+ eq('code', codeOperation)
+ }
+
+ if (!operation) {
+ operation = new OperationMaintenance(code: codeOperation)
+ }
+
+ operation.etat = OperationMaintenance.ETAT_TERMINE
+ operation.save(failOnError: true)
+ }
+
+
+ protected void migrePermissionsExistantesSurGroupesLocaux(SecuriteSession securiteSession,
+ Item item) {
+
+ List<ProprietesScolarite> groupesLocaux = findAllGroupeLocalAvecAutorisationParDefaut(item)
+
+ groupesLocaux.each {ProprietesScolarite groupeLocal ->
+
+ switch (groupeLocal.fonction.code) {
+ case FonctionEnum.ELEVE.code :
+ copiePermissionsGroupeEleves(securiteSession, groupeLocal, item)
+ break
+
+ case FonctionEnum.PERS_REL_ELEVE.code :
+ copiePermissionsGroupeParents(securiteSession, groupeLocal, item)
+ break
+
+ case FonctionEnum.ENSEIGNANT.code :
+ if (groupeLocal.responsableStructureEnseignement) {
+ copiePermissionsGroupeEnseignantsPrincipaux(securiteSession, groupeLocal, item)
+ } else {
+ copiePermissionsGroupeEnseignants(securiteSession, groupeLocal, item)
+ }
+ break
+
+ case FonctionEnum.DIRECTION.code :
+ copiePermissionsGroupeDirecteurs(groupeLocal, item)
+ break
+
+ case FonctionEnum.EDUCATION.code :
+ copiePermissionsGroupeEducations(groupeLocal, item)
+ break
+
+ case FonctionEnum.DOCUMENTALISTE.code :
+ copiePermissionsGroupeDocumentalistes(groupeLocal, item)
+ break
+
+ case FonctionEnum.ADMIN_LOCAL.code :
+ copiePermissionsGroupeAdminsLocaux(groupeLocal, item)
+ break
+
+ case FonctionEnum.CHEF_TRAVAUX.code :
+ copiePermissionsGroupeChefsTravaux(groupeLocal, item)
+ break
+ }
+ }
+
+ supprimeAllAutorisationParDefautGroupesDistants(item)
+ }
+
+
+ protected List<ProprietesScolarite> findAllGroupeLocalAvecAutorisationParDefaut(Item item) {
+
+ String hql = """
+ select groupe
+ from ProprietesScolarite as groupe
+ left join fetch groupe.structureEnseignement
+ left join fetch groupe.etablissement
+ left join fetch groupe.fonction,
+ Autorisation as autorisation
+ where groupe.autorite = autorisation.autorite
+ and autorisation.item = :item
+ and autorisation.valeurPermissionsExpliciteDefaut != 0
+ """
+
+ return ProprietesScolarite.executeQuery(hql, [item: item])
+ }
+
+
+ protected void copiePermissionsGroupeEleves(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal,
+ Item item) {
+
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ List<GroupeInfo> groupeDistants =
+ annuaireService.getGroupeInfoElevePourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+
+ copiePermissionsFromGroupesDistants(groupeLocal, groupeDistants, item)
+ }
+
+
+ protected void copiePermissionsGroupeParents(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal,
+ Item item) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ List<GroupeInfo> groupeDistants =
+ annuaireService.getGroupeInfoParentsPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+
+ copiePermissionsFromGroupesDistants(groupeLocal, groupeDistants, item)
+ }
+
+
+ protected void copiePermissionsGroupeEnseignantsPrincipaux(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal,
+ Item item) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ List<GroupeInfo> groupeDistants =
+ annuaireService.getGroupeInfoProfPrincipauxPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+
+ copiePermissionsFromGroupesDistants(groupeLocal, groupeDistants, item)
+ }
+
+
+ protected void copiePermissionsGroupeEnseignants(SecuriteSession securiteSession,
+ ProprietesScolarite groupeLocal,
+ Item item) {
+
+ StructureInformations structureInfo =
+ distantStructureEnseignementService.
+ newStructureInformations(groupeLocal.structureEnseignement)
+
+ List<GroupeInfo> groupeDistants =
+ annuaireService.getGroupeInfoEnseignantPourStructureEnseignement(
+ securiteSession,
+ structureInfo
+ )
+
+ copiePermissionsFromGroupesDistants(groupeLocal, groupeDistants, item)
+ }
+
+
+ protected void copiePermissionsGroupeDirecteurs(ProprietesScolarite groupeLocal,
+ Item item) {
+
+ GroupeInfo groupeDistant =
+ annuaireService.getGroupeInfoDirectionForEtablissement(
+ groupeLocal.etablissement.idExterne)
+
+ copiePermissionsFromGroupesDistants(groupeLocal, [groupeDistant], item)
+ }
+
+
+ protected void copiePermissionsGroupeEducations(ProprietesScolarite groupeLocal,
+ Item item) {
+
+ GroupeInfo groupeDistant =
+ annuaireService.getGroupeInfoEducationForEtablissement(
+ groupeLocal.etablissement.idExterne)
+
+ copiePermissionsFromGroupesDistants(groupeLocal, [groupeDistant], item)
+ }
+
+
+ protected void copiePermissionsGroupeDocumentalistes(ProprietesScolarite groupeLocal,
+ Item item) {
+
+ GroupeInfo groupeDistant =
+ annuaireService.getGroupeInfoDocumentationForEtablissement(
+ groupeLocal.etablissement.idExterne)
+
+ copiePermissionsFromGroupesDistants(groupeLocal, [groupeDistant], item)
+ }
+
+
+ protected void copiePermissionsGroupeAdminsLocaux(ProprietesScolarite groupeLocal,
+ Item item) {
+
+ GroupeInfo groupeDistant =
+ annuaireService.getGroupeInfoAdminsLocauxForEtablissement(
+ groupeLocal.etablissement.idExterne)
+
+ copiePermissionsFromGroupesDistants(groupeLocal, [groupeDistant], item)
+ }
+
+
+ protected void copiePermissionsGroupeChefsTravaux(ProprietesScolarite groupeLocal,
+ Item item) {
+
+ GroupeInfo groupeDistant =
+ annuaireService.getGroupeInfoChefDeTravauxForEtablissement(
+ groupeLocal.etablissement.idExterne)
+
+ copiePermissionsFromGroupesDistants(groupeLocal, [groupeDistant], item)
+ }
+
+
+ protected void copiePermissionsFromGroupesDistants(ProprietesScolarite groupeLocal,
+ List<GroupeInfo> groupesDistants,
+ Item item) {
+
+ Autorisation autorisationGroupeLocal =
+ Autorisation.findByAutoriteAndItem(groupeLocal.autorite, item)
+
+ List<Autorite> autoriteGroupeDistants =
+ distantAutoriteService.getAutoritesForTypeAndIdExterne(
+ Autorite.TYPE_GROUPE,
+ groupesDistants*.groupeId*.toString(),
+ false
+ )
+
+ copiePermissionsFromAutorites(autorisationGroupeLocal, autoriteGroupeDistants)
+ }
+
+
+ protected void copiePermissionsFromAutorites(Autorisation autorisationCible,
+ List<Autorite> autoriteSources) {
+
+ if (!autoriteSources) {
+ return
+ }
+
+ List<Autorisation> autorisationSources =
+ findAllAutorisationByAutoritesAndItem(
+ autoriteSources,
+ autorisationCible.item
+ )
+
+ int valeurMaxGroupeDistant = autorisationSources*.valeurPermissionsExplicite.max()
+
+ if (valeurMaxGroupeDistant &&
+ valeurMaxGroupeDistant > autorisationCible.valeurPermissionsExplicite) {
+
+ autorisationCible.valeurPermissionsExplicite = valeurMaxGroupeDistant
+ autorisationCible.save(failOnError: true)
+ }
+ }
+
+
+ protected void supprimeAllAutorisationParDefautGroupesDistants(Item item) {
+
+ List<Autorisation> autorisations = Autorisation.createCriteria().list {
+ eq('item', item)
+ ne('valeurPermissionsExpliciteDefaut', 0)
+ autorite {
+ eq('localisation', Autorite.LOCALISATION_DISTANTE)
+ eq('type', 'groupe')
+ }
+ }
+
+ autorisations.each {
+ it.item.removeFromAutorisations(it)
+ it.delete()
+ }
+ }
+
+
+ protected List<Autorisation> findAllAutorisationByAutoritesAndItem(List<Autorite> autorites,
+ Item item) {
+ if (!autorites) {
+ return []
+ }
+
+ return Autorisation.createCriteria().list {
+ 'in'('autorite', autorites)
+ eq('item', item)
+ }
+ }
+
+
+ protected SecuriteSession getSecuriteSessionSystem(Etablissement etablissement) {
+ return DefaultSecuriteSessionFactory.
+ getEliotTextesSecuriteSessionForCodePorteurENT(etablissement.porteurEnt.code)
+ }
+}
--- /dev/null
+package org.lilie.services.eliot.securite.permission
+
+import org.lilie.services.eliot.securite.impl.Autorite
+
+/**
+ * Reprèsente un droit sur un item
+ * @author bahj
+ */
+public class Droit {
+
+ String type
+ String nomAutorite
+ String autoriteIdExterne
+ String groupeLocalisation = null
+ Long autoriteIdInterne
+ Autorite autorite
+
+ Boolean consultation = false
+ Boolean modification = false
+ Boolean consultationParDefaut = false
+ Boolean modificationParDefaut = false
+
+ Boolean estDansAnnuaireEliot = true
+ // si l'autorite est le proprietaire d'item
+ Boolean estProprietaire = false
+
+ String getEntreeId() {
+ return "$type;idExterne=$autoriteIdExterne;idInterne=$autoriteIdInterne;localisation=$groupeLocalisation"
+ }
+}
\ No newline at end of file
+++ /dev/null
-package org.lilie.services.eliot.securite.permission
-
-import org.lilie.services.eliot.DistantAutoriteService
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.temps.TempsSecuriteService
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.securite.AutorisationException
-import org.lilie.services.eliot.securite.AccessManager
-import org.lilie.services.eliot.annuaire.AnnuaireService
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.securite.impl.Item
-import org.lilie.services.eliot.securite.Permission
-import org.lilie.services.eliot.securite.impl.Autorisation
-import org.lilie.services.eliot.scolarite.personne.AutoriteNomAffichageService
-import org.lilie.services.eliot.droits.Droit
-
-/**
- * Gestion des droits et permissions des groupes et utilisateurs sur les items
- * @author othe
- */
-class DroitsEtPermissionsService {
-
- public static final String TYPE_GROUPE = 'g'
- public static final String TYPE_ACTEUR = 'u'
-
- DistantAutoriteService distantAutoriteService
- AnnuaireService annuaireService
- LocalPersonneService localPersonneService
- AutoriteNomAffichageService autoriteNomAffichageService
-
- /**
- * Retourne la liste des autorités par rapport à une liste d'id
- * externes
- * @param ids : idExternes
- * @param paramType
- * @return
- */
- public List<Autorite> getListeAutorites(String ids, String paramType) {
- // On reçoit une liste d'ids de groupes ou d'users
- List idsExternes = (ids && ids != "\"\"") ? (List) (ids)?.split(",") : []
- String type
-
- if (paramType == 'g') {
- type = Autorite.TYPE_GROUPE
- } else {
- type = Autorite.TYPE_ACTEUR
- }
-
- List<Autorite> autorites = distantAutoriteService.getAutoritesForTypeAndIdExterne(
- type,
- idsExternes,
- true
- )
-
- return autorites
-
- }
-
- /**
- * Recoupere la liste des droits des acteurs d'un cdt
- * @return une liste d'objets <code>Droit</code>
- */
- public List<Droit> chargeDroitsActeursItem(Item item,
- SecuriteSession securiteSession) {
-
- verificationAutorisationConsultationDroits(item, securiteSession)
- List<Droit> droits = []
- if (item) {
- List<Autorisation> autos = item.findAllActeurAutorisations()
- autos.each {Autorisation autorisation ->
-
- Autorite autorite = autorisation.autorite
- String nomAutorite = localPersonneService.getNomAffichage(autorite)
- Boolean estDansAnnuaireEliot = true
-
- // le cas ou la personne n'extiste pas dans l'annuaire eliot, mais est
- // present dans l'annuaire logica
- if (nomAutorite == null) {
- nomAutorite = annuaireService.getPersonneNomAffichage(
- autorite.idExterne
- )
- estDansAnnuaireEliot = false
- }
-
- droits.add(new Droit(
- type: TYPE_ACTEUR,
- nomAutorite: nomAutorite,
- consultation: autorisation.autoriseConsulterLeContenu(),
- consultationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_CONSULTER_CONTENU),
- modification: autorisation.autoriseModifierLeContenu(),
- modificationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_MODIFIER_CONTENU),
- idAutorite: autorite.idExterne,
- estDansAnnuaireEliot: estDansAnnuaireEliot,
- estProprietaire: autorisation.proprietaire
-
- ))
- }
- }
- return droits
- }
-
- public void verificationAutorisationConsultationDroits(Item item,
- SecuriteSession securiteSession) {
- AccessManager accessManager = new AccessManager(item, securiteSession)
- if (!accessManager.peutConsulterLesPermissions()) {
- throw AutorisationException.consultationPermissionsException()
- }
- }
-
- /**
- * Recoupere la liste des droits des groupes d'un cdt
- * @return une liste d'objets <code>Droit</code>
- */
- List<Droit> chargeDroitsGroupes(Item item,
- SecuriteSession securiteSession) {
- verificationAutorisationConsultationDroits(item, securiteSession)
- List<Droit> droits = []
-
- if (item) {
- List<Autorisation> autos = item.findAllGroupeAutorisations()
- autos.each {Autorisation autorisation ->
-
- Autorite autorite = autorisation.autorite
- droits.add(new Droit(
- type: TYPE_GROUPE,
- nomAutorite: autoriteNomAffichageService.
- getNomAffichageAutoriteGroupe(autorite, true),
- idAutorite: autorite.getIdExterne(),
- consultation: autorisation.autoriseConsulterLeContenu(),
- consultationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_CONSULTER_CONTENU),
- modification: autorisation.autoriseModifierLeContenu(),
- modificationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_MODIFIER_CONTENU),
- ))
- }
- }
-
- return droits
- }
-
- /**
- * Trie les droits d'acteurs.
- * Le proprietaire le premiere, apres tries par l'ordre alphabetique.
- * @param droitsActeurs
- */
- void trieDroitsUtilisateur(List<Droit> droitsActeurs) {
- droitsActeurs.sort { a,b ->
- int cmp = -1 * (a.estProprietaire <=> b.estProprietaire)
- if (cmp!=0) {
- return cmp
- } else {
- return a.nomAutorite <=> b.nomAutorite
- }
- }
-
- }
-
-
-}
--- /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.securite.permission
+
+import org.lilie.services.eliot.securite.impl.Item
+
+/**
+ * @author bahj
+ */
+class ItemDroits {
+
+ Item item
+ List<Droit> groupe = []
+ List<Droit> personne = []
+
+}
--- /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.securite.permission
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.securite.permission.partagemanuel.AutoritePartageType
+
+import org.lilie.services.eliot.securite.impl.Autorisation
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.securite.Permission
+import org.lilie.services.eliot.securite.AccessManager
+import org.lilie.services.eliot.securite.AutorisationException
+
+/**
+ * @author bahj
+ */
+class ItemDroitsService {
+
+ static transactional = true
+
+ ItemDroits findAllItemDroits(SecuriteSession securiteSession, Item item) {
+
+ ItemDroits itemDroits = new ItemDroits(
+ item: item,
+ groupe: findAllDroits(securiteSession, item, AutoritePartageType.GROUPE),
+ personne: findAllDroits(securiteSession, item, AutoritePartageType.ACTEUR)
+ )
+
+ trieDroitsUtilisateur(itemDroits.personne)
+
+ return itemDroits
+ }
+
+ /*
+ * Recupere les droits de type typeAutorite pour un item
+ */
+
+ public List<Droit> findAllDroits(SecuriteSession securiteSession,
+ Item item,
+ AutoritePartageType typeAutorite) {
+
+ verificationAutorisationConsultationDroits(item, securiteSession)
+
+ List droits = []
+ if (item) {
+ // retourne toutes les autorisations de groupes/d'acteurs (sur l'Item)
+ List<Autorisation> autorisations = (typeAutorite == AutoritePartageType.ACTEUR) ?
+ item.findAllActeurAutorisations() :
+ item.findAllGroupeAutorisations()
+
+ autorisations.each {Autorisation autorisation ->
+ Autorite autorite = autorisation.autorite
+ droits.add(
+ new Droit(
+ type: typeAutorite.getPrefix(),
+ groupeLocalisation: (typeAutorite == AutoritePartageType.ACTEUR) ?
+ null :
+ autorite.localisation,
+ autorite: autorite,
+ autoriteIdExterne: autorite.getIdExterne(),
+ autoriteIdInterne: autorite.id,
+ nomAutorite: autorite.nomAffichage(true),
+ modification: autorisation.autoriseModifierLeContenu(),
+ modificationParDefaut: autorisation.
+ estPermissionParDefaut(Permission.PEUT_MODIFIER_CONTENU),
+ consultation: autorisation.autoriseConsulterLeContenu(),
+ consultationParDefaut: autorisation.
+ estPermissionParDefaut(Permission.PEUT_CONSULTER_CONTENU),
+ estProprietaire: autorisation.proprietaire
+ )
+ )
+ }
+ }
+ return droits
+ }
+
+ /**
+ * Trie les droits d'acteurs.
+ * Le proprietaire le premiere, apres tries par l'ordre alphabetique.
+ * @param droitsActeurs
+ */
+ void trieDroitsUtilisateur(List<Droit> droitsActeurs) {
+ droitsActeurs.sort { a, b ->
+ int cmp = -1 * (a.estProprietaire <=> b.estProprietaire)
+ if (cmp != 0) {
+ return cmp
+ } else {
+ return a.nomAutorite <=> b.nomAutorite
+ }
+ }
+ }
+
+ public void verificationAutorisationConsultationDroits(Item item,
+ SecuriteSession securiteSession) {
+ AccessManager accessManager = new AccessManager(item, securiteSession)
+ if (!accessManager.peutConsulterLesPermissions()) {
+ throw AutorisationException.consultationPermissionsException()
+ }
+ }
+
+}
--- /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.securite.permission.partageauto
+
+import org.lilie.services.eliot.temps.Agenda
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Etablissement
+
+import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.temps.TypeAgendaEnum
+
+/**
+ * Service de partage automatiques d'agenda scolaires
+ * @author bahj
+ */
+
+class AgendaPartageAutoService {
+
+ static transactional = true
+
+ LocalGroupeService localGroupeService
+ CiteScolaireService citeScolaireService
+ PartageAutoService partageAutoService
+
+ void partageAgenda(Agenda agenda) {
+
+ switch (agenda.typeAgenda.code) {
+
+ case TypeAgendaEnum.ETS.code:
+ partageAgendaStructure(agenda)
+ break
+
+ case TypeAgendaEnum.ETE.code:
+ partageAgendaEnseignant(agenda)
+ break
+
+ case TypeAgendaEnum.CSE.code:
+ partageAgendaEtablissement(agenda)
+ break
+
+ default:
+ throw new IllegalArgumentException(
+ "Cet agenda ne peut pas avoir des partages automatiques"
+ )
+ break
+ }
+
+ }
+
+ /**
+ * Créee les partages par défaut pour les agendas de structure d'enseignement
+ */
+ private partageAgendaStructure(Agenda agenda) {
+
+ partageAutoService.enregistreGroupesEnDroit(
+ agenda.item,
+ agenda.structureEnseignement.etablissement,
+ getAllGroupeEnDroitAgendaStructure(agenda)
+ )
+ }
+
+ /**
+ * Créee les partages par défaut pour les agendas d'enseignant
+ */
+ private partageAgendaEnseignant(Agenda agenda) {
+
+ partageAutoService.enregistreGroupesEnDroit(
+ agenda.item,
+ agenda.etablissement,
+ getAllGroupeEnDroitAgendaEnseignant(agenda)
+ )
+
+ partageAutoService.ajouteDefaultDroitConsultation(
+ agenda.item,
+ agenda.etablissement,
+ [agenda.enseignant]
+ )
+ }
+
+ /**
+ * Créee les partages par défaut pour les agendas d'établissement
+ */
+ private partageAgendaEtablissement(Agenda agenda) {
+
+
+ partageAutoService.enregistreGroupesEnDroit(
+ agenda.item,
+ agenda.etablissement,
+ getAllGroupeEnDroitAgendaEtablissement(agenda)
+ )
+ }
+
+ private GroupesEnDroit getAllGroupeEnDroitAgendaStructure(Agenda agenda) {
+ GroupesEnDroit groupesEnDroit = new GroupesEnDroit()
+
+ groupesEnDroit = AjouteAgendaStructureAllGroupeCiteScolaire(
+ agenda.structureEnseignement.etablissement,
+ groupesEnDroit
+ )
+
+ groupesEnDroit = ajouteAllGroupeStructureEnseignement(
+ agenda.structureEnseignement,
+ groupesEnDroit
+ )
+
+ return groupesEnDroit
+ }
+
+ private GroupesEnDroit getAllGroupeEnDroitAgendaEnseignant(Agenda agenda) {
+ return getAgendaEnseignantAllGroupeCiteScolaire(agenda.etablissement)
+ }
+
+ private GroupesEnDroit getAllGroupeEnDroitAgendaEtablissement(Agenda agenda) {
+ return getAgendaEtablissementAllGroupeCiteScolaire(agenda.etablissement)
+ }
+
+ private GroupesEnDroit getAgendaEtablissementAllGroupeCiteScolaire(Etablissement etablissement) {
+ GroupesEnDroit groupesEnDroit = new GroupesEnDroit()
+
+ List<ProprietesScolarite> directionsPs =
+ localGroupeService.findOrCreeGroupeDeDirectionCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> chefDeTravauxPs =
+ localGroupeService.findOrCreeGroupeDeChefDeTravauxCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> adminLocauxPs =
+ localGroupeService.findOrCreeGroupeDAdminLocalCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> educationsPs =
+ localGroupeService.findOrCreeGroupeDEducationCiteScolaire(etablissement)
+
+ groupesEnDroit.modification.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ educationsPs +
+ adminLocauxPs
+ )
+
+ groupesEnDroit.consultationDEP.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ educationsPs +
+ adminLocauxPs
+ )
+
+ return groupesEnDroit
+ }
+
+
+ private GroupesEnDroit getAgendaEnseignantAllGroupeCiteScolaire(Etablissement etablissement) {
+ GroupesEnDroit groupesEnDroit = new GroupesEnDroit()
+
+ List<ProprietesScolarite> directionsPs =
+ localGroupeService.findOrCreeGroupeDeDirectionCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> chefDeTravauxPs =
+ localGroupeService.findOrCreeGroupeDeChefDeTravauxCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> adminLocauxPs =
+ localGroupeService.findOrCreeGroupeDAdminLocalCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> educationsPs =
+ localGroupeService.findOrCreeGroupeDEducationCiteScolaire(etablissement)
+
+ groupesEnDroit.modification.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ educationsPs +
+ adminLocauxPs
+ )
+
+ groupesEnDroit.consultationDEP.addAll(adminLocauxPs)
+
+ groupesEnDroit.modificationDEP.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ adminLocauxPs
+ )
+
+ return groupesEnDroit
+ }
+
+ private GroupesEnDroit AjouteAgendaStructureAllGroupeCiteScolaire(Etablissement etablissement, GroupesEnDroit groupesEnDroit) {
+
+ List<ProprietesScolarite> directionsPs =
+ localGroupeService.findOrCreeGroupeDeDirectionCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> chefDeTravauxPs =
+ localGroupeService.findOrCreeGroupeDeChefDeTravauxCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> adminLocauxPs =
+ localGroupeService.findOrCreeGroupeDAdminLocalCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> educationsPs =
+ localGroupeService.findOrCreeGroupeDEducationCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> documentalistesPs =
+ localGroupeService.findOrCreeGroupeDeDocumentalisteCiteScolaire(etablissement)
+
+ groupesEnDroit.consultation.addAll(
+ documentalistesPs
+ )
+
+ groupesEnDroit.modification.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ educationsPs +
+ adminLocauxPs
+ )
+
+ groupesEnDroit.consultationDEP.addAll(educationsPs + adminLocauxPs + documentalistesPs)
+
+ groupesEnDroit.modificationDEP.addAll(
+ directionsPs +
+ chefDeTravauxPs +
+ adminLocauxPs
+ )
+
+ return groupesEnDroit
+ }
+
+
+ private GroupesEnDroit ajouteAllGroupeStructureEnseignement(StructureEnseignement structureEnseignement,
+ GroupesEnDroit groupesEnDroit
+ ) {
+
+ List<ProprietesScolarite> enseignants = []
+ List<ProprietesScolarite> enseignantsPrincipaux = []
+
+ if (structureEnseignement.type == StructureEnseignement.TYPE_CLASSE) {
+ enseignants =
+ [localGroupeService.findOrCreeGroupeDEnseignants(structureEnseignement)]
+
+ enseignantsPrincipaux =
+ [localGroupeService.findOrCreeGroupeDEnseignantsPrincipaux(structureEnseignement)]
+ } else {
+ enseignants =
+ localGroupeService.findOrCreeAllGroupeEnseignantForStructureGroupe(
+ structureEnseignement
+ )
+
+ enseignantsPrincipaux = localGroupeService.
+ findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(structureEnseignement)
+ }
+
+ ProprietesScolarite eleves =
+ localGroupeService.findOrCreeGroupeDEleves(structureEnseignement)
+
+ ProprietesScolarite parents =
+ localGroupeService.findOrCreeGroupeDeParents(structureEnseignement)
+
+ groupesEnDroit.consultation.addAll(enseignants + [eleves, parents])
+
+ groupesEnDroit.modification.addAll(enseignantsPrincipaux)
+
+ return groupesEnDroit
+ }
+
+}
--- /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.securite.permission.partageauto
+
+import org.lilie.services.eliot.textes.CahierDeTextes
+import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+
+/**
+ * Service de partage automatiques de cahier de textes de service
+ * @author bahj
+ */
+
+class CahierDeTextesPartageAutoService {
+
+ static transactional = true
+ LocalGroupeService localGroupeService
+ PartageAutoService partageAutoService
+
+ /**
+ * Créee les partages par défaut pour les cahiers de textes de service
+ */
+ void partageCahierService(CahierDeTextes cahier) {
+
+ if (!cahier.service) {
+ throw new IllegalArgumentException(
+ "Le cahier de textes n'est pas de service. Il ne peut pas avoir des partages automatiques"
+ )
+ }
+
+ partageAutoService.enregistreGroupesEnDroit(
+ cahier.item,
+ cahier.service.structureEnseignement.etablissement,
+ getAllGroupeEnDroit(cahier)
+ )
+ }
+
+ private GroupesEnDroit getAllGroupeEnDroit(CahierDeTextes cahier) {
+
+ GroupesEnDroit groupesEnDroit = new GroupesEnDroit()
+
+ groupesEnDroit = ajouteAllGroupeCiteScolaire(
+ cahier.service.structureEnseignement.etablissement,
+ groupesEnDroit
+ )
+
+ groupesEnDroit = ajouteAllGroupeStructureEnseignement(
+ cahier.service.structureEnseignement,
+ groupesEnDroit
+ )
+
+ return groupesEnDroit
+ }
+
+ private GroupesEnDroit ajouteAllGroupeCiteScolaire(Etablissement etablissement, GroupesEnDroit groupesEnDroit) {
+
+ List<ProprietesScolarite> directions =
+ localGroupeService.findOrCreeGroupeDeDirectionCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> chefDeTravaux =
+ localGroupeService.findOrCreeGroupeDeChefDeTravauxCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> adminLocaux =
+ localGroupeService.findOrCreeGroupeDAdminLocalCiteScolaire(etablissement)
+
+ List<ProprietesScolarite> educations =
+ localGroupeService.findOrCreeGroupeDEducationCiteScolaire(etablissement)
+
+ groupesEnDroit.consultation.addAll(
+ educations
+ )
+
+ groupesEnDroit.modificationDEP.addAll(
+ directions +
+ chefDeTravaux +
+ adminLocaux
+ )
+
+ return groupesEnDroit
+ }
+
+ private GroupesEnDroit ajouteAllGroupeStructureEnseignement(StructureEnseignement structureEnseignement,
+ GroupesEnDroit groupesEnDroit) {
+
+ List<ProprietesScolarite> enseignants = []
+ List<ProprietesScolarite> enseignantsPrincipaux = []
+
+ if (structureEnseignement.type == StructureEnseignement.TYPE_CLASSE) {
+ enseignants =
+ [localGroupeService.findOrCreeGroupeDEnseignants(structureEnseignement)]
+
+ enseignantsPrincipaux =
+ [localGroupeService.findOrCreeGroupeDEnseignantsPrincipaux(structureEnseignement)]
+ } else {
+ enseignants =
+ localGroupeService.findOrCreeAllGroupeEnseignantForStructureGroupe(
+ structureEnseignement
+ )
+
+ enseignantsPrincipaux = localGroupeService.
+ findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(structureEnseignement)
+ }
+
+ groupesEnDroit.consultation.addAll(
+ enseignants +
+ enseignantsPrincipaux +
+ localGroupeService.findOrCreeGroupeDEleves(structureEnseignement) +
+ localGroupeService.findOrCreeGroupeDeParents(structureEnseignement)
+ )
+
+ return groupesEnDroit
+ }
+
+}
* <http://www.cecill.info/licences.fr.html>.
*/
-package org.lilie.services.eliot.temps
+package org.lilie.services.eliot.securite.permission.partageauto
-import org.lilie.services.eliot.annuaire.GroupeInfo
-import org.lilie.services.eliot.scolarite.StructureEnseignement
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
/**
- * @author bper
+ * Définit la liste des groupes locaux avec leurs droits
+ * @author bahj
*/
-class AgendaGroupesEnDroit {
+class GroupesEnDroit {
- Agenda agenda
- StructureEnseignement structureEnseignement
-
- // Les groupes ayant le droit de consulter l'aganda
- List<GroupeInfo> groupeEnDroitConsultations = []
- // Les groupes ayant le droit de consulter et de modifier l'aganda
- List<GroupeInfo> groupeEnDroitEcritures = []
+ // Les groupes ayant le droit de consulter
+ List<ProprietesScolarite> consultation = []
+ // Les groupes ayant le droit de consulter et de modifier
+ List<ProprietesScolarite> modification = []
// Les groupes ayant le droit de consulter les droits et permissions
- List<GroupeInfo> groupeEnDroitConsultationDEP = []
+ List<ProprietesScolarite> consultationDEP = []
// Les groupes ayant le droit de modifier les droits et permissions
- List<GroupeInfo> groupeEnDroitModificationDEP = []
+ List<ProprietesScolarite> modificationDEP = []
+
}
--- /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.securite.permission.partageauto
+
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.securite.PermissionsManager
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
+import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
+import org.lilie.services.eliot.securite.impl.Item
+
+/**
+ * @author bahj
+ */
+class PartageAutoService {
+
+ static transactional = true
+
+
+ void enregistreGroupesEnDroit(Item item,
+ Etablissement etablissement,
+ GroupesEnDroit groupesEnDroit
+ ) {
+
+ if (groupesEnDroit.consultation.size() > 0) {
+ ajouteDefaultDroitConsultation(
+ item,
+ etablissement,
+ groupesEnDroit.consultation*.autorite
+ )
+ }
+
+ if (groupesEnDroit.modification.size() > 0) {
+ ajouteDefaultDroitsEcritureLecture(
+ item,
+ etablissement,
+ groupesEnDroit.modification*.autorite
+ )
+ }
+
+ if (groupesEnDroit.consultationDEP.size() > 0) {
+ ajouteDefaultDroitConsultationPermissions(
+ item,
+ etablissement,
+ groupesEnDroit.consultationDEP*.autorite
+ )
+ }
+
+ if (groupesEnDroit.modificationDEP.size() > 0) {
+ ajouteDefaultDroitModificationPermissions(
+ item,
+ etablissement,
+ groupesEnDroit.modificationDEP*.autorite
+ )
+ }
+ }
+
+
+ void ajouteDefaultDroitConsultation(Item item,
+ Etablissement etablissement,
+ List<Autorite> autorites
+ ) {
+
+ autorites.each {Autorite autorite ->
+ PermissionsManager permission = creePermission(
+ item,
+ autorite,
+ etablissement.codePorteurENT
+ )
+
+ permission.addPermissionConsultationParDefaut()
+ }
+ }
+
+ void ajouteDefaultDroitsEcritureLecture(Item item,
+ Etablissement etablissement,
+ List<Autorite> autorites
+ ) {
+
+ autorites.each {Autorite autorite ->
+ PermissionsManager permission = creePermission(
+ item,
+ autorite,
+ etablissement.codePorteurENT
+ )
+
+ permission.addPermissionModificationParDefaut()
+ }
+ }
+
+
+ void ajouteDefaultDroitConsultationPermissions(Item item,
+ Etablissement etablissement,
+ List<Autorite> autorites
+ ) {
+ autorites.each {Autorite autorite ->
+ PermissionsManager permission = creePermission(
+ item,
+ autorite,
+ etablissement.codePorteurENT
+ )
+
+ permission.addPermissionConsultationPermissionsParDefaut()
+ }
+ }
+
+
+ void ajouteDefaultDroitModificationPermissions(Item item,
+ Etablissement etablissement,
+ List<Autorite> autorites
+ ) {
+ autorites.each {Autorite autorite ->
+ PermissionsManager permission = creePermission(
+ item,
+ autorite,
+ etablissement.codePorteurENT
+ )
+
+ permission.addPermissionModificationPermissionsParDefaut()
+ }
+ }
+
+
+ private PermissionsManager creePermission(Item item,
+ Autorite autorite,
+ String codePorteurENT) {
+ SecuriteSession eliotScolariteSecuriteSess =
+ DefaultSecuriteSessionFactory.getEliotScolariteSecuriteSessionForCodePorteurENT(
+ codePorteurENT
+ )
+ PermissionsManager permManager = new DefaultPermissionsManager(
+ item,
+ autorite,
+ eliotScolariteSecuriteSess
+ )
+ return permManager
+ }
+
+
+}
-package org.lilie.services.eliot.temps\r
+package org.lilie.services.eliot.securite.permission.partagemanuel\r
\r
/**\r
* Type d'autorite pour laquelle on cherche les droits\r
* @author msan\r
*/\r
-public enum TypeAutorite {\r
+public enum AutoritePartageType {\r
GROUPE('g'),\r
ACTEUR('u')\r
\r
private String prefix // pour distinquer groupes/acteur\r
\r
- TypeAutorite(String prefix) {\r
+ AutoritePartageType(String prefix) {\r
this.prefix = prefix\r
}\r
\r
--- /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.securite.permission.partagemanuel
+
+import org.lilie.services.eliot.securite.permission.Droit
+import org.lilie.services.eliot.securite.permission.ItemDroits
+import org.lilie.services.eliot.DistantAutoriteService
+
+class PartageManuelRequestParserService {
+
+ static transactional = true
+ DistantAutoriteService distantAutoriteService
+
+ ItemDroits getItemDroitsFrom(Map paramMap) {
+ ItemDroits itemDroits = new ItemDroits()
+
+ paramMap.each {Object key, Object value ->
+ // Si il y a une entree Groupe ou Utilisateur
+ String keyString = key.toString()
+
+ if (keyString.startsWith(AutoritePartageType.GROUPE.getPrefix()) ||
+ keyString.startsWith(AutoritePartageType.ACTEUR.getPrefix())
+ ) {
+
+ Map info = [:]
+ List split = keyString.split(';')
+ split[1, 2, 3].each {
+ List temp = it.split('=')
+ info[temp[0]] = temp[1]
+ }
+
+ String type = keyString.charAt(0)
+ String nomAutorite = value?.toString()
+ String autoriteIdExterne = info['idExterne'] != 'null' ?
+ info['idExterne'] :
+ null
+
+ Long autoriteIdInterne = info['idInterne'] != 'null' ?
+ Long.parseLong(info['idInterne']) : null
+
+ String localisation = info['localisation'] != 'null' ?
+ info['localisation'] :
+ null
+ Boolean ecrire = paramMap['e_' + keyString] == 'on'
+ Boolean lire = paramMap['l_' + keyString] == 'on'
+
+ // Quand un checkbox est désactivé il n'est pas passé dans les params
+ // Pour cette raison si Ecrire est coché et Lire coché par défaut + désactivé
+ // On n'a pas Lire dans les params
+ // ==> il faut mettre Lire à true là où Ecrire est à true
+ if (ecrire) {
+ lire = true
+ }
+
+ Droit droit = new Droit(
+ type: type,
+ nomAutorite: nomAutorite,
+ consultation: lire,
+ modification: ecrire,
+ // vu qu'on le change ca ne peut pas etre une permission par defaut
+ consultationParDefaut: false,
+ // vu qu'on le change ca ne peut pas etre une permission par defaut
+ modificationParDefaut: false,
+ autoriteIdExterne: distantAutoriteService.isAutoriteEncodee(autoriteIdExterne) ?
+ distantAutoriteService.getIdExterneFromAutoriteEncodee(autoriteIdExterne) :
+ autoriteIdExterne,
+ autoriteIdInterne: autoriteIdInterne,
+ groupeLocalisation: localisation
+ )
+
+ if (keyString.startsWith(AutoritePartageType.GROUPE.getPrefix())) {
+ itemDroits.groupe << droit
+ } else {
+ itemDroits.personne << droit
+ }
+ }
+ }
+
+ return itemDroits
+ }
+
+}
--- /dev/null
+package org.lilie.services.eliot.securite.permission.partagemanuel
+
+import org.lilie.services.eliot.DistantAutoriteService
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.annuaire.SecuriteSession
+
+import org.lilie.services.eliot.annuaire.AnnuaireService
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.securite.impl.Item
+
+import org.lilie.services.eliot.securite.permission.Droit
+
+import org.lilie.services.eliot.securite.PermissionsManager
+import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
+
+import org.lilie.services.eliot.securite.permission.ItemDroits
+import org.lilie.services.eliot.securite.permission.ItemDroitsService
+
+/**
+ * Gestion des droits et permissions des groupes et utilisateurs sur les items
+ * @author othe , bahj
+ */
+class PartageManuelService {
+
+
+ DistantAutoriteService distantAutoriteService
+ AnnuaireService annuaireService
+ LocalPersonneService localPersonneService
+ PartageManuelRequestParserService partageManuelRequestParserService
+ ItemDroitsService itemDroitsService
+
+ /**
+ * Retourne la liste des autorités par rapport à une liste d'id
+ * externes
+ * @param ids : idExternes
+ * @param paramType
+ * @return
+ */
+ public List<Autorite> getListeAutorites(String ids, String paramType) {
+ // On reçoit une liste d'ids de groupes ou d'users
+ List idsExternes = (ids && ids != "\"\"") ? (List) (ids)?.split(",") : []
+ String type
+
+ if (paramType == AutoritePartageType.GROUPE.getPrefix()) {
+ type = Autorite.TYPE_GROUPE
+ } else {
+ type = Autorite.TYPE_ACTEUR
+ }
+
+ List<Autorite> autorites = distantAutoriteService.getAutoritesForTypeAndIdExterne(
+ type,
+ idsExternes,
+ true
+ )
+
+ return autorites
+
+ }
+
+ ItemDroits mettreAjourDroitEtPermission(SecuriteSession securiteSession, Item item, Map paramMap) {
+
+ ItemDroits itemDroits =
+ partageManuelRequestParserService.getItemDroitsFrom(paramMap)
+ itemDroits.item = item
+
+ majPersonnesDroits(securiteSession, item, itemDroits.personne)
+
+ majGroupesLocauxDroits(securiteSession,
+ item,
+ itemDroits.groupe.findAll {Droit droit ->
+ droit.groupeLocalisation == Autorite.LOCALISATION_LOCALE &&
+ droit.type == AutoritePartageType.GROUPE.getPrefix()
+ } as List
+ )
+
+ majGroupesDistantsDroits(securiteSession,
+ item,
+ itemDroits.groupe.findAll {Droit droit ->
+ // Groupe distant existants
+ (droit.groupeLocalisation == Autorite.LOCALISATION_DISTANTE &&
+ droit.type == AutoritePartageType.GROUPE.getPrefix()) ||
+ // nouveaux groupes distants
+ (!droit.autoriteIdInterne && droit.autoriteIdExterne && droit.type == AutoritePartageType.GROUPE.getPrefix())
+ } as List
+ )
+
+ return itemDroits
+ }
+
+
+ void majPersonnesDroits(SecuriteSession securiteSession, Item item, List<Droit> droits) {
+ // Récupération des droits existants
+ List<Droit> allPersonneDroitExistant =
+ itemDroitsService.findAllDroits(securiteSession, item, AutoritePartageType.ACTEUR)
+
+ // Calcul des droits à supprimer = droits existants - droits à ajouter ou maj,
+ List allIdAutoriteASuppr =
+ allPersonneDroitExistant*.autoriteIdExterne - droits*.autoriteIdExterne
+
+ droits = filtreDroitsPasChanges(droits, allPersonneDroitExistant)
+
+ // enregistre les droits à ajouter ou a maj
+ enregistreDroitsActeurs(securiteSession, item, droits)
+
+ // enregistre les droits à supprimmer
+ enleveDroitsActeurs(securiteSession, item, allIdAutoriteASuppr)
+ }
+
+ void majGroupesLocauxDroits(SecuriteSession securiteSession, Item item, List<Droit> droits) {
+ List<Droit> allGrpLocDroitExistant =
+ itemDroitsService.findAllDroits(securiteSession, item, AutoritePartageType.GROUPE).findAll {
+ Droit droit ->
+ droit.groupeLocalisation == Autorite.LOCALISATION_LOCALE &&
+ droit.type == AutoritePartageType.GROUPE.getPrefix()
+ } as List
+
+ // Calcul des droits à supprimer = droits existants - droits à ajouter ou maj,
+ List allIdAutoriteASuppr =
+ allGrpLocDroitExistant*.autoriteIdInterne - droits*.autoriteIdInterne
+
+ droits = filtreDroitsPasChanges(droits, allGrpLocDroitExistant)
+
+ // enregistre les droits à ajouter ou a maj
+ enregistreDroitsGroupeLocal(securiteSession, item, droits)
+
+ // enregistre les droits à supprimmer
+ enleveDroitsGroupeLocal(securiteSession, item, allIdAutoriteASuppr)
+ }
+
+ void majGroupesDistantsDroits(SecuriteSession securiteSession, Item item, List<Droit> droits) {
+
+ List<Droit> allGrDistDroitExistant =
+ itemDroitsService.findAllDroits(securiteSession, item, AutoritePartageType.GROUPE).findAll {
+ Droit droit ->
+ droit.groupeLocalisation == Autorite.LOCALISATION_DISTANTE &&
+ droit.type == AutoritePartageType.GROUPE.getPrefix()
+ } as List
+
+ // Calcul des droits à supprimer = droits existants - droits à ajouter ou maj,
+ List allIdAutoriteASuppr =
+ allGrDistDroitExistant*.autoriteIdExterne - droits*.autoriteIdExterne
+
+ droits = filtreDroitsPasChanges(droits, allGrDistDroitExistant)
+
+ // enregistre les droits à ajouter ou a maj
+ enregistreDroitsGroupeDistant(securiteSession, item, droits)
+
+ // enregistre les droits à supprimmer
+ enleveDroitsGroupeDistant(securiteSession, item, allIdAutoriteASuppr)
+ }
+
+ /**
+ * Enregistre les droits des groupes distants sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enregistreDroitsGroupeDistant(SecuriteSession securiteSession,
+ Item item,
+ List<Droit> droits) {
+ droits.each {Droit droit ->
+ Autorite autorite = distantAutoriteService.getAutoriteGroupeForIdExterne(
+ droit.autoriteIdExterne,
+ true
+ )
+ enregistreDroits(
+ securiteSession,
+ item,
+ autorite,
+ droit.consultation,
+ droit.modification
+ )
+ }
+ }
+
+ /**
+ * Enleve les droits des groupes sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enleveDroitsGroupeDistant(SecuriteSession securiteSession,
+ Item item,
+ List groupeAutoriteIds) {
+ groupeAutoriteIds.each {String idAutorite ->
+ Autorite autorite = distantAutoriteService.getAutoriteGroupeForIdExterne(
+ idAutorite,
+ true
+ )
+ enregistreDroits(securiteSession, item, autorite, false, false)
+ }
+ }
+
+ /**
+ * Enregistre les droits des groupes locaux sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enregistreDroitsGroupeLocal(SecuriteSession securiteSession,
+ Item item,
+ List<Droit> droits) {
+ List<Autorite> autorites = Autorite.findAllByIdInList(droits*.autoriteIdInterne)
+ droits.each {Droit droit ->
+
+ enregistreDroits(
+ securiteSession,
+ item,
+ autorites.find {it.id == droit.autoriteIdInterne},
+ droit.consultation,
+ droit.modification
+ )
+ }
+ }
+
+ /**
+ * Enleve les droits des groupes locaux sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enleveDroitsGroupeLocal(SecuriteSession securiteSession,
+ Item item,
+ List autoritesGroupeIdInterne) {
+ List<Autorite> autorites = Autorite.findAllByIdInList(autoritesGroupeIdInterne)
+ autorites.each {Autorite autorite ->
+ enregistreDroits(securiteSession, item, autorite, false, false)
+ }
+ }
+
+ /**
+ * Enleve les droits d'acteurs sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enleveDroitsActeurs(SecuriteSession securiteSession,
+ Item item,
+ List acteurAutoriteIds) {
+ acteurAutoriteIds.each {String idAutorite ->
+ Autorite autorite = distantAutoriteService.getAutoriteActeurForIdExterne(
+ idAutorite,
+ true
+ )
+ enregistreDroits(securiteSession, item, autorite, false, false)
+ }
+ }
+
+ /**
+ * Enregistre les droits d'acteurs sur un item
+ * @param securiteSession
+ * @param item
+ * @param droits
+ */
+ private void enregistreDroitsActeurs(SecuriteSession securiteSession,
+ Item item,
+ List<Droit> droits) {
+ droits.each { Droit droit ->
+ Autorite autorite = distantAutoriteService.getAutoriteActeurForIdExterne(
+ droit.autoriteIdExterne,
+ true
+ )
+ enregistreDroits(
+ securiteSession,
+ item,
+ autorite,
+ droit.consultation,
+ droit.modification)
+ }
+ }
+
+ /**
+ * Enregistre les droits d'une autorite sur un item
+ * @param securiteSession
+ * @param item
+ * @param autorite
+ * @param peutConsulter
+ * @param peutModifier
+ */
+ private void enregistreDroits(SecuriteSession securiteSession,
+ Item item,
+ Autorite autorite,
+ Boolean peutConsulter,
+ Boolean peutModifier) {
+ PermissionsManager permManager = new DefaultPermissionsManager(
+ item,
+ autorite,
+ securiteSession
+ )
+ changeDroits(permManager, peutConsulter, peutModifier)
+ }
+
+ /**
+ * Enleve de droitsNouvels les droits qui n'ont pas changee par rapport
+ * aux droits existants
+ * @param droitsNouvels
+ * @param droitsExistants
+ * @return droits a enregistrer
+ */
+ private List<Droit> filtreDroitsPasChanges(List<Droit> droitsNouvels,
+ List<Droit> droitsExistants) {
+ droitsNouvels.each { Droit droitNouvel ->
+ Droit droitExistant = droitsExistants.find {
+ it.autoriteIdExterne == droitNouvel.autoriteIdExterne &&
+ it.autoriteIdInterne == droitNouvel.autoriteIdInterne &&
+ it.groupeLocalisation == droitNouvel.groupeLocalisation
+ }
+ if (droitExistant) {
+
+ if (droitExistant.consultationParDefaut) {
+ droitNouvel.consultation = null // droit par defaut - on ne peut pas le changer
+ } else if (droitExistant.consultation == droitNouvel.consultation) {
+ droitNouvel.consultation = null // rien a change
+ }
+
+ if (droitExistant.modificationParDefaut) {
+ droitNouvel.modification = null // droit par defaut - on ne peut pas le changer
+ } else if (droitExistant.modification == droitNouvel.modification) {
+ droitNouvel.modification = null // rien a change
+ }
+ }
+ }
+
+ return droitsNouvels.findAll { it.consultation != null || it.modification != null }
+ }
+
+ /**
+ * Changement des droits en fonction des permissions passées en paramètre.
+ */
+ private void changeDroits(PermissionsManager permManager,
+ Boolean peutConsulter,
+ Boolean peutModifier) {
+ if (peutModifier != null) {
+ if (peutModifier) {
+ permManager.addPermissionModification()
+ } else {
+ permManager.deletePermissionModification()
+ }
+ }
+ if (peutConsulter != null) {
+ if (peutConsulter) {
+ permManager.addPermissionConsultation()
+ } else {
+ permManager.deletePermissionConsultation()
+ }
+ }
+ }
+
+
+}
import org.lilie.services.eliot.DistantAutoriteService
import org.lilie.services.eliot.AutoriteTypeEliot
import org.lilie.services.eliot.scolarite.Etablissement
-import org.lilie.services.eliot.annuaire.GroupeInfo
-import org.lilie.services.eliot.annuaire.StructureInformations
-import org.hibernate.FetchMode
-import org.lilie.services.eliot.securite.PermissionsManager
-import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
import org.lilie.services.eliot.ItemService
import org.hibernate.SessionFactory
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.scolarite.etablissement.CiteScolaireService
import org.lilie.services.eliot.scolarite.AnneeScolaire
import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
-import org.lilie.services.eliot.annuaire.DistantGroupeService
+import org.lilie.services.eliot.securite.permission.partageauto.AgendaPartageAutoService
+import org.hibernate.FetchMode
/**
* Services des différents types d'agenda
PreferencesUtilisateursAgendaService preferencesUtilisateursAgendaService
AnnuaireService annuaireService
DistantAutoriteService distantAutoriteService
- DistantGroupeService distantGroupeService
TypeAgendaService typeAgendaService
TempsSecuriteService tempsSecuriteService
EleveAnnuaireService eleveAnnuaireService
CiteScolaireService citeScolaireService
AnneeScolaireService anneeScolaireService
+ AgendaPartageAutoService agendaPartageAutoService
public static final String ET = "Emploi du temps "
public static final String ETABLISSEMENT = " de l'établissement "
*
*/
Agenda getAgendaEmploiDuTempsForStructure(StructureEnseignement structEnseignement,
- boolean forceCreation = true)
- throws EliotTempsException {
- // type de l'agenda, création si il n'existe pas
+ boolean forceCreation = true
+ ) throws EliotTempsException {
+
TypeAgenda typeAgenda = typeAgendaService.getAgendaTypeFromCode(
TypeAgendaEnum.ETS
)
- Agenda agendaStructure = Agenda.findByStructureEnseignementAndTypeAgenda(
+ Agenda agenda = Agenda.findByStructureEnseignementAndTypeAgenda(
structEnseignement,
typeAgenda
)
// si l'agenda n'existe pas et si la force créeation est à true, en crée un nouvel
- if (!agendaStructure && forceCreation) {
+ if (!agenda && forceCreation) {
log.info "Création de l'agenda de la structure $structEnseignement"
//infos agenda
0
)
// création de l'agenda
- agendaStructure = internalCreerAgenda(
+ agenda = internalCreerAgenda(
nom,
description,
preferencesUtilisateursAgendaService.getCouleur(),
null
)
// autorisations par défaut sur l'agenda
- mettreDroitsParDefautETStructure(
- agendaStructure,
- structEnseignement
- )
+ agendaPartageAutoService.partageAgenda(agenda)
+
}
- return agendaStructure
+
+ return agenda
}
/**
)
// recherche de l'agenda
- Agenda agendaEnseignant = (Agenda) Agenda.createCriteria().get {
+ Agenda agenda = (Agenda) Agenda.createCriteria().get {
eq("enseignant", autoriteEnseignant)
eq("typeAgenda", typeAgenda)
eq("etablissement", etablissement)
}
// si l'agenda n'existe pas et si la force créeation est à true, en crée un nouvel
- if (!agendaEnseignant && forceCreation) {
+ if (!agenda && forceCreation) {
String nomAffichage = localPersonneService.getNomAffichage(autoriteEnseignant)
log.info "Création de l'agenda de l'enseignant " + nomAffichage
0
)
// creation de l'agenda
- agendaEnseignant = internalCreerAgenda(
+ agenda = internalCreerAgenda(
nom,
description,
preferencesUtilisateursAgendaService.getCouleur(),
autoriteEnseignant
)
// autorisations par défaut sur l'agenda
- mettreDroitsParDefautETEnseignant(agendaEnseignant,
- autoriteEnseignant,
- etablissement
- )
+ agendaPartageAutoService.partageAgenda(agenda)
}
- return agendaEnseignant
+ return agenda
}
/**
TypeAgendaEnum.CSE
)
- Agenda agendaEtablissement = Agenda.findByEtablissementAndTypeAgenda(
+ Agenda agenda = Agenda.findByEtablissementAndTypeAgenda(
etablissement,
typeAgenda
)
// si l'agenda n'existe pas et si la force créeation est à true, en crée un nouvel
- if (!agendaEtablissement && forceCreation) {
+ if (!agenda && forceCreation) {
log.info "Création de l'agenda scolaire de l'établissement $etablissement.nomAffichage"
// infos établissement
String nom = CS + etablissement.nomAffichage
0
)
// creation de l'agenda
- agendaEtablissement = internalCreerAgenda(nom,
+ agenda = internalCreerAgenda(nom,
description,
preferencesUtilisateursAgendaService.getCouleur(),
typeAgenda,
null
)
// autorisations par défaut sur l'agenda
- mettreDroitsParDefautCSEtablissement(
- agendaEtablissement,
- etablissement
- )
- }
- return agendaEtablissement
- }
-
- /**
- * Met les droits par défaut d'un agenda ETS
- * - Direction, Chef de travaux, admins locaux:
- * modification de contenu
- * modification des droits et permissions
- *
- * - Personnel d'éducation : modification de contenu
- * consultation des droits et permissions
- *
- *
- * Droit en consultation
- * - Documentalistes
- * - Elèves
- * - Parents d'élèves
- * - Enseignants
- *
- * Les profils (Pers Direc + Chef de trav + Pers Educ + Pers Doc + admins locaux)
- * des établissements de la même cité scolaire
- * que l'établissement de la structure ont les même droits que les profils
- * de l'établissement en question
- */
- void mettreDroitsParDefautETStructure(Agenda agenda,
- StructureEnseignement structureEnseignement) {
-
-
- AgendaGroupesEnDroit groupesEnDroit = new AgendaGroupesEnDroit(
- agenda: agenda,
- structureEnseignement: structureEnseignement
- )
-
- Boolean droitsIncomplets = true
- groupesEnDroit = ajouteGroupesCiteScolaire(groupesEnDroit)
-
- if (structureEnseignement.idExterne != "-1") {
- agenda.droitsIncomplets = false
- groupesEnDroit = ajouteGroupesStructureEnseignement(groupesEnDroit)
+ agendaPartageAutoService.partageAgenda(agenda)
}
- enregistreGroupesEnDroit(groupesEnDroit)
-
- agenda.droitsIncomplets = droitsIncomplets
- agenda.save(failOnError: true, flush: true)
- }
-
-
- private AgendaGroupesEnDroit ajouteGroupesCiteScolaire(AgendaGroupesEnDroit groupesEnDroit) {
-
- List<Etablissement> etablissementsCiteScolaire =
- citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
- groupesEnDroit.structureEnseignement.etablissement)
-
- // Droits aux profils Pers Direc + Pers Educ + Pers Doc + admins locaux de la cité scolaire
- etablissementsCiteScolaire.each {Etablissement etab ->
- // Direction :
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo direction = distantGroupeService.getGroupeInfoDeDirection(etab)
- if (direction) {
- groupesEnDroit.groupeEnDroitEcritures.add(direction)
- groupesEnDroit.groupeEnDroitModificationDEP.add(direction)
- }
-
- // Chef de travaux :
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo chefDeTravaux = distantGroupeService.getGroupeInfoDeChefDeTravaux(etab)
- if (chefDeTravaux) {
- groupesEnDroit.groupeEnDroitEcritures.add(chefDeTravaux)
- groupesEnDroit.groupeEnDroitModificationDEP.add(chefDeTravaux)
- }
-
- //Admins locaux
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo adminsLocaux = distantGroupeService.getGroupeInfoDAdminsLocaux(etab)
- if (adminsLocaux) {
- groupesEnDroit.groupeEnDroitEcritures.add(adminsLocaux)
- groupesEnDroit.groupeEnDroitModificationDEP.add(adminsLocaux)
- }
-
- // Personnel d'éducation :
- // - droit de modification de contenu
- // - droit de consultation des droits et permissions
- GroupeInfo education = distantGroupeService.getGroupeInfoDEducation(etab)
- if (education) {
- groupesEnDroit.groupeEnDroitEcritures.add(education)
- groupesEnDroit.groupeEnDroitConsultationDEP.add(education)
- }
-
- // Documentatliste :
- // - droit de consultation de contenu
- // - droit de consultation des droits et permissions
- GroupeInfo documentaliste = distantGroupeService.getGroupeInfoDeDocumentaliste(etab)
- if (documentaliste) {
- groupesEnDroit.groupeEnDroitConsultations.add(documentaliste)
- groupesEnDroit.groupeEnDroitConsultationDEP.add(documentaliste)
- }
- }
-
- return groupesEnDroit
- }
-
-
- private AgendaGroupesEnDroit ajouteGroupesStructureEnseignement(AgendaGroupesEnDroit groupesEnDroit) {
-
- // StructureInformation
- StructureInformations structureInfos = new StructureInformations(
- idExterne: groupesEnDroit.structureEnseignement.idExterne,
- type: groupesEnDroit.structureEnseignement.type,
- code: groupesEnDroit.structureEnseignement.getCode(),
- etablissementId: groupesEnDroit.structureEnseignement.etablissement.idExterne
- )
-
- SecuriteSession securiteSession =
- DefaultSecuriteSessionFactory.getEliotTempsSecuriteSessionForCodePorteurENT(
- groupesEnDroit.structureEnseignement.etablissement.codePorteurENT
- )
-
- // Profs principaux :
- // - droit de modification de contenu
- List<GroupeInfo> groupeProfsPrincipaux = distantGroupeService.getGroupeInfoProfsPrincipaux(
- securiteSession,
- structureInfos
- )
- if (groupeProfsPrincipaux.size() > 0) {
- groupesEnDroit.groupeEnDroitEcritures.addAll(groupeProfsPrincipaux)
- }
-
- // Enseignants :
- // - droit de consulter l'aganda
- List<GroupeInfo> groupeEnseignants = distantGroupeService.getGroupeInfoEnseignants(
- securiteSession,
- structureInfos
- )
- if (groupeEnseignants.size() > 0) {
- groupesEnDroit.groupeEnDroitConsultations.addAll(groupeEnseignants)
- }
-
- // Elèves:
- // - droit de consulter
- List<GroupeInfo> groupesEleves = distantGroupeService.getGroupeInfoEleves(securiteSession,
- structureInfos
- )
- if (groupesEleves.size() > 0) {
- groupesEnDroit.groupeEnDroitConsultations.addAll(groupesEleves)
- }
-
- // Parents:
- // - droit de consulter l'aganda
- List<GroupeInfo> groupesParents = distantGroupeService.getGroupeInfoParents(
- securiteSession,
- structureInfos
- )
- if (groupesParents.size() > 0) {
- groupesEnDroit.groupeEnDroitConsultations.addAll(groupesParents)
- }
-
- return groupesEnDroit
- }
-
-
- private void enregistreGroupesEnDroit(AgendaGroupesEnDroit groupesEnDroit) {
-
- // Attributs les droits par défaut de consultation de contenu
- if (groupesEnDroit.groupeEnDroitConsultations.size() > 0) {
- ajouteDroitConsultation(
- groupesEnDroit.groupeEnDroitConsultations,
- groupesEnDroit.agenda,
- groupesEnDroit.structureEnseignement.etablissement
- )
- }
-
- // Attributs les droits par défaut de modification de contenu
- if (groupesEnDroit.groupeEnDroitEcritures.size() > 0) {
- ajouteDroitModificationEtConsultation(
- groupesEnDroit.groupeEnDroitEcritures,
- groupesEnDroit.agenda,
- groupesEnDroit.structureEnseignement.etablissement
- )
- }
-
- // Attributs les droits par défaut de consultation des droits et permissions
- if (groupesEnDroit.groupeEnDroitConsultationDEP.size() > 0) {
- ajouteDroitConsultationEDP(
- groupesEnDroit.groupeEnDroitConsultationDEP,
- groupesEnDroit.agenda,
- groupesEnDroit.structureEnseignement.etablissement
- )
- }
-
- // Attributs les droits par défaut de modification des droits et permissions
- if (groupesEnDroit.groupeEnDroitModificationDEP.size() > 0) {
- ajouteDroitModificationDEP(
- groupesEnDroit.groupeEnDroitModificationDEP,
- groupesEnDroit.agenda,
- groupesEnDroit.structureEnseignement.etablissement
- )
- }
- }
-
- /**
- * Met les droits par défaut d'un agenda ETE
- * - Direction, Chef de travaux, admins locaux:
- * modification de contenu
- * modification des droits et permissions
- *
- * - Personnel d'éducation : modification de contenu
- * consultation des droits et permissions
- *
- *
- * Les profils (Pers Direc + Chef de trav + Pers Educ + Pers Doc + Admins locaux)
- * des établissements de la même cité scolaire
- * que l'établissement de la structure ont les même droits que les profils
- * de l'établissement en question
- *
- * seul l'enseignant a le droit en lecture
- */
- private mettreDroitsParDefautETEnseignant(Agenda agenda,
- Autorite enseignant,
- Etablissement etablissement
- ) {
-
- // Les groupes ayant le droit de consulter et de modifier l'aganda
- List<GroupeInfo> groupeEnDroitEcritures = []
-
- // Les groupes ayant le droit de consulter les droits et permissions
- List<GroupeInfo> groupeEnDroitConsultationDEP = []
-
- // Les groupes ayant le droit de modifier les droits et permissions
- List<GroupeInfo> groupeEnDroitModificationDEP = []
-
- List<Etablissement> etablissementsCiteScolaire =
- citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
- etablissement
- )
-
- etablissementsCiteScolaire.each {Etablissement etab ->
- // Direction :
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo direction = distantGroupeService.getGroupeInfoDeDirection(etab)
- if (direction) {
- groupeEnDroitEcritures.add(direction)
- groupeEnDroitModificationDEP.add(direction)
- }
-
- // Chef de travaux :
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo chefDeTravaux = distantGroupeService.getGroupeInfoDeChefDeTravaux(etab)
- if (chefDeTravaux) {
- groupeEnDroitEcritures.add(chefDeTravaux)
- groupeEnDroitModificationDEP.add(chefDeTravaux)
- }
-
- // Admins locaux :
- // - droit de modification de contenu
- // - droit de modification des droits et permissions
- GroupeInfo adminsLocaux = distantGroupeService.getGroupeInfoDAdminsLocaux(etab)
- if (adminsLocaux) {
- groupeEnDroitEcritures.add(adminsLocaux)
- groupeEnDroitModificationDEP.add(adminsLocaux)
- }
-
- // Personnel d'éducation :
- // - droit de modification de contenu
- // - droit de consultation des droits et permissions
- GroupeInfo education = distantGroupeService.getGroupeInfoDEducation(etab)
- if (education) {
- groupeEnDroitEcritures.add(education)
- groupeEnDroitConsultationDEP.add(education)
- }
- }
-
- // Attributs les droits par défaut de modification de contenu
- if (groupeEnDroitEcritures.size() > 0) {
- ajouteDroitModificationEtConsultation(groupeEnDroitEcritures,
- agenda,
- etablissement
- )
- }
-
- // Attributs les droits par défaut de consultation des droits et permissions
- if (groupeEnDroitConsultationDEP.size() > 0) {
- ajouteDroitConsultationEDP(groupeEnDroitConsultationDEP,
- agenda,
- etablissement
- )
- }
-
- // Attributs les droits par défaut de modification des droits et permissions
- if (groupeEnDroitModificationDEP.size() > 0) {
- ajouteDroitModificationDEP(groupeEnDroitModificationDEP,
- agenda,
- etablissement
- )
- }
-
- //Enseignant : droit en consultation
- ajouteDefaultDroitConsultation(agenda, [enseignant], etablissement)
- }
-
- /**
- * Met les droits par défaut d'un agenda CSE
- * Les profils : Direction + Education + admins locaux de l'ensemble
- * des établissements de la cité scolaire de l'établissement en court,
- * ont le droit en (consultation/Modification de contenu +
- * accès aux droits et permissions)
- * Tous les utilisateurs ont le droit en consultation
- */
- private mettreDroitsParDefautCSEtablissement(Agenda agenda,
- Etablissement etablissement) {
-
- // Les groupes ayant le droit de consulter et de modifier l'aganda
- List<GroupeInfo> groupeEnDroitEcritures = []
-
- // Les groupes ayant le droit de consulter les droits et permissions
- List<GroupeInfo> groupeEnDroitConsultationDEP = []
-
- List<Etablissement> etablissementsCiteScolaire =
- citeScolaireService.findAllEtablissementBySameCiteScolaireFor(
- etablissement
- )
-
- etablissementsCiteScolaire.each {Etablissement etab ->
-
- // Direction :
- // - droit de modification de contenu
- // - droit de consulter des droits et permissions
- GroupeInfo direction = distantGroupeService.getGroupeInfoDeDirection(etab)
- if (direction) {
- groupeEnDroitEcritures.add(direction)
- groupeEnDroitConsultationDEP.add(direction)
- }
-
- // Chef de travaux :
- // - droit de modification de contenu
- // - droit de consulter des droits et permissions
- GroupeInfo chefDeTravaux = distantGroupeService.getGroupeInfoDeChefDeTravaux(etab)
- if (chefDeTravaux) {
- groupeEnDroitEcritures.add(chefDeTravaux)
- groupeEnDroitConsultationDEP.add(chefDeTravaux)
- }
-
- // Personnel d'éducation :
- // - droit de modification de contenu
- // - droit de consultation des droits et permissions
- GroupeInfo education = distantGroupeService.getGroupeInfoDEducation(etab)
- if (education) {
- groupeEnDroitEcritures.add(education)
- groupeEnDroitConsultationDEP.add(education)
- }
-
- // Admins locaux :
- // - droit de modification de contenu
- // - droit de consultation des droits et permissions
- GroupeInfo adminsLocaux = distantGroupeService.getGroupeInfoDAdminsLocaux(etab)
- if (adminsLocaux) {
- groupeEnDroitEcritures.add(adminsLocaux)
- groupeEnDroitConsultationDEP.add(adminsLocaux)
- }
- }
-
- // Attributs les droits par défaut de modification de contenu
- if (groupeEnDroitEcritures.size() > 0) {
- ajouteDroitModificationEtConsultation(groupeEnDroitEcritures,
- agenda,
- etablissement
- )
- }
-
- // Attributs les droits par défaut de consultation des droits et permissions
- if (groupeEnDroitConsultationDEP.size() > 0) {
- ajouteDroitConsultationEDP(groupeEnDroitConsultationDEP,
- agenda,
- etablissement
- )
- }
- }
-
-
- private ajouteDroitConsultation(List<GroupeInfo> groupeEnDroitConsultations,
- Agenda agenda,
- Etablissement etablissement) {
- List<Autorite> autoriteEnDroitConsultations =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitConsultations*.groupeId*.toString(),
- true
- )
-
- ajouteDefaultDroitConsultation(
- agenda,
- autoriteEnDroitConsultations,
- etablissement
- )
- }
-
- private ajouteDroitModificationEtConsultation(List<GroupeInfo> groupeEnDroitEcritures,
- Agenda agenda,
- Etablissement etablissement) {
- List<Autorite> autoriteEnDroitEcritures =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitEcritures*.groupeId*.toString(),
- true
- )
-
- ajouteDroitsEcritureLecture(agenda,
- autoriteEnDroitEcritures,
- etablissement
- )
- }
-
- private ajouteDroitConsultationEDP(List<GroupeInfo> groupeEnDroitConsultationDEP,
- Agenda agenda,
- Etablissement etablissement) {
- List<Autorite> autoriteEnDroitConsultationDEP =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitConsultationDEP*.groupeId*.toString(),
- true
- )
-
- ajouteDefaultDroitConsultationPermissions(agenda,
- autoriteEnDroitConsultationDEP,
- etablissement
- )
- }
-
- private ajouteDroitModificationDEP(List<GroupeInfo> groupeEnDroitModificationDEP,
- Agenda agenda,
- Etablissement etablissement) {
- List<Autorite> autoriteEnDroitModificationDEP =
- distantAutoriteService.getAutoritesForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- groupeEnDroitModificationDEP*.groupeId*.toString(),
- true
- )
-
- ajouteDefaultDroitModificationPermissions(agenda,
- autoriteEnDroitModificationDEP,
- etablissement
- )
- }
-
- /**
- * Crée des autorisations acteurs en écriture sur un Item
- * si l'autorisation existe, la permession sera mise à jour
- */
- private ajouteDroitsEcritureLecture(Agenda agenda,
- List<Autorite> listeAutorites,
- Etablissement etablissement) {
- if (listeAutorites) {
- listeAutorites.each {Autorite autorite ->
- ajouteDefaultDroitsEcritureLecture(agenda,
- autorite,
- etablissement
- )
- }
- }
- }
-
- /**
- * Crée des autorisations acteurs en écriture sur un Item
- * si l'autorisation existe, la permession sera mise à jour
- */
- private ajouteDefaultDroitsEcritureLecture(Agenda agenda,
- Autorite autorite,
- Etablissement etablissement) {
- if (autorite) {
- PermissionsManager permission = creePermission(
- agenda,
- autorite,
- etablissement.codePorteurENT
- )
-
- ajouteDefaultPermissionModification(permission)
- }
- }
-
- /**
- * Permet de créer des autorisations acteurs en consultation sur un Item
- * si l'autorité n'existe pas, elle est crée
- */
- private ajouteDefaultDroitConsultation(Agenda agenda,
- List<Autorite> listeAutorites,
- Etablissement etablissement) {
-
- listeAutorites.each {Autorite autorite ->
- PermissionsManager permission = creePermission(
- agenda,
- autorite,
- etablissement.codePorteurENT
- )
-
- ajouteDefaultPermissionConsultation(permission)
- }
- }
-
-
- private ajouteDefaultDroitConsultationPermissions(Agenda agenda,
- List<Autorite> listeAutorites,
- Etablissement etablissement) {
- listeAutorites.each {Autorite autorite ->
- PermissionsManager permission = creePermission(
- agenda,
- autorite,
- etablissement.codePorteurENT
- )
-
- ajouteDefaultPermissionConsultationDesPermissions(permission)
- }
- }
-
-
- private ajouteDefaultDroitModificationPermissions(Agenda agenda,
- List<Autorite> listeAutorites,
- Etablissement etablissement) {
- listeAutorites.each {Autorite autorite ->
- PermissionsManager permission = creePermission(
- agenda,
- autorite,
- etablissement.codePorteurENT
- )
-
- ajouteDefaultPermissionModificationDesPermissions(permission)
- }
- }
-
-
- private PermissionsManager creePermission(Agenda agenda,
- Autorite autorite,
- String codePorteurENT) {
- SecuriteSession eliotScolariteSecuriteSess =
- DefaultSecuriteSessionFactory.getEliotScolariteSecuriteSessionForCodePorteurENT(
- codePorteurENT
- )
- PermissionsManager permManager = new DefaultPermissionsManager(
- agenda.item,
- autorite,
- eliotScolariteSecuriteSess
- )
- return permManager
- }
-
-
- private ajouteDefaultPermissionConsultation(PermissionsManager permission) {
- permission.addPermissionConsultationParDefaut()
- }
-
- private ajouteDefaultPermissionModification(PermissionsManager permission) {
- permission.addPermissionModificationParDefaut()
- }
-
- private ajouteDefaultPermissionConsultationDesPermissions(PermissionsManager permission) {
- permission.addPermissionConsultationPermissionsParDefaut()
- }
-
- private ajouteDefaultPermissionModificationDesPermissions(PermissionsManager permission) {
- permission.addPermissionModificationPermissionsParDefaut()
+ return agenda
}
/**
+++ /dev/null
-package org.lilie.services.eliot.temps
-
-import org.lilie.services.eliot.securite.impl.Item
-import org.lilie.services.eliot.securite.impl.Autorisation
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.DistantAutoriteService
-import org.lilie.services.eliot.securite.PermissionsManager
-import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
-import org.lilie.services.eliot.annuaire.SecuriteSession
-import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
-import org.lilie.services.eliot.droits.Droit
-import org.lilie.services.eliot.securite.Permission
-
-/**
- * Gestion des permissions d'un agenda
- * @author bahj
- * @author msan
- */
-
-public class TempsDroitsService {
-
- //TOREFACT a unifier avec DroitsService de textes - a descendre les methodes communes dans le plugin
-
- DistantAutoriteService distantAutoriteService
- LocalPersonneService localPersonneService
- TempsSecuriteService tempsSecuriteService
-
- /**
- * Recupere les droits sur un agenda
- * @param securiteSession
- * @param agenda
- * @param typeAutorite
- * @return
- */
- private List<Droit> getDroits(SecuriteSession securiteSession,
- Agenda agenda,
- TypeAutorite typeAutorite) {
- Item item = agenda.item
- tempsSecuriteService.verifieAutorisationConsultationPermissions(
- agenda,
- securiteSession
- )
- List droits = []
- if (item) {
- // retourne toutes les autorisations de groupes/d'acteurs (sur l'Item)
- List<Autorisation> autorisations =
- (typeAutorite == TypeAutorite.ACTEUR) ?
- item.findAllActeurAutorisations() :
- item.findAllGroupeAutorisations()
-
- autorisations.each {Autorisation autorisation ->
- Autorite autorite = autorisation.autorite
- droits.add( new Droit(
- type: typeAutorite.getPrefix(),
- autorite: autorite,
- idAutorite: autorite.getIdExterne(),
- nomAutorite: autorite.nomAffichage(true),
- modification: autorisation.autoriseModifierLeContenu(),
- modificationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_MODIFIER_CONTENU),
- consultation: autorisation.autoriseConsulterLeContenu(),
- consultationParDefaut: autorisation.
- estPermissionParDefaut(Permission.PEUT_CONSULTER_CONTENU),
- estProprietaire: autorisation.proprietaire
- ))
- }
- }
- return droits
- }
-
- /**
- * Permet de charger les droits des groupes d'un agenda
- * @param agenda
- * @param securiteSession
- * @return liste des objets Droit
- */
- List<Droit> getDroitsForGroupes(SecuriteSession securiteSession, Agenda agenda) {
- return getDroits(securiteSession, agenda, TypeAutorite.GROUPE)
- }
-
- /**
- * Récupère la liste des droits de tous les acteurs d'un agenda
- * @param agenda
- * @param securiteSession
- * @return liste des droits
- */
- List<Droit> getDroitsForActeurs(SecuriteSession securiteSession, Agenda agenda) {
- return getDroits(securiteSession, agenda, TypeAutorite.ACTEUR)
- }
-
- /**
- * Permet de mettre à jour les droits sur l'agenda
- * @param agenda
- * @param droitsActeurs : liste d'objets 'Droit' pour les acteurs
- * @param droitsGroupes : liste d'objets 'Droit' pour les groupes
- */
- void majDroits(SecuriteSession securiteSession,
- Agenda agenda,
- List<Droit> droitsActeurs,
- List<Droit> droitsGroupes
- ) {
-
- Item item = agenda.item
- if (securiteSession) {
- tempsSecuriteService.verifieAutorisationModificationPermissions(
- agenda,
- securiteSession
- )
- }
-
- // Récupère les droits existants
- List<Droit> droitsActeursExistants = getDroitsForActeurs(securiteSession, agenda)
- List<Droit> droitsGroupesExistants = getDroitsForGroupes(securiteSession, agenda)
-
- // Calcul des droits à supprimer = droits existants - droits à ajouter ou maj,
- List<Droit> droitsActeursSuppr = chercheDroitsASupprimmer(
- droitsActeursExistants,
- droitsActeurs
- )
- List<Droit> droitsGroupesSuppr = chercheDroitsASupprimmer(
- droitsGroupesExistants,
- droitsGroupes
- )
-
- // enlève les droits par défauts et non modifiable
- droitsActeurs = filtreDroitsPasChanges(droitsActeurs, droitsActeursExistants)
- droitsGroupes = filtreDroitsPasChanges(droitsGroupes, droitsGroupesExistants)
-
- // enregistre les droits à ajouter ou a maj
- enregistreDroitsActeurs(securiteSession, item, droitsActeurs)
- enregistreDroitsGroupes(securiteSession, item, droitsGroupes)
-
- // enregistre les droits à supprimmer
- enleveDroitsActeurs(securiteSession, item, droitsActeursSuppr)
- enleveDroitsGroupes(securiteSession, item, droitsGroupesSuppr)
-
- }
-
- /**
- * Cherche les droits qui doivent etre supprimes
- * @param droitsExistants
- * @param droitsNouvels
- * @return
- */
- private List<Droit> chercheDroitsASupprimmer(List<Droit> droitsExistants,
- List<Droit> droitsNouvels) {
- List<Droit> droitsASupprimmer = []
- droitsExistants.each { Droit droit ->
- Boolean droitAConserver =
- droitsNouvels.find {it.idAutorite == droit.idAutorite} ? true : false
- if (!droitAConserver) {
- droitsASupprimmer.add(droit)
- }
- }
- return droitsASupprimmer
- }
-
- /**
- * Changement des droits en fonction des permissions passées en paramètre.
- */
- private void changeDroits(PermissionsManager permManager,
- Boolean peutConsulter,
- Boolean peutModifier) {
-
- if (peutModifier != null) {
- if (peutModifier) {
- permManager.addPermissionModification()
- } else {
- permManager.deletePermissionModification()
- }
- }
- if (peutConsulter != null) {
- if (peutConsulter) {
- permManager.addPermissionConsultation()
- } else {
- permManager.deletePermissionConsultation()
- }
- }
- }
-
- /**
- * Enleve de droitsNouvels les droits qui n'ont pas changee par rapport
- * aux droits existants
- * @param droitsNouvels
- * @param droitsExistants
- * @return droits a enregistrer
- */
- List<Droit> filtreDroitsPasChanges(List<Droit> droitsNouvels,
- List<Droit> droitsExistants) {
- droitsNouvels.each { Droit droitNouvel ->
- Droit droitExistant = droitsExistants.find { it.idAutorite == droitNouvel.idAutorite }
- if (droitExistant) {
-
- if (droitExistant.consultationParDefaut) {
- droitNouvel.consultation = null // droit par defaut - on ne peut pas le changer
- } else if (droitExistant.consultation == droitNouvel.consultation) {
- droitNouvel.consultation = null // rien a change
- }
-
- if (droitExistant.modificationParDefaut) {
- droitNouvel.modification = null // droit par defaut - on ne peut pas le changer
- } else if (droitExistant.modification == droitNouvel.modification) {
- droitNouvel.modification = null // rien a change
- }
- }
- }
-
- return droitsNouvels.findAll { it.consultation !=null || it.modification != null }
- }
-
-
- /**
- * Enregistre les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- void enregistreDroitsActeurs(SecuriteSession securiteSession,
- Item item,
- List<Droit> droits) {
- droits.each { Droit droit ->
- enregistreDroits(
- securiteSession,
- item,
- droit.autorite,
- droit.consultation,
- droit.modification)
- }
- }
-
- /**
- * Enregistre les droits des groupes sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- void enregistreDroitsGroupes(SecuriteSession securiteSession,
- Item item,
- List<Droit> droits) {
- droits.each {Droit droit ->
- enregistreDroits(
- securiteSession,
- item,
- droit.autorite,
- droit.consultation,
- droit.modification)
- }
- }
-
- /**
- * Enregistre les droits d'une autorite sur un item
- * @param securiteSession
- * @param item
- * @param autorite
- * @param peutConsulter
- * @param peutModifier
- */
- private void enregistreDroits(SecuriteSession securiteSession,
- Item item,
- Autorite autorite,
- Boolean peutConsulter,
- Boolean peutModifier) {
- PermissionsManager permManager = new DefaultPermissionsManager(
- item,
- autorite,
- securiteSession
- )
- changeDroits(permManager, peutConsulter, peutModifier)
- }
-
- /**
- * Enleve les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- void enleveDroitsActeurs(SecuriteSession securiteSession,
- Item item,
- List<Droit> droitsActeur) {
- droitsActeur.each { Droit droit ->
- enregistreDroits(securiteSession, item, droit.autorite, false, false)
- }
- }
-
- /**
- * Enleve les droits des groupes sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- void enleveDroitsGroupes(SecuriteSession securiteSession,
- Item item,
- List<Droit> droitsGroupe) {
- droitsGroupe.each { Droit droit ->
- enregistreDroits(securiteSession, item, droit.autorite, false, false)
- }
- }
-
-}
import org.lilie.services.eliot.temps.importsts.info.StsProfPrincInfo
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
import org.lilie.services.eliot.temps.importudt.UdtImportParametrageService
+import org.lilie.services.eliot.securite.permission.partageauto.AgendaPartageAutoService
/**
* Service d'import dans le référentiel scolarité d'eliot des données contenues
PersonneStsService personneStsService
UdtImportParametrageService udtImportParametrageService
CalendrierService calendrierService
+ AgendaPartageAutoService agendaPartageAutoService
/**
* Vérifie l'intégrité des 2 fichiers XML empSts et stsEmp :
String codeAnneeScolaireEnCours = anneeEnCours.code
String anneeStsEmp = rootStsEmp?.PARAMETRES?.ANNEE_SCOLAIRE?.
- @ANNEE?.text()?.trim()
+ @ANNEE?.text()?.trim()
String anneeEmpSts = rootEmpSts?.PARAMETRES?.ANNEE_SCOLAIRE?.text()?.trim()
boolean testAnneeStsEmp =
- (codeAnneeScolaireEnCours == StsImportUtil.getCodeAnneeScolaire(anneeStsEmp))
+ (codeAnneeScolaireEnCours == StsImportUtil.getCodeAnneeScolaire(anneeStsEmp))
boolean testAnneeEmpSts =
- (codeAnneeScolaireEnCours == StsImportUtil.getCodeAnneeScolaire(anneeEmpSts))
+ (codeAnneeScolaireEnCours == StsImportUtil.getCodeAnneeScolaire(anneeEmpSts))
// Vérification du code établissement
String codeEtablissementStsEmp = rootStsEmp?.PARAMETRES?.UAJ?.
- @CODE?.text()?.trim()
+ @CODE?.text()?.trim()
String codeEtablissementEmpSts = rootEmpSts.PARAMETRES.UAJ
etablissementATraiter = (Etablissement) listeEtablissement.find {
etablissement: etablissementATraiter
)
}
-
+
return etablissementATraiter
}
}
List<Personne> listeEnseignants =
- personneStsService.internalfindAllPersonne(
- enseignantInfo.nom,
- enseignantInfo.prenom,
- enseignantInfo.dateNaissance,
- enseignantInfo.academie,
- FonctionEnum.ENSEIGNANT,
- true
- )
+ personneStsService.internalfindAllPersonne(
+ enseignantInfo.nom,
+ enseignantInfo.prenom,
+ enseignantInfo.dateNaissance,
+ enseignantInfo.academie,
+ FonctionEnum.ENSEIGNANT,
+ true
+ )
if (listeEnseignants.size() == 0) {
throw new IllegalStateException(
libelleEdition: noeudMatiere?.LIBELLE_EDITION?.text()?.trim(),
codeSts: codeMatiere
)
-
+
try {
// Création ou mise à jour de la matière
matiereService.insertUpdateMatiereFromSTS(matiereInfo)
try {
// Récupère l'année en cours
AnneeScolaire anneeEnCours =
- anneeScolaireService.anneeScolaireEnCours()
+ anneeScolaireService.anneeScolaireEnCours()
// Pour le premier import de l'année les services créés seront évaluables
// Pour les imports suivant les services créés ne seront pas évaluables
// Vérifie que la date de début de semaine est dans l'année scolaire
Calendar date = StsImportUtil.parseDateDebutSemaine(dateDebutSemaine.toString())
if (
- (date.getTime() >= cal.getTime() &&
- date.getTime() <= calendrier.dernierJour)
+ (date.getTime() >= cal.getTime() &&
+ date.getTime() <= calendrier.dernierJour)
) {
listeDatesDebutSemaine << dateDebutSemaine.toString()
}
// (exception-safe)
Personne enseignant = personneStsService.
internalFindEnseignantByIdStsAndAcademie(
- enseignantCodeSts,
- etablissement.academie
- )
+ enseignantCodeSts,
+ etablissement.academie
+ )
// Récupère la structure d'enseignement
//(exception-safe)
StructureEnseignement structure =
- findClasseByCodeStsAndEtablissement(
- structureCodeSts,
- etablissement,
- enseignantCodeSts,
- rapport
- )
+ findClasseByCodeStsAndEtablissement(
+ structureCodeSts,
+ etablissement,
+ enseignantCodeSts,
+ rapport
+ )
if (enseignant && structure) {
// Mis à jour les relations du professeur principal
String enseignantCodeSts,
StsImportRapport rapport) {
StructureEnseignement classe =
- localStructureEnseignementService.findStructureEnseignement(
- structureCodeSts,
- StructureEnseignement.TYPE_CLASSE,
- etablissement,
- false
- )
+ localStructureEnseignementService.findStructureEnseignement(
+ structureCodeSts,
+ StructureEnseignement.TYPE_CLASSE,
+ etablissement,
+ false
+ )
if (!classe) {
traiteErreurRechercheStructureEnseignement(
rapport.incNbStructuresImportees()
if (structureEnseignementClasse.idExterne == '-1') {
- String messageAlerte = "La structure d'enseignement ${structureEnseignementClasse.code} n'existe pas." +
- "Les droits des cahiers de textes et agendas générés seront incomplets."
+ String messageAlerte = "La structure d'enseignement ${structureEnseignementClasse.code} n'existe pas."
ajouteAlerteEmpSts(messageAlerte, rapport)
rapport.nbStructuresInexistants++
}
traiteErreurGetAgendaStructure(codeStructure, rapport)
return // Interrompt l'import de la structure d'enseignement
}
- else if (agendaStructure.droitsIncomplets ||
- (agendaStructure.structureEnseignement.idExterne == "-1")) {
- miseAJourDroitsAgenda(agendaStructure)
- }
rapport.incNbAgendaStructureCree()
}
}
- /**
- * Repositionne les droits par défaut
- * @param agenda : l'agenda dont on veut mettre à jour les droits
- */
- private void miseAJourDroitsAgenda(Agenda agenda) {
- creeDroitsParDefautSurAgenda(agenda)
-
- }
-
- /**
- * Re-crée les droits par défaut sur l'agenda
- * @param securiteSession : la session de sécurité
- * @param agenda : l'agenda dont on veut créer les droits
- */
- void creeDroitsParDefautSurAgenda(Agenda agenda) {
- tempsAgendaService.mettreDroitsParDefautETStructure(
- agenda,
- agenda.structureEnseignement
- )
- }
-
/**
* Importe les données contenues dans la section groupes du fichier empSts
* @param noeudGroupes le noeud de la section 'groupes' de fichier empSts
rapport.incNbStructuresImportees()
if (structureEnseignementGroupe.idExterne == '-1') {
- String messageAlerte = "La structure d'enseignement ${structureEnseignementGroupe.code} n'existe pas." +
- " Les droits des cahiers de textes et agendas générés seront incomplets."
+ String messageAlerte = "La structure d'enseignement ${structureEnseignementGroupe.code} n'existe pas."
ajouteAlerteEmpSts(messageAlerte, rapport)
rapport.nbStructuresInexistants++
}
)
return // Interruption de l'import de la structure
}
- else if (agendaStructure.droitsIncomplets ||
- (agendaStructure.structureEnseignement.idExterne == "-1")) {
- miseAJourDroitsAgenda(agendaStructure)
- }
-
rapport.incNbAgendaStructureCree()
// Récupération de l'enseignant
Personne anseignant = personneStsService.
internalFindEnseignantByIdStsAndAcademie(
- enseignantIdSts,
- etablissement.academie
- )
+ enseignantIdSts,
+ etablissement.academie
+ )
Autorite autoriteEnseignant = anseignant?.autorite
// Si l'autorité n'a pas pu être récupérée
// Création / mis à jour de l'enseignement et de cahier de textes correspondant
EnseignementMisAjourRapport enseignementMisAjourRapport =
- insertUpdateEnseignement(
- service,
- autoriteEnseignant,
- nbHeures
- )
+ insertUpdateEnseignement(
+ service,
+ autoriteEnseignant,
+ nbHeures
+ )
// Si l'enseignement ne peut pas être récupéré
if (!enseignementMisAjourRapport.enseignement) {
// Récupère l'info d'alternance de ce cours
StsAlternanceInfo alternanceInfo =
- (StsAlternanceInfo) alternanceInfoByCodeAlternance.get(codeAlternance)
+ (StsAlternanceInfo) alternanceInfoByCodeAlternance.get(codeAlternance)
if (!alternanceInfo) {
log.error("Erreur lors du parsing des Alterances.")
String objet = matiere.libelleLong + " - " + structureEnseignement.code
Autorite autoriteTemps =
- DefaultSecuriteSessionFactory.getAutoriteEliotForIdExterne(
- AutoriteTypeEliot.IDEXTERNE_ELIOT_AUTORITE_TEMPS,
- true
- )
+ DefaultSecuriteSessionFactory.getAutoriteEliotForIdExterne(
+ AutoriteTypeEliot.IDEXTERNE_ELIOT_AUTORITE_TEMPS,
+ true
+ )
TypeEvenement type = TypeEvenement.findByType(TypeEvenement.COURS)
// La création de l'événement dans l'agenda de la structure et
// Ajout de l'événement correspondant au cours dans l'agenda enseignemant
tempsEvenementService.
ajouterEvenementToAgendaByTempsAutorite(
- evenementCours,
- agendaEnseignant
- )
+ evenementCours,
+ agendaEnseignant
+ )
}
}
catch (Exception e) {
Double nbHeures) {
SecuriteSession securiteSession = DefaultSecuriteSessionFactory.
getEliotTempsSecuriteSessionForCodePorteurENT(
- service.structureEnseignement.etablissement.codePorteurENT
- )
+ service.structureEnseignement.etablissement.codePorteurENT
+ )
EnseignementMisAjourRapport enseignementMisAjourRapport =
- enseignementService.insertUpdateEnseignement(securiteSession,
- service,
- autoriteEnseignant,
- nbHeures
- )
+ enseignementService.insertUpdateEnseignement(securiteSession,
+ service,
+ autoriteEnseignant,
+ nbHeures
+ )
return enseignementMisAjourRapport
}
service = serviceService.insertUpdateService(
structure,
- matiere,
+ matiere,
modaliteCours,
nbHeuresService,
coEns,
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteParam
import org.lilie.services.eliot.scolarite.annuaire.PersonneProprietesScolariteService
import org.lilie.services.eliot.scolarite.OrigineEnum
+import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.annuaire.PorteurEnt
/**
* Classe utilitaire pour faciliter les tests d'intégration du nouvel annuaire
private static final LIB_LONG = "Libellé long : "
private static final LIB_COURT = "lib court : "
+
+ Personne creePersonne(String idExterne, String nom, String prenom) {
+ checkEnvironnement()
+
+ Autorite autorite = new Autorite(
+ type: Autorite.TYPE_ACTEUR,
+ idExterne: idExterne
+ )
+
+ autorite.setEtat(CompteUtilisateurEtat.ACTIF)
+
+ autorite.save(failOnError: true)
+
+ Personne personne = new Personne(
+ nom: nom,
+ prenom: prenom,
+ autorite: autorite,
+ idSconet: idExterne,
+ dateNaissance: new Date()
+ )
+
+ personne.save(flush: true, failOnError: true)
+ return personne
+ }
+
+
/**
* Inscription d'un élève dans une classe pour une matière, un niveau,
* une année, un établissement, etc...
personneProprietesScolariteService.findOrCreePPS(param)
}
+
+ void ajouteDirecteurDansEtablissement(Personne personne,
+ Etablissement etablissement,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+ checkEnvironnement()
+
+ PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
+ personne: personne,
+ origine: OrigineEnum.MANUEL,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ etablissement: etablissement,
+ anneeScolaire: anneeScolaire,
+ fonction: Fonction.findByCode(FonctionEnum.DIRECTION.getCode()),
+ )
+ )
+
+ personneProprietesScolariteService.findOrCreePPS(param)
+ }
+
+
+ void ajouteParentDansEnt(Personne personne,
+ PorteurEnt porteurEnt,
+ AnneeScolaire anneeScolaire = anneeScolaireService.anneeScolaireEnCours()) {
+ checkEnvironnement()
+
+ PersonneProprietesScolariteParam param = new PersonneProprietesScolariteParam(
+ personne: personne,
+ origine: OrigineEnum.MANUEL,
+ proprietesScolariteParam: new ProprietesScolariteParam(
+ porteurEnt: porteurEnt,
+ anneeScolaire: anneeScolaire,
+ fonction: Fonction.findByCode(FonctionEnum.PERS_REL_ELEVE.getCode()),
+ )
+ )
+
+ personneProprietesScolariteService.findOrCreePPS(param)
+ }
+
+
/**
* Création d'un niveau
* @author othe
</script>
<g:form enctype='multipart/form-data' name="recherche" style="overflow:hidden">
-
+ <g:hiddenField name="itemId" value="${itemId}"/>
<g:if test="${typeRechercheAutorisee!='groupesEtUtilisateurs'}">
<g:hiddenField name="champsRecherche" value="${typeRechercheAutorisee}"/>
</g:if>
<g:remoteLink
controller="annuaire"
action="afficherRechercheGroupe"
- params="${[listeDroitsAMasquer:listeDroitsAMasquerGroupes]}"
+ params="${[listeDroitsAMasquer: listeDroitsAMasquerGroupes, itemId: itemId]}"
update="dialog"
onSuccess="afficherGroupes();">
<img
<tr id="add_u">
<td class="align-right" colspan="4">
-<g:remoteLink
+ <g:remoteLink
controller="annuaire"
action="afficherRechercheUtilisateur"
- params="${[listeDroitsAMasquer:listeDroitsAMasquerActeurs]}"
+ params="${[listeDroitsAMasquer: listeDroitsAMasquerActeurs, itemId: itemId]}"
update="dialog"
onSuccess="afficherUtilisateurs();">
<g:render
template="/commons/droitsEtPermissions/rechercheGroupe"
plugin="eliot-app-plugin"
- model="${[listeDroitsAMasquer:listeDroitsAMasquerGroupes]}"/>
+ model="${[listeDroitsAMasquer:listeDroitsAMasquerGroupes,itemId : itemId]}"/>
</g:if>
</tbody>
<g:render
template="/commons/droitsEtPermissions/rechercheUtilisateur"
plugin="eliot-app-plugin"
- model="${[listeDroitsAMasquer:listeDroitsAMasquerActeurs]}"/>
+ model="${[listeDroitsAMasquer:listeDroitsAMasquerActeurs, itemId : itemId]}"/>
</g:if>
</tbody>
+++ /dev/null
-package org.lilie.services.eliot.droits
-
-import org.lilie.services.eliot.securite.impl.Autorite
-
-/**
- * Reprèsente un droit sur un item
- * @author bahj
- */
-public class Droit {
-
- String type
- String nomAutorite
- String idAutorite
- Autorite autorite
-
- Boolean consultation = false
- Boolean modification = false
- Boolean consultationParDefaut = false
- Boolean modificationParDefaut = false
-
- Boolean estDansAnnuaireEliot = true
- // si l'autorite est le proprietaire d'item
- Boolean estProprietaire = false
-
- String getEntreeId() {
- return type + idAutorite
- }
-
-// boolean equals(o) {
-// if (this.is(o)) {return true}
-// if (!o || getClass() != o.class) {return false}
-// Droit droit = (Droit) o
-// if (!modification.equals(droit.modification)) {return false}
-// if (!type.equals(droit.type)) {return false}
-// if (!idAutorite.equals(droit.idAutorite)) {return false}
-// if (!consultation.equals(droit.consultation)) {return false}
-//
-// return true;
-// }
-//
-// int hashCode() {
-// int result;
-// result = type.hashCode();
-// result = 31 * result + idAutorite.hashCode();
-// result = 31 * result + consultation.hashCode();
-// result = 31 * result + modification.hashCode();
-// return result;
-// }
-
-}
\ No newline at end of file
package org.lilie.services.eliot.securite.impl
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.utils.SpringUtils
+import org.lilie.services.eliot.applications.BaseDonneesEliot
+import org.lilie.services.eliot.applications.ModuleEliot
+import org.codehaus.groovy.grails.commons.ApplicationHolder
-
-/**
- * Classe ancêtre des différentes implémentations de ACLSession
- */
class AbstractACLSession {
// Liste des toutes les autorités (acteur & groupe) associées à cette session
List<Autorite> autorites
+ def grailsApplication = ApplicationHolder.application
+
+ // Service de gestion des groupes de scolarité locaux (= propriétés scolarités)
+ LocalGroupeService localGroupeService =
+ (LocalGroupeService) SpringUtils.getMainContext().getBean(
+ "localGroupeService"
+ )
+
/**
* Méthode retournant la liste des autorisations de la session sur l'item donné
*
return (List<Autorisation>) autorisations
}
+ /**
+ * Récupération de la base de données utilisée par le module
+ */
+ protected BaseDonneesEliot getBaseDonneesEliotUtilisee(){
+ String applicationName = grailsApplication.applicationMeta?.get('app.name')
+ ModuleEliot moduleEliot = ModuleEliot.parseByNom(applicationName)
+ return moduleEliot.getBaseCorrespondante()
+ }
+
+ /**
+ * Récupération des autorités représentant les groupes de scolarité locaux de la personne
+ */
+ protected List<Autorite> getGroupesScolariteLocaux(Personne personne){
+ List<ProprietesScolarite> groupesLocaux = localGroupeService.findAllGroupePourPersonne(personne)
+ return groupesLocaux.findAll{it.autorite != null}*.autorite
+ }
+
}
package org.lilie.services.eliot.securite.impl
/**
- * Décrit les modes (ou implémentations) d'annuaires
+ * Décrit les différents types d'annuaires qu'un module peut utiliser
* @author jtra
*/
public enum AnnuaireMode {
- // Annuaire embarqué par les applications Eliot (référentiel de scolarité)
+ /* NB: Annuaire :
+ voir Eliot-v2 / Glossaire
+ */
+
+ // Concerne les modules qui n'utilisent que l'annuaire local
LOCAL,
- // Annuaire du socle de l'ENT (accès via les API du socle)
- DISTANT
+ // Concerne les modules qui n'utilisent que l'annuaire distant
+ DISTANT,
+
+ // Concerne les modules qui utilisent les annuaires local + distant
+ MIXTE
}
\ No newline at end of file
import org.lilie.services.eliot.securite.PermissionsManager
import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.Permission
/**
* Classe fournissant la gestion des permissions pour un item donné par une
)
- // Définit si les ACL doivent être gérés avec l'annuaire local ou l'annuaire distant
+ // Définit si les ACL doivent être gérés avec l'annuaire local ou l'annuaire distant ou les deux
AnnuaireMode sessionACLmode = null
// Définit si le mode annuaire est distant ou local
case AnnuaireMode.DISTANT:
aclSession = new DistantACLSession(lilieHttpInfo)
break
+ case AnnuaireMode.MIXTE:
+ aclSession = new MixteACLSession(lilieHttpInfo)
+ break
default:
throw new IllegalStateException(
"Le modeACL est incorrect : $sessionACLmode"
import org.lilie.services.eliot.portail.http.LilieHttpInfo
/**
- * Implémentation de l'interface ACLSession utilisant l'annuaire local
+ * Implémentation de l'interface ACLSession pour les modules utilisant uniquement
+ * l'annuaire distant
* @author jtra
*
* Note : dans un 1er les données nomAffichage & defaultAutorite doivent être fournies à la
codePorteurENT: lilieHttpInfo.codePorteurENT
)
- // initialisation des autorites
+ // récupération de l'autorité représentant l'acteur + des autorités représentant
+ // les groupes de scolarité distant de l'acteur
autorites = (List) distantAutoriteService.getAutoritesForActeur(
acteur.codePorteurENT,
acteur
import org.lilie.services.eliot.portail.http.LilieHttpInfo
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.utils.SpringUtils
+import org.lilie.services.eliot.applications.BaseDonneesEliot
/**
- * Implémentation de l'interface ACLSession utilisant l'annuaire local
+ * Implémentation de l'interface ACLSession pour les modules utilisant uniquement
+ * l'annuaire local
* @author jtra
*/
class LocalACLSession extends AbstractACLSession implements ACLSession {
LocalPersonneService localPersonneService =
(LocalPersonneService)SpringUtils.mainContext.getBean(
- 'localPersonneService'
+ 'localPersonneService'
)
/**
def LocalACLSession(LilieHttpInfo lilieHttpInfo) {
// Récupération de la personne
Personne personne = localPersonneService.findPersonneByIdExterne(
- lilieHttpInfo.personneIdExterne
+ lilieHttpInfo.personneIdExterne
)
// Traite l'erreur si la personne n'existe pas
if(!personne) {
throw new IllegalStateException(
- "La personne d'idExterne ${lilieHttpInfo.personneIdExterne} "+
- "n'existe pas"
+ "La personne d'idExterne ${lilieHttpInfo.personneIdExterne} "+
+ "n'existe pas"
)
}
+ // on récupère les groupes locaux seulement si on utilise la base eliot-scolarite
+ // car les groupes de scolarités sont les ps et les ps n'existent que dans
+ // cette base
+ if (BaseDonneesEliot.ELIOT_SCOLARITE == getBaseDonneesEliotUtilisee()){
+ // récupération des autorités représentant les groupes de scolarité locaux de la personne
+ autorites = (getGroupesScolariteLocaux(personne))
+ }
+
defaultAutorite = personne.autorite
nomAffichage = localPersonneService.getNomAffichage(personne)
}
return defaultAutorite
}
- List<Autorite> getAutorites() {
- throw new IllegalStateException(
- "Cette méthode n'est pas encore supportée par l'annuaire local"
- )
- }
-
}
--- /dev/null
+package org.lilie.services.eliot.securite.impl
+
+import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
+import org.lilie.services.eliot.utils.SpringUtils
+import org.lilie.services.eliot.portail.http.LilieHttpInfo
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.DistantAutoriteService
+import org.lilie.services.eliot.annuaire.Acteur
+import org.lilie.services.eliot.securite.ACLSession
+import org.lilie.services.eliot.applications.BaseDonneesEliot
+
+/*
+ * Implémentation de l'interface ACLSession pour les modules
+ * utilisant à la fois l'annuaire local et l'annuaire de CGI
+ */
+class MixteACLSession extends AbstractACLSession implements ACLSession {
+
+
+ String nomAffichage
+ Autorite defaultAutorite
+
+
+ LocalPersonneService localPersonneService =
+ (LocalPersonneService)SpringUtils.mainContext.getBean(
+ 'localPersonneService'
+ )
+ // Service de gestion des autorités correspondant à des données de l'annuaire distant
+ DistantAutoriteService distantAutoriteService =
+ (DistantAutoriteService) SpringUtils.getMainContext().getBean(
+ "distantAutoriteService"
+ )
+
+
+ def MixteACLSession(LilieHttpInfo lilieHttpInfo){
+ // Récupération de la personne
+ Personne personne = localPersonneService.findPersonneByIdExterne(
+ lilieHttpInfo.personneIdExterne
+ )
+
+ // Traite l'erreur si la personne n'existe pas
+ if(!personne) {
+ throw new IllegalStateException(
+ "La personne d'idExterne ${lilieHttpInfo.personneIdExterne} "+
+ "n'existe pas"
+ )
+ }
+
+
+ // Note jtra : cette construction de l'acteur est partielle ... idéalement, il faudrait définir
+ // des méthodes de récupération des autorités dans DistantAutoriteService qui soient
+ // basées sur un objet LilieHttpInfo au lieu de l'objet Acteur
+ Acteur acteur = new Acteur(
+ idExterne: lilieHttpInfo.personneIdExterne,
+ groupesIds: lilieHttpInfo.groupesIds,
+ codePorteurENT: lilieHttpInfo.codePorteurENT
+ )
+
+ // on récupère les groupes locaux seulement si on utilise la base eliot-scolarite
+ // car les groupes de scolarités sont les ps et les ps n'existent que dans
+ // cette base
+ if (BaseDonneesEliot.ELIOT_SCOLARITE == getBaseDonneesEliotUtilisee()){
+ // récupération des autorités représentant les groupes de scolarité locaux de la personne
+ autorites = (getGroupesScolariteLocaux(personne))
+ }
+ // récupération de l'autorité représentant l'acteur + des autorités représentant
+ // les groupes de scolarité distants de l'acteur
+ if (!autorites){
+ autorites = []
+ }
+ autorites.addAll(distantAutoriteService.getAutoritesForActeur(
+ acteur.codePorteurENT,
+ acteur
+ ))
+
+ nomAffichage = localPersonneService.getNomAffichage(personne)
+ defaultAutorite = personne.autorite
+
+ }
+
+ Autorite getDefaultAutorite() {
+ return defaultAutorite
+ }
+}
}
void testGetAutoriteForTypeAndIdExterne() {
- Autorite autorite1 = localAutoriteService.getAutoriteForTypeAndIdExterne(
- Autorite.TYPE_ACTEUR,
+ Autorite autorite1 = localAutoriteService.getAutoriteActeurForIdExterne(
PopulationTestActeur.ENSEIGNANT_2_2.idExterne
)
assertNotNull("L'autorite n'a pas été trouvée", autorite1)
- Autorite autorite2 = localAutoriteService.getAutoriteForTypeAndIdExterne(
- Autorite.TYPE_ACTEUR,
+ Autorite autorite2 = localAutoriteService.getAutoriteActeurForIdExterne(
'TEST--ID--EXTERNE'
)
assertNull("L'autorite a été trouvée à tort", autorite2)
- Autorite autorite3 = localAutoriteService.getAutoriteForTypeAndIdExterne(
- Autorite.TYPE_ACTEUR,
+ Autorite autorite3 = localAutoriteService.getAutoriteActeurForIdExterne(
'TEST--ID--EXTERNE',
true
)
assertNotNull("L'autorite n'a pas été créée", autorite3)
-
- Autorite autorite4 = localAutoriteService.getAutoriteForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- PopulationTestActeur.ENSEIGNANT_2_2.idExterne
- )
- assertNull("L'autorite a été trouvée à tort", autorite4)
-
}
void testGetAutoriteByIdSts() {
--- /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.scolarite
+
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.annuaire.Fonction
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.annuaire.PorteurEnt
+import org.lilie.services.eliot.securite.impl.Autorite
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.annuaire.Niveau
+
+import org.lilie.services.eliot.test.ProprieteScolariteTestUtilService
+import org.lilie.services.eliot.annuaire.ResponsableEleve
+
+
+class LocalGroupeServiceTests extends GroovyTestCase{
+
+ LocalGroupeService localGroupeService
+ LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
+ AnneeScolaireService anneeScolaireService
+ ProprieteScolariteTestUtilService proprieteScolariteTestUtilService
+
+ AnneeScolaire anneeScolaireEnCours
+
+ private void setUp(){
+ super.setUp()
+ init()
+ }
+
+ private void init(){
+ anneeScolaireEnCours = anneeScolaireService.anneeScolaireEnCours()
+ }
+
+ void testFindOrCreeGroupeStructureEnseignement(){
+
+ // test avec un groupe existant
+
+ Etablissement etablissement = new Etablissement(
+ idExterne: '12345abcde',
+ codePorteurENT: 'aaaaa',
+ nomAffichage: 'établissement de test'
+ )
+ etablissement.save(failOnError: true)
+
+ StructureEnseignement se = new StructureEnseignement(
+ idExterne: 'abcde1234',
+ etablissement: etablissement,
+ type: StructureEnseignement.TYPE_GROUPE,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'groupe de test'
+ )
+ se.save(failOnError: true)
+
+ Fonction fonction = (Fonction)Fonction.getAll().get(0)
+
+ Boolean responsableStructureEnseignement = null
+
+ ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ structureEnseignement: se,
+ fonction: fonction,
+ responsableStructureEnseignement: responsableStructureEnseignement
+ )
+
+ ProprietesScolarite psDepart =
+ proprietesScolarite.save(failOnError: true, flush: true)
+
+ assertNotNull("Le groupe de départ n'a pas été sauvegardé en base", psDepart)
+
+ ProprietesScolarite ps =
+ localGroupeService.findOrCreeGroupeStructureEnseignement(se, fonction, responsableStructureEnseignement)
+
+ assertNotNull("Le groupe n'a pas été retrouvé", ps)
+
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.anneeScolaire,
+ ps.anneeScolaire)
+ assertEquals("La structure d'enseignement du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.structureEnseignement,
+ ps.structureEnseignement)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.fonction,
+ ps.fonction)
+ assertEquals("""La valeur de l'attribut responsableStructureEnseignement
+ du groupe retrouvé ne correspond pas à celle du groupe recherché""",
+ proprietesScolarite.responsableStructureEnseignement,
+ ps.responsableStructureEnseignement)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+
+
+ // test avec un groupe inexistant
+
+ Etablissement etablissement2 = new Etablissement(
+ idExterne: '12345abcdeEtab2',
+ codePorteurENT: 'aaaaa2',
+ nomAffichage: 'établissement de test 2'
+ )
+ etablissement2.save(failOnError: true)
+
+ StructureEnseignement se2 = new StructureEnseignement(
+ idExterne: 'abcde1234se2',
+ etablissement: etablissement2,
+ type: StructureEnseignement.TYPE_GROUPE,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'groupe de test 2'
+ )
+ se2.save(failOnError: true)
+
+ Fonction fonction2 = (Fonction)Fonction.getAll().get(0)
+
+ boolean responsableStructureEnseignement2 = true
+
+ ProprietesScolarite proprietesScolarite2 = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ structureEnseignement: se2,
+ fonction: fonction2,
+ responsableStructureEnseignement: responsableStructureEnseignement2
+ )
+
+ ProprietesScolarite ps2 =
+ localGroupeService.findOrCreeGroupeStructureEnseignement(se2, fonction2, responsableStructureEnseignement2)
+
+ assertNotNull("Le groupe n'a pas été créé", ps)
+
+ assertEquals("L'année scolaire du groupe créé n'est pas correcte",
+ proprietesScolarite2.anneeScolaire,
+ ps2.anneeScolaire)
+ assertEquals("La structure d'enseignement du groupe créé n'est pas correcte",
+ proprietesScolarite2.structureEnseignement,
+ ps2.structureEnseignement)
+ assertEquals("La fonction du groupe créé n'est pas correcte",
+ proprietesScolarite2.fonction,
+ ps2.fonction)
+ assertEquals("""La valeur de l'attribut responsableStructureEnseignement
+ du groupe créé n'est pas correcte""",
+ proprietesScolarite2.responsableStructureEnseignement,
+ ps2.responsableStructureEnseignement)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps2.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps2.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps2.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps2.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps2.autorite.idEnregistrementCible == ps2.id)
+
+ }
+
+ void testFindOrCreeGroupeEtablissement(){
+
+ // test avec un groupe existant
+
+ Etablissement etablissement = new Etablissement(
+ idExterne: '12345abcde',
+ codePorteurENT: 'aaaaa',
+ nomAffichage: 'établissement de test'
+ )
+ etablissement.save(failOnError: true)
+
+ Fonction fonction = (Fonction)Fonction.getAll().get(0)
+
+ Matiere matiere = null
+
+ ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ etablissement: etablissement,
+ fonction: fonction,
+ matiere: matiere
+ )
+
+ ProprietesScolarite psDepart =
+ proprietesScolarite.save(failOnError: true, flush: true)
+
+ assertNotNull("Le groupe de départ n'a pas été sauvegardé en base", psDepart)
+
+ ProprietesScolarite ps =
+ localGroupeService.findOrCreeGroupeEtablissement(etablissement, fonction, matiere)
+
+ assertNotNull("Le groupe n'a pas été retrouvé", ps)
+
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.anneeScolaire,
+ ps.anneeScolaire)
+ assertEquals("L'établissement du groupe retrouvé ne correspond pas à celui du groupe recherché",
+ proprietesScolarite.etablissement,
+ ps.etablissement)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.fonction,
+ ps.fonction)
+ assertEquals("La matière du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.matiere,
+ ps.matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+
+
+ // test avec un groupe inexistant
+
+ Etablissement etablissement2 = new Etablissement(
+ idExterne: '12345abcdeEtab2',
+ codePorteurENT: 'aaaaa2',
+ nomAffichage: 'établissement de test 2'
+ )
+ etablissement2.save(failOnError: true)
+
+ Fonction fonction2 = (Fonction)Fonction.getAll().get(0)
+
+ ProprietesScolarite proprietesScolarite2 = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ etablissement: etablissement2,
+ fonction: fonction2,
+ matiere: matiere
+ )
+
+ ProprietesScolarite ps2 =
+ localGroupeService.findOrCreeGroupeEtablissement(etablissement2, fonction2, matiere)
+
+ assertNotNull("Le groupe n'a pas été créé", ps)
+
+ assertEquals("L'année scolaire du groupe créé n'est pas correcte",
+ proprietesScolarite2.anneeScolaire,
+ ps2.anneeScolaire)
+ assertEquals("L'établissement du groupe créé n'est pas correct",
+ proprietesScolarite2.etablissement,
+ ps2.etablissement)
+ assertEquals("La fonction du groupe créé n'est pas correcte",
+ proprietesScolarite2.fonction,
+ ps2.fonction)
+ assertEquals("La matière du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.matiere,
+ ps.matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps2.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps2.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps2.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps2.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps2.autorite.idEnregistrementCible == ps2.id)
+
+ }
+
+ void testFindOrCreeGroupePorteurEnt(){
+
+ // test avec un groupe existant
+
+ PorteurEnt porteurEnt = new PorteurEnt(
+ code: 'porteur de test'
+ )
+ porteurEnt.save(failOnError: true)
+
+ Fonction fonction = (Fonction)Fonction.getAll().get(0)
+
+ ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ porteurEnt: porteurEnt,
+ fonction: fonction
+ )
+
+ ProprietesScolarite psDepart =
+ proprietesScolarite.save(failOnError: true, flush: true)
+
+ assertNotNull("Le groupe de départ n'a pas été sauvegardé en base", psDepart)
+
+ ProprietesScolarite ps =
+ localGroupeService.findOrCreeGroupePorteurEnt(porteurEnt, fonction)
+
+ assertNotNull("Le groupe n'a pas été retrouvé", ps)
+
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.anneeScolaire,
+ ps.anneeScolaire)
+ assertEquals("Le porteur ENT du groupe retrouvé ne correspond pas à celui du groupe recherché",
+ proprietesScolarite.porteurEnt,
+ ps.porteurEnt)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolarite.fonction,
+ ps.fonction)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+
+
+ // test avec un groupe inexistant
+
+ PorteurEnt porteurEnt2 = new PorteurEnt(
+ code: 'porteur de test 2'
+ )
+ porteurEnt2.save(failOnError: true)
+
+ Fonction fonction2 = (Fonction)Fonction.getAll().get(0)
+
+ ProprietesScolarite proprietesScolarite2 = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ porteurEnt: porteurEnt2,
+ fonction: fonction2
+ )
+
+ ProprietesScolarite ps2 =
+ localGroupeService.findOrCreeGroupePorteurEnt(porteurEnt2, fonction2)
+
+ assertNotNull("Le groupe n'a pas été créé", ps)
+
+ assertEquals("L'année scolaire du groupe créé n'est pas correcte",
+ proprietesScolarite2.anneeScolaire,
+ ps2.anneeScolaire)
+ assertEquals("Le porteur ENT du groupe créé n'est pas correct",
+ proprietesScolarite2.porteurEnt,
+ ps2.porteurEnt)
+ assertEquals("La fonction du groupe créé n'est pas correcte",
+ proprietesScolarite2.fonction,
+ ps2.fonction)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps2.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps2.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps2.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps2.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps2.autorite.idEnregistrementCible == ps2.id)
+
+ }
+
+ void testFindOrCreeAllGroupeEtablissementCiteScolaire(){
+
+ /** test avec cité scolaire avec groupes **/
+
+ Etablissement citeScolaire = new Etablissement(
+ idExterne: '12345abcde',
+ codePorteurENT: 'aaaaa',
+ nomAffichage: 'cité scolaire de test'
+ )
+ citeScolaire.etablissementRattachement = citeScolaire
+ citeScolaire.save(failOnError: true)
+
+ Fonction fonction = (Fonction)Fonction.getAll().get(0)
+
+ Matiere matiere = null
+
+ ProprietesScolarite proprietesScolariteCite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ etablissement: citeScolaire,
+ fonction: fonction,
+ matiere: matiere
+ )
+
+ ProprietesScolarite psCiteDepart =
+ proprietesScolariteCite.save(failOnError: true, flush: true)
+
+ assertNotNull("Le groupe de départ de la cité scolaire ${citeScolaire.nomAffichage} n'a pas été sauvegardé en base", psCiteDepart)
+
+ Etablissement etablissementRattache = new Etablissement(
+ idExterne: 'abcde12345',
+ codePorteurENT: 'aaaaa',
+ nomAffichage: 'établissement de test'
+ )
+ etablissementRattache.etablissementRattachement = citeScolaire
+ etablissementRattache.save(failOnError: true)
+
+ ProprietesScolarite proprietesScolariteEtab = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ etablissement: etablissementRattache,
+ fonction: fonction,
+ matiere: matiere
+ )
+
+ ProprietesScolarite psEtabDepart =
+ proprietesScolariteEtab.save(failOnError: true, flush: true)
+
+ assertNotNull("Le groupe de départ de l'établissement ${etablissementRattache.nomAffichage} n'a pas été sauvegardé en base", psEtabDepart)
+
+ // recherche des groupes en passant en paramètre la cité scolaire
+ List<ProprietesScolarite> psListByCite =
+ localGroupeService.findOrCreeAllGroupeEtablissementCiteScolaire(citeScolaire, fonction, matiere)
+
+ assertNotNull("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste",
+ psListByCite)
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste non vide",
+ !psListByCite.isEmpty())
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste contenant 2 ps",
+ psListByCite.size() == 2)
+
+ boolean psDeCiteExiste = false
+ boolean psDetabExiste = false
+
+ psListByCite.each{ ProprietesScolarite ps ->
+ if (ps.etablissement == citeScolaire){
+ psDeCiteExiste = true
+ assertTrue("L'année scolaire du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ } else if (ps.etablissement == etablissementRattache){
+ psDetabExiste = true
+ assertTrue("L'année scolaire du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ }
+ }
+
+ assertTrue("Aucun groupe n'a été créé pour la cité scolaire ${citeScolaire.nomAffichage}", psDeCiteExiste)
+ assertTrue("Aucun groupe n'a été créé pour l'établissement rattaché ${etablissementRattache.nomAffichage}", psDetabExiste)
+
+ // recherche des groupes en passant en paramètre l'établissement lié à la cité scolaire
+ List<ProprietesScolarite> psListByEtab =
+ localGroupeService.findOrCreeAllGroupeEtablissementCiteScolaire(etablissementRattache, fonction, matiere)
+
+ assertNotNull("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste",
+ psListByEtab)
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste non vide",
+ !psListByEtab.isEmpty())
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste contenant 2 ps",
+ psListByEtab.size() == 2)
+
+ boolean psDeCiteExiste2 = false
+ boolean psDetabExiste2 = false
+
+ psListByEtab.each{ ProprietesScolarite ps ->
+ if (ps.etablissement == citeScolaire){
+ psDeCiteExiste2 = true
+ assertTrue("L'année scolaire du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de la cité scolaire ${citeScolaire.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ } else if (ps.etablissement == etablissementRattache){
+ psDetabExiste2 = true
+ assertTrue("L'année scolaire du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de l'établissement ${etablissementRattache.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ }
+ }
+
+ assertTrue("Aucun groupe n'a été créé pour la cité scolaire ${citeScolaire.nomAffichage}", psDeCiteExiste2)
+ assertTrue("Aucun groupe n'a été créé pour l'établissement rattaché ${etablissementRattache.nomAffichage}", psDetabExiste2)
+
+ /****/
+
+ /** test avec cité scolaire sans groupes **/
+
+ Etablissement citeScolaire2 = new Etablissement(
+ idExterne: '12345abcde2',
+ codePorteurENT: 'aaaaa2',
+ nomAffichage: 'cité scolaire de test 2'
+ )
+ citeScolaire2.etablissementRattachement = citeScolaire2
+ citeScolaire2.save(failOnError: true)
+
+ Etablissement etablissementRattache2 = new Etablissement(
+ idExterne: 'abcde123452',
+ codePorteurENT: 'aaaaa2',
+ nomAffichage: 'établissement de test 2'
+ )
+ etablissementRattache2.etablissementRattachement = citeScolaire2
+ etablissementRattache2.save(failOnError: true)
+
+ List<ProprietesScolarite> psListByCite2 =
+ localGroupeService.findOrCreeAllGroupeEtablissementCiteScolaire(citeScolaire2, fonction, matiere)
+
+ assertNotNull("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste",
+ psListByCite2)
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste non vide",
+ !psListByCite2.isEmpty())
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste contenant 2 ps",
+ psListByCite2.size() == 2)
+
+ boolean psDeCiteExiste3 = false
+ boolean psDetabExiste3 = false
+
+ psListByCite2.each{ ProprietesScolarite ps ->
+ if (ps.etablissement == citeScolaire2){
+ psDeCiteExiste3 = true
+ assertTrue("L'année scolaire du groupe de la cité scolaire ${citeScolaire2.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de la cité scolaire ${citeScolaire2.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de la cité scolaire ${citeScolaire2.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ } else if (ps.etablissement == etablissementRattache2){
+ psDetabExiste3 = true
+ assertTrue("L'année scolaire du groupe de l'établissement ${etablissementRattache2.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de l'établissement ${etablissementRattache2.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de l'établissement ${etablissementRattache2.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ }
+ }
+
+ assertTrue("Aucun groupe n'a été créé pour la cité scolaire ${citeScolaire2.nomAffichage}", psDeCiteExiste3)
+ assertTrue("Aucun groupe n'a été créé pour l'établissement rattaché ${etablissementRattache2.nomAffichage}", psDetabExiste3)
+
+ /****/
+
+ /** test avec cité scolaire dont la cité et un établissement ont un groupe et l'autre non **/
+
+ Etablissement etablissementRattache3 = new Etablissement(
+ idExterne: 'abcde123453',
+ codePorteurENT: 'aaaaa3',
+ nomAffichage: 'établissement de test 3'
+ )
+ etablissementRattache3.etablissementRattachement = citeScolaire2
+ etablissementRattache3.save(failOnError: true)
+
+ List<ProprietesScolarite> psListByCite3 =
+ localGroupeService.findOrCreeAllGroupeEtablissementCiteScolaire(citeScolaire2, fonction, matiere)
+
+ assertNotNull("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste",
+ psListByCite3)
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste non vide",
+ !psListByCite3.isEmpty())
+ assertTrue("La méthode findOrCreeAllGroupeEtablissementCiteScolaire devrait retourner une liste contenant 3 ps",
+ psListByCite3.size() == 3)
+
+ boolean psDetabExiste4 = false
+
+ psListByCite3.each{ ProprietesScolarite ps ->
+ if (ps.etablissement == etablissementRattache3){
+ psDetabExiste4 = true
+ assertTrue("L'année scolaire du groupe de l'établissement ${etablissementRattache3.nomAffichage} n'est pas correcte",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La fonction du groupe de l'établissement ${etablissementRattache3.nomAffichage} n'est pas correct",
+ ps.fonction == fonction)
+ assertTrue("La matière du groupe de l'établissement ${etablissementRattache3.nomAffichage} n'est pas correcte",
+ ps.matiere == matiere)
+ assertNotNull("Le groupe/ps devrait être liée à une autorité", ps.autorite)
+ assertTrue("L'autorité liée au groupe devrait être de type Groupe",
+ ps.autorite.type == Autorite.TYPE_GROUPE)
+ assertTrue("La localisation de l'autorité liée au groupe devrait être Locale",
+ ps.autorite.localisation == Autorite.LOCALISATION_LOCALE)
+ assertTrue("Le nom de l'entité cible de l'autorité liée au groupe devrait être 'ent.propriete_scolarite'",
+ ps.autorite.nomEntiteCible.equalsIgnoreCase('ent.propriete_scolarite'))
+ assertTrue("L'id de l'enregistrement cible de l'autorité devrait être l'id du groupe/ps",
+ ps.autorite.idEnregistrementCible == ps.id)
+ }
+ }
+
+ assertTrue("Aucun groupe n'a été créé pour l'établissement rattaché ${etablissementRattache3.nomAffichage}", psDetabExiste4)
+
+ /****/
+
+ }
+
+ void testFindOrCreeAllGroupeEnseignantForStructureGroupe(){
+
+ Etablissement etablissement = new Etablissement(
+ idExterne: '12345abcde',
+ codePorteurENT: 'aaaaa',
+ nomAffichage: 'établissement de test'
+ )
+ etablissement.save(failOnError: true)
+
+ Niveau niveau = (Niveau) Niveau.getAll().get(0)
+
+ StructureEnseignement classe1 = new StructureEnseignement(
+ idExterne: '111111111x',
+ etablissement: etablissement,
+ type: StructureEnseignement.TYPE_CLASSE,
+ niveau: niveau,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'classe de test 1'
+ )
+ classe1.save(failOnError: true)
+
+ StructureEnseignement classe2 = new StructureEnseignement(
+ idExterne: '222222222x',
+ etablissement: etablissement,
+ type: StructureEnseignement.TYPE_CLASSE,
+ niveau: niveau,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'classe de test 2'
+ )
+ classe2.save(failOnError: true)
+
+ StructureEnseignement groupe = new StructureEnseignement(
+ idExterne: 'abcde1234',
+ etablissement: etablissement,
+ type: StructureEnseignement.TYPE_GROUPE,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'groupe de test',
+ classes: [classe1, classe2]
+ )
+ groupe.save(failOnError: true)
+
+ Fonction fonctionEnseignant = Fonction.findByCode(FonctionEnum.ENSEIGNANT.code)
+
+ // groupe d'enseignants non principaux de la classe 1
+ ProprietesScolarite proprietesScolariteClasse1 = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ structureEnseignement: classe1,
+ fonction: fonctionEnseignant,
+ responsableStructureEnseignement: null
+ )
+ proprietesScolariteClasse1.save(failOnError: true, flush: true)
+
+ // groupe d'enseignants principaux de la classe 2
+ ProprietesScolarite proprietesScolariteClasse2 = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireEnCours,
+ structureEnseignement: classe2,
+ fonction: fonctionEnseignant,
+ responsableStructureEnseignement: true
+ )
+ proprietesScolariteClasse2.save(failOnError: true, flush: true)
+
+ /** test recherche groupes d'enseignants non principaux des classes d'une structure d'ens. de type groupe **/
+
+ List<ProprietesScolarite> psList =
+ localGroupeService.findOrCreeAllGroupeEnseignantForStructureGroupe(groupe)
+
+ assertNotNull("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner une liste de ps""", psList)
+ assertTrue("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner une liste non vide de ps""", !psList.isEmpty())
+ assertTrue("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner 3 ps""", psList.size() == 3)
+
+ boolean existePsGroupe = false
+ boolean existePsClasse1 = false
+ boolean existePsClasse2 = false
+
+ psList.each{ ProprietesScolarite ps ->
+ if (ps.structureEnseignement == groupe){
+ existePsGroupe = true
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ anneeScolaireEnCours,
+ ps.anneeScolaire)
+ assertEquals("La structure d'enseignement du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ groupe,
+ ps.structureEnseignement)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ fonctionEnseignant,
+ ps.fonction)
+ assertTrue("Le groupe retrouvé devrait être un groupe d'enseignants non principaux",
+ !ps.responsableStructureEnseignement)
+ } else if (ps.structureEnseignement == classe1){
+ existePsClasse1 = true
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.anneeScolaire,
+ ps.anneeScolaire)
+ assertEquals("La structure d'enseignement du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.structureEnseignement,
+ ps.structureEnseignement)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.fonction,
+ ps.fonction)
+ assertTrue("Le groupe retrouvé devrait être un groupe d'enseignants non principaux",
+ !ps.responsableStructureEnseignement)
+ } else if (ps.structureEnseignement == classe2){
+ existePsClasse2 = true
+ assertTrue("L'année scolaire du groupe créé devrait être l'année en cours",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La structure d'enseignement du groupe créé devrait être la classe de code ${classe2.code}",
+ ps.structureEnseignement == classe2)
+ assertTrue("La fonction du groupe créé devrait être Enseignant",
+ ps.fonction == fonctionEnseignant)
+ assertTrue("Le groupe créé devrait être un groupe d'enseignants non principaux",
+ !ps.responsableStructureEnseignement)
+ }
+ }
+
+ assertTrue("Il n'y a pas de groupe d'enseignants non principaux pour la classe 1",
+ existePsClasse1)
+ assertTrue("Il n'y a pas de groupe d'enseignants non principaux pour la classe 2",
+ existePsClasse2)
+
+ /****/
+
+ /** test recherche groupes d'enseignants principaux des classes d'une structure d'ens. de type groupe **/
+
+ List<ProprietesScolarite> psList2 =
+ localGroupeService.findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(groupe)
+
+ assertNotNull("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner une liste de ps""", psList2)
+ assertTrue("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner une liste non vide de ps""", !psList2.isEmpty())
+ assertTrue("""La méthode findOrCreeAllGroupeEnseignantDeClasseForStructureGroupe devrait
+ retourner 2 ps""", psList2.size() == 2)
+
+ existePsClasse1 = false
+ existePsClasse2 = false
+
+ psList2.each{ ProprietesScolarite ps ->
+ if (ps.structureEnseignement == classe1){
+ existePsClasse1 = true
+ assertEquals("L'année scolaire du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.anneeScolaire,
+ ps.anneeScolaire)
+ assertEquals("La structure d'enseignement du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.structureEnseignement,
+ ps.structureEnseignement)
+ assertEquals("La fonction du groupe retrouvé ne correspond pas à celle du groupe recherché",
+ proprietesScolariteClasse1.fonction,
+ ps.fonction)
+ assertTrue("Le groupe retrouvé devrait être un groupe d'enseignants principaux",
+ ps.responsableStructureEnseignement)
+ } else if (ps.structureEnseignement == classe2){
+ existePsClasse2 = true
+ assertTrue("L'année scolaire du groupe créé devrait être l'année en cours",
+ ps.anneeScolaire == anneeScolaireEnCours)
+ assertTrue("La structure d'enseignement du groupe créé devrait être la classe de code ${classe2.code}",
+ ps.structureEnseignement == classe2)
+ assertTrue("La fonction du groupe créé devrait être Enseignant",
+ ps.fonction == fonctionEnseignant)
+ assertTrue("Le groupe créé devrait être un groupe d'enseignants principaux",
+ ps.responsableStructureEnseignement)
+ }
+ }
+
+ assertTrue("Il n'y a pas de groupe d'enseignants non principaux pour la classe 1",
+ existePsClasse1)
+ assertTrue("Il n'y a pas de groupe d'enseignants non principaux pour la classe 2",
+ existePsClasse2)
+
+
+ /****/
+
+ }
+
+
+ void testFindAllGroupePourPersonne() {
+
+ PorteurEnt porteurEnt = new PorteurEnt(
+ code: 'TEST'
+ )
+ porteurEnt.save(failOnError: true)
+
+ Etablissement etablissement = new Etablissement(
+ idExterne: '12345abcde',
+ porteurEnt: porteurEnt,
+ codePorteurENT: porteurEnt.code,
+ nomAffichage: 'établissement de test'
+ )
+ etablissement.save(failOnError: true)
+
+ Niveau niveau = (Niveau) Niveau.getAll().get(0)
+
+ StructureEnseignement classe = new StructureEnseignement(
+ idExterne: '111111111x',
+ etablissement: etablissement,
+ type: StructureEnseignement.TYPE_CLASSE,
+ niveau: niveau,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'classe de test 1'
+ )
+ classe.save(failOnError: true)
+
+ localGroupeService.findOrCreeGroupeDeParents(classe)
+
+ Personne personne = proprieteScolariteTestUtilService.creePersonne(
+ '00000002',
+ 'Dupont',
+ 'Pierre'
+ )
+
+ proprieteScolariteTestUtilService.ajouteParentDansEnt(personne, porteurEnt)
+ proprieteScolariteTestUtilService.ajouteDirecteurDansEtablissement(personne, etablissement)
+ proprieteScolariteTestUtilService.ajouteEnseignantDansStructureEnseignement(personne, classe)
+
+ Personne eleve = proprieteScolariteTestUtilService.creePersonne(
+ '00000001',
+ 'Dupont',
+ 'Marie'
+ )
+
+ proprieteScolariteTestUtilService.ajouteEleveDansStructureEnseignement(eleve, classe)
+
+ ResponsableEleve responsableEleve = new ResponsableEleve(
+ personne: personne,
+ eleve: eleve,
+ estValidee: true,
+ responsableLegal: 1
+ )
+
+ responsableEleve.save(failOnError: true, flush: true)
+
+ List<ProprietesScolarite> groupes = localGroupeService.findAllGroupePourPersonne(personne)
+
+ assertEquals (
+ "La nombre de groupes retournés n'est pas correct",
+ 4,
+ groupes.size())
+
+ ProprietesScolarite groupeDirection = (ProprietesScolarite) groupes.find {
+ it.fonction.code == FonctionEnum.DIRECTION.code &&
+ it.etablissement?.id == etablissement.id
+ }
+
+ assertNotNull (
+ "Il manque le groupe de direction de l'établissement parmis les groupes retournés",
+ groupeDirection)
+
+ ProprietesScolarite groupeEnseignants = (ProprietesScolarite) groupes.find {
+ it.fonction.code == FonctionEnum.ENSEIGNANT.code &&
+ it.structureEnseignement?.id == classe.id
+ }
+
+ assertNotNull (
+ "Il manque le groupe d'enseignants de la classe parmis les groupes retournés",
+ groupeEnseignants)
+
+ ProprietesScolarite groupeParentsClasse = (ProprietesScolarite) groupes.find {
+ it.fonction.code == FonctionEnum.PERS_REL_ELEVE.code &&
+ it.structureEnseignement?.id == classe.id
+ }
+
+ assertNotNull (
+ "Il manque le groupe de parents de la classe parmis les groupes retournés",
+ groupeParentsClasse)
+
+ ProprietesScolarite groupeParentsEnt = (ProprietesScolarite) groupes.find {
+ it.fonction.code == FonctionEnum.PERS_REL_ELEVE.code &&
+ it.porteurEnt?.id == porteurEnt.id
+ }
+
+ assertNotNull (
+ "Il manque le groupe de parents de l'ENT parmis les groupes retournés",
+ groupeParentsEnt)
+
+ }
+
+}
),
anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
fonction: Fonction.findByCode(FonctionEnum.DOCUMENTALISTE.getCode()),
- responsableStructureEnseignement: false
+ responsableStructureEnseignement: null
)
PersonneProprietesScolariteParam paramPps =
--- /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.temps
+
+import org.lilie.services.eliot.securite.impl.Item
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+
+
+class DroitsParGroupe {
+ ProprietesScolarite ps
+ Item item
+ boolean peutConsulter
+ boolean peutModifier
+ boolean peutConsulterDEP
+ boolean peutModifierDEP
+}
package org.lilie.services.eliot.temps
-import grails.test.*
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.securite.impl.Item
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.DistantAutoriteService
import org.lilie.services.eliot.securite.Permission
-import org.lilie.services.eliot.securite.AccessManager
-import org.lilie.services.eliot.securite.AutorisationException
import org.lilie.services.eliot.scolarite.structureenseignement.DistantStructureEnseignementService
import org.lilie.services.eliot.ItemService
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.test.PopulationTestClasse
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
+import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
class TempsAgendaServiceTests extends GroovyTestCase {
DistantAutoriteService distantAutoriteService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
DistantStructureEnseignementService distantStructureEnseignementService
+ LocalStructureEnseignementService localStructureEnseignementService
+ LocalGroupeService localGroupeService
protected void setUp() {
super.setUp()
assertNotNull('IdExterne str', str.idExterne)
// récupère le type d'agenda
- TypeAgendaEnum typeAgendaEnumStruct = TypeAgendaEnum.ETS
TypeAgenda typeAgendaStruct = typeAgendaService.getAgendaTypeFromCode(
- typeAgendaEnumStruct
+ TypeAgendaEnum.ETS
)
//création de l'Item
}
/**
- * test création d'un agenda ETS
+ * test création d'un agenda ETS de type classe
* vérifie les propriétés et les droits attribués
* Vérifie l'unicité de l'agenda
*/
- void testGetAgendaEmploiDuTempsForStructure() {
- // création d'une structure d'enseignement
- StructureEnseignement str =
- localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1
+ void testGetAgendaEmploiDuTempsForStructureClasse() {
+ Etablissement etablissement =
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
- assertNotNull('IdExterne str', str.idExterne)
+ // création d'une nouvelle structure d'enseignement
+ StructureEnseignement str =
+ localStructureEnseignementService.findStructureEnseignement(
+ "codeStructureInexistante",
+ StructureEnseignement.TYPE_CLASSE,
+ etablissement,
+ true
+ )
+ assertNotNull('Structure null', str)
- // création de l'agenda structure
- // suppression et recréation pour éviter de récupérer un agenda déjà crée dans la base
- Agenda agenda = tempsAgendaService.getAgendaEmploiDuTempsForStructure(
- str
- )
+ Agenda agenda = tempsAgendaService.getAgendaEmploiDuTempsForStructure(str)
// vérification des propriétés
assertNotNull("Not null", agenda)
assert agenda.typeAgenda.code == TypeAgendaEnum.ETS.getCode()
assert agenda.nom == tempsAgendaService.ET + str.code
- //Direction droit en modification
- boolean pDirectionALeDroitDeModifier = null
- Acteur acteurPersonnelDeDirection1 =
- localInitDonneesCommunesTestService.getActeur(
- PopulationTestActeur.DIRECTION_1
- )
+ // Vérifie les droits par défaut
+ verifieDroitsAgendaStructure(agenda, str)
- try {
- verificationAutorisationModification(agenda,
- acteurPersonnelDeDirection1.securiteSession
- )
- pDirectionALeDroitDeModifier = true
- } catch (Exception e) {
- pDirectionALeDroitDeModifier = false
- }
- assertTrue pDirectionALeDroitDeModifier
+ Agenda getAgenda = tempsAgendaService.getAgendaEmploiDuTempsForStructure(str)
+ assertNotNull("Non nul Agenda", getAgenda)
+ assertEquals(agenda.id, getAgenda.id)
+ }
- //Elève droit en lecture
- boolean eleveStructureALeDroitDeModifier = null
- boolean eleveStructureALeDroitDeConsulter = null
- Acteur acteurEleve1Structure = localInitDonneesCommunesTestService.getActeur(
- PopulationTestActeur.ELEVE_1_CLASSE_1
- )
+ /**
+ * test création d'un agenda ETS de type groupe
+ * vérifie les propriétés et les droits attribués
+ * Vérifie l'unicité de l'agenda
+ */
+ void testGetAgendaEmploiDuTempsForStructureGroupe() {
- assertNotNull acteurEleve1Structure
- // Modification
- try {
- verificationAutorisationModification(agenda,
- acteurEleve1Structure.securiteSession
+ Etablissement etablissement =
+ localInitDonneesCommunesTestService.getEtablissement(
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
- eleveStructureALeDroitDeModifier = true
- } catch (Exception e) {
- eleveStructureALeDroitDeModifier = false
- }
- // Lecture
- try {
- verificationAutorisationConsultation(agenda,
- acteurEleve1Structure.securiteSession
+ // création d'une nouvelle structure d'enseignement
+ StructureEnseignement strGroupe =
+ localStructureEnseignementService.findStructureEnseignement(
+ "structureGroupeInexistante",
+ StructureEnseignement.TYPE_GROUPE,
+ etablissement,
+ true
)
- eleveStructureALeDroitDeConsulter = true
- } catch (Exception e) {
- eleveStructureALeDroitDeConsulter = false
- }
+ StructureEnseignement strClasse =
+ localStructureEnseignementService.findStructureEnseignement(
+ "structureGroupeInexistante",
+ StructureEnseignement.TYPE_CLASSE,
+ etablissement,
+ true
+ )
+ assertNotNull('Structure classe null', strClasse)
+ assertNotNull('Structure groupe null', strGroupe)
- assertFalse("Elève droits modification", eleveStructureALeDroitDeModifier)
- assertTrue("Elève droits lecture", eleveStructureALeDroitDeConsulter)
+ localStructureEnseignementService.updateRelClasseGroupe(
+ strGroupe,
+ [strClasse]
+ )
- Agenda getAgendaStructure =
- tempsAgendaService.getAgendaEmploiDuTempsForStructure(
- str
- )
- assertNotNull("Non nul Agenda", getAgendaStructure)
- assertEquals(agenda.id, getAgendaStructure.id)
+
+ Agenda agenda = tempsAgendaService.getAgendaEmploiDuTempsForStructure(strGroupe)
+ assertNotNull("Agenda est null", agenda)
+
+ // Vérifie les droits par défaut
+ assertEquals(
+ (localGroupeService.findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(strGroupe)).size(),
+ 1
+ )
+ assertEquals(
+ (localGroupeService.findOrCreeAllGroupeEnseignantForStructureGroupe(strGroupe)).size(),
+ 2
+ )
+
+ verifieDroitsAgendaStructure(agenda, strGroupe)
}
/**
localInitDonneesCommunesTestService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
- // création de l'enseignant - il faut, qu'il ne soit pas un admin local en meme temps!
- Acteur enseignant =
- localInitDonneesCommunesTestService.getActeur(
- PopulationTestActeur.ENSEIGNANT_2_2
- )
- Autorite autoriteEnseignant =
+ Autorite autorite =
localInitDonneesCommunesTestService.getAutorite(
PopulationTestActeur.ENSEIGNANT_2_2
)
// suppression et recréation pour éviter de récupérer un agenda déjà crée dans la base
Agenda agenda =
tempsAgendaService.getAgendaEmploiDuTempsForEnseignantAndEtablissement(
- enseignant.idExterne,
+ autorite.idExterne,
etablissement.idExterne
)
agenda.delete(flush: true)
+
agenda =
tempsAgendaService.getAgendaEmploiDuTempsForEnseignantAndEtablissement(
- enseignant.idExterne,
+ autorite.idExterne,
etablissement.idExterne
)
assertNotNull("Agenda not null", agenda)
assertNotNull("Etablissement agenda", agenda.etablissement)
assertTrue(agenda.etablissement.id == etablissement.id)
- assertTrue(agenda.enseignant.id == autoriteEnseignant.id)
+ assertTrue(agenda.enseignant.id == autorite.id)
assertNull(agenda.structureEnseignement)
- //Vérification des droits
- Boolean enseignantADroitDeLecture = false
- Boolean enseignantADroitDeModification = false
- // Droit en lecture seul Enseignant
- try {
- verificationAutorisationConsultation(agenda, enseignant.securiteSession)
- enseignantADroitDeLecture = true
- } catch (Exception e) {
- enseignantADroitDeLecture = false
- }
- // Droit en modification Enseignant
- try {
- verificationAutorisationModification(agenda, enseignant.securiteSession)
- enseignantADroitDeModification = true
- } catch (Exception e) {
- enseignantADroitDeModification = false
- }
+ // Vérifie les droits
+ verifieDroitsAgendaEnseignant(agenda, etablissement, autorite)
- // Droit de lecture
- assertTrue("Enseignant n'a pas le droit de lecture", enseignantADroitDeLecture)
- // Droit de modification
- assertFalse("Enseignant a le droit de modification, mais il ne faudrait pas",
- enseignantADroitDeModification)
// récupère l'agenda, vu qu'il a été déjà crée
Agenda getAgendaEnseignant =
tempsAgendaService.getAgendaEmploiDuTempsForEnseignantAndEtablissement(
- enseignant.idExterne,
+ autorite.idExterne,
etablissement.idExterne
)
assertNotNull("Non nul Agenda", getAgendaEnseignant)
)
// création de l'agenda
// suppression et recréation pour éviter de récupérer un agenda déjà crée dans la base
- Agenda agendaScolaire = tempsAgendaService.
- getAgendaScolaireForEtablissement(etablissement)
- agendaScolaire.delete(flush: true)
- agendaScolaire = tempsAgendaService.
- getAgendaScolaireForEtablissement(etablissement)
+ Agenda agenda =
+ tempsAgendaService.getAgendaScolaireForEtablissement(etablissement)
+ agenda.delete(flush: true)
+
+ agenda =
+ tempsAgendaService.getAgendaScolaireForEtablissement(etablissement)
+
// vérification des propriétés
- assertNotNull("Agenda non null", agendaScolaire)
- assertTrue(agendaScolaire.etablissement.id == etablissement.id)
- assertNull(agendaScolaire.structureEnseignement)
- assertNull(agendaScolaire.enseignant)
+ assertNotNull("Agenda non null", agenda)
+ assertTrue(agenda.etablissement.id == etablissement.id)
+ assertNull(agenda.structureEnseignement)
+ assertNull(agenda.enseignant)
+
// Vérification de l'unicité de l'agenda
Agenda getAgendaScolaire = tempsAgendaService.
getAgendaScolaireForEtablissement(etablissement)
assertNotNull("Agenda get non null", getAgendaScolaire)
- assertTrue(getAgendaScolaire.id == agendaScolaire.id)
+ assertTrue(getAgendaScolaire.id == agenda.id)
+
+ // Vérifie les droits
+ verifieDroitsAgendaEtablissement(agenda, etablissement)
}
/**
Long nbAgendasVisibles = getAgendasVisibles(securiteSession, typeStandard).size()
- // crée agenda personnel
Agenda agendaPerso = retournerAgenda("Agenda Perso", securiteSession)
- // crée agenda structure
+
StructureEnseignement str = localInitDonneesCommunesTestService.
getClasse(PopulationTestClasse.CLASSE_1)
Agenda agendaStruct = tempsAgendaService.getAgendaEmploiDuTempsForStructure(
str
)
- // crée calendrier scolaire
+
Etablissement etablissement =
localInitDonneesCommunesTestService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
- // création de l'agenda
Agenda agendaScolaire = tempsAgendaService.
getAgendaScolaireForEtablissement(etablissement)
*/
void testGetConsultablesAgendasForSessionByType() {
SecuriteSession securiteSession = SessionUtils.securiteSession(dummySession())
- // agenda perso
+
Agenda agendaPerso = retournerAgenda("AgendaConsultable1", securiteSession)
- // crée agenda structure
+
StructureEnseignement str = localInitDonneesCommunesTestService.
getClasse(PopulationTestClasse.CLASSE_1)
String nomStructure = "Structure"
Agenda agendaStruct = tempsAgendaService.getAgendaEmploiDuTempsForStructure(
str
)
- // crée calendrier scolaire
+
Etablissement etablissement =
localInitDonneesCommunesTestService.getEtablissement(
PopulationTestEtablissement.ETABLISSEMENT_1
)
- // création de l'agenda
+
Agenda agendaScolaire = tempsAgendaService.
getAgendaScolaireForEtablissement(etablissement)
void testGetAgendaInfoScolairesForActeur() {
SecuriteSession securiteSession = SessionUtils.securiteSession(dummySessionProf())
- // crée agenda perso
+
Agenda agendaPerso = retournerAgenda("agenda", securiteSession)
- // crée agenda structure
+
Etablissement etablissement =
localInitDonneesCommunesTestService.getEtablissement(PopulationTestEtablissement.ETABLISSEMENT_1)
StructureEnseignement str = localInitDonneesCommunesTestService.
etablissement.idExterne
)
- // calendrier scolaire
+
Agenda agendaCal = tempsAgendaService.
getAgendaScolaireForEtablissement(etablissement)
}
-// void testGetListeAgendaEnseignemantForEnseignant() {
-// SecuriteSession securiteSession = SessionUtils.securiteSession(dummySessionRachid())
-// List<Agenda> agendas = tempsAgendaService.getListeAgendaEnseignantForEnseignant(
-// securiteSession
-// )
-// println("Agenda du Rachid est $agendas[0]")
-// assertTrue("Nombre agenda", agendas.size()==1)
-// }
-
-
- private void verificationAutorisationModification(Agenda agenda,
- SecuriteSession securiteSession
- ) {
- AccessManager accessManager = new AccessManager(agenda.item, securiteSession)
- if (!accessManager.peutModifierLeContenu())
- throw AutorisationException.modificationContenuException()
+ private void verifieDroitsAgendaStructure(Agenda agenda, StructureEnseignement str) {
+
+ //Direction
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDirection(str.etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ //Chef de travaux
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeChefDeTravaux(str.etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ //Admin local
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDAdminLocal(str.etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ // Education
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEducation(str.etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ // Documentatlise
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDocumentaliste(str.etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: false,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ if (str.type == StructureEnseignement.TYPE_CLASSE) {
+ //Enseignants
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEnseignants(str),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+
+ // Profs principaux
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEnseignantsPrincipaux(str),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+ } else {
+ //Enseignants des classes qui composent le groupe
+ localGroupeService.findOrCreeAllGroupeEnseignantForStructureGroupe(str).each {
+ ProprietesScolarite ps ->
+
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: ps,
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+ }
+
+ //Enseignants principaux des classes qui composent le groupe
+ localGroupeService.findOrCreeAllGroupeEnseignantPrincipalDeClasseForStructureGroupe(str).each {
+ ProprietesScolarite ps ->
+
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: ps,
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+ }
+ }
+
+ //Elèves
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEleves(str),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+
+ //Parents
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeParents(str),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+ }
+
+ void verifieDroitsAgendaEnseignant(Agenda agenda, Etablissement etablissement, Autorite autorite) {
+
+ //Direction
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDirection(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ //Chef de travaux
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeChefDeTravaux(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ //Admin local
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDAdminLocal(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: true
+ )
+ )
+
+ // Education
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEducation(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+
+ // Documentatlise
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDocumentaliste(etablissement),
+ item: agenda.item,
+ peutConsulter: false,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+
+ // Enseignant
+ Autorisation autorisation = findAutorisationDroitsParDefautBy(agenda.item, autorite)
+ assertTrue autorisation.autoriseConsulterLeContenuParDefaut()
+ assertFalse autorisation.autoriseModifierLeContenu()
+ assertFalse autorisation.autoriseModifierLeContenu()
+ assertFalse autorisation.autoriseModifierLeContenu()
}
- /**
- * Vérification des droits de consultation de l'agenda
- * @param agenda : l'agenda à consulter
- * @param securiteSession : la session de securité courante
- */
- private void verificationAutorisationConsultation(Agenda agenda,
- SecuriteSession securiteSession
- ) {
- AccessManager accessManager = new AccessManager(agenda.item, securiteSession)
- if (!accessManager.peutConsulterLeContenu())
- throw AutorisationException.consultationContenuException()
+ void verifieDroitsAgendaEtablissement(Agenda agenda, Etablissement etablissement) {
+
+ //Direction
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDirection(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ //Chef de travaux
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeChefDeTravaux(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ //Admin local
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDAdminLocal(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ // Education
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDEducation(etablissement),
+ item: agenda.item,
+ peutConsulter: true,
+ peutModifier: true,
+ peutConsulterDEP: true,
+ peutModifierDEP: false
+ )
+ )
+
+ // Documentatlise
+ verifieValeurPermissionDefault(
+ new DroitsParGroupe(
+ ps: localGroupeService.findOrCreeGroupeDeDocumentaliste(etablissement),
+ item: agenda.item,
+ peutConsulter: false,
+ peutModifier: false,
+ peutConsulterDEP: false,
+ peutModifierDEP: false
+ )
+ )
+ }
+
+
+ private verifieValeurPermissionDefault(DroitsParGroupe droitsParAutorite) {
+ Autorisation autorisation = findAutorisationDroitsParDefautBy(
+ droitsParAutorite.item,
+ droitsParAutorite.ps.autorite
+ )
+ // si aucune autorisation et on a au moins un droit à true, l'assertion est failed
+ if (!autorisation &&
+ (droitsParAutorite.peutConsulter ||
+ droitsParAutorite.peutModifier ||
+ droitsParAutorite.peutConsulterDEP ||
+ droitsParAutorite.peutModifierDEP)
+ ) {
+ assertTrue("Aucune autorisation n'a été donnée à la fonction $droitsParAutorite.ps.fonction.libelle", false)
+ }
+
+ // si aucune autorisation, on continue pas le test
+ if (!autorisation) {
+ return
+ }
+
+ assertEquals(
+ "Le droit de consultation pour la fonction $droitsParAutorite.ps.fonction.libelle est incorrect",
+ droitsParAutorite.peutConsulter,
+ autorisation.autoriseConsulterLeContenuParDefaut()
+ )
+
+ assertEquals(
+ "Le droit de modification pour la fonction $droitsParAutorite.ps.fonction.libelle est incorrect",
+ droitsParAutorite.peutModifier,
+ autorisation.autoriseModifierLeContenuParDefaut()
+ )
+
+ assertEquals(
+ "Le droit de consultation des DEP pour la fonction $droitsParAutorite.ps.fonction.libelle est incorrect",
+ droitsParAutorite.peutConsulterDEP,
+ autorisation.autoriseConsulterLesPermissionsParDefaut()
+ )
+
+ assertEquals(
+ "Le droit de modification des DEP pour la fonction $droitsParAutorite.ps.fonction.libelle est incorrect",
+ droitsParAutorite.peutModifierDEP,
+ autorisation.autoriseModifierLesPermissionsParDefaut()
+ )
+ }
+
+
+ private findAutorisationDroitsParDefautBy(Item item, Autorite autorite) {
+ return Autorisation.withCriteria(uniqueResult: true) {
+ eq('autorite', autorite)
+ eq('item', item)
+ ne('valeurPermissionsExpliciteDefaut', 0)
+ }
}
/**
securiteSession)
}
- private Evenement retournerEvenement(Agenda agenda,
- SecuriteSession securiteSession) {
- String objet = "Un événement simple"
- Calendar dateHeureDebut = Calendar.getInstance()
- dateHeureDebut.set(2010, 02, 1, 14, 30)
- Calendar dateHeureFin = Calendar.getInstance()
- dateHeureFin.set(2010, 02, 1, 15, 30)
- Evenement evenement = tempsEvenementService.creerEvenementSimple(agenda,
- objet,
- dateHeureDebut.getTime(),
- dateHeureFin.getTime(),
- securiteSession
- )
- return evenement
- }
-
- /**
- * Retourne l'autorite
- */
- private Autorite utilisateur() {
- return (Autorite) SessionUtils.utilisateur(session)
- }
-
/*
* élève
*/
return httpSession
}
- private def dummySessionRachid() {
- def httpSession = [:]
- Acteur acteur = localInitDonneesCommunesTestService.getActeurForLogin('rachid.elmellah')
- if (acteur)
- httpSession.acteur = acteur
- return httpSession
- }
-
}
\ No newline at end of file
+++ /dev/null
-package org.lilie.services.eliot.temps
-
-import grails.test.*
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.annuaire.Acteur
-import org.lilie.services.eliot.SessionUtils
-import org.lilie.services.eliot.DistantAutoriteService
-import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
-
-class TempsDroitsServiceTests extends GrailsUnitTestCase {
- protected void setUp() {
- super.setUp()
-
- }
-
- protected void tearDown() {
- super.tearDown()
- }
-
- TempsAgendaService tempsAgendaService
- TempsDroitsService tempsDroitsService
- DistantAutoriteService distantAutoriteService
- LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
-
- /**
- * Vérifie l'ajout des droits et la mise à jour de ces droits à un acteur
- */
- void testmajDroitsForAgenda(){
- /* SecuriteSession securiteSession = SessionUtils.securiteSession(dummySession())
- //Création de l'agenda
- Agenda agenda = tempsAgendaService.creerAgendaPersonnel("nom",
- "description",
- securiteSession)
- List droitsGroupes = []
- List droitsActeurs = []
- //Création des droits pour l'acteur Y
- Autorite autorite2 =
- (Autorite) SessionUtils.securiteSession(dummySession2()).getDefaultAutorite()
- Droit droit = new Droit(type: TempsDroitsService.TYPE_ACTEUR,
- idAutorite: autorite2.getIdExterne(),
- nomAutorite: autorite2.nomAffichage(),
- lire: true,
- ecrire: true
- )
- droitsActeurs << droit
- tempsDroitsService.majDroits(
- securiteSession,
- agenda,
- new HashSet(droitsActeurs),
- new HashSet(droitsGroupes)
- )
-
- Boolean exceptionLevee = false
- try{
- tempsAgendaService.supprimerAgenda(agenda.id,
- SessionUtils.securiteSession(dummySession2())
- )
- }
- catch (Exception e){
- exceptionLevee = true
- }
- assertTrue("Droits de suppression", exceptionLevee)
-
- //Récupère les droits de l'acteur Y et Vérifie les droits
- Map droitsNouveauActeur = tempsDroitsService.getDroitsAgendaForAutorite(
- autorite2,
- agenda,
- securiteSession
- )
- assertTrue droitsNouveauActeur.lire
- assertTrue droitsNouveauActeur.ecrire
-
- droitsActeurs = []
- droitsGroupes = []
- //Modifie les droits de l'acteur Y
- Droit droit2 = new Droit(type: TempsDroitsService.TYPE_ACTEUR,
- idAutorite: autorite2.getIdExterne(),
- nomAutorite: autorite2.nomAffichage(),
- lire: false,
- ecrire: false
- )
- droitsActeurs << droit2
- tempsDroitsService.majDroits(
- securiteSession,
- agenda,
- new HashSet(droitsActeurs),
- new HashSet(droitsGroupes)
- )
- Map droits2NouveauActeur = tempsDroitsService.getDroitsAgendaForAutorite(
- autorite2,
- agenda,
- securiteSession
- )
- assertNotNull droits2NouveauActeur
- assertTrue (!droits2NouveauActeur.lire)
- assertTrue (!droits2NouveauActeur.ecrire)
-*/
- }
-
-
- /**
- * Retourne l'autorite
- */
- private Autorite utilisateur() {
- return (Autorite) SessionUtils.utilisateur(session)
- }
-
- private def dummySession() {
- def httpSession = [:]
- Acteur acteur = localInitDonneesCommunesTestService.getActeurForLogin(
- "anais.rousseau"
- )
- if (acteur)
- httpSession.acteur = acteur
- return httpSession
- }
-
-
- private def dummySession2() {
- def httpSession = [:]
- Acteur acteur = localInitDonneesCommunesTestService.getActeurForLogin(
- "claire.rougier"
- )
-
- //assertNotNull acteur
- if (acteur)
- httpSession.acteur = acteur
- return httpSession
- }
-
-}
\ No newline at end of file
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.securite.impl.DefaultSecuriteSessionFactory
import org.lilie.services.eliot.applications.textes.CahierDeTextesService
-import org.junit.Ignore
+import org.lilie.services.eliot.annuaire.Niveau
+import org.lilie.services.eliot.scolarite.AnneeScolaire
+import org.lilie.services.eliot.scolarite.anneescolaire.AnneeScolaireService
+import org.lilie.services.eliot.scolarite.Personne
+import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+import org.lilie.services.eliot.annuaire.ProprietesScolarite
+import org.lilie.services.eliot.annuaire.Fonction
+import org.lilie.services.eliot.annuaire.PersonneProprietesScolarite
+import org.lilie.services.eliot.annuaire.FonctionEnum
+import org.lilie.services.eliot.scolarite.annuaire.LocalGroupeService
+import org.lilie.services.eliot.AutorisationService
/**
* Test de la classe CahierDeTextesService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
EnseignementService enseignementService
ServiceService serviceService
+ AnneeScolaireService anneeScolaireService
+ LocalGroupeService localGroupeService
+ AutorisationService autorisationService
Matiere matiere
+ Matiere matiereAnglais
Autorite groupe
Autorite enseignant
Autorite enseignant2
Etablissement etab
Enseignement enseignement
Service service
+ AnneeScolaire anneeScolaireEnCours
protected void setUp() {
super.setUp()
securiteSessionDirecteur = localInitDonneesCommunesTestService.getSecuriteSession(
- PopulationTestActeur.DIRECTION_1
+ PopulationTestActeur.DIRECTION_1
)
+ anneeScolaireEnCours = anneeScolaireService.anneeScolaireEnCours()
+
modaliteCours = localInitDonneesCommunesTestService.getModaliteTestCG()
matiere = localInitDonneesCommunesTestService.getMatiere(
- PopulationTestMatiere.FRANCAIS
+ PopulationTestMatiere.FRANCAIS
+ )
+
+ matiereAnglais = localInitDonneesCommunesTestService.getMatiere(
+ PopulationTestMatiere.ANGLAIS
)
enseignant = localInitDonneesCommunesTestService.getAutorite(
- PopulationTestActeur.ENSEIGNANT_1
+ PopulationTestActeur.ENSEIGNANT_1
)
enseignant2 = localInitDonneesCommunesTestService.getAutorite(
- PopulationTestActeur.ENSEIGNANT_2
+ PopulationTestActeur.ENSEIGNANT_2
)
struct = localInitDonneesCommunesTestService.getClasse(
- PopulationTestClasse.CLASSE_1
+ PopulationTestClasse.CLASSE_1
)
etab = localInitDonneesCommunesTestService.getEtablissement(
- PopulationTestEtablissement.ETABLISSEMENT_1
+ PopulationTestEtablissement.ETABLISSEMENT_1
)
service = serviceService.creeService(
- securiteSessionDirecteur,
- matiere,
- struct,
- modaliteCours
+ securiteSessionDirecteur,
+ matiere,
+ struct,
+ modaliteCours
)
enseignement = enseignementService.creeEnseignement(
- enseignant,
- service
+ enseignant,
+ service
)
}
void testGenereNomPourCahierDeTextesService() {
Service service = enseignement.service
String nomGenere =
- "${service.structureEnseignement.code} - ${service.matiere.libelleLong}"
+ "${service.structureEnseignement.code} - ${service.matiere.libelleLong}"
log.info "Nom attendu : ${nomGenere}"
assertEquals(
- nomGenere,
- cahierDeTextesService.genereNomPourCahierDeTextesService(service)
+ nomGenere,
+ cahierDeTextesService.genereNomPourCahierDeTextesService(service)
)
}
Service service = enseignement.service
assertNull cahierDeTextesService.findCahierDeTextesByEnseignantAndService(
- enseignant, service)
+ enseignant, service)
CahierDeTextes cdt = cahierDeTextesService.insertUpdateCahierDeTextes(
- DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
- localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
- ),
- service,
- enseignant
+ DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
+ localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
+ ),
+ service,
+ enseignant
)
CahierDeTextes fetchedCdt = CahierDeTextes.get(cdt.id)
assertNotNull fetchedCdt
fetchedCdt = cahierDeTextesService.findCahierDeTextesByEnseignantAndService(
- enseignant, service)
+ enseignant, service)
assertNotNull "Il devrait y avoir un cdt", fetchedCdt
void testFindCahierDeTextesByEnseignantAndServiceSansModalite() {
CahierDeTextes cdt = cahierDeTextesService.insertUpdateCahierDeTextes(
- DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
- localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
- ),
- service,
- enseignant
+ DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
+ localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
+ ),
+ service,
+ enseignant
)
CahierDeTextes fetchedCdt = CahierDeTextes.get(cdt.id)
assertNotNull fetchedCdt
fetchedCdt = cahierDeTextesService.findCahierDeTextesByEnseignantAndServiceSansModalite(
- enseignant, service)
+ enseignant, service)
assertNotNull "Il devrait y avoir un cdt", fetchedCdt
}
- @Ignore /*Ce test ne peut pas être réalisé sans injecter les données dont
- il a besoin*/
void testInsertUpdateCahierDeTextes() {
- Service service = enseignement.service
- CahierDeTextes cdt = cahierDeTextesService.insertUpdateCahierDeTextes(
- DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
- localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
- ),
- service,
- enseignant
+ // cdt lié à une structure d'ens. de type CLASSE
+
+ Niveau niveau = (Niveau) Niveau.getAll().get(0)
+
+ StructureEnseignement classe1 = new StructureEnseignement(
+ idExterne: '111111111x',
+ etablissement: etab,
+ type: StructureEnseignement.TYPE_CLASSE,
+ niveau: niveau,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'classe de test 1'
+ )
+ classe1.save(failOnError: true)
+
+ Autorite enseignant = creeNouvelEnseignant(classe1, "test5678")
+
+ Service service = serviceService.creeService(
+ securiteSessionDirecteur,
+ matiere,
+ classe1,
+ null
)
- // TOTEST : tester les droits
- def autorisationsActeur = cdt.item.findAllActeurAutorisations()
- assertEquals 1, autorisationsActeur.size()
- def autorisationsGroupe = cdt.item.findAllGroupeAutorisations()
- //Groupes de : Admin + Direction + Education + Chef de travaux + Elèves + Parents + Enseignants
- assertEquals 7, autorisationsGroupe.size()
+ CahierDeTextes cdt = cahierDeTextesService.insertUpdateCahierDeTextes(
+ DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
+ localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
+ ),
+ service,
+ enseignant
+ )
- assertNotNull "cdt doit être non null", cdt
+ assertNotNull "cdt ne doit pas être null", cdt
String nomGenere =
- "${service.structureEnseignement.code} - ${service.matiere.libelleLong}"
+ "${service.structureEnseignement.code} - ${service.matiere.libelleLong}"
assertEquals cdt.nom, nomGenere
Item item = cdt.item
assertNotNull item
Autorisation autorisation =
- Autorisation.findByItemAndAutorite(item, enseignant)
+ Autorisation.findByItemAndAutorite(item, enseignant)
assertNotNull autorisation
assertTrue autorisation.proprietaire
+
+ // tester les droits
+
+ // Enseignant propriétaire
+ Autorisation autorisationEnsProprietaire = autorisationService.findAutorisation(
+ enseignant,
+ cdt.item
+ )
+
+ assertTrue(autorisationEnsProprietaire.autoriseConsulterLeContenuParDefaut())
+ assertTrue(autorisationEnsProprietaire.autoriseModifierLeContenuParDefaut())
+ assertTrue(autorisationEnsProprietaire.autoriseConsulterLesPermissionsParDefaut())
+ assertTrue(autorisationEnsProprietaire.autoriseModifierLesPermissionsParDefaut())
+
+ // Enseignants
+ ProprietesScolarite enseignantPs = localGroupeService.findOrCreeGroupeDEnseignants(
+ classe1
+ )
+
+ Autorisation autorisationEns = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ enseignantPs.autorite
+ )
+
+ assertTrue(autorisationEns.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEns.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEns.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEns.autoriseModifierLesPermissionsParDefaut())
+
+ // Direction
+ ProprietesScolarite directionPs = localGroupeService.findOrCreeGroupeDeDirection(
+ classe1.etablissement
+ )
+
+ Autorisation autorisationDir = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ directionPs.autorite
+ )
+
+ assertTrue(autorisationDir.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationDir.autoriseModifierLeContenuParDefaut())
+ assertTrue(autorisationDir.autoriseConsulterLesPermissionsParDefaut())
+ assertTrue(autorisationDir.autoriseModifierLesPermissionsParDefaut())
+
+ // Chef de travaux
+ ProprietesScolarite chefTravauxPs = localGroupeService.findOrCreeGroupeDeChefDeTravaux(
+ classe1.etablissement
+ )
+
+ Autorisation autorisationCT = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ chefTravauxPs.autorite
+ )
+
+ assertTrue(autorisationCT.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationCT.autoriseModifierLeContenuParDefaut())
+ assertTrue(autorisationCT.autoriseConsulterLesPermissionsParDefaut())
+ assertTrue(autorisationCT.autoriseModifierLesPermissionsParDefaut())
+
+ // Admin locaux
+ ProprietesScolarite admlPs = localGroupeService.findOrCreeGroupeDAdminLocal(
+ classe1.etablissement
+ )
+
+ Autorisation autorisationADML = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ admlPs.autorite
+ )
+
+ assertTrue(autorisationADML.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationADML.autoriseModifierLeContenuParDefaut())
+ assertTrue(autorisationADML.autoriseConsulterLesPermissionsParDefaut())
+ assertTrue(autorisationADML.autoriseModifierLesPermissionsParDefaut())
+
+ // Education
+ ProprietesScolarite educationPs = localGroupeService.findOrCreeGroupeDEducation(
+ classe1.etablissement
+ )
+
+ Autorisation autorisationEdu = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ educationPs.autorite
+ )
+
+ assertTrue(autorisationEdu.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEdu.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEdu.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEdu.autoriseModifierLesPermissionsParDefaut())
+
+ // Documentaliste
+ ProprietesScolarite documentalistePs = localGroupeService.findOrCreeGroupeDeDocumentaliste(
+ classe1.etablissement
+ )
+
+ Autorisation autorisationDoc = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ documentalistePs.autorite
+ )
+
+ assertNull(autorisationDoc)
+
+ // Enseignants principaux
+ ProprietesScolarite ensprincPs = localGroupeService.findOrCreeGroupeDEnseignantsPrincipaux(
+ classe1
+ )
+
+ Autorisation autorisationEnsPrin = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ ensprincPs.autorite
+ )
+
+ assertNotNull(autorisationEnsPrin)
+ assertTrue(autorisationEnsPrin.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEnsPrin.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEnsPrin.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEnsPrin.autoriseModifierLesPermissionsParDefaut())
+
+ // Eleve
+ ProprietesScolarite elevePs = localGroupeService.findOrCreeGroupeDEleves(
+ classe1
+ )
+
+ Autorisation autorisationEleve = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ elevePs.autorite
+ )
+
+ assertTrue(autorisationEleve.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEleve.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEleve.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEleve.autoriseModifierLesPermissionsParDefaut())
+
+ // Parent
+ ProprietesScolarite parentPs = localGroupeService.findOrCreeGroupeDEleves(
+ classe1
+ )
+
+ Autorisation autorisationParent = findAutorisationDroitsParDefautBy(
+ cdt.item,
+ parentPs.autorite
+ )
+
+ assertTrue(autorisationParent.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationParent.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationParent.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationParent.autoriseModifierLesPermissionsParDefaut())
+
+
+ // cdt lié à une structure d'ens. de type GROUPE
+
+ StructureEnseignement classe2 = new StructureEnseignement(
+ idExterne: '111111111y',
+ etablissement: etab,
+ type: StructureEnseignement.TYPE_GROUPE,
+ anneeScolaire: anneeScolaireEnCours,
+ code: 'classe de test 2',
+ classes : [classe1]
+ )
+ classe2.save(failOnError: true)
+
+ Autorite enseignant2 = creeNouvelEnseignant(classe2, "test123")
+
+ Service service2 = serviceService.creeService(
+ securiteSessionDirecteur,
+ matiereAnglais,
+ classe2,
+ null
+ )
+
+ CahierDeTextes cdt2 = cahierDeTextesService.insertUpdateCahierDeTextes(
+ DefaultSecuriteSessionFactory.getEliotTextesSecuriteSessionForCodePorteurENT(
+ localInitDonneesCommunesTestService.CODE_PORTEUR_ENT
+ ),
+ service2,
+ enseignant2
+ )
+
+ assertNotNull "cdt ne doit pas être null", cdt
+ String nomGenere2 =
+ "${service2.structureEnseignement.code} - ${service2.matiere.libelleLong}"
+ assertEquals cdt2.nom, nomGenere2
+ Item item2 = cdt2.item
+ assertNotNull item2
+ Autorisation autorisation2 =
+ Autorisation.findByItemAndAutorite(item2, enseignant2)
+ assertNotNull autorisation2
+ assertTrue autorisation2.proprietaire
+
+ // tester les droits
+
+ // Enseignant propriétaire - il est le seul à avoir les droits d'écriture
+ Autorisation autorisationEnsProprietaire2 = autorisationService.findAutorisation(
+ enseignant2,
+ cdt2.item
+ )
+
+ assertTrue(autorisationEnsProprietaire2.autoriseConsulterLeContenuParDefaut())
+ assertTrue(autorisationEnsProprietaire2.autoriseModifierLeContenuParDefaut())
+ assertTrue(autorisationEnsProprietaire2.autoriseConsulterLesPermissionsParDefaut())
+ assertTrue(autorisationEnsProprietaire2.autoriseModifierLesPermissionsParDefaut())
+
+ // Enseignants
+ ProprietesScolarite enseignantPs2 = localGroupeService.findOrCreeGroupeDEnseignants(
+ classe2
+ )
+
+ Autorisation autorisationEns2 = findAutorisationDroitsParDefautBy(
+ cdt2.item,
+ enseignantPs2.autorite // groupe des enseignants du groupe
+ )
+
+ assertTrue(autorisationEns2.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEns2.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEns2.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEns2.autoriseModifierLesPermissionsParDefaut())
+
+ // Enseignants des classes composant la struct. d'ens. de type GROUPE
+ Autorisation autorisationEns3 = findAutorisationDroitsParDefautBy(
+ cdt2.item,
+ enseignantPs.autorite // groupe des enseignants de la classe 1
+ )
+
+ assertTrue(autorisationEns3.autoriseConsulterLeContenuParDefaut())
+ assertFalse(autorisationEns3.autoriseModifierLeContenuParDefaut())
+ assertFalse(autorisationEns3.autoriseConsulterLesPermissionsParDefaut())
+ assertFalse(autorisationEns3.autoriseModifierLesPermissionsParDefaut())
+
+ }
+
+ private Autorite creeNouvelEnseignant(StructureEnseignement structureEnseignement,
+ String idExterne) {
+ // crée l'autorité
+ Autorite autorite = new Autorite(
+ type: Autorite.TYPE_ACTEUR,
+ idExterne: idExterne
+ )
+ autorite.modifieEtat(CompteUtilisateurEtat.ACTIF)
+
+ autorite.save(failOnError: true)
+
+ // crée la personne
+ Personne personne = new Personne(
+ nom: "Alicia",
+ prenom: "Blablabla",
+ autorite: autorite,
+ etablissementRattachement: structureEnseignement.etablissement,
+ )
+ personne.save(failOnError: true)
+
+ // crée la propriété scolarité
+ ProprietesScolarite proprietesScolarite = new ProprietesScolarite(
+ anneeScolaire: anneeScolaireService.anneeScolaireEnCours(),
+ fonction: Fonction.findByCode(FonctionEnum.ENSEIGNANT.getCode()),
+ structureEnseignement: structureEnseignement
+ )
+ proprietesScolarite.save(failOnError: true)
+
+ // crée la personne propriété scolarité
+ PersonneProprietesScolarite personneProprietesScolarite =
+ new PersonneProprietesScolarite(
+ personne: personne,
+ proprietesScolarite: proprietesScolarite,
+ estActive: true
+ )
+ personneProprietesScolarite.save(failOnError: true)
+
+ return autorite
+ }
+
+ private findAutorisationDroitsParDefautBy(Item item, Autorite autorite) {
+ return Autorisation.withCriteria(uniqueResult: true) {
+ eq('autorite', autorite)
+ eq('item', item)
+ ne('valeurPermissionsExpliciteDefaut', 0)
+ }
}
}
<include file="changelogs/securite/2013-06-28-0028850.xml"/>
<include file="changelogs/securite/2013-07-08-0029100.xml"/>
<include file="changelogs/securite/2013-08-23-0029765.xml"/>
+ <include file="changelogs/securite/2013-09-06-0028847.xml"/>
+ <include file="changelogs/securite/2013-09-09-0028847.xml"/>
</databaseChangeLog>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ 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>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="bper">
+ <comment>
+ Suppression des tables 'appartenance_personne_groupe' et 'groupe_personnes'
+ </comment>
+
+ <dropColumn schemaName="td" tableName="modalite_activite" columnName="groupe_id" />
+
+ <dropTable schemaName="ent" tableName="appartenance_personne_groupe" />
+ <dropSequence schemaName="ent" sequenceName="appartenance_personne_groupe_id_seq" />
+
+ <dropTable schemaName="ent" tableName="appartenance_groupe_groupe" />
+ <dropSequence schemaName="ent" sequenceName="appartenance_groupe_groupe_id_seq" />
+
+ <dropTable schemaName="ent" tableName="groupe_personnes" />
+ <dropSequence schemaName="ent" sequenceName="groupe_personnes_id_seq" />
+
+ </changeSet>
+</databaseChangeLog>
<include file="changelogs/scolarite/release-changes.xml"/>
<include file="migrations/changelog-tice-dbmigration.xml"/>
+ <include file="changelogs/scolarite_all/2013-09-06-0028847.xml"/>
+
</databaseChangeLog>
\ No newline at end of file
-->
<databaseChangeLog
- xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
-
- <changeSet id="1" author="bahj">
-
- <comment>
- Ajout de la colonne 'autorite' dans la table ent.propriete_scolarite
- </comment>
-
- <addColumn tableName="propriete_scolarite" schemaName="ent">
- <column name="autorite_id" type="bigint">
- <constraints nullable="true"/>
- </column>
- </addColumn>
-
- <addForeignKeyConstraint baseTableSchemaName="ent"
- baseTableName="propriete_scolarite"
- baseColumnNames="autorite_id"
- constraintName="fk_propriete_scolarite_autorite"
- referencedTableSchemaName="securite"
- referencedTableName="autorite"
- referencedColumnNames="id"/>
-
- </changeSet>
-
- <changeSet id="2" author="bahj">
- <comment>
- Ajout de la colonne localisation dans la table securite.autorite
- </comment>
-
- <addColumn tableName="autorite" schemaName="securite">
- <column name="localisation" type="varchar(8)">
- <constraints nullable="true"/>
- </column>
- </addColumn>
-
- </changeSet>
-
- <changeSet id="3" author="bahj">
- <comment>
- Migration des autorités groupes en localisation = DISTANTE
- </comment>
- <sql>
- UPDATE securite.autorite
- SET localisation='DISTANTE'
- WHERE type='groupe';
- </sql>
-
- </changeSet>
-
-
- <changeSet id="4" author="bahj">
- <comment>
- Ajout des contraintes de vérifications
- </comment>
-
- <sql>
- ALTER TABLE securite.autorite
- add constraint chk_autorite_type_localisation_id_externe
- check (
- (id_externe IS NOT NULL AND localisation = 'DISTANTE' AND type =
- 'groupe') OR
- (id_externe IS NOT NULL AND localisation IS NULL AND type =
- 'acteur') OR
- (id_externe IS NOT NULL AND localisation IS NULL AND type = 'eliot')
- OR
- (id_externe IS NULL AND localisation = 'LOCALE' AND type = 'groupe')
- );
- </sql>
-
- </changeSet>
-
- <changeSet id="5" author="bahj">
- <comment>
- Suppression de la colonne niveau de la table propriete_scolarite.
- Il faut d'abord supprimer la vue annuaire qui reference cette
- colonne
- </comment>
-
- <dropView viewName="vue_annuaire" schemaName="ent"/>
-
-
- <dropColumn schemaName="ent"
- tableName="propriete_scolarite"
- columnName="niveau_id"/>
-
- <createView viewName="vue_annuaire" schemaName="ent"
- replaceIfExists="true">
- SELECT p.nom, p.prenom, e.nom_affichage AS nom_etab,
- se.code AS structure_code, se.type AS structure_type,
- se.actif AS structure_actif, f.code AS fonction_code,
- ps.responsable_structure_enseignement AS resp_structure,
- an.code AS annee_code,
- mat.libelle_court AS matiere_lib, mef.code AS mef_code,
- p.id AS personne_id, p.autorite_id, pps.id AS pps_id,
- e.id AS etablissement_id, se.id AS structure_id,
- f.id AS fonction_id, an.id AS annee_id,
- mat.id AS matiere_id, mef.id AS mef_id, aut.id_externe
- FROM ent.personne p
- JOIN ent.personne_propriete_scolarite pps ON pps.personne_id = p.id
- AND pps.est_active = true
- JOIN ent.propriete_scolarite ps ON ps.id =
- pps.propriete_scolarite_id
- LEFT JOIN ent.etablissement e ON e.id = ps.etablissement_id
- LEFT JOIN ent.structure_enseignement se ON se.id =
- ps.structure_enseignement_id
- LEFT JOIN ent.fonction f ON f.id = ps.fonction_id
- LEFT JOIN ent.annee_scolaire an ON an.id = ps.annee_scolaire_id
- LEFT JOIN ent.matiere mat ON mat.id = ps.matiere_id
- LEFT JOIN ent.mef mef ON mef.id = ps.mef_id
- LEFT JOIN securite.autorite aut ON p.autorite_id = aut.id
- ORDER BY p.nom, p.prenom
- </createView>
-
- </changeSet>
-
- <changeSet id="6" author="bahj">
- <comment>
- Ajout de la table eleve_proprietes
- </comment>
-
- <createSequence schemaName="ent"
- sequenceName="eleve_proprietes_id_seq"/>
-
- <createTable schemaName="ent"
- tableName="eleve_proprietes">
- <column name="id" type="bigint"/>
- <column name="personne_id" type="bigint">
- <constraints nullable="false"/>
- </column>
- <column name="mef_id" type="bigint">
- </column>
- <column name="annee_scolaire_id" type="bigint">
- <constraints nullable="false"/>
- </column>
- </createTable>
-
- <addPrimaryKey schemaName="ent"
- tableName="eleve_proprietes"
- columnNames="id"
- constraintName="pk_eleve_proprietes"/>
-
- <addForeignKeyConstraint baseTableSchemaName="ent"
- baseTableName="eleve_proprietes"
- baseColumnNames="personne_id"
- constraintName="fk_eleve_proprietes_personne"
- referencedTableSchemaName="ent"
- referencedTableName="personne"
- referencedColumnNames="id"/>
-
- <addForeignKeyConstraint baseTableSchemaName="ent"
- baseTableName="eleve_proprietes"
- baseColumnNames="mef_id"
- constraintName="fk_eleve_proprietes_mef"
- referencedTableSchemaName="ent"
- referencedTableName="mef"
- referencedColumnNames="id"/>
-
- <addForeignKeyConstraint baseTableSchemaName="ent"
- baseTableName="eleve_proprietes"
- baseColumnNames="annee_scolaire_id"
- constraintName="fk_eleve_proprietes_annee_scolaire"
- referencedTableSchemaName="ent"
- referencedTableName="annee_scolaire"
- referencedColumnNames="id"/>
-
- </changeSet>
-
- <changeSet id="7" author="bahj">
- <comment>
- Ajout d'une contrainte d'unicité dans la table eleve_proprietes
- </comment>
- <addUniqueConstraint schemaName="ent"
- tableName="eleve_proprietes"
- columnNames="personne_id,annee_scolaire_id"
- constraintName="uk_eleve_proprietes_personne_annee_scolaire"/>
- </changeSet>
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="bahj">
+
+ <comment>
+ Ajout de la colonne 'autorite' dans la table ent.propriete_scolarite
+ </comment>
+
+ <addColumn tableName="propriete_scolarite" schemaName="ent">
+ <column name="autorite_id" type="bigint">
+ <constraints nullable="true"/>
+ </column>
+ </addColumn>
+
+ <addForeignKeyConstraint baseTableSchemaName="ent"
+ baseTableName="propriete_scolarite"
+ baseColumnNames="autorite_id"
+ constraintName="fk_propriete_scolarite_autorite"
+ referencedTableSchemaName="securite"
+ referencedTableName="autorite"
+ referencedColumnNames="id"/>
+
+ </changeSet>
+
+ <changeSet id="2" author="bahj">
+ <comment>
+ Suppression de la colonne niveau de la table propriete_scolarite.
+ Il faut d'abord supprimer la vue annuaire qui reference cette
+ colonne
+ </comment>
+
+ <dropView viewName="vue_annuaire" schemaName="ent"/>
+
+
+ <dropColumn schemaName="ent"
+ tableName="propriete_scolarite"
+ columnName="niveau_id"/>
+
+ <createView viewName="vue_annuaire" schemaName="ent"
+ replaceIfExists="true">
+ SELECT p.nom, p.prenom, e.nom_affichage AS nom_etab,
+ se.code AS structure_code, se.type AS structure_type,
+ se.actif AS structure_actif, f.code AS fonction_code,
+ ps.responsable_structure_enseignement AS resp_structure,
+ an.code AS annee_code,
+ mat.libelle_court AS matiere_lib, mef.code AS mef_code,
+ p.id AS personne_id, p.autorite_id, pps.id AS pps_id,
+ e.id AS etablissement_id, se.id AS structure_id,
+ f.id AS fonction_id, an.id AS annee_id,
+ mat.id AS matiere_id, mef.id AS mef_id, aut.id_externe
+ FROM ent.personne p
+ JOIN ent.personne_propriete_scolarite pps ON pps.personne_id = p.id
+ AND pps.est_active = true
+ JOIN ent.propriete_scolarite ps ON ps.id =
+ pps.propriete_scolarite_id
+ LEFT JOIN ent.etablissement e ON e.id = ps.etablissement_id
+ LEFT JOIN ent.structure_enseignement se ON se.id =
+ ps.structure_enseignement_id
+ LEFT JOIN ent.fonction f ON f.id = ps.fonction_id
+ LEFT JOIN ent.annee_scolaire an ON an.id = ps.annee_scolaire_id
+ LEFT JOIN ent.matiere mat ON mat.id = ps.matiere_id
+ LEFT JOIN ent.mef mef ON mef.id = ps.mef_id
+ LEFT JOIN securite.autorite aut ON p.autorite_id = aut.id
+ ORDER BY p.nom, p.prenom
+ </createView>
+
+ </changeSet>
+
+ <changeSet id="3" author="bahj">
+ <comment>
+ Ajout de la table eleve_proprietes
+ </comment>
+
+ <createSequence schemaName="ent"
+ sequenceName="eleve_proprietes_id_seq"/>
+
+ <createTable schemaName="ent"
+ tableName="eleve_proprietes">
+ <column name="id" type="bigint"/>
+ <column name="personne_id" type="bigint">
+ <constraints nullable="false"/>
+ </column>
+ <column name="mef_id" type="bigint">
+ </column>
+ <column name="annee_scolaire_id" type="bigint">
+ <constraints nullable="false"/>
+ </column>
+ </createTable>
+
+ <addPrimaryKey schemaName="ent"
+ tableName="eleve_proprietes"
+ columnNames="id"
+ constraintName="pk_eleve_proprietes"/>
+
+ <addForeignKeyConstraint baseTableSchemaName="ent"
+ baseTableName="eleve_proprietes"
+ baseColumnNames="personne_id"
+ constraintName="fk_eleve_proprietes_personne"
+ referencedTableSchemaName="ent"
+ referencedTableName="personne"
+ referencedColumnNames="id"/>
+
+ <addForeignKeyConstraint baseTableSchemaName="ent"
+ baseTableName="eleve_proprietes"
+ baseColumnNames="mef_id"
+ constraintName="fk_eleve_proprietes_mef"
+ referencedTableSchemaName="ent"
+ referencedTableName="mef"
+ referencedColumnNames="id"/>
+
+ <addForeignKeyConstraint baseTableSchemaName="ent"
+ baseTableName="eleve_proprietes"
+ baseColumnNames="annee_scolaire_id"
+ constraintName="fk_eleve_proprietes_annee_scolaire"
+ referencedTableSchemaName="ent"
+ referencedTableName="annee_scolaire"
+ referencedColumnNames="id"/>
+
+ </changeSet>
+
+ <changeSet id="4" author="bahj">
+ <comment>
+ Ajout d'une contrainte d'unicité dans la table eleve_proprietes
+ </comment>
+ <addUniqueConstraint schemaName="ent"
+ tableName="eleve_proprietes"
+ columnNames="personne_id,annee_scolaire_id"
+ constraintName="uk_eleve_proprietes_personne_annee_scolaire"/>
+ </changeSet>
</databaseChangeLog>
</sql>
</changeSet>
+
+ <changeSet id="2" author="bper">
+ <comment>
+ Suppression des liens des responsables élève avec les structures d'enseignement
+ </comment>
+
+ <!-- On supprime toutes les PPS des parents liées aux structures d'enseignement.
+ L'appartenance d'un parent à une classe/groupe sera gérée implicitement
+ par le lien de son enfant avec cette classe/groupe -->
+
+ <sql>
+ DELETE FROM ent.personne_propriete_scolarite
+ WHERE propriete_scolarite_id IN (
+ SELECT ps.id FROM ent.propriete_scolarite AS ps
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id
+ WHERE f.code = 'PERS_REL_ELEVE'
+ AND ps.structure_enseignement_id IS NOT NULL
+ )
+ </sql>
+
+ </changeSet>
+
</databaseChangeLog>
</changeSet>
+ <changeSet id="12" author="agia">
+ <comment>
+ Rétablissement de l'état de la contrainte CHECK sur les colonnes 'responsable_structure_enseignement' et 'structure_enseignement_id' de la table 'ent.propriete_scolarite'
+ </comment>
+
+ <!--
+ La colonne 'responsable_structure_enseignement' ne peut avoir comme valeur null ou true.
+ Si la valeur est true la valeur de 'structure_enseignement_id' ne doit pas etre null.
+ Cela est nécessaire pour mettre les contraintes d'unicité et ne pas mettre une valeur
+ différente de null là où elle n'a pas de sens.
+ -->
+ <sql>
+ ALTER TABLE ent.propriete_scolarite
+ DROP CONSTRAINT chk_responsable_structure_ens_dep_structure_ens;
+
+ ALTER TABLE ent.propriete_scolarite
+ ADD CONSTRAINT chk_responsable_structure_ens_dep_structure_ens
+ CHECK (
+ (responsable_structure_enseignement = true AND structure_enseignement_id IS NOT NULL)
+ OR
+ (responsable_structure_enseignement IS NULL)
+ );
+ </sql>
+
+ </changeSet>
+
+
+ <changeSet id="13" author="bper" >
+ <comment>
+ Ajout des enseignants des structures d'enseignement de type 'GROUPE' dans les classes dont ces groupes sont composés
+ </comment>
+
+ <sql>
+ CREATE TEMP TABLE ps_pps_a_ajouter ON COMMIT DROP AS
+ SELECT
+ pps.personne_id,
+ classe.id AS classe_id,
+ f.id AS fonction_id,
+ ps.annee_scolaire_id,
+ min(pps.origine) AS origine -- origine 'AUTO' est dominant
+ FROM ent.personne_propriete_scolarite AS pps
+ INNER JOIN ent.propriete_scolarite AS ps ON pps.propriete_scolarite_id = ps.id
+ INNER JOIN ent.fonction AS f ON ps.fonction_id = f.id AND f.code = 'ENS'
+ INNER JOIN ent.structure_enseignement AS groupe ON ps.structure_enseignement_id = groupe.id AND groupe.type = 'GROUPE'
+ INNER JOIN ent.rel_classe_groupe AS rel ON rel.groupe_id = groupe.id
+ INNER JOIN ent.structure_enseignement AS classe ON rel.classe_id = classe.id AND classe.type = 'CLASSE'
+ WHERE pps.est_active = true
+ GROUP BY pps.personne_id, classe.id, f.id, ps.annee_scolaire_id;
+
+ INSERT INTO ent.propriete_scolarite (id, structure_enseignement_id, fonction_id, annee_scolaire_id)
+ SELECT nextval('ent.propriete_scolarite_id_seq'), classe_id, fonction_id, annee_scolaire_id
+ FROM ps_pps_a_ajouter
+ WHERE NOT EXISTS (
+ SELECT * FROM ent.propriete_scolarite
+ WHERE structure_enseignement_id = ps_pps_a_ajouter.classe_id
+ AND fonction_id = ps_pps_a_ajouter.fonction_id
+ AND annee_scolaire_id = ps_pps_a_ajouter.annee_scolaire_id
+ AND responsable_structure_enseignement IS DISTINCT FROM true
+ )
+ GROUP BY classe_id, fonction_id, annee_scolaire_id;
+
+ INSERT INTO ent.personne_propriete_scolarite (id, personne_id, propriete_scolarite_id, est_active, origine)
+ SELECT
+ nextval('ent.personne_propriete_scolarite_id_seq'),
+ personne_id,
+ ps.id,
+ true,
+ origine
+ FROM ps_pps_a_ajouter
+ INNER JOIN ent.propriete_scolarite AS ps
+ ON ps.structure_enseignement_id = ps_pps_a_ajouter.classe_id
+ AND ps.fonction_id = ps_pps_a_ajouter.fonction_id
+ AND ps.annee_scolaire_id = ps_pps_a_ajouter.annee_scolaire_id
+ AND ps.responsable_structure_enseignement IS DISTINCT FROM true
+ WHERE NOT EXISTS (
+ SELECT * FROM ent.personne_propriete_scolarite
+ WHERE personne_id = ps_pps_a_ajouter.personne_id
+ AND propriete_scolarite_id = ps.id
+ AND est_active = true
+ );
+ </sql>
+
+ </changeSet>
+
</databaseChangeLog>
--- /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>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+
+ <changeSet id="1" author="bper">
+ <comment>
+ Ajout de la table 'operation_maintenance'
+ </comment>
+
+ <createTable schemaName="public" tableName="operation_maintenance">
+ <column name="id" type="bigint">
+ <constraints primaryKey="true" nullable="false"/>
+ </column>
+
+ <column name="code" type="varchar(64)">
+ <constraints nullable="false" unique="true"/>
+ </column>
+
+ <column name="etat" type="varchar(32)">
+ <constraints nullable="false"/>
+ </column>
+ </createTable>
+
+ <createSequence
+ schemaName="public"
+ sequenceName="operation_maintenance_id_seq"/>
+
+ </changeSet>
+
+</databaseChangeLog>
<include file="changelogs/scolarite/2013-07-31-0029591.xml"/>
<include file="changelogs/scolarite/2013-08-01-0028847.xml"/>
<include file="changelogs/securite/2013-08-23-0029765.xml"/>
+ <include file="changelogs/scolarite/2013-08-29-0028847.xml"/>
+ <include file="changelogs/securite/2013-09-06-0028847.xml"/>
+ <include file="changelogs/securite/2013-09-09-0028847.xml"/>
</databaseChangeLog>
public static final String TYPE_GROUPE = "groupe";
public static final String TYPE_ELIOT = "eliot";
public static final String LOCALISATION_LOCALE = "LOCALE";
- public static final String LOCALISATION_DISTANTES = "DISTANTES";
+ public static final String LOCALISATION_DISTANTE = "DISTANTE";
public static final String ENT = "ENT";
/**
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ 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>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+ <changeSet id="1" author="bper">
+ <comment>
+ Suppression de la table 'securite.permission'
+ </comment>
+
+ <dropTable schemaName="securite" tableName="permission" />
+ <dropSequence schemaName="securite" sequenceName="permission_id_seq" />
+
+ </changeSet>
+</databaseChangeLog>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ 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>.
+ -->
+
+<databaseChangeLog
+ xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+
+ <changeSet id="1" author="bahj">
+ <comment>
+ Ajout de la colonne localisation dans la table securite.autorite
+ </comment>
+
+ <addColumn tableName="autorite" schemaName="securite">
+ <column name="localisation" type="varchar(8)">
+ <constraints nullable="true"/>
+ </column>
+ </addColumn>
+
+ </changeSet>
+
+ <changeSet id="1" author="agia">
+ <comment>
+ Rendre la colonne securite.autorite.id_externe nullable (car n'a pas de
+ sens
+ pour les autorités de type 'groupe' avec la localisation 'locale')
+ </comment>
+
+ <dropNotNullConstraint schemaName="securite"
+ tableName="autorite"
+ columnName="id_externe"/>
+
+ </changeSet>
+
+ <changeSet id="2" author="bahj">
+ <comment>
+ Migration des autorités groupes en localisation = DISTANTE
+ Ajout des contraintes de vérifications
+ </comment>
+ <sql>
+
+ UPDATE securite.autorite
+ SET localisation='DISTANTE'
+ WHERE type='groupe'
+ AND id_externe IS NOT NULL;
+
+ ALTER TABLE securite.autorite
+ add constraint chk_autorite_type_localisation_id_externe
+ check (
+ (id_externe IS NOT NULL AND localisation IS NOT DISTINCT FROM 'DISTANTE'
+ AND type = 'groupe')
+ OR(id_externe IS NOT NULL AND localisation IS NULL AND type ='acteur')
+ OR (id_externe IS NOT NULL AND localisation IS NULL AND type = 'eliot')
+ OR (id_externe IS NULL AND localisation IS NOT DISTINCT FROM 'LOCALE' AND
+ type = 'groupe')
+ );
+
+ </sql>
+
+ </changeSet>
+</databaseChangeLog>
* <http://www.cecill.info/licences.fr.html>.
*/
-
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
import org.lilie.services.eliot.url.UrlServeurResolutionMode
}
}
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.LOCAL.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
// Définit où chercher les données suivante de la classe Personne :
// login, email, numeroBureau, telephonePro, telephonePerso, telephonePortable
eliot.personne.sourceDonneesPersoLocal = false // Par défaut à false
import org.lilie.services.eliot.environnement.EnvironnementUtil
import org.lilie.services.eliot.applications.textes.datastore.verification.DataStoreVerificationService
import org.lilie.services.eliot.VerifieWebServiceJob
+import org.lilie.services.eliot.agenda.AgendaMigrationPartagesService
/*
* Copyright © FYLAB and the Conseil Régional d'Île-de-France, 2009
EliotVersionService eliotVersionService
ActiviteMarshallerService activiteMarshallerService
DataStoreVerificationService dataStoreVerificationService
+ AgendaMigrationPartagesService agendaMigrationPartagesService
def init = {servletContext ->
activiteMarshallerService.createConfig()
scheduleVerifieWebServiceJob()
+
+ agendaMigrationPartagesService.execute()
}
private void scheduleVerifieWebServiceJob() {
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.lilie.services.eliot.environnement.EnvironnementUtil
import org.lilie.services.eliot.url.UrlServeurResolutionMode
import org.apache.log4j.FileAppender
// Permet de modifier les régles utilisées
codenarc.propertiesFile = "file:grails-app/conf/codenarc.properties"
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
// Proprietes du service d'impression
//
eliot {
import org.lilie.services.eliot.temps.exception.EliotTempsException
import org.lilie.services.eliot.temps.TempsAgendaService
-import org.lilie.services.eliot.temps.TempsDroitsService
-import org.lilie.services.eliot.droits.Droit
import org.lilie.services.eliot.securite.impl.Autorite
import org.lilie.services.eliot.securite.AccessManager
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.codehaus.groovy.grails.commons.ConfigurationHolder
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.scolarite.Personne
-import org.lilie.services.eliot.temps.TypeAutorite
+
import org.lilie.services.eliot.SessionUtils
-import org.lilie.services.eliot.securite.permission.DroitsEtPermissionsService
+
import org.lilie.services.eliot.temps.TypeAgendaEnum
+import org.lilie.services.eliot.securite.permission.ItemDroits
+import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
+
+import org.lilie.services.eliot.securite.permission.ItemDroitsService
/**
* author bahj
DistantAutoriteService distantAutoriteService
LocalPersonneService localPersonneService
TempsAgendaService tempsAgendaService
- TempsDroitsService tempsDroitsService
TempsSecuriteService tempsSecuriteService
EliotUrlService eliotUrlService
AgendaPersonnaliseService agendaPersonnaliseService
- DroitsEtPermissionsService droitsEtPermissionsService
+ PartageManuelService partageManuelService
+ ItemDroitsService itemDroitsService
def accueil = {
}
}
- // Récupère la liste des droits de type groupe
- List droitsGroupes = tempsDroitsService.getDroitsForGroupes(
- getSecuriteSession(),
- agenda
- )
-
- // Récupère la liste des droits de type acteur
- List droitsActeurs = tempsDroitsService.getDroitsForActeurs(
- getSecuriteSession(),
- agenda
+ ItemDroits itemDroits = itemDroitsService.findAllItemDroits(
+ securiteSession,
+ agenda.item
)
- droitsEtPermissionsService.trieDroitsUtilisateur(droitsActeurs)
-
- // Encode l'idExterne
- droitsActeurs.each {Droit droitActeur ->
- droitActeur.idAutorite =
- distantAutoriteService.getAutoriteEncodeeForTypeAndIdExterne(
- Autorite.TYPE_ACTEUR,
- droitActeur.idAutorite
- )
- }
-
- droitsGroupes.each {Droit droitGroupe ->
- droitGroupe.idAutorite =
- distantAutoriteService.getAutoriteEncodeeForTypeAndIdExterne(
- Autorite.TYPE_GROUPE,
- droitGroupe.idAutorite
- )
- }
response.setHeader('Cache-Control', 'no-cache') // pour que IE ne cache pas les réponses
response.setHeader('Expires', '-1') // pour que IE ne cache pas les réponses
render(template: '/commons/droitsEtPermissions/tabDroitsEtPermissions',
plugin: "eliot-app-plugin",
model: [
+ itemId: agenda.item.id,
restreint: false,
afficheDroitsEtPermissions: true,
- droitsGroupes: droitsGroupes,
- droitsActeurs: droitsActeurs,
+ droitsGroupes: itemDroits.groupe,
+ droitsActeurs: itemDroits.personne,
idObjetEdite: agenda.id,
disableEdit: disableEdit,
- listeDroitsAMasquerActeurs: droitsActeurs.collect {it.idAutorite},
- listeDroitsAMasquerGroupes: droitsGroupes.collect {it.idAutorite},
+ listeDroitsAMasquerActeurs: itemDroits.personne.collect {it.autoriteIdExterne},
+ listeDroitsAMasquerGroupes: itemDroits.groupe.collect {it.autoriteIdExterne},
message: message,
messageComplement: messageComplement
]
*
*/
def majDroits = {
-
- List<Droit> droitsGroupes = []
- List<Droit> droitsActeurs = []
-
// reconstitue la liste des droitsGroupes et droitsActeurs
Map paramMap = chainModel ?: params
Agenda agenda = Agenda.get(params.id)
- // Vérification des droits
- if (getSecuriteSession()) {
- tempsSecuriteService.verifieAutorisationModificationPermissions(
- agenda,
- getSecuriteSession()
- )
- }
- // Construit la liste des identifiants des autorités encodées
- List<String> autoritesEncodee = []
- paramMap.each {Object key, Object value ->
- // Si il y a une entree Groupe ou Utilisateur
- String keyString = key.toString()
- if (keyString.startsWith('g') || keyString.startsWith('u')) {
- autoritesEncodee.add(keyString.substring(1))
- }
- }
-
- // Récupère la liste des autorités des autorités encodées
- List<Autorite> autorites = distantAutoriteService.getAutoritesForAllAutoritesEncodees(
- autoritesEncodee,
- true
+ ItemDroits itemDroits = partageManuelService.mettreAjourDroitEtPermission(
+ securiteSession,
+ agenda.item,
+ paramMap
)
- // Construit une map dans l'identifiant est l'autorité encodée, la valeur est l'autorité
- Map<String, Autorite> autoritesEncodeeAndAutorite = [:]
- autorites.each { Autorite autorite ->
- String identifiantAutorite = distantAutoriteService.getAutoriteEncodeeForTypeAndIdExterne(
- autorite.type,
- autorite.idExterne)
- autoritesEncodeeAndAutorite.put(identifiantAutorite, autorite)
- }
-
- Droit droit
-
- paramMap.each {Object key, Object value ->
- // Si il y a une entree Groupe ou Utilisateur
- String keyString = key.toString()
-
- String autoriteEncodee = null
-
- if (keyString.startsWith('g') || keyString.startsWith('u')) {
-
- autoriteEncodee = keyString.substring(1)
-
- // récupère l'autorité à partir de l'identifiant encodé de l'autorité
- Autorite autorite = autoritesEncodeeAndAutorite[autoriteEncodee]
-
- Boolean ecrire = paramMap['e_' + keyString] == 'on'
- Boolean lire = paramMap['l_' + keyString] == 'on'
-
- // Quand un checkbox est désactivé il n'est pas passé dans les params
- // Pour cette raison si Ecrire est coché et Lire coché par défaut + désactivé
- // On n'a pas Lire dans les params
- // ==> il faut mettre Lire à troue là où Ecrire est à true
- if (ecrire == true) {
- lire = true
- }
-
- droit = new Droit(
- type: '',
- idAutorite: autorite?.idExterne,
- autorite: autorite,
- consultation: lire,
- modification: ecrire,
- modificationParDefaut: false,
- consultationParDefaut: false
- )
-
- // Flitrage des autorités
- if (autorite.type == Autorite.TYPE_GROUPE) {
- droit.type = TypeAutorite.GROUPE.getPrefix()
- droitsGroupes << droit
- }
- if (autorite.type == Autorite.TYPE_ACTEUR) {
- droit.type = TypeAutorite.ACTEUR.getPrefix()
- droitsActeurs << droit
- }
-
- }
- }
-
- // Appel le service qui va créer les autorisations
- tempsDroitsService.majDroits(
- getSecuriteSession(),
- agenda,
- droitsActeurs,
- droitsGroupes,
- )
- droitsActeurs.sort { it.nomAutorite }
- droitsGroupes.sort { it.nomAutorite }
+ itemDroits.personne.sort { it.nomAutorite }
+ itemDroits.groupe.sort { it.nomAutorite }
response.setHeader('Cache-Control', 'no-cache') // pour que IE ne cache pas les réponses
response.setHeader('Expires', '-1') // pour que IE ne cache pas les réponse
Map modele = prepareBaseModele(null)
modele += [
- agendaId: agenda.id,
+ agendaId: agenda.id,
ongletNum: 0,
nature: 'agenda',
agenda: agendaInfo as JSON,
agendaObj: agendaInfo,
- droitsGroupes: droitsGroupes,
- droitsActeurs: droitsActeurs,
+ droitsGroupes: itemDroits.groupe,
+ droitsActeurs: itemDroits.personne,
modeEdition: true,
disableDroitsEtPermissions: false,
droitsIncomplets: agenda.droitsIncomplets,
--- /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.agenda
+
+import org.lilie.services.eliot.securite.permission.AbstractMigraionPartgasService
+import org.hibernate.SessionFactory
+import org.lilie.services.eliot.securite.permission.partageauto.AgendaPartageAutoService
+import org.lilie.services.eliot.temps.Agenda
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.temps.TypeAgendaEnum
+import org.codehaus.groovy.grails.commons.ConfigurationHolder
+
+class AgendaMigrationPartagesService extends AbstractMigraionPartgasService {
+
+ static transactional = false
+
+ private static final CODE_OPERATION = 'AGENDA_MIGRATION_PARTAGES_AUTO'
+
+ AgendaPartageAutoService agendaPartageAutoService
+
+ SessionFactory sessionFactory
+
+
+ void execute() {
+ // La migration se fait uniquement en mode maintenance
+ if (ConfigurationHolder.config.eliot.mode.maintenance != true) {
+ return
+ }
+
+ if (dejaExecute(CODE_OPERATION)) {
+ return
+ }
+
+ List<Long> agendaDejaTraiteIds = []
+
+ Agenda.withTransaction {
+ for (
+ Agenda agenda = findAgendaATraiter(agendaDejaTraiteIds);
+ agenda != null;
+ agenda = findAgendaATraiter(agendaDejaTraiteIds << agenda.id)
+ ) {
+ migrePermissionsExistantesSurGroupesLocaux(agenda)
+ }
+
+ marqueFinOperation(CODE_OPERATION)
+ }
+ }
+
+
+ private Agenda findAgendaATraiter(List<Long> agendaDejaTraiteIds) {
+ return (Agenda) Agenda.createCriteria().get {
+ typeAgenda {
+ 'in'('code', [
+ TypeAgendaEnum.ETS.code,
+ TypeAgendaEnum.ETE.code,
+ TypeAgendaEnum.CSE.code
+ ])
+ }
+
+ if (agendaDejaTraiteIds) {
+ not {
+ 'in'('id',agendaDejaTraiteIds)
+ }
+ }
+ maxResults(1)
+ }
+ }
+
+
+ private void migrePermissionsExistantesSurGroupesLocaux(Agenda agenda) {
+ log.info "Migration des partages pour l'agenda ${agenda.nom}"
+
+ SecuriteSession securiteSession = getSecuriteSessionSystem(
+ agenda.structureEnseignement?.etablissement ?: agenda.etablissement
+ )
+
+ agendaPartageAutoService.partageAgenda(agenda)
+
+ migrePermissionsExistantesSurGroupesLocaux(securiteSession, agenda.item)
+
+ agenda.droitsIncomplets = false
+ agenda.save(failOnError: true, flush: true)
+
+ sessionFactory.currentSession.clear()
+ }
+}
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.test.PopulationTestActeur
import org.lilie.services.eliot.temps.TempsAgendaService
-import org.lilie.services.eliot.temps.TempsDroitsService
import org.lilie.services.eliot.test.PopulationTestEtablissement
import org.lilie.services.eliot.scolarite.Etablissement
import org.lilie.services.eliot.temps.Agenda
import org.lilie.services.eliot.temps.TypeAgendaEnum
+import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
+
/**
* todoc
*/
DistantInitDonneesCommunesTestService distantInitDonneesCommunesTestService
TempsAgendaService tempsAgendaService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
- TempsDroitsService tempsDroitsService
+ PartageManuelService partageManuelService
SecuriteSession securiteSessionDirecteur
SecuriteSession securiteSessionEnseignant
"mon agenda partagé en consultation avec le directeur",
securiteSessionEnseignant
)
- tempsDroitsService.enregistreDroits(
+ partageManuelService.enregistreDroits(
securiteSessionEnseignant,
agendaTestPopulation.agendaPartagesEnConsultation.item,
securiteSessionDirecteur.defaultAutorite,
"mon agenda partagé en modification avec le directeur",
securiteSessionEnseignant
)
- tempsDroitsService.enregistreDroits(
+ partageManuelService.enregistreDroits(
securiteSessionEnseignant,
agendaTestPopulation.agendaPartagesEnModification.item,
securiteSessionDirecteur.defaultAutorite,
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
eliot.messagerie.redirectionActive = true
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.DISTANT.toString()
// Proprietes du service d'impression
//
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
import org.lilie.services.eliot.environnement.EnvironnementUtil
//Chemin vers le script de lancement de l'import Talend
eliot.scolarite.import.udt.cheminscript = "/tmp"
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
//Proprietes du service d'impression
eliot {
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.FileAppender
import org.apache.log4j.DailyRollingFileAppender
import org.lilie.services.eliot.url.UrlServeurResolutionMode
// Permet de modifier les régles utilisées
codenarc.propertiesFile = "file:grails-app/conf/codenarc.properties"
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.DISTANT.toString()
-
// Proprietes du service d'impression
//
eliot {
import org.springframework.context.ApplicationContext
import org.springframework.context.ApplicationContextAware
import org.lilie.services.eliot.urllabel.UrlLabelInfo
-import org.lilie.services.eliot.droits.Droit
+import org.lilie.services.eliot.securite.permission.Droit
import org.lilie.services.eliot.DistantAutoriteService
-import org.lilie.services.eliot.securite.permission.DroitsEtPermissionsService
+
+import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
/**
* Controlleur de gestion des fichiers (documents ou dossiers)
FichierUtilsService fichierUtilsService
DistantPersonneService distantPersonneService
GestionnaireFichierService gestionnaireFichierService
- DroitsEtPermissionsService droitsEtPermissionsService
+ PartageManuelService partageManuelService
// Chargement de la factory de session JCR pour pouvoir fermer les sessions
// Nécessaire pour patcher un problème de cache avec le Workspace
nomAutorite: nomAutorite,
modification: peutEcrire,
consultation: peutLire,
- idAutorite: autoriteEncodee
+ autoriteIdExterne: autoriteEncodee
)
}
else {
nomAutorite: nomAutorite,
modification: peutEcrire,
consultation: peutLire,
- idAutorite: autoriteEncodee
+ autoriteIdExterne: autoriteEncodee
)
}
}
List<String> listeDroitsAMasquerGroupes = []
droitsActeurs.each {Droit unDroit ->
- listeDroitsAMasquerActeurs << unDroit.idAutorite
+ listeDroitsAMasquerActeurs << unDroit.autoriteIdExterne
}
droitsGroupes.each {Droit unDroit ->
- listeDroitsAMasquerGroupes << unDroit.idAutorite
+ listeDroitsAMasquerGroupes << unDroit.autoriteIdExterne
}
String fichierIdComplet = IdUtils.genereIdComplet(
modificationParDefaut: true,
consultation: true,
consultationParDefaut: true,
- idAutorite: autoriteEncodee,
+ autoriteIdExterne: autoriteEncodee,
estProprietaire: true
)
listeDroitsAMasquerActeurs << autoriteEncodee
}
- droitsEtPermissionsService.trieDroitsUtilisateur(droitsActeurs)
+ partageManuelService.trieDroitsUtilisateur(droitsActeurs)
response.setHeader('Cache-Control', 'no-cache') // pour que IE ne cache pas les réponses
response.setHeader('Expires', '-1') // pour que IE ne cache pas les réponses
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.FileAppender
import org.apache.log4j.DailyRollingFileAppender
org.lilie.socle.api.annuaire.util.ConstantesApiAnnuaire.FONCTION_PERSONNEL_VIE_SCOLAIRE
]
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.DISTANT.toString()
-
eliot.messagerie.redirectionActive = true
//Indique que l'application doit être compatible avec la version 1.8.0 de l'API
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
import org.lilie.services.eliot.url.UrlServeurResolutionMode
// Permet de modifier les régles utilisées
codenarc.propertiesFile = "file:grails-app/conf/codenarc.properties"
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.LOCAL.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
eliot.notes.triggerCalculMoyennes.startDelay = 60 * 1000 // 1 minute après le deploiment
eliot.notes.triggerCalculMoyennes.repeatInterval = 60 * 1000 // intervalle de répetition = 1 minute
eliot.notes.calculMoyennes.verrou.expiration.periode = 60 * 60 * 1000 // 1 heure.
* <http://www.cecill.info/licences.fr.html>.
*/
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
import org.apache.log4j.FileAppender
import org.apache.log4j.DailyRollingFileAppender
import org.lilie.services.eliot.url.UrlServeurResolutionMode
// Paramètre l'emplacement des fichiers pour la bascule d'année scolarité
eliot.racineDossiersBasculeAnnee = '/tmp/rapportsBascules'
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
// Proprietes du service d'impression
//
eliot {
import org.lilie.services.eliot.applications.textes.ActiviteMarshallerService
import org.lilie.services.eliot.VerifieWebServiceJob
import org.codehaus.groovy.grails.commons.GrailsApplication
+import org.lilie.services.eliot.textes.TextesMigrationPartagesService
class BootStrap {
EliotVersionService eliotVersionService
DataStoreVerificationService dataStoreVerificationService
ActiviteMarshallerService activiteMarshallerService
- GrailsApplication grailsApplication
+ GrailsApplication grailsApplication
+ TextesMigrationPartagesService textesMigrationPartagesService
def init = {servletContext ->
activiteMarshallerService.createConfig()
scheduleVerifieWebServiceJob()
+
+ textesMigrationPartagesService.execute()
}
private void scheduleVerifieWebServiceJob() {
* <http://www.cecill.info/licences.fr.html>.
*/
-
-
-import org.lilie.services.eliot.securite.impl.AnnuaireMode
-
import org.lilie.services.eliot.url.UrlServeurResolutionMode
import org.lilie.services.eliot.environnement.EnvironnementUtil
-import org.lilie.services.eliot.textes.DataStoreId
-import org.lilie.services.eliot.applications.textes.datastore.verification.DataStoreErreurConsequence
import org.apache.log4j.DailyRollingFileAppender
import org.apache.log4j.FileAppender
// Peremt d'activer ou désactiver l'affichage de cdt par emploi du temps
eliot.textes.affichage.presentationCdt.emploiDuTemps = true
-/**
- * Configuration de l'annuaire
- * @author jtra
- */
-eliot.annuaire.sessionACL.mode = AnnuaireMode.DISTANT.toString()
-eliot.annuaire.sessionAnnuaire.mode = AnnuaireMode.LOCAL.toString()
-
eliot {
textes {
racineRessourcesApplication = "/tmp"
import org.lilie.services.eliot.scolarite.personne.AutoriteNomAffichageService
import org.lilie.services.eliot.applications.textes.FichierService
import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
-import org.lilie.services.eliot.securite.permission.DroitsEtPermissionsService
-import org.lilie.services.eliot.droits.Droit
+
+import org.lilie.services.eliot.securite.permission.Droit
import org.lilie.services.eliot.scolarite.personne.LocalPersonneService
import org.lilie.services.eliot.parametrages.calendrier.CalendrierService
import grails.converters.JSON
import org.lilie.services.eliot.applications.EliotApplicationEnum
import org.lilie.services.eliot.url.EliotUrlService
import org.lilie.services.eliot.applications.agendatextes.RelCahierEvenement
+import org.lilie.services.eliot.securite.permission.ItemDroits
+import org.lilie.services.eliot.applications.textes.recherche.TextesIndexationService
+import org.lilie.services.eliot.securite.permission.partagemanuel.PartageManuelService
+
+import org.lilie.services.eliot.securite.permission.ItemDroitsService
/**
* Controller dirigeant tout ce qui touche aux cahiers de textes.
VisaService visaService
AutoriteNomAffichageService autoriteNomAffichageService
ArbreService arbreService
- DroitsEtPermissionsService droitsEtPermissionsService
+ PartageManuelService partageManuelService
AccueilEtatSessionService accueilEtatSessionService
CalendrierService calendrierService
DemandeTraitementService demandeTraitementService
CahierDeTextesDroitsService cahierDeTextesDroitsService
CahierDeTextesEmploiDuTempsService cahierDeTextesEmploiDuTempsService
CahierDeTextesMasqueService cahierDeTextesMasqueService
+ TextesIndexationService textesIndexationService
+ ItemDroitsService itemDroitsService
private static final FICHIER_TAILLE_MAX_MO =
ConfigurationHolder.config.eliot.textes.fichier.tailleMax.megaOctets
CahierDeTextes.withTransaction {
List listeDroits = []
- List autorites = droitsEtPermissionsService.getListeAutorites(params.ids, params.type)
+ List autorites = partageManuelService.getListeAutorites(params.ids, params.type)
Map idExterneNomAffichages = [:]
idExterneNomAffichages.each { String idExterne, String nomAffichage ->
listeDroits << new Droit(
nomAutorite: nomAffichage,
- idAutorite: idExterne,
+ autoriteIdExterne: idExterne,
type: params.type,
consultation: Boolean.TRUE,
modification: Boolean.FALSE
*/
def majDroits = {
CahierDeTextes.withTransaction {
- List<Droit> droitsGroupes = []
- List<Droit> droitsActeurs = []
Map modele = prepareBaseModele(Page.EDITION_CAHIERS_DE_TEXTES)
+ CahierDeTextes cdt = CahierDeTextes.get(params.id)
+
// reconstitue la liste des droitsGroupes et droitsActeurs
Map paramMap = chainModel ?: params
- paramMap.each {Object key, Object value ->
- // Si il y a une entree Groupe ou Utilisateur
- String keyString = key.toString()
-
- if (keyString.startsWith(DroitsService.TYPE_GROUPE) ||
- keyString.startsWith(DroitsService.TYPE_ACTEUR)) {
- String type = keyString.charAt(0)
- String nomAutorite = value?.toString()
- String idAutorite = keyString.substring(1)
- Boolean ecrire = paramMap['e_' + keyString] == 'on'
- Boolean lire = paramMap['l_' + keyString] == 'on'
-
- // Quand un checkbox est désactivé il n'est pas passé dans les params
- // Pour cette raison si Ecrire est coché et Lire coché par défaut + désactivé
- // On n'a pas Lire dans les params
- // ==> il faut mettre Lire à troue là où Ecrire est à true
- if (ecrire) {
- lire = true
- }
- Droit droit = new Droit(
- type: type,
- nomAutorite: nomAutorite,
- consultation: lire,
- modification: ecrire,
- // vu qu'on le change ca ne peut pas etre une permission par defaut
- consultationParDefaut: false,
- // vu qu'on le change ca ne peut pas etre une permission par defaut
- modificationParDefaut: false,
- idAutorite: idAutorite
- )
+ ItemDroits itemDroits = partageManuelService.mettreAjourDroitEtPermission(
+ securiteSession,
+ cdt.item,
+ paramMap
+ )
- if (keyString.startsWith(DroitsService.TYPE_GROUPE)) {
- droitsGroupes << droit
- } else {
- droitsActeurs << droit
- }
- }
+ // indéxation du cdt
+ try {
+ textesIndexationService.reindexerCahierDeTextesDroits(
+ securiteSession,
+ cdt
+ )
+ } catch (Exception e) {
+ log.warn("Erreur durant la réindexation des droits du cahier", e)
}
- CahierDeTextes cdt = CahierDeTextes.get(params.id)
-
- droitsService.majDroits(
- cdt,
- droitsActeurs,
- droitsGroupes,
- getSecuriteSession()
- )
-
- droitsActeurs.sort {it.nomAutorite }
- droitsGroupes.sort {it.nomAutorite }
+ itemDroits.personne.sort {it.nomAutorite }
+ itemDroits.groupe.sort {it.nomAutorite }
CahierDeTextesCommand cdtCmd = new CahierDeTextesCommand()
setCahierDeTextesCommand(cdtCmd, cdt)
cdt: cdt,
cdtCmd: cdtCmd,
ongletNum: 0,
- droitsGroupes: droitsGroupes,
- droitsActeurs: droitsActeurs,
+ droitsGroupes: itemDroits.groupe,
+ droitsActeurs: itemDroits.personne,
modeEdition: true,
isCahierDeService: isCahierDeService,
peutAfficherVisas: peutAfficherVisas,
]
- modele += cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession,cdt)
+ modele += cahierDeTextesMarshallerService.marsallAccesDroitEtPermissions(securiteSession, cdt)
render(view: 'proprietes',
model: modele
menuInfo: modele.menuInfo,
activerPresentationParTemps: activerPresentationParTemps,
dateDebutAnnee: debutAnneeScolaire,
- contientCdtMasque:cahierDeTextesMasqueService.hasCahierDeTextesMasque(getSecuriteSession()),
+ contientCdtMasque: cahierDeTextesMasqueService.hasCahierDeTextesMasque(getSecuriteSession()),
isDirectionOuADML: isDirectionOuADML
]
}
/**
- * Trmplis le modele avec les droits des groupes at utilisateurs
+ * Remplis le modele avec les droits des groupes at utilisateurs
* @param modele
* @param cdt
* @param secSession
SecuriteSession secSession,
Map params) {
- List<Droit> droitsGroupes = droitsService.chargeDroitsGroupes(
- cdt,
- secSession
- )
- List<Droit> droitsActeurs = droitsService.chargeDroitsActeurs(
- cdt,
- secSession
+ ItemDroits itemDroits = itemDroitsService.findAllItemDroits(
+ secSession,
+ cdt.item
)
- // patch: traite le cas ou la personne n'est pas present dans l'annuaire eliot
- droitsActeurs.each { Droit droit ->
- if (!droit.estDansAnnuaireEliot) {
- droit.nomAutorite = creeNomAffichageManquante(droit.nomAutorite)
- }
- }
-
- droitsEtPermissionsService.trieDroitsUtilisateur(droitsActeurs)
// si on passe message par GET il faut le URLencodé pour traiter non-ascii
// chars
String actionEnregistrement = (params.mode == 'creation') ? 'enregistrer' : 'maj'
modele.cdt = cdt
+ modele.itemId = cdt.item.id
modele.actionEnregistrement = actionEnregistrement
- modele.droitsGroupes = droitsGroupes
- modele.droitsActeurs = droitsActeurs
+ modele.droitsGroupes = itemDroits.groupe
+ modele.droitsActeurs = itemDroits.personne
modele.message = message
modele.messageComplement = messageComplement
- modele.listeDroitsAMasquerActeurs = droitsActeurs.collect {it.idAutorite}
- modele.listeDroitsAMasquerGroupes = droitsGroupes.collect {it.idAutorite}
+ modele.listeDroitsAMasquerActeurs = itemDroits.personne.collect {it.autoriteIdExterne}
+ modele.listeDroitsAMasquerGroupes = itemDroits.groupe.collect {it.autoriteIdExterne}
}
/**
}
-
}
package org.lilie.services.eliot.textes
-import org.lilie.services.eliot.securite.impl.Item
-
-import org.lilie.services.eliot.securite.impl.Autorite
-import org.lilie.services.eliot.securite.PermissionsManager
-import org.lilie.services.eliot.securite.impl.DefaultPermissionsManager
-import org.lilie.services.eliot.DistantAutoriteService
-import org.lilie.services.eliot.annuaire.AnnuaireService
import org.lilie.services.eliot.applications.textes.recherche.TextesIndexationService
import org.lilie.services.eliot.annuaire.SecuriteSession
import org.lilie.services.eliot.annuaire.FonctionEnum
-import org.lilie.services.eliot.scolarite.personne.AutoriteNomAffichageService
import org.lilie.services.eliot.securite.EliotDroitsService
import org.lilie.services.eliot.fonctionnalites.EliotFonctionnalite
import org.lilie.services.eliot.fonctionnalites.TextesFonctionnalite
import org.codehaus.groovy.grails.commons.GrailsApplication
-import org.lilie.services.eliot.securite.permission.DroitsEtPermissionsService
-import org.lilie.services.eliot.droits.Droit
import org.lilie.services.eliot.textes.activite.TextesActiviteService
/**
static transactional = false
- DistantAutoriteService distantAutoriteService
TextesIndexationService textesIndexationService
- AnnuaireService annuaireService
TextesActiviteService textesActiviteService
- org.lilie.services.eliot.scolarite.personne.LocalPersonneService localPersonneService
- AutoriteNomAffichageService autoriteNomAffichageService
- DroitsEtPermissionsService droitsEtPermissionsService
// jcok : grailsApplication est un singleton
@SuppressWarnings('GrailsStatelessService')
GrailsApplication grailsApplication
- public static final String TYPE_GROUPE = 'g'
- public static final String TYPE_ACTEUR = 'u'
-
protected List<EliotFonctionnalite> getFonctionnalites() {
List<EliotFonctionnalite> result = []
HashSet fonctionnalitesAccessibles = (HashSet) listeFonctionnalites
return fonctionnalitesAccessibles
}
-
- /**
- * Recoupere la liste des droits des groupes d'un cdt
- * @return une liste d'objets <code>Droit</code>
- */
- List<Droit> chargeDroitsGroupes(CahierDeTextes cahierDeTextes,
- SecuriteSession securiteSession) {
- Item item = cahierDeTextes.item
-
- return droitsEtPermissionsService.chargeDroitsGroupes(item, securiteSession)
- }
-
- /**
- * Recupere la liste des droits des acteurs d'un cdt
- * @return une liste d'objets <code>Droit</code>
- */
- List<Droit> chargeDroitsActeurs(CahierDeTextes cahierDeTextes,
- SecuriteSession securiteSession) {
- Item item = cahierDeTextes.item
- return droitsEtPermissionsService.chargeDroitsActeursItem(item, securiteSession)
- }
-
- /**
- * Met à jour les droits.
- * @param cahierDeTextes cahier de textes affecté
- * @param droitsActeurs une liste d'objets <code>Droit</code> pour les acteurs
- * @param droitsGroupes une liste d'objets <code>Droit </code> pour les groupes
- * @param item l'élément pour lequel on veut modifier les droits
- * @param securiteSession une session de securité
- * @throws org.lilie.services.eliot.securite.AutorisationException si la
- * <code>securiteSession</code> n'a pas les droits de modifer les droits...
- */
- @SuppressWarnings('CatchException') // JTRA : On traite toutes les exceptions pouvant être levée par l'indexation pour rendre les erreurs non bloquantes
- void majDroits(CahierDeTextes cahierDeTextes,
- List<Droit> droitsActeurs,
- List<Droit> droitsGroupes,
- SecuriteSession securiteSession) {
-
- Item item = cahierDeTextes.item
-
- // Récupération des droits existants
- List droitsActeursExistants = chargeDroitsActeurs(
- cahierDeTextes,
- securiteSession
- )
- List droitsGroupesExistants = chargeDroitsGroupes(
- cahierDeTextes,
- securiteSession
- )
-
- // Calcul des droits à supprimer = droits existants - droits à ajouter ou maj,
- List idsAutoriteActeursSuppr =
- droitsActeursExistants*.idAutorite - droitsActeurs*.idAutorite
-
- List idsAutoriteGroupesSuppr =
- droitsGroupesExistants*.idAutorite - droitsGroupes*.idAutorite
-
- droitsActeurs = filtreDroitsPasChanges(droitsActeurs, droitsActeursExistants)
- droitsGroupes = filtreDroitsPasChanges(droitsGroupes, droitsGroupesExistants)
-
- // enregistre les droits à ajouter ou a maj
- enregistreDroitsActeurs(securiteSession, item, droitsActeurs)
- enregistreDroitsGroupes(securiteSession, item, droitsGroupes)
-
- // enregistre les droits à supprimmer
- enleveDroitsActeurs(securiteSession, item, idsAutoriteActeursSuppr)
- enleveDroitsGroupes(securiteSession, item, idsAutoriteGroupesSuppr)
-
- try {
- textesIndexationService.reindexerCahierDeTextesDroits(
- securiteSession,
- cahierDeTextes
- )
- } catch (Exception e) {
- log.warn("Erreur durant la réindexation des droits du cahier", e)
- }
- }
-
- /**
- * Enleve de droitsNouvels les droits qui n'ont pas changee par rapport
- * aux droits existants
- * @param droitsNouvels
- * @param droitsExistants
- * @return droits a enregistrer
- */
- private List<Droit> filtreDroitsPasChanges(List<Droit> droitsNouvels,
- List<Droit> droitsExistants) {
- droitsNouvels.each { Droit droitNouvel ->
- Droit droitExistant = droitsExistants.find { it.idAutorite == droitNouvel.idAutorite }
- if (droitExistant) {
-
- if (droitExistant.consultationParDefaut) {
- droitNouvel.consultation = null // droit par defaut - on ne peut pas le changer
- } else if (droitExistant.consultation == droitNouvel.consultation) {
- droitNouvel.consultation = null // rien a change
- }
-
- if (droitExistant.modificationParDefaut) {
- droitNouvel.modification = null // droit par defaut - on ne peut pas le changer
- } else if (droitExistant.modification == droitNouvel.modification) {
- droitNouvel.modification = null // rien a change
- }
- }
- }
-
- return droitsNouvels.findAll { it.consultation != null || it.modification != null }
- }
-
- /**
- * Enleve les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- private void enleveDroitsActeurs(SecuriteSession securiteSession,
- Item item,
- List acteurAutoriteIds) {
- acteurAutoriteIds.each {String idAutorite ->
- Autorite autorite = distantAutoriteService.getAutoriteActeurForIdExterne(
- idAutorite,
- true
- )
- enregistreDroits(securiteSession, item, autorite, false, false)
- }
- }
-
- /**
- * Enleve les droits des groupes sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- private void enleveDroitsGroupes(SecuriteSession securiteSession,
- Item item,
- List groupeAutoriteIds) {
- groupeAutoriteIds.each {String idAutorite ->
- Autorite autorite = distantAutoriteService.getAutoriteGroupeForIdExterne(
- idAutorite,
- true
- )
- enregistreDroits(securiteSession, item, autorite, false, false)
- }
- }
-
- /**
- * Enregistre les droits d'acteurs sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- private void enregistreDroitsActeurs(SecuriteSession securiteSession,
- Item item,
- List<Droit> droits) {
- droits.each { Droit droit ->
- Autorite autorite = distantAutoriteService.getAutoriteActeurForIdExterne(
- droit.idAutorite,
- true
- )
- enregistreDroits(
- securiteSession,
- item,
- autorite,
- droit.consultation,
- droit.modification)
- }
- }
-
- /**
- * Enregistre les droits des groupes sur un item
- * @param securiteSession
- * @param item
- * @param droits
- */
- private void enregistreDroitsGroupes(SecuriteSession securiteSession,
- Item item,
- List<Droit> droits) {
- droits.each {Droit droit ->
- Autorite autorite = distantAutoriteService.getAutoriteGroupeForIdExterne(
- droit.idAutorite,
- true
- )
- enregistreDroits(
- securiteSession,
- item,
- autorite,
- droit.consultation,
- droit.modification)
- }
- }
-
- /**
- * Enregistre les droits d'une autorite sur un item
- * @param securiteSession
- * @param item
- * @param autorite
- * @param peutConsulter
- * @param peutModifier
- */
- private void enregistreDroits(SecuriteSession securiteSession,
- Item item,
- Autorite autorite,
- Boolean peutConsulter,
- Boolean peutModifier) {
- PermissionsManager permManager = new DefaultPermissionsManager(
- item,
- autorite,
- securiteSession
- )
- changeDroits(permManager, peutConsulter, peutModifier)
- }
-
- /**
- * Changement des droits en fonction des permissions passées en paramètre.
- */
- private void changeDroits(PermissionsManager permManager,
- Boolean peutConsulter,
- Boolean peutModifier) {
- if (peutModifier != null) {
- if (peutModifier) {
- permManager.addPermissionModification()
- } else {
- permManager.deletePermissionModification()
- }
- }
- if (peutConsulter != null) {
- if (peutConsulter) {
- permManager.addPermissionConsultation()
- } else {
- permManager.deletePermissionConsultation()
- }
- }
- }
-
}
package org.lilie.services.eliot.textes
-import org.lilie.services.eliot.securite.impl.Permission
import org.lilie.services.eliot.securite.Permission as ConstantesPermission
import org.lilie.services.eliot.scolarite.TypeActiviteService
}
typeActiviteService.initAllTypesParDefaut()
-
- initPermissions()
}
private void initContextes() {
).save(flush: true)
}
-
- private void initPermissions() {
- // Récupère les permissions existantes en base
- def permissionsEnBase = Permission.findAll()
-
- // Construit une map nom -> valeur des permissions en bases
- Map mapPermissionsEnBase = [:]
- permissionsEnBase.each { Permission permission ->
- mapPermissionsEnBase.put(permission.nom, permission.valeur)
- }
-
- // Ajoute les permissions manquantes en base
- PERMISSIONS.each {key, value ->
-
- if (mapPermissionsEnBase[key]) {
- if (mapPermissionsEnBase[key] != value) {
- throw new IllegalStateException(
- "La valeur de la permission $key est incorrecte " +
- "(valeur actuelle : ${mapPermissionsEnBase[key]}, " +
- "valeur attendue : $value)"
- )
- }
- }
- else {
- new Permission(nom: key, valeur: value).save()
- }
- }
- }
-
}
\ No newline at end of file
String hql = """select count(*) from CahierDeTextes cdt
where cdt.service.structureEnseignement = :struct
and cdt.parentIncorporation is null
- and cdt.isMasque = false
+ and cdt.estMasque = false
and exists (
from Autorisation aut
where aut.item = cdt.item
--- /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.textes
+
+import org.lilie.services.eliot.annuaire.SecuriteSession
+import org.lilie.services.eliot.securite.permission.partageauto.CahierDeTextesPartageAutoService
+import org.hibernate.SessionFactory
+import org.lilie.services.eliot.securite.permission.AbstractMigraionPartgasService
+import org.codehaus.groovy.grails.commons.ConfigurationHolder
+
+class TextesMigrationPartagesService extends AbstractMigraionPartgasService {
+
+ static transactional = false
+
+ private static final CODE_OPERATION = 'TEXTES_MIGRATION_PARTAGES_AUTO'
+
+ CahierDeTextesPartageAutoService cahierDeTextesPartageAutoService
+
+ SessionFactory sessionFactory
+
+
+ void execute() {
+ // La migration se fait uniquement en mode maintenance
+ if (ConfigurationHolder.config.eliot.mode.maintenance != true) {
+ return
+ }
+
+ if (dejaExecute(CODE_OPERATION)) {
+ return
+ }
+
+ List<Long> cdtDejaTraiteIds = []
+
+ CahierDeTextes.withTransaction {
+ for (
+ CahierDeTextes cdt = findCahierDeTextesATraiter(cdtDejaTraiteIds);
+ cdt != null;
+ cdt = findCahierDeTextesATraiter(cdtDejaTraiteIds << cdt.id)
+ ) {
+ migrePermissionsExistantesSurGroupesLocaux(cdt)
+ }
+
+ marqueFinOperation(CODE_OPERATION)
+ }
+ }
+
+
+ private CahierDeTextes findCahierDeTextesATraiter(List<Long> cdtDejaTraiteIds) {
+ return (CahierDeTextes) CahierDeTextes.createCriteria().get {
+ isNotNull('service')
+ anneeScolaire{
+ eq('anneeEnCours', true)
+ }
+ if (cdtDejaTraiteIds) {
+ not {
+ 'in'('id',cdtDejaTraiteIds)
+ }
+ }
+ maxResults(1)
+ }
+ }
+
+
+ private void migrePermissionsExistantesSurGroupesLocaux(CahierDeTextes cdt) {
+ log.info "Migration des partages pour le cahier de textes ${cdt.nom}"
+
+ SecuriteSession securiteSession = getSecuriteSessionSystem(
+ cdt.service.structureEnseignement.etablissement
+ )
+
+ cahierDeTextesPartageAutoService.partageCahierService(cdt)
+
+ migrePermissionsExistantesSurGroupesLocaux(securiteSession, cdt.item)
+
+ cdt.droitsIncomplets = false
+ cdt.save(failOnError: true, flush: true)
+
+ sessionFactory.currentSession.clear()
+ }
+}
import org.lilie.services.eliot.applications.textes.recherche.RechercheService
import org.lilie.services.eliot.applications.textes.RessourceUrlParams
-import org.lilie.services.eliot.droits.Droit
+import org.lilie.services.eliot.securite.permission.Droit
class TextesIndexationServiceTests extends GrailsUnitTestCase {
nomAutorite: "n'importe",
modification: true,
consultation: true,
- idAutorite: enseignantAutorite.getIdExterne())
+ autoriteIdExterne: enseignantAutorite.getIdExterne())
Droit droit2 = new Droit(
type: DroitsService.TYPE_ACTEUR,
nomAutorite: "n'importe",
modification: false,
consultation: true,
- idAutorite: autorite_2.getIdExterne())
+ autoriteIdExterne: autorite_2.getIdExterne())
Droit droit3 = new Droit(
type: DroitsService.TYPE_GROUPE,
nomAutorite: "n'importe",
modification: false,
consultation: true,
- idAutorite: groupe_2.getIdExterne())
+ autoriteIdExterne: groupe_2.getIdExterne())
List nouvelDroitsU = [droit1, droit2]
List nouvelDroitsG = [droit3]
- droitsService.majDroits(
- cahierDeTextes,
- new HashSet(nouvelDroitsU),
- new HashSet(nouvelDroitsG),
- dummySecuriteSession)
+ // todo partager et reprendre les vérification
+ // est ce nécesaire déjà tester les droits dans un autre service de test
+// droitsService.majDroits(
+// cahierDeTextes,
+// new HashSet(nouvelDroitsU),
+// new HashSet(nouvelDroitsG),
+// dummySecuriteSession)
// verifie droits
cdtTrouve = rechercheEtVerifieCahier(cahierDeTextes)